| /** | |
| * loadJSONP( url, hollaback [, context] ) -> Null | |
| * - url (String): URL to data resource. | |
| * - hollaback (Function): Function to call when data is successfully loaded, | |
| * it receives one argument: the data. | |
| * - context (Object): Context to invoke the hollaback function in. | |
| * | |
| * Load external data through a JSONP interface. | |
| * | |
| * ### Examples |
By default, Rails applications build URLs based on the primary key -- the id column from the database. Imagine we have a Person model and associated controller. We have a person record for Bob Martin that has id number 6. The URL for his show page would be:
/people/6
But, for aesthetic or SEO purposes, we want Bob's name in the URL. The last segment, the 6 here, is called the "slug". Let's look at a few ways to implement better slugs.
| var http = require('http'); | |
| http.createServer(function (request, response) { | |
| response.setHeader('Content-Type', 'text/html; charset=UTF-8'); | |
| response.setHeader('Transfer-Encoding', 'chunked'); | |
| var html = | |
| '<!DOCTYPE html>' + | |
| '<html lang="en">' + | |
| '<head>' + |
| # Not our code | |
| class Action | |
| def start | |
| "just do it" | |
| end | |
| end | |
| # The module including our modifying code | |
| module RubyIt | |
| def start |
| module RecognizePath | |
| def recognize_path(path, options) | |
| recognized_path = Rails.application.routes.recognize_path(path, options) | |
| # We have a route that catches everything and sends it to 'errors#not_found', you might | |
| # need to rescue ActionController::RoutingError | |
| return recognized_path unless recognized_path.slice(:controller, :action) == {controller: 'errors', action: 'not_found'} | |
| # The main app didn't recognize the path, try the engines... | |
| Rails.application.railties.engines.each do |engine| |
| class Array | |
| def slice_before | |
| [].tap do |chunks| | |
| each do |item| | |
| chunks << [] if yield(item) || chunks.empty? | |
| chunks.last << item | |
| chunks | |
| end | |
| end | |
| end |
| git branch -m old_branch new_branch # Rename branch locally | |
| git push origin :old_branch # Delete the old branch | |
| git push --set-upstream origin new_branch # Push the new branch, set local branch to track the new remote |
| <div id="details"> | |
| <h1 id='head'>{user.firstName}</h1> | |
| <h2 rv-text='user.surname'></h2> | |
| <input id='input' type='text' rv-value="user.firstName"> | |
| </div> | |
| <script src='rivets.js'></script> | |
| <script> | |
| var user = { |
| #!/usr/bin/env ruby | |
| def Inherits(*classes) | |
| klass = Class.new classes.shift # inherit from the last clas | |
| while refine_with = classes.shift # include the others as module refinements just so we can turn them into modules | |
| klass.include Module.new { include refine(refine_with) { } } | |
| end | |
| klass | |
| end |
| # `Hash#dig!` | |
| # | |
| # Like Ruby 2.3's `Hash#dig`, but raises an exception instead of returning `nil` | |
| # when a key isn't found. | |
| # | |
| # Ruby 2.3 introduces the new Hash#dig method for safe extraction of | |
| # a nested value. See http://ruby-doc.org/core-2.3.0/Hash.html#method-i-dig. | |
| # It is the equivalent of a safely repeated Hash#[]. | |
| # | |
| # `#dig!`, on the other hand, is the equivalent of a repeated `Hash#fetch`. It's |
