RubyGems - dom_routes - Versions diffs - 1.0.0 - Mend

dom_routes 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

checksums.yaml +7 -0
data/.gitignore +19 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +141 -0
data/Rakefile +1 -0
data/app/assets/javascripts/dom_routes.js +71 -0
data/app/views/layouts/application.js.erb +5 -0
data/dom_routes.gemspec +25 -0
data/lib/dom_routes.rb +12 -0
data/lib/dom_routes/controller.rb +71 -0
data/lib/dom_routes/version.rb +3 -0
data/lib/dom_routes/view_helpers.rb +110 -0
metadata +100 -0

checksums.yaml ADDED

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f167cc007cf2326be1d2256ea21feb8831efda1e
+  data.tar.gz: 90e8ef89d35101a067341072c6b5cdc2ca020bc2
+SHA512:
+  metadata.gz: 26a799981bc263a0cf8605eaf99d3b9aab819968e4790504f00cded7b11c59d8810973ea0701f66fa024e4d939d562ef64c4f91a4625a523114a6a04ef26636e
+  data.tar.gz: 0b9afacb3fa28a6994e79de1a82966e40f7c48d96e43a393320a39d3b062a54224aa5f2804e67dcf1dcde9f8fd3d1c1b6a20682481eb689bac95b3e34c41d327

data/.gitignore ADDED

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea/

data/Gemfile ADDED

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+# Specify your gem's dependencies in dom_routes.gemspec
+gemspec

data/LICENSE.txt ADDED

@@ -0,0 +1,22 @@
+Copyright (c) 2013 s12chung
+MIT License
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md ADDED

@@ -0,0 +1,141 @@
+# PokeJs
+Auto-magical scaffolding for
+[Paul Irish's DOM-based Routing](http://www.paulirish.com/2009/markup-based-unobtrusive-comprehensive-dom-ready-execution/)
+(or Garber-Irish Implementation) way of organizing your javascript.
+## Purpose
+Javascript is hard to organize and debugging ajax is a mess. This is one method to organizing your javascript neatly by mirroring the controllers and having all the it outside of your HTML views.
+## How it works
+### Setup your namespace
+```javascript
+DR.routes = {
+	all: {
+		html: {
+			before: function() {
+			}
+		}
+	},
+	demos: {
+		html: {
+			before: function() {
+			},
+			demo_action: function() {
+			}
+		}
+	}
+}
+```
+### What happens
+After, requests to `demos#demo_action` with format `html` will call the following functions (if they exist):
+* `DR.routes.all.html.before`
+* `DR.routes.demos.html.before`
+* `DR.routes.demos.html.demo_action` (with parameters if given)
+* `DR.routes.demos.html.after`
+* `DR.routes.all.html.after`
+`js` format is also supported, i.e.:
+* `DR.routes.all.js.before`
+* `DR.routes.demos.js.before`
+* `DR.routes.demos.js.demo_action` (with parameters if given)
+* `DR.routes.demos.js.after`
+* `DR.routes.all.js.after`
+## Installation
+Add this line to your application's `Gemfile`:
+    gem 'dom_routes'
+And then execute:
+    $ bundle
+Add this to your `app/assets/javascripts/application.js`
+    //= require dom_routes
+Make sure your `app/views/layouts/application.html.erb` (and all your other layouts) looks like this:
+```erb
+<html>
+<head>… <%= execute_js_routes %> …</head>
+<body data-controller="<%= js_route.controller_path %>" data-action="<%= js_route.action %>">
+    …
+</body>
+</html>
+```
+## Basic Use
+I like to have a JS file for every route in `app/assets/javascripts/routes`. Like so:
+`app/assets/javascripts/routes/demos.js`:
+```javascript
+(function() {
+	var demos = DR.define('demos', {
+		html: {
+			edit: function(params) {
+				alert(params.alert_message);
+			}
+		},
+		js: {
+			new: function(params) {
+				console.log(params.log_message);
+			}
+		}
+	});
+})();
+```
+`DR.define()` extends or creates the namespace `DR.routes.demos`
+and returns it. This allows me to access `DR.routes.demos` through
+the `demos` variable. You can also use the traditional hash
+namespacing shown in the [Setup your namespace](https://github.com/s12chung/dom_routes#setup-your-namespace) section.
+So if a `html` request is sent to `demos#edit`, `DR.routes.demos.html.edit` is called with the HTML view rendering.
+For a `js` request sent to `demos#new`, `DR.routes.demos.js.new` is called and nothing else happens.
+### Passing parameters
+__Optional__ Parameters are passed from a JSON DSL (such as [jbuilder](https://github.com/rails/jbuilder/)) and is passed as the `params` object to the function. You can pass any JSON object.
+#### HTML
+`app/views/demos/edit_params.js.jbuilder`:
+```ruby
+json.alert_message "ploop"
+```
+so
+```javascript
+DR.routes.demos.html.edit({ alert_message: "ploop" });
+```
+is called automatically.
+#### Javascript
+`app/views/demos/new.js.jbuilder`:
+```ruby
+json.log_message "loggggggggggggg"
+```
+so
+```javascript
+DR.routes.demos.js.new({ log_message: "loggggggggggggg" });
+```
+is called automatically.
+## Advanced Use
+### Manually execute a route
+Use `#execute_js_route(js_route=self.js_route, format=formats.first)`
+### Executing a different route
+Sometimes you want to execute a different route too. For that, you can specify it like so:
+```ruby
+self.js_route = "demos/edit" # can be "demos#edit", "edit", { controller: "demos", action: "edit" }, or a DomRoutes::Route object
+```
+When this is done, the original route and the new route will be executed.
+### Handling redirects with flash
+Other times you may want to use a route after a redirect, use `#flash_js_route(js_route=nil)` then.
+## Credits
+Extracted out of [Placemark](https://www.placemarkhq.com/). Originally called [poke_js](https://github.com/s12chung/poke_js).
+## Contribution
+Feel free to fork, post issues or send any pull requests. Thanks.

data/Rakefile ADDED

	@@ -0,0 +1 @@
1	+ require "bundler/gem_tasks"

data/app/assets/javascripts/dom_routes.js ADDED

@@ -0,0 +1,71 @@
+DR = {
+    namespace_prefix: "DR.routes",
+    blank: function(o) {
+        return typeof o === "undefined" || o === null;
+    },
+    namespace_string: function(namespace_string) {
+        return DR.namespace_prefix + "." + namespace_string;
+    },
+    get_or_create: function(namespace_string) {
+        var current_namepace = window;
+        $.each(namespace_string.split('.'), function(index, level) {
+            if (DR.blank(current_namepace[level]))
+                current_namepace[level] = {};
+            current_namepace = current_namepace[level];
+        });
+        return current_namepace;
+    },
+    define: function(namespace_string, definition) {
+        namespace_string = DR.namespace_string(namespace_string);
+        return DR.define_namespace(namespace_string, definition);
+    },
+    define_namespace: function(namespace_string, definition) {
+        var found_namespace = DR.get_or_create(namespace_string);
+        return $.extend(found_namespace, definition);
+    },
+    traverse_namespace: function(namespace, levels) {
+        if (!$.isArray(levels)) levels = [levels.controller, levels.format, levels.action];
+        levels = DR.formatted_levels(levels);
+        var current_level = namespace;
+        var level;
+        for (var i=0;i<levels.length;i++) {
+            level = levels[i];
+            current_level = current_level[level];
+            if (typeof current_level === "undefined") return undefined;
+        }
+        return current_level;
+    },
+    formatted_levels: function(levels) {
+        var formatted_levels = [];
+        var level;
+        for (var i=0;i<levels.length;i++) {
+            level = levels[i];
+            formatted_levels = formatted_levels.concat(level.split('/'));
+        }
+        return formatted_levels;
+    },
+    create_namespace: function(namespace) {
+        var current_level = window;
+        $.each(namespace.split("."), function(index, level) {
+            if (!$.isPlainObject(current_level[level])) current_level[level] = {};
+            current_level = current_level[level];
+        });
+    },
+    exec_all: function(params) {
+        DR.exec("application", params.format, "before", params);
+        DR.exec(params.controller, params.format, "before", params);
+        DR.exec("application", params.format, params.action, params);
+        DR.exec(params.controller, params.format, params.action, params);
+        DR.exec(params.controller, params.format, "after", params);
+        DR.exec("application", params.format, "after", params);
+    },
+    exec: function(controller, format, action, params) {
+        var action_namespace = DR.traverse_namespace(DR.routes, [controller, format, action]);
+        if ($.isFunction(action_namespace)) action_namespace(params);
+    }
+};

data/app/views/layouts/application.js.erb ADDED

@@ -0,0 +1,5 @@
+(function() {
+    DR.create_namespace('<%= js_params_namespace %>');
+    <%= js_params_namespace %> = <%= js_params_value { yield } %>;
+    DR.exec_all(<%= js_params_namespace %>);
+})();

data/dom_routes.gemspec ADDED

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dom_routes/version'
+Gem::Specification.new do |spec|
+  spec.name          = "dom_routes"
+  spec.version       = DomRoutes::VERSION
+  spec.authors       = ["s12chung"]
+  spec.email         = ["steve@placemarkhq.com"]
+  spec.description   = %q{ Auto-magical scaffolding for Paul Irish's DOM-based Routing way of organizing your javascript. }
+  spec.summary       = %q{ Auto-magical scaffolding for Paul Irish's DOM-based Routing way of organizing your javascript. }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency 'rails', '>= 3.1'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/dom_routes.rb ADDED

@@ -0,0 +1,12 @@
+require "dom_routes/view_helpers"
+require "dom_routes/controller"
+module DomRoutes
+  if defined?(Rails) && defined?(Rails::Engine)
+    class Engine < ::Rails::Engine
+      initializer "dom_routes.view_helpers" do
+        ActionView::Base.send :include, ViewHelpers
+      end
+    end
+  end
+end

data/lib/dom_routes/controller.rb ADDED

@@ -0,0 +1,71 @@
+module DomRoutes
+  class Route
+    attr_accessor :controller_path, :action
+    def set(controller_path, action)
+      self.controller_path = controller_path
+      self.action = action
+    end
+    def controller_namespace
+      controller_path.gsub("/", ".")
+    end
+    def parts
+      [controller_path, action]
+    end
+    def to_s
+      "#{controller_path}/#{action}"
+    end
+    def ==(route)
+      parts == route.parts
+    end
+  end
+  module Controller
+    extend ActiveSupport::Concern
+    included do
+      helper_method :js_route
+      helper_method :js_route=
+      helper_method :extract_js_route
+    end
+    protected
+    def js_route; @js_route || extract_js_route end
+    def js_route=(js_route); @js_route = extract_js_route js_route end
+    def flash_js_route(js_route=self.js_route)
+      flash[:js_route] = extract_js_route(js_route).to_s
+    end
+    def extract_js_route(js_route=nil)
+      extracted_route = Route.new
+      extracted_route.set controller_path, action_name
+      if js_route
+        if js_route.class == Route
+          extracted_route = js_route
+        elsif js_route.class.ancestors.include? Hash
+          hash = HashWithIndifferentAccess.new(js_route)
+          extracted_route.set hash[:controller], hash[:action]
+        else
+          js_route = js_route.to_s
+          controller = if js_route.index("#")
+                                 split = js_route.split('#')
+                                 [split.first]
+                               else
+                                 split = js_route.split('/')
+                                 split[0..-2]
+                               end
+          extracted_route.action = split.last
+          unless controller.empty?
+            extracted_route.controller_path = controller.join('/')
+          end
+        end
+      end
+      extracted_route
+    end
+  end
+end
+::ActionController::Base.send :include, DomRoutes::Controller

data/lib/dom_routes/version.rb ADDED

@@ -0,0 +1,3 @@
+module DomRoutes
+  VERSION = "1.0.0"
+end

data/lib/dom_routes/view_helpers.rb ADDED

@@ -0,0 +1,110 @@
+module DomRoutes
+  module ViewHelpers
+    #http://stackoverflow.com/questions/339130/how-do-i-render-a-partial-of-a-different-format-in-rails
+    def with_format(format, &block)
+      old_formats = formats
+      self.formats = [format]
+      result = block.call
+      self.formats = old_formats
+      result
+    end
+    def with_js_route(js_route)
+      old_js_route = self.js_route
+      self.js_route = js_route
+      result = yield
+      self.js_route = old_js_route
+      result
+    end
+    def js_params_namespace(js_route=self.js_route)
+      raw "DR.routes.#{js_route.controller_namespace}.#{formats.first}.#{js_route.action}_params"
+    end
+    def js_params_value(js_route=self.js_route)
+      controller_path, action = js_route.parts
+      params = { controller: controller_path, action: action, method: request.method, path: request.env['PATH_INFO'], format: formats.first }
+      if self.respond_to? :add_params; params.reverse_merge! add_params end
+      javascript = params.to_json
+      if block_given?
+        generated_params = yield
+        if generated_params
+          javascript = "$.extend(#{generated_params}, #{javascript});"
+        end
+      end
+      raw javascript
+    end
+    def execute_js_routes
+      raw "#{execute_flash_js_route}\n#{execute_js_route}"
+    end
+    def execute_js_route(js_route=self.js_route, format=formats.first)
+      controller_path, action = js_route.parts
+      lambda = -> do
+        if format == :html
+          javascript_tag do
+            raw %Q/
+                DR.create_namespace('#{js_params_namespace}');
+                #{js_params_namespace} = #{ js_params_value do
+                  with_format :js do
+                    if lookup_context.template_exists? "#{controller_path}/#{action}_params"
+                      render(template: "#{controller_path}/#{action}_params")
+                    end
+                  end
+                end };
+                #{
+            if is_flash_js_route?
+              %Q/$(function() { DR.exec_all(#{js_params_namespace}); });/
+            else
+              %Q/
+                    DR.define_namespace('DR.routes', {
+                        params: #{js_params_namespace},
+                        init: function() { DR.exec_all(DR.routes.params); },
+                    });
+                    $(DR.routes.init);
+                  /
+            end
+            }
+                /
+          end
+        elsif format == :js
+          with_format :js do
+            content_for :head do
+              javascript_tag do
+                raw "$(function(){#{render template: "#{controller_path}/#{action}", formats: [:js], layout: "layouts/application"}});"
+              end
+            end
+          end
+        end
+      end
+      if js_route != self.js_route
+        with_js_route(js_route) { lambda.call }
+      else
+        lambda.call
+      end
+    end
+    def execute_flash_js_route
+      flash_js_route = flash[:js_route]
+      if flash_js_route
+        with_flash_js_route do
+          execute_js_route extract_js_route(flash_js_route)
+        end
+      end
+    end
+    def with_flash_js_route
+      @is_flash_js_route = true
+      result = yield
+      @is_flash_js_route = false
+      result
+    end
+    def is_flash_js_route?
+      @is_flash_js_route
+    end
+  end
+end

metadata ADDED

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: dom_routes
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- s12chung
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ' Auto-magical scaffolding for Paul Irish''s DOM-based Routing way of
+  organizing your javascript. '
+email:
+- steve@placemarkhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/dom_routes.js
+- app/views/layouts/application.js.erb
+- dom_routes.gemspec
+- lib/dom_routes.rb
+- lib/dom_routes/controller.rb
+- lib/dom_routes/version.rb
+- lib/dom_routes/view_helpers.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.0.3
+signing_key:
+specification_version: 4
+summary: Auto-magical scaffolding for Paul Irish's DOM-based Routing way of organizing
+  your javascript.
+test_files: []