CRUDtree 0.1

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,42 @@
+= 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
+
+  CRUDtree::Interface.for(:usher_rack, rango: true).add_helper(CRUDtree::Interface::Helper)
+  
+  Usher::Interface.for(:rack) do
+    node(klass: Posts) do
+      sub(type: :member, call: :show, rest: :get)
+      sub(type: :collection, call: :index, rest: :get)
+    end
+  end
+
+=== As Dev
+
+  CRUDtree::Interface.for(:usher_rack, rango: true)
+  
+  Usher::Interface.for(:rack) do
+    resource(klass: Posts) 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,86 @@
+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 << resource
+        node = @master
+        url = ""
+      else
+        node, identifiers = find_node(resource)
+        url = generate_url_from_node(node, identifiers)
+      end
+      url << generate_from_sub(node, names) 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)
+      name = names.shift
+      sub = node.subs.find{|sub| sub.name == name} or raise(ArgumentError, "No subnode found on #{node} with name of #{name}.")
+      url = "/#{sub.path}"
+      url << generate_from_sub(sub, names) unless names.empty?
+      url
+    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: "")
+          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,40 @@
+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
+
+  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,121 @@
+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
+
+    private
+    def find_parent(node)
+      if node.parent.respond_to? :parent
+        [node.parent, find_parent(node.parent)]
+      end
+    end
+  end
+end

data/test/helper/suite/lib/generator.rb

@@ -0,0 +1,44 @@
+class Model0
+  def id
+    0
+  end
+end
+class Model1
+end
+class Model2
+  def id
+    2
+  end
+  def model0
+    Model0.new
+  end
+end
+class Klass0
+end
+class Klass1
+end
+class Klass2
+end
+
+class Mod0
+  def id
+    0
+  end
+end
+class Mod1
+  def id
+    1
+  end
+  def mod0
+    Mod0.new
+  end
+end
+class Mod2
+  def id
+    2
+  end
+  def initialize(parent = Mod0)
+    instance_variable_set("@#{parent.to_s.downcase}", parent.new)
+  end
+  attr_accessor :mod0, :mod1, :mod2
+end

data/test/helper/suite/lib/integration.rb

@@ -0,0 +1,9 @@
+module Usher
+  module Interface
+    def self.class_for(interface)
+      Rack
+    end
+    class Rack
+    end
+  end
+end

data/test/helper/suite/lib/interface/blackbox.rb

@@ -0,0 +1,36 @@
+def results_in(path, klass, call, params)
+  klass.expects(:dispatcher).with(call).returns(:yeah!)
+  to_mock = mock('to')
+  to_mock.expects(:to).with(:yeah!).returns(true)
+  Usher::Interface.class_for(:rack).any_instance.expects(:path).with(path, params).returns(to_mock)
+end
+
+module Usher; module Interface; class Rack;
+  include CRUDtree::Interface::Usher::Rack
+  def initialize(app = nil, options = nil, &block) 
+    instance_eval(&block) if block
+  end
+end; end; end
+class TestObj0; end
+class TestObj1; end
+class TestObj2; end
+
+def default_routes(number=0)
+  default_route(TestObj0)
+  default_route(TestObj1, "/testobj0/:id") if number > 0
+  default_route(TestObj2, "/testobj0/:id/testobj1/:id") if number > 1
+end
+
+def default_route(klass, pre_path=nil)
+  results_in("#{pre_path}/#{klass.to_s.downcase}", klass, :index, :conditions => {:request_method => "GET"})
+  results_in("#{pre_path}/#{klass.to_s.downcase}/:id", klass, :show, :conditions => {:request_method => "GET"})
+end
+module Usher
+  module Interface
+    def self.class_for(interface)
+      Rack
+    end
+    class Rack
+    end
+  end
+end

data/test/setup.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.expand_path("#{__FILE__}/../../lib")) # Add PROJECT/lib to $LOAD_PATH
+require 'crudtree'
+require 'baretest/mocha'
+include CRUDtree
+include Mocha::API
+require 'ruby-debug'

data/test/suite/lib/generator.rb

@@ -0,0 +1,218 @@
+require 'ostruct'
+BareTest.suite do
+
+  suite "CRUDtree" do
+
+    suite "Generator" do
+
+      suite "#generate_url_from_node" do
+
+        setup :node, "a simple node" do
+          @node = Node.new(nil, :paths => ["foo"], klass: Object, model: Object ){:foo}
+          @path = "/foo/23"
+          @identifiers = [23]
+        end
+
+        setup :node, "a node with multiple parents" do
+          master = Master.new
+          master.node(klass: Object, model: Object, paths: ["foo"]) do
+            node(klass: Object, model: Object, paths: ["bar"]) do
+              node(klass: Object, model: Object, paths: ["baz"]) {:foo}
+            end
+          end
+          @node = master.nodes.first.nodes.first.nodes.first
+          @path = "/foo/1/bar/2/baz/3"
+          @identifiers = [1,2,3]
+        end
+
+        assert ":node goes to the right path" do
+          equal(@path, CRUDtree::Generator.allocate.send(:generate_url_from_node, @node, @identifiers))
+        end
+
+      end
+
+      suite "#model_to_node" do
+
+        setup do
+          class TestObj0; end
+          class TestObj1; end
+        end
+
+        setup :master, "a simple master" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: ::TestObj0) {:foo}
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first
+          @model = ::TestObj0
+        end
+
+        setup :master, "a complex master" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: ::TestObj1){
+            node(klass: Object, model: ::TestObj0){:foo}
+          }
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first.nodes.first
+          @model = ::TestObj0
+        end
+
+        setup :master, "a master with duplicate models" do
+          master = CRUDtree::Master.new
+          master.node(klass: Object, model: TestObj1){
+            node(klass: Object, model: ::TestObj0){:foo}
+            node(klass: Object, model: ::TestObj0){:foo}
+          }
+          @generator = CRUDtree::Generator.new(master)
+          @node = master.nodes.first.nodes
+          @model = ::TestObj0
+        end
+
+        assert "The right model is found on :master." do
+          equal(@node, @generator.instance_variable_get(:@model_to_node)[@model])
+        end
+
+      end
+
+      suite "node finding" do
+
+        suite "without duplicates" do
+
+          setup do
+            @master = CRUDtree::Master.new
+          end
+
+          setup :master, "a simple master" do
+            @node = @master.node(klass: Klass0, model: Model0){:foo}
+            @resource = Model0.new
+            @valid = [[Model0.new, @node, ["0"]]]
+            @invalid = [[Model2.new, @node], [Model1.new, @node]]
+          end
+
+          setup :master, "a complex master" do
+            @master.node(klass: Klass0, model: Model0) do
+              node(klass: Klass1, model: Model1){:foo}
+              node(klass: Klass2, model: Model2){:foo}
+            end
+            @node = @master.nodes.first.nodes.last
+            @resource = Model2.new
+            @valid = [[Model2.new, @node, ["0","2"]], [Model0.new, @master.nodes.first, ["0"]]]
+            @invalid = [[Model0.new, @node], [Model1.new, @node]]
+          end
+
+          assert "#identifiers_returns the corret identifiers with :master" do
+            generator = CRUDtree::Generator.new(@master)
+            @valid.all?{|model, node, ary| generator.send(:identifiers_to_node, model, node) == ary}
+          end
+
+          assert "#identifiers returns false invalid with :master" do
+            generator = CRUDtree::Generator.new(@master)
+            @invalid.all?{|model, node| ! generator.send(:identifiers_to_node, model, node)}
+          end
+
+          assert "#find_node gets the correct node from :master" do
+            same(@node, CRUDtree::Generator.new(@master).send(:find_node, @resource).first)
+          end
+
+        end
+
+        suite "with duplicates" do
+
+          setup do
+            @master = Master.new
+            @master.node(klass: Klass0, model: Mod0) do
+              node(klass: Klass1, model: Mod1){:foo}
+              node(klass: Klass2, model: Mod2) do
+                node(klass: Klass2, model: Mod2){:foo}
+              end
+            end
+            @generator = CRUDtree::Generator.new(@master)
+          end
+
+          setup :node, "nested node" do
+            @node = @master.nodes.first.nodes.last.nodes.first
+            @resource = Mod2.new(Mod2)
+            @identifier = %w(0 2 2)
+          end
+
+          setup :node, "first node" do
+            @node = @master.nodes.first.nodes.last
+            @resource = Mod2.new(Mod0)
+            @identifier = %w(0 2)
+          end
+
+          assert "#identifiers_to_node returns an Array of identifiers for the :node" do
+            equal(@identifier, @generator.send(:identifiers_to_node, @resource, @node))
+          end
+
+          assert "#find_node gets :node based on the model" do
+            same(@node, @generator.send(:find_node, @resource).first)
+          end
+
+        end
+
+      end
+
+      suite "#generate_from_sub" do
+
+        setup do
+          @foo = OpenStruct.new(:name => :foo, :path => "foo")
+          @bar = OpenStruct.new(:name => :bar, :path => "bar")
+        end
+
+        setup :names, "one name" do
+          @node = OpenStruct.new(:subs => [@foo, @bar])
+          @names = [:foo]
+          @path = "/foo"
+        end
+
+        setup :names, "stacked names" do
+          @node = OpenStruct.new(:subs => [OpenStruct.new(:subs => [@foo, @bar], :name => :foo, :path => "foo"), @bar])
+          @names = [:foo, :bar]
+          @path = "/foo/bar"
+        end
+
+        assert "generates the correct url from :names" do
+          equal @path, Generator.allocate.send(:generate_from_sub, @node, @names)
+        end
+
+      end
+
+      suite "blackbox" do
+
+        setup do
+          @master = Master.new
+          @master.node(klass: Klass0, model: Mod0) do
+            node(klass: Klass1, model: Mod1){:foo}
+            node(klass: Klass2, model: Mod2) do
+              node(klass: Klass2, model: Mod2){:foo}
+            end
+          end
+          @generator = CRUDtree::Generator.new(@master)
+        end
+
+        setup :model, "model for the nested node" do
+          @resource = Mod2.new(Mod2)
+          @path = "/klass0/0/klass2/2/klass2/2"
+        end
+
+        setup :model, "model for the first node" do
+          @resource = Mod2.new(Mod0)
+          @path = "/klass0/0/klass2/2"
+        end
+
+        setup :model, "model for the simplest node" do
+          @resource = Mod0.new
+          @path = "/klass0/0"
+        end
+
+        assert "#generate" do
+          equal(@path, @generator.generate(@resource))
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/integration.rb

@@ -0,0 +1,33 @@
+require 'crudtree/interface/usher/rack'
+module Usher
+  module Interface
+    class Rack
+      def initialize(app = nil, options = nil, &blk)
+      end
+    end
+  end
+end
+
+BareTest.suite do
+
+  suite "CRUDtree" do
+
+    suite "integartion" do
+
+      suite "inclusion" do
+
+        setup do
+          CRUDtree::Interface.for(:usher_rack)
+        end
+
+        assert "the module gets included and the methods are avaible" do
+          Usher::Interface.class_for(:rack).new.respond_to? :node
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/interface/blackbox.rb

@@ -0,0 +1,132 @@
+BareTest.suite "CRUDtree" do
+
+  suite "blackbox" do
+
+    setup :tree, "a simple tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          collection(call: :index, rest: :get)
+        end
+      }
+      results_in("/testobj0/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes
+    end
+
+     setup :tree, "a nested tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          node(model: Object, klass: TestObj1) do
+            member(call: :show, rest: :get)
+          end
+        end
+      }
+      results_in("/testobj0/:id/testobj1/:id/show", TestObj1, :show, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes(1)
+     end
+
+     setup :tree, "a twice nested tree" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          node(model: Object, klass: TestObj1) do
+            node(model: Object, klass: TestObj2) do
+              collection(call: :create, rest: :post)
+            end
+          end
+        end
+      }
+      results_in("/testobj0/:id/testobj1/:id/testobj2/create", TestObj2, :create, :conditions => {:request_method => "POST"})
+      # default routes
+      default_routes(2)
+     end
+
+     setup :tree, "a tree with some subnodes" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          collection(call: :index, rest: :get)
+          member(call: :show, rest: :get)
+          member(call: :update, path: "edit", rest: :put)
+        end
+      }
+      results_in("/testobj0/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/edit", TestObj0, :update, :conditions => {:request_method => "PUT"})
+      results_in("/testobj0/:id/show", TestObj0, :show, :conditions => {:request_method => "GET"})
+      # default routes
+      default_routes
+     end
+
+     setup :tree, "a nested tree with some subnodes" do
+      @block = proc {
+        node(model: Object, klass: TestObj0) do
+          member(call: :show, rest: :get)
+          node(model: Object, klass: TestObj1) do
+            collection(call: :index, rest: :get)
+            member(call: :show, rest: :get)
+            member(call: :update, path: "edit", rest: :put)
+          end
+        end
+      }
+      results_in("/testobj0/:id/show", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/index", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/:id/show", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/testobj0/:id/testobj1/:id/edit", TestObj1, :update, :conditions => {:request_method => "PUT"})
+      # default routes
+      default_routes(1)
+     end
+
+     setup :tree, "a tree with multiple paths" do
+      @block = proc {
+        node(model: Object, paths: ["test", "foo", "bar"], klass: TestObj0) do
+          collection(call: :index, rest: :get)
+        end
+      }
+      results_in("/test/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      # default routes
+      results_in("/test", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/test/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+     end
+
+     setup :tree, "a nested tree with multiple paths" do
+      @block = proc {
+        node(model: Object, paths: ["foo", "bar"], klass: TestObj0) do
+          collection(call: :index, rest: :get)
+          node(model: Object, paths: ["test", "baz"], klass: TestObj1) do
+            member(call: :edit, rest: :get)
+          end
+        end
+      }
+      results_in("/foo/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/index", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz/:id/edit", TestObj1, :edit, :conditions => {:request_method => "GET"})
+      # default routes
+      results_in("/foo", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar", TestObj0, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id", TestObj0, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz", TestObj1, :index, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/test/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/test/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/foo/:id/baz/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+      results_in("/bar/:id/baz/:id", TestObj1, :show, :conditions => {:request_method => "GET"})
+     end
+
+    assert "compilation of :tree" do
+      Usher::Interface.class_for(:rack).new(&@block)
+    end
+
+  end
+
+end

data/test/suite/lib/interface/usher.rb

@@ -0,0 +1,55 @@
+require 'crudtree/interface/usher'
+require 'ostruct'
+
+module CRUDtree::Interface::Usher
+  public :compile_subnode, :compile_node
+  extend self
+end
+
+BareTest.suite "CRUDtree" do
+
+  suite "interface" do
+
+    suite "usher" do
+
+      suite "#compile_subnode" do
+
+        setup :subnode, "Node" do
+          @pre_path = "/foo"
+          @subnode = Node.new(nil, klass: Object, paths: "foo", model: Object) {:foo}
+          CRUDtree::Interface::Usher.expects(:compile_node).with("/foo/:id", @subnode).returns(true)
+        end
+
+        setup :subnode, "EndNode" do
+          @pre_path = ""
+          @subnode = EndNode.allocate
+          CRUDtree::Interface::Usher.expects(:compile_subnode).with(@pre_path, @subnode).returns(true)
+        end
+
+        assert "Compilation with a :subnode as subnode" do
+          CRUDtree::Interface::Usher.compile_subnode(@pre_path, @subnode)
+        end
+
+      end
+
+      suite "#compile_node" do
+
+        setup do
+          @subnode = Object.new
+          @pre_path = "/baz"
+          @node = OpenStruct.new(paths: ["foo", "bar"], subnodes: [@subnode])
+          CRUDtree::Interface::Usher.expects(:compile_subnode).with("/baz/foo", @subnode).returns(true)
+          CRUDtree::Interface::Usher.expects(:compile_subnode).with("/baz/bar", @subnode).returns(true)
+        end
+
+        assert "compilation" do
+          CRUDtree::Interface::Usher.compile_node(@pre_path, @node)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/interface/usher/rack.rb

@@ -0,0 +1,90 @@
+require 'crudtree/interface/usher/rack'
+require 'ostruct'
+
+
+
+BareTest.suite "CRUDtree" do
+
+  suite "interface" do
+
+    suite "usher" do
+
+      suite "rack" do
+
+        setup do
+          module CRUDtree::Interface::Usher::Rack
+            public :compile_path
+            extend self
+          end
+
+          class TestObj < Object; end
+          class TestObj2 < Object; end
+          class Cont1 < Object; end
+          class Cont2 < Object; end
+        end
+
+        suite "#compile_path" do
+
+          setup :subnode, "a simple member subnode" do
+            @pre_path = ""
+            @node = OpenStruct.new(klass: TestObj, identifier: :id, paths: "testobj")
+            @subnode = EndNode.new(@node, type: :member, call: :foo, name: "foo")
+            @path = "/testobj/:id/foo"
+            @params = {conditions: {}}
+            @send = [:foo]
+            @master_params = {}
+          end
+
+          setup :subnode, "a more complex collection subnode" do
+            @pre_path = "/bar"
+            @node = OpenStruct.new(klass: TestObj, identifier: :id, paths: "testobj")
+            @subnode = EndNode.new(@node, type: :collection, call: :foo, name: "foo")
+            @path = "/bar/testobj/foo"
+            @params = {conditions: {}}
+            @send = [:dispatcher, :foo]
+            @master_params = {rango: true}
+          end
+
+          setup :subnode, "a nested collection subnode" do
+            @pre_path = ""
+            @node1 = Node.new(nil, klass: Cont1, identifier: :id, paths: "cont1", model: Object){:foo}
+            @node2 = Node.new(@node1, klass: TestObj, model: Object){:foo}
+            @subnode = EndNode.new(@node2, type: :collection, call: :foo, name: "foo", model: Object)
+            @path = "/cont1/:id/testobj/foo"
+            @params = {conditions: {}}
+            @send = [:dispatcher, :foo]
+            @master_params = {rango: true}
+          end
+
+          setup :subnode, "a nested member subnode" do
+            @pre_path = ""
+            @node1 = Node.new(nil, klass: Cont1, identifier: :id, paths: "cont1", model: Object){:foo}
+            @node2 = Node.new(@node1, klass: TestObj, model: Object){:foo}
+            @subnode = EndNode.new(@node2, type: :member, call: :foo, name: "foo")
+            @path = "/cont1/:id/testobj/:id/foo"
+            @params = {conditions: {}}
+            @send = [:foo]
+            @master_params = {}
+          end
+
+          setup :foo, "Foo" do
+            TestObj.expects(:send).with(*@send).returns(:yeah)
+            TestObj2.any_instance.expects(:to).with(:yeah)
+            CRUDtree::Interface::Usher::Rack.expects(:master_params).returns(@master_params)
+            CRUDtree::Interface::Usher::Rack.expects(:path).with(@path, @params).returns(TestObj2.new)
+          end
+
+          assert "compilaton with :subnode" do
+            CRUDtree::Interface::Usher::Rack.compile_path(@pre_path, @subnode)
+            true
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/tree/endnode.rb

@@ -0,0 +1,27 @@
+BareTest.suite "CRUDtree" do
+
+  suite "tree" do
+
+    suite "EndNode" do
+
+      suite "initialize" do
+
+        assert ":type should only accept :member or :collection" do
+          raises(ArgumentError) {EndNode.new(nil, type: :foo, call: :foo)}
+        end
+
+        assert ":call should not accept an empty argument" do
+          raises(ArgumentError) {EndNode.new(nil, type: :member, path: "/foo")}
+        end
+
+        assert ":path should default to :call" do
+          EndNode.new(nil, type: :member, call: :foo, name: :foo).path == "foo"
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/suite/lib/tree/master.rb

@@ -0,0 +1,9 @@
+BareTest.suite "CRUDtree" do
+
+  suite "tree" do
+
+    suite "master"
+
+  end
+
+end

data/test/suite/lib/tree/node.rb

@@ -0,0 +1,91 @@
+BareTest.suite "CRUDtree" do
+
+  suite "tree" do
+
+    suite "node" do
+
+      suite "initialize" do
+        
+        suite "paths" do
+
+          assert "defaults to the name of the class" do
+            Node.new(nil, klass: Node, model: Object){:foo}.paths == ["node"]
+          end
+
+          assert "raises if no path is given" do
+            raises(ArgumentError) {Node.new(nil, foo: :bar){:foo}}
+          end
+
+        end
+
+        assert "raises if no block is given" do
+          raises(ArgumentError) {Node.new(nil, foo: :bar)}
+        end
+        
+      end
+
+      suite "extended subnodes" do
+
+        setup :method, "#member" do
+          @method = :member
+        end
+
+        setup :method, "#collection" do
+          @method = :collection
+        end
+
+        setup :node, "node" do
+          @node = Node.allocate
+          @params = {foo: :bar}
+          @result = @params.merge({type: @method})
+          @node.expects(:endnode).with(@result)
+        end
+
+        assert ":method" do
+          case @method
+          when :member
+            @node.member @params
+          when :collection
+            @node.collection @params
+          end
+          true
+        end
+
+      end
+
+      suite "tree walking" do
+
+        setup :master, "a simple master" do
+          @master = Master.new
+          @node = @master.node(klass: Object, model: Object){:foo}
+          @parents = []
+          @children = {}
+        end
+
+        suite "#parents" do
+
+          setup :master, "a more complex master" do
+            @master = Master.new
+            @master.node(klass: Object, model: Object){
+              node(klass: Object, model: Object){
+                node(klass: Object, model: Object){:foo}
+                node(klass: Object, model: Object){:foo}
+              }
+            }
+            @node = @master.nodes.first.nodes.first.nodes.first
+            @parents = [@master.nodes.first.nodes.first,@master.nodes.first]
+          end
+
+          assert "it find the parents in :master" do
+            equal(@node.parents, @parents)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: CRUDtree
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Simon Hafner aka Tass
+autorequire: 
+bindir: bin
+cert_chain: 
+date: 2010-01-25 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: hafnersimon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/crudtree/generator.rb
+- lib/crudtree/helper.rb
+- lib/crudtree/interface/usher/rack.rb
+- lib/crudtree/interface/usher.rb
+- lib/crudtree/interface.rb
+- lib/crudtree/tree/endnode.rb
+- lib/crudtree/tree/master.rb
+- lib/crudtree/tree/node.rb
+- lib/crudtree/tree.rb
+- lib/crudtree.rb
+- test/helper/suite/lib/generator.rb
+- test/helper/suite/lib/integration.rb
+- test/helper/suite/lib/interface/blackbox.rb
+- test/setup.rb
+- test/suite/lib/generator.rb
+- test/suite/lib/integration.rb
+- test/suite/lib/interface/blackbox.rb
+- test/suite/lib/interface/usher/rack.rb
+- test/suite/lib/interface/usher.rb
+- test/suite/lib/tree/endnode.rb
+- test/suite/lib/tree/master.rb
+- test/suite/lib/tree/node.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/Tass/CRUDtree
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ~>
+    - !ruby/object:Gem::Version 
+      version: "1.9"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A resource helper mainly for usher, but may be adapted for other routers as well.
+test_files: []
+