crudtree 0.1.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Simon Hafner aka Tass
+ 
+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.rdoc

@@ -0,0 +1,46 @@
+= CRUDtree
+
+== Summary
+
+A resource helper mainly for usher, but may be adapted for other routers as
+well.
+
+== See
+
+Usher:: http://github.com/joshbuddy/usher
+IRC::   #rango@irc.freenode.net
+Baretest:: http://github.com/apeiros/baretest
+
+== Terminology
+
+Master:: The main body, only one per Usher instance as well.
+Node:: You attach other Nodes or EndNodes as subnodes here.
+EndNode:: A route endpoint.
+
+== Usage
+
+=== as Tinkerer
+
+  require 'crudtree/interface/usher/rack'
+
+  Usher::Interface.for(:rack) do
+    extend CRUDtree::Interface::Usher::Rack
+    node(klass: Posts, model: Post) do
+      sub(type: :member, call: :show, rest: :get)
+      sub(type: :collection, call: :index, rest: :get)
+    end
+  end
+
+=== As Dev
+
+  require 'crudtree/interface/usher/rack'
+  require 'crudtree/helper'
+  
+  Usher::Interface.for(:rack) do
+    extend CRUDtree::Interface::Usher::Rack
+    extend CRUDtree::Interface::Helper
+    resource(klass: Posts, model: Post) do # the resource helper will include a bunch of default routes
+      member(call: :show, rest: :get)
+      collection(call: :index, rest: :get)
+    end
+  end

data/lib/crudtree.rb

@@ -0,0 +1,3 @@
+require_relative 'crudtree/tree'
+require_relative 'crudtree/interface'
+require_relative 'crudtree/generator'

data/lib/crudtree/generator.rb

@@ -0,0 +1,87 @@
+module CRUDtree
+  class Generator
+    def initialize(master)
+      @master = master
+      @model_to_node = {}
+      @master.nodes.each {|node| add_node_models(node) }
+    end
+
+    def generate(resource, *names)
+      if resource.is_a? Symbol
+        names.unshift(resource)
+        node = @master
+        url = ""
+      else
+        node, identifiers = find_node(resource)
+        last_identifier = identifiers.last
+        url = generate_url_from_node(node, identifiers)
+      end
+      generate_from_sub(node, names, url, last_identifier) unless names.empty?
+      url
+    end
+
+    private
+    def find_node(resource)
+      case nodes = @model_to_node[resource.class]
+      when Node
+        [nodes, [resource.send(nodes.identifier)]]
+      when Array
+        valid_nodes = {}
+        nodes.each do |node|
+          identifiers = identifiers_to_node(resource, node)
+          valid_nodes[node] = identifiers if identifiers
+        end
+        parents = valid_nodes.keys.map(&:parents).flatten
+        valid_nodes.reject!{|node, identifiers| parents.include?(node)}
+        case valid_nodes.size
+        when 1
+          valid_nodes.first
+        when 0
+          raise(NoNode, "No node found for #{resource}.")
+        else
+          raise(NoUniqueNode, "No unique node found for #{resource}.")
+        end
+      end
+    end
+
+    def add_node_models(node)
+      @model_to_node[node.model] = if target_node = @model_to_node[node.model]
+                                     ([target_node] << node).flatten
+                                   else
+                                     node
+                                   end
+      node.nodes.each { |subnode|
+        add_node_models(subnode)
+      }
+    end
+
+    def generate_url_from_node(node, identifiers)
+      (node.parents.reverse + [node]).map {|parent|
+        "/#{parent.path}/#{identifiers.shift}"
+      }.join
+    end
+
+    # @return [Array] with [String] of identifiers or false if the model is invalid
+    #         for this node
+    def identifiers_to_node(model, node, identifiers = [])
+      return false unless node.model == model.class
+      identifiers << model.send(node.identifier).to_s
+      unless node.parent_is_master?
+        identifiers_to_node(model.send(node.parent_call), node.parent, identifiers) or return false
+      end
+      identifiers.reverse
+    end
+
+    def generate_from_sub(node, names, url, last_identifier=nil)
+      name = names.shift
+      sub = node.subs.find{|sub| sub.name == name} or raise(ArgumentError, "No subnode found on #{node} with name of #{name}.")
+      url.chomp!("/#{last_identifier}") if last_identifier && sub.collection?
+      url << "/#{sub.path}"
+      generate_from_sub(sub, names, url) unless names.empty?
+    end
+  end
+
+  class InvalidPath < StandardError; end
+  class NoUniqueNode < StandardError; end
+  class NoNode < StandardError; end
+end

data/lib/crudtree/helper.rb

@@ -0,0 +1,19 @@
+module CRUDtree
+  module Interface
+    module Helper
+      def resource(params, &resource_block)
+        node(params) do
+          collection(call: :index, rest: :get)
+          collection(call: :new, rest: :get)
+          collection(call: :create, rest: :post, path: "")
+          member(call: :show, rest: :get)
+          member(call: :edit, rest: :get)
+          member(call: :update, rest: :put, path: "")
+          member(call: :delete, rest: :get)
+          member(call: :destroy, rest: :delete, path: "")
+          instance_eval(&resource_block) if resource_block
+        end
+      end
+    end
+  end
+end

data/lib/crudtree/interface.rb

@@ -0,0 +1,14 @@
+require_relative "tree"
+module CRUDtree
+  module Interface
+    InterfaceRegistry = {}
+
+    def self.register(name, mod)
+      InterfaceRegistry[name.to_sym] = mod
+    end
+
+    def self.for(name)
+      InterfaceRegistry[name.to_sym].attach
+    end
+  end
+end

data/lib/crudtree/interface/usher.rb

@@ -0,0 +1,43 @@
+require_relative "../interface"
+module CRUDtree
+  module Interface
+    module Usher
+      # Integration part
+      
+      def master_params
+        master.params
+      end
+
+      def master
+        @master ||= Master.new
+      end
+
+      # Logic part
+
+      def node(params, &block)
+        node = master.node(params, &block)
+        compile_node("", node)
+      end
+
+      private
+      def compile_node(pre_path, node)
+        paths = node.paths.map {|p| "#{pre_path}/#{p}"}
+        paths.each do |path|
+          node.subnodes.each do |subnode|
+            compile_subnode(path, subnode)
+          end
+        end
+      end
+
+      def compile_subnode(pre_path, subnode)
+        case subnode
+        when EndNode
+          compile_endnode(pre_path, subnode)
+        when Node
+          compile_node("#{pre_path}/:#{subnode.identifier}", subnode)
+        end
+      end
+
+    end
+  end
+end

data/lib/crudtree/interface/usher/rack.rb

@@ -0,0 +1,40 @@
+require_relative '../usher'
+
+module CRUDtree
+  module Interface
+    module Usher
+      module Rack
+        include CRUDtree::Interface::Usher
+
+        def self.attach
+          ::Usher::Interface.class_for(:rack).send(:include, self)
+        end
+
+        def self.add_helper(helper)
+          include helper
+        end
+
+        private
+        def compile_endnode(pre_path, endnode)
+          conditions = {}
+          conditions.merge!({request_method: endnode.rest.to_s.upcase}) if endnode.rest
+          method_call = [endnode.call]
+          method_call.unshift(master_params[:dispatcher])
+          # Here we call usher.
+          path(compile_path(pre_path, endnode), conditions: conditions).to(endnode.parent.klass.send(*method_call))
+        end
+
+        def compile_path(pre_path, endnode)
+          node = endnode.parent
+          compiled_path = [pre_path]
+          compiled_path << ":#{node.identifier}" if endnode.type == :member
+          compiled_path << "#{endnode.path}" unless endnode.path.empty?
+          compiled_path.join('/')
+        end
+
+      end
+    end
+  end
+end
+
+CRUDtree::Interface.register(:usher_rack, CRUDtree::Interface::Usher::Rack)

data/lib/crudtree/tree.rb

@@ -0,0 +1,3 @@
+require_relative 'tree/master'
+require_relative 'tree/node'
+require_relative 'tree/endnode'

data/lib/crudtree/tree/endnode.rb

@@ -0,0 +1,44 @@
+module CRUDtree
+  class EndNode
+    # The params Hash takes the following keys:
+    #
+    # :type
+    # may either be member or collection
+    #
+    # :path
+    # path to this endnode - you can use 
+    # join
+    # or
+    # join/:date/:foo/:whatever
+    # the interface will handle those parameters.
+    # Defaults to call.to_s
+    #
+    # :rest
+    # which REST method should match this route. Defaults to nil, aka all.
+    #
+    # :call
+    # The method to be called if this route is matched. Required.
+    #
+    # :name
+    # The name of this route, used for generating. Symbol.
+    # Defaults to call
+    # 
+    def initialize(parent, params)
+      @type = params[:type] if [:member, :collection].include? params[:type]
+      raise ArgumentError, "Invalid type: #{params[:type]}" unless @type
+      @call = params[:call] or raise ArgumentError, "No call given."
+      @path = params[:path] || @call.to_s
+      raise ArgumentError, "No path given." unless @path
+      @rest = params[:rest]
+      @name = params[:name] || @call
+      @parent = parent
+    end
+
+    attr_reader :type, :path, :rest, :call, :name, :parent
+
+    def collection?
+      type == :collection
+    end
+
+  end
+end

data/lib/crudtree/tree/master.rb

@@ -0,0 +1,20 @@
+module CRUDtree
+  class Master
+
+    # Use :rango => true if you're using rango
+    def initialize(params = {})
+      @nodes = []
+      @params = {dispatcher: :dispatcher}.merge(params)
+    end
+
+    attr_reader :nodes
+    attr_accessor :mapping, :params
+
+    alias_method :subs, :nodes
+
+    def node(params, &block)
+      @nodes << new_node = Node.new(self, params, &block)
+      new_node
+    end
+  end
+end

data/lib/crudtree/tree/node.rb

@@ -0,0 +1,129 @@
+module CRUDtree
+  class Node
+    # The params Hash takes the following keys:
+    #
+    # :klass
+    # The object where to send the method that is returned by the router.
+    # Mostly a class, therefore it's called 'class_name'. Defaults to nil,
+    # but the interface may complain. You have been warned ;).
+    # May be used by the interface as needed (Rango wants Class.send
+    # :dispatcher, :send_method)
+    #
+    # :identifier
+    # The identifier used to identify a resource, aka /user/:name instead of
+    # /user/:id (default).
+    #
+    # :default_collection
+    # The collection that is called when nothing is given. Defaults to :index.
+    #
+    # :default_member
+    # The member which is chosen when no method is given. Defaults to :show.
+    #
+    # :paths
+    # Specify the path(s) you want to call this resource with.
+    # Defaults to klass.to_s.downcase
+    # The first one is used for generation.
+    #
+    # Options used for generating
+    #
+    # :model
+    # The name of the model. Needed. We don't do magic here.
+    #
+    # :parent_call
+    # The method to call on the model object to get its parent (for nested
+    # resources). Defaults to :model.downcase of the parent.
+    #
+    # :name
+    # Symbol used to identify the node when generating a collection route.
+    # Defaults to Klass.to_s.downcase.to_sym
+    #
+    def initialize(parent, params, &block)
+      @klass = params[:klass]
+      @identifier = params[:identifier] || :id
+      @default_collection = params[:default_collection] || :index
+      @default_member = params[:default_member] || :show
+      @paths = if params[:paths]
+                 [params[:paths]].flatten
+               elsif params[:klass]
+                 [params[:klass].to_s.downcase.split("::").last]
+               else
+                raise ArgumentError, "No paths given"
+               end
+      @subnodes = []
+      @parent = parent
+      # default routes
+      @subnodes.unshift(EndNode.new(self, type: :member, call: :show, path: "", rest: :get))
+      @subnodes.unshift(EndNode.new(self, type: :collection, call: :index, path: "", rest: :get))
+      # generating
+      unless @model = params[:model]
+        raise(ArgumentError, "No model given.")
+      end
+      @parent_call =  if params[:parent_call]
+                        params[:parent_call]
+                      elsif ! parent_is_master?
+                        parent.model.to_s.split('::').last.downcase
+                      else
+                        nil
+                      end
+      @name = params[:name] || klass.to_s.downcase.to_sym
+      block ? instance_eval(&block) : raise(ArgumentError, "No block given.")
+    end
+
+    attr_reader :klass, :identifier, :default_collection, :default_member, :paths, :parent, :subnodes, :model, :parent_call, :name
+
+    # Creates a new End and attaches it to this Node.
+    def endnode(params)
+      @subnodes << EndNode.new(self, params)
+    end
+
+    # Creates a new endnode with type member. See Endnode.
+    def member(params)
+      endnode(params.merge({type: :member}))
+    end
+
+    # Creates a new endnode with type collection. See EndNode.
+    def collection(params)
+      endnode(params.merge({type: :collection}))
+    end
+
+    def node(params, &block)
+      @subnodes << Node.new(self, params, &block)
+    end
+
+    def parents
+      [find_parent(self)].flatten[0..-2]
+    end
+
+    def nodes
+      subnodes.select{|subnode| subnode.is_a? Node}
+    end
+
+    def endnodes
+      subnodes.select{|subnode| subnode.is_a? EndNode}
+    end
+
+    def parent_is_master?
+      ! parent.respond_to? :parent
+    end
+
+    # Duck typing used for generation
+    def path
+      @paths.first
+    end
+
+    def subs
+      endnodes
+    end
+
+    def collection?
+      false
+    end
+
+    private
+    def find_parent(node)
+      if node.parent.respond_to? :parent
+        [node.parent, find_parent(node.parent)]
+      end
+    end
+  end
+end