nested 0.0.24 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38c9a0d53765eb2f648f9d4f5ef2a9fb5fc4b528
-  data.tar.gz: 3d8212a2d22886567404470d0b288514a961f2b5
+  metadata.gz: da43c009c3ff14c2773df3a11e9ea8d5ae2f8de0
+  data.tar.gz: f63ecccb28294309d354362ca5bcff05937dd11a
 SHA512:
-  metadata.gz: 9e9ebefde4d1f116da2ceeaa625334d2eba6b1b54dcd45cf25e2c71f32722467b1bfbd9181f634c440704d19251cfe7fdcffd8ba4542011f48e70bde04b05698
-  data.tar.gz: 2d7284067772373590898e15fc13cfe8df87581c39c4f446360b82199a851e32dd7a788c6f97647067d85059a732f24b328ca3a437cd8c0df49980a541158b60
+  metadata.gz: dc57e5a73bea891b475bc0810cecd6b9e3f48f3710d173f6b30c358c5345bf19e5075c9e8424effaf46aa5196b23951b522e09e3c0e717f2c8b314ff3049a469
+  data.tar.gz: 3b753f26a8ac5d8d57133b707637e78ce1ce80751ae8132b3979be3037edb1030ab72415a789a74e4409f3ca9021fa158b5da150c6a55e0c5d3e83f14c6389d1

data/lib/nested.rb

@@ -2,9 +2,6 @@ require "json"
 
 module Nested
 
-  class OneWithNameInManyError < StandardError
-  end
-
   class ManyInManyError < StandardError
   end
 
@@ -21,23 +18,60 @@ module Nested
     end
   end
 
-  class Resource
-    FETCH = -> do
-      raise "implement fetch for resource #{@__resource.name}"  unless @__resource.parent
-      raise "implement fetch for singleton #{@__resource.name}" if @__resource.singleton?
+  class SerializerField
+    attr_accessor :name, :condition
+    def initialize(name, condition)
+      @name = name
+      @condition = condition
+    end
+  end
 
-      parent_resource = @__resource.parent
-      parent_obj = instance_variable_get("@#{parent_resource.instance_variable_name}")
+  class Serializer
+    attr_accessor :includes, :excludes
 
-      if @__resource.name
-        scope = parent_obj.send(@__resource.name.to_s.pluralize.to_sym)
-        @__resource.collection? ? scope : scope.where(id: params["#{@__resource.name.to_s.singularize}_id"]).first
-      else
-        parent_obj.where(id: params["#{parent_resource.name.to_s.singularize}_id"]).first
+    def initialize(includes=[])
+      @includes = includes.clone
+      @excludes = []
+    end
+
+    def +(field)
+      field = field.is_a?(SerializerField) ? field : SerializerField.new(field, ->{ true })
+
+      @includes << field unless @includes.detect{|e| e.name == field.name}
+      @excludes = @excludes.reject{|e| e.name == field.name}
+      self
+    end
+
+    def -(field)
+      field = field.is_a?(SerializerField) ? field : SerializerField.new(field, ->{ true })
+
+      @excludes << field unless @excludes.detect{|e| e.name == field.name}
+      self
+    end
+
+    def serialize
+      this = self
+      ->(obj) do
+        excludes = this.excludes.select{|e| instance_exec(&e.condition)}
+
+        this.includes.reject{|e| excludes.detect{|e2| e2.name == e.name}}.inject({}) do |memo, field|
+          if instance_exec(&field.condition)
+            case field.name
+              when Symbol
+                memo[field.name] = obj.is_a?(Hash) ? obj[field.name] : obj.send(field.name)
+              when Hash
+                field_name, proc = field.name.to_a.first
+                memo[field_name] = instance_exec(obj, &proc)
+            end
+          end
+          memo
+        end
       end
     end
+  end
 
-    attr_reader :name, :parent, :actions, :resources
+  class Resource
+    attr_reader :name, :parent, :actions, :resources, :serializer
 
     def initialize(sinatra, name, singleton, collection, parent, init_block)
       raise SingletonAndCollectionError.new if singleton && collection
@@ -50,18 +84,10 @@ module Nested
       @parent = parent
       @resources = []
       @actions = []
+      @init_block = init_block
+      @run_blocks = []
 
-      init &-> do
-        fetched = instance_exec(&(init_block||FETCH))
-
-        # puts "set @#{@__resource.instance_variable_name} to #{fetched.inspect} for #{self}"
-        # self.instance_variable_set("@#{@__resource.instance_variable_name}", fetched)
-        @__resource.sinatra_set_instance_variable(self, @__resource.instance_variable_name, fetched)
-      end
-
-      if member?
-        serialize *@parent.instance_variable_get("@__serialize_args")
-      end
+      @serializer = Serializer.new(member? ? parent.serializer.includes : [])
     end
 
     def singleton?
@@ -76,6 +102,11 @@ module Nested
       @collection == true
     end
 
+    def run(&block)
+      @run_blocks << block
+      self
+    end
+
     def type
       if singleton?
         :singleton
@@ -89,46 +120,34 @@ module Nested
     end
 
     def serialize(*args)
-      @__serialize_args = args
-
-      @__serialize = ->(obj) do
-        args.inject({}) do |memo, field|
-          case field
-            when Symbol
-              memo[field] = obj.is_a?(Hash) ? obj[field] : obj.send(field)
-            when Hash
-              field, proc = field.to_a.first
-              memo[field] = self.instance_exec(obj, &proc)
-          end
-          memo
-        end
-      end
+      args.each {|arg| serializer + arg }
+      serializer
     end
 
-    def init(&block)
-      @__init = block
+    def serialize_include_if(condition, *args)
+      args.each {|arg| @serializer + SerializerField.new(arg, condition) }
     end
 
-    def route(args={}, action=nil)
+    def serialize_exclude_if(condition, *args)
+      args.each {|arg| @serializer - SerializerField.new(arg, condition) }
+    end
+
+    def route_replace(route, args)
+      args.each do |k, v|
+        route = route.gsub(":#{k}", "#{v}")
+      end
+      route
+    end
+
+    def route(action=nil)
       "".tap do |r|
-        r << @parent.route(args) if @parent
+        r << @parent.route if @parent
 
-        if singleton?
-          r << "/" + @name.to_s.singularize
-        elsif collection?
-          r << "/" + @name.to_s.pluralize
-        else
-          if @name
-            r << "/" + @name.to_s.pluralize
-          end
-          r << "/"
-          key = ((@name || @parent.name).to_s.singularize + "_id").to_sym
 
-          if args.key?(key)
-            r << args[key].to_s
-          else
-            r << ":#{key}"
-          end
+        if singleton? || collection?
+          r << "/#{@name}"
+        else
+          r << "/:#{@name}_id"
         end
 
         r << "/#{action}" if action
@@ -152,17 +171,45 @@ module Nested
     end
 
     def singleton(name, init_block=nil, &block)
-      child_resource(name, true, false, init_block, &block)
+      child_resource(name, true, false, init_block, &(block||Proc.new{ }))
     end
 
     def many(name, init_block=nil, &block)
       raise ManyInManyError.new "do not nest many in many" if collection?
-      child_resource(name, false, true, init_block, &block)
+      child_resource(name, false, true, init_block, &(block||Proc.new{ }))
+    end
+
+    def default_init_block_singleton
+      if parent
+        Proc.new{ instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name) }
+      else
+        Proc.new { nil }
+      end
+    end
+
+    def default_init_block_many
+      if parent
+        Proc.new{ instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name) }
+      else
+        Proc.new { nil }
+      end
     end
 
-    def one(name=nil, init_block=nil, &block)
-      raise OneWithNameInManyError.new("call one (#{name}) without name argument when nested in a many (#{@name})") if name && collection?
-      child_resource(name, false, false, init_block, &block)
+    def default_init_block_one
+      if parent
+        Proc.new do
+          instance_variable_get("@#{@__resource.parent.instance_variable_name}")
+            .where(id: params[:"#{@__resource.parent.name.to_s.singularize.to_sym}_id"])
+            .first
+        end
+      else
+        Proc.new { nil }
+      end
+    end
+
+    def one(&block)
+      raise "calling one() is only allowed within many() resource" unless collection?
+      child_resource(self.name.to_s.singularize.to_sym, false, false, nil, &(block||Proc.new{ }))
     end
 
     def child_resource(name, singleton, collection, init_block, &block)
@@ -172,13 +219,7 @@ module Nested
     end
 
     def instance_variable_name
-      if @name
-        @name.to_s.send(collection? ? :pluralize : :singularize).to_sym
-      elsif member? && @parent
-        @parent.name.to_s.singularize.to_sym
-      else
-        nil
-      end
+      member? ? parent.name.to_s.singularize.to_sym : @name
     end
 
     def parents
@@ -198,7 +239,22 @@ module Nested
 
     def sinatra_init(sinatra)
       sinatra.instance_variable_set("@__resource", self)
-      sinatra.instance_exec(&@__init)
+
+      init_block = if @init_block
+        @init_block
+      else
+        if singleton?
+          default_init_block_singleton
+        elsif collection?
+          default_init_block_many
+        else
+          default_init_block_one
+        end
+      end
+
+      sinatra.instance_variable_set("@#{self.instance_variable_name}", sinatra.instance_exec(&init_block))
+
+      @run_blocks.each{|e| sinatra.instance_exec(&e)}
     end
 
     def sinatra_exec_get_block(sinatra, &block)
@@ -267,9 +323,9 @@ module Nested
 
     def sinatra_response_create_data(sinatra, response, method)
       data = if response && (collection? || response.is_a?(Array)) && method != :post
-        response.to_a.map{|e| sinatra.instance_exec(e, &@__serialize) }
+        response.to_a.map{|e| sinatra.instance_exec(e, &@serializer.serialize) }
       else
-        sinatra.instance_exec(response, &@__serialize)
+        sinatra.instance_exec(response, &@serializer.serialize)
       end
 
       {data: data, ok: true}
@@ -292,8 +348,7 @@ module Nested
 
       resource = self
 
-      route = resource.route({}, action)
-      puts "sinatra router [#{method}] #{@sinatra.nested_config[:prefix]}#{route}"
+      route = resource.route(action)
 
       @sinatra.send(method, route) do
         def self.error(message)
@@ -319,10 +374,19 @@ module Nested
           context_arr << "route: #{route}"
           context_arr << "method: #{method}"
           context_arr << "action: #{action}"
-          context_arr << "resource: #{resource.name} (#{resource.type})"
 
+          context_arr << "resource: #{resource.name} (#{resource.type})"
           resource_object = instance_variable_get("@#{resource.instance_variable_name}")
           context_arr << "@#{resource.instance_variable_name}: #{resource_object.inspect}"
+
+          parent = resource.try(:parent)
+
+          if parent
+            context_arr << "parent: #{parent.try(:name)} (#{parent.try(:type)})"
+            parent_object = instance_variable_get("@#{parent.try(:instance_variable_name)}")
+            context_arr << "@#{parent.try(:instance_variable_name)}: #{parent_object.inspect}"
+          end
+
           puts context_arr.join("\n")
           raise e
         end
@@ -365,7 +429,7 @@ module Nested
           memo[:"#{e}_id"] = "'+(typeof(values[#{idx}]) == 'number' ? values[#{idx}].toString() : (values[#{idx}].id || values[#{idx}]))+'"
           memo
         end
-        route = "#{self.nested_config[:prefix]}" + resource.route(route_args, action)
+        route = "#{self.nested_config[:prefix]}" + resource.route_replace(resource.route(action), route_args)
         when_args = args.map{|a| "$q.when(#{a})"}
 
         js << "  impl.#{fun_name}Url = function(#{args.join(',')}){"
@@ -457,29 +521,21 @@ module Nested
       arr << "create" if method == :post
       arr << "destroy" if method == :delete
 
-      parents = resource.parents
-      parents.each_with_index do |p, idx|
-        if p.collection? && method != :post && ((parents[idx + 1] && parents[idx + 1].singleton?) || parents.last == p)
-          arr << p.name.to_s.send(:pluralize)
-        else
-          arr << p.name.to_s.send(:singularize)
-        end
-      end
+      all = resource.self_and_parents.reverse
 
-      if resource.member?
-        if resource.parent
-          arr = arr.slice(0...-1)
-          arr << resource.parent.name.to_s.send(:singularize)
-        else
-          arr << resource.name.to_s.send(:singularize)
-        end
-      elsif resource.singleton?
-        arr << resource.name.to_s.send(:singularize)
-      elsif resource.collection?
-        if method == :post
-          arr << resource.name.to_s.send(:singularize)
+      all.each do |e|
+        if e.collection?
+          if e == all.last
+            if method == :post
+              arr << e.name.to_s.singularize.to_sym
+            else
+              arr << e.name
+            end
+          else
+            arr << e.name unless all[all.index(e) + 1].member?
+          end
         else
-          arr << resource.name.to_s.send(:pluralize)
+          arr << e.name
         end
       end
 
@@ -512,9 +568,6 @@ module Nested
     def many(name, init_block=nil, &block)
       create_resource(name, false, true, init_block, &block)
     end
-    def one(name, init_block=nil, &block)
-      create_resource(name, false, false, init_block, &block)
-    end
     def create_resource(name, singleton, collection, init_block, &block)
       ::Nested::Resource.new(self, name, singleton, collection, nil, init_block).tap{|r| r.instance_eval(&block) }
     end

data/nested.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name               = "nested"
-  s.version            = "0.0.24"
+  s.version            = "0.0.25"
 
   s.authors = ["Jan Zimmek"]
   s.email = %q{jan.zimmek@web.de}

data/test/nested_test.rb

@@ -4,20 +4,11 @@ require "active_support/all"
 require "active_model/errors"
 require "active_record"
 require "nested"
+require "./test/test_helper"
 
 class NestedTest < Test::Unit::TestCase
 
-  def singleton!
-    @r = Nested::Resource.new(@sinatra, :project, true, false, nil, nil)
-  end
-
-  def collection!
-    @r = Nested::Resource.new(@sinatra, :project, false, true, nil, nil)
-  end
-
-  def member!
-    @r = Nested::Resource.new(@sinatra, :project, false, false, nil, nil)
-  end
+  include TestHelper
 
   def setup
     @sinatra = mock
@@ -34,481 +25,334 @@ class NestedTest < Test::Unit::TestCase
   end
 
   def test_is_singleton
-    singleton!
-    assert_equal true, @r.singleton?
-
-    collection!
-    assert_equal false, @r.singleton?
+    assert_equal true, singleton(:project).singleton?
+    assert_equal false, many(:projects).singleton?
+    assert_equal false, many(:projects).one.singleton?
   end
 
   def test_is_collection
-    collection!
-    assert_equal true, @r.collection?
-
-    singleton!
-    assert_equal false, @r.collection?
+    assert_equal true, many(:projects).collection?
+    assert_equal false, many(:projects).one.collection?
+    assert_equal false, singleton(:project).collection?
   end
 
   def test_is_member
-    member!
-    assert_equal true, @r.member?
-
-    singleton!
-    assert_equal false, @r.member?
-
-    collection!
-    assert_equal false, @r.member?
+    assert_equal true, many(:projects).one.member?
+    assert_equal false, many(:projects).member?
+    assert_equal false, singleton(:project).member?
   end
 
-  def test_init
-    singleton!
-
-    init = -> { }
-    @r.init &init
-
-    assert_equal init, @r.instance_variable_get("@__init")
-  end
+  # def test_init
+  #   init = ->{ }
+  #   assert_equal init, singleton(:project).init(&init).instance_variable_get("@__init")
+  # end
 
   def test_serialize
-    singleton!
+    serializer = mock()
 
-    @r.serialize :name
+    r = singleton(:project)
+    r.stubs(:serializer).returns(serializer)
 
-    assert_equal({name: :joe}, @r.instance_variable_get("@__serialize").call({name: :joe, test: true}))
-  end
+    assert_equal serializer, r.serialize
 
-  def test_route
-    # no parent
-    singleton!
-    assert_equal "/project", @r.route
-
-    collection!
-    assert_equal "/projects", @r.route
-
-    member!
-    assert_equal "/projects/:project_id", @r.route
-    assert_equal "/projects/1", @r.route(project_id: 1)
-
-    member!
-    assert_equal "/projects/:project_id/myaction", @r.route({}, :myaction)
-    assert_equal "/projects/1/myaction", @r.route({project_id: 1}, :myaction)
+    serializer.expects(:+).with(:name)
+    r.serialize :name
+  end
 
-    # --- singleton
+  def test_route_replace
+    resource = many(:projects).one
 
-    singleton!
-    @r2 = @r.singleton(:statistic) { }
-    assert_equal "/project/statistic", @r2.route
+    assert_equal "/projects/1", resource.route_replace(resource.route, project_id: 1)
+    assert_equal "/projects/1/myaction", resource.route_replace(resource.route(:myaction), project_id: 1)
 
-    singleton!
-    @r2 = @r.many(:statistics) { }
-    assert_equal "/project/statistics", @r2.route
+    resource = singleton(:project).many(:statistics).one
+    assert_equal "/project/statistics/1", resource.route_replace(resource.route, statistic_id: 1)
 
-    singleton!
-    @r2 = @r.one(:statistic) { }
-    assert_equal "/project/statistics/:statistic_id", @r2.route
-    assert_equal "/project/statistics/1", @r2.route(statistic_id: 1)
+    resource = singleton(:project).many(:statistics).one.singleton(:today)
+    assert_equal "/project/statistics/1/today", resource.route_replace(resource.route, statistic_id: 1)
 
-    # --- collection
+    resource = singleton(:project).many(:statistics).one.many(:entries)
+    assert_equal "/project/statistics/1/entries", resource.route_replace(resource.route, statistic_id: 1)
 
-    collection!
-    @r2 = @r.singleton(:statistic) { }
-    assert_equal "/projects/statistic", @r2.route
+    resource = singleton(:project).many(:statistics).one.many(:entries).one
+    assert_equal "/project/statistics/1/entries/2", resource.route_replace(resource.route, statistic_id: 1, entry_id: 2)
+  end
 
-    collection!
-    @r2 = @r.one { }
-    assert_equal "/projects/:project_id", @r2.route
-    assert_equal "/projects/1", @r2.route(project_id: 1)
+  def test_route
+    assert_equal "/project", singleton(:project).route
+    assert_equal "/projects", many(:projects).route
 
-    # --- member
+    assert_equal "/projects/:project_id", many(:projects).one.route
+    assert_equal "/projects/:project_id/myaction", many(:projects).one.route(:myaction)
 
-    member!
-    @r2 = @r.singleton(:statistic) { }
-    assert_equal "/projects/:project_id/statistic", @r2.route
-    assert_equal "/projects/1/statistic", @r2.route(project_id: 1)
+    assert_equal "/project/statistic", singleton(:project).singleton(:statistic).route
+    assert_equal "/project/statistics", singleton(:project).many(:statistics).route
 
-    member!
-    @r2 = @r.many(:statistic) { }
-    assert_equal "/projects/:project_id/statistics", @r2.route
-    assert_equal "/projects/1/statistics", @r2.route(project_id: 1)
+    assert_equal "/project/statistics/:statistic_id", singleton(:project).many(:statistics).one.route
+    assert_equal "/project/statistics/:statistic_id/today", singleton(:project).many(:statistics).one.singleton(:today).route
 
-    member!
-    @r2 = @r.one(:statistic) { }
-    assert_equal "/projects/:project_id/statistics/:statistic_id", @r2.route
-    assert_equal "/projects/1/statistics/2", @r2.route(project_id: 1, statistic_id: 2)
+    assert_equal "/project/statistics/:statistic_id/entries", singleton(:project).many(:statistics).one.many(:entries).route
+    assert_equal "/project/statistics/:statistic_id/entries/:entry_id", singleton(:project).many(:statistics).one.many(:entries).one.route
   end
 
 
   def test_singleton
-    singleton!
-    @r.expects(:child_resource).with(:statistic, true, false, nil)
-    @r.singleton(:statistic)
+    resource = singleton(:project)
+    resource.expects(:child_resource).with(:statistic, true, false, nil)
+    resource.singleton(:statistic)
 
-    member!
-    @r.expects(:child_resource).with(:statistic, true, false, nil)
-    @r.singleton(:statistic)
+    resource = many(:projects)
+    resource.expects(:child_resource).with(:statistic, true, false, nil)
+    resource.singleton(:statistic)
 
-    collection!
-    @r.expects(:child_resource).with(:statistic, true, false, nil)
-    @r.singleton(:statistic)
+    resource = many(:projects).one
+    resource.expects(:child_resource).with(:statistic, true, false, nil)
+    resource.singleton(:statistic)
   end
 
   def test_one
-    singleton!
-    @r.expects(:child_resource).with(:statistic, false, false, nil)
-    @r.one(:statistic)
-
-    member!
-    @r.expects(:child_resource).with(:statistic, false, false, nil)
-    @r.one(:statistic)
-
-    collection!
-    @r.expects(:child_resource).with(nil, false, false, nil)
-    @r.one
-
-    collection!
-    assert_raise ::Nested::OneWithNameInManyError do
-      @r.one :statistic
-    end
+    resource = many(:projects)
+    resource.expects(:child_resource).with(:project, false, false, nil)
+    resource.one
   end
 
   def test_many
-    singleton!
-    @r.expects(:child_resource).with(:statistics, false, true, nil)
-    @r.many(:statistics)
-
-    member!
-    @r.expects(:child_resource).with(:statistics, false, true, nil)
-    @r.many(:statistics)
+    resource = singleton(:project)
+    resource.expects(:child_resource).with(:statistics, false, true, nil)
+    resource.many(:statistics)
 
-    collection!
-    assert_raise ::Nested::ManyInManyError do
-      @r.many :statistic
-    end
+    resource = singleton(:project).many(:statistics).one
+    resource.expects(:child_resource).with(:entries, false, true, nil)
+    resource.many(:entries)
   end
 
   def test_get
-    singleton!
+    resource = singleton(:project)
 
-    @r.expects(:create_sinatra_route).with(:get, nil)
-    @r.get
+    resource.expects(:create_sinatra_route).with(:get, nil)
+    resource.get
 
-    @r.expects(:create_sinatra_route).with(:get, :action)
-    @r.get :action
+    resource.expects(:create_sinatra_route).with(:get, :action)
+    resource.get :action
   end
 
   def test_post
-    singleton!
+    resource = singleton(:project)
 
-    @r.expects(:create_sinatra_route).with(:post, nil)
-    @r.post
+    resource.expects(:create_sinatra_route).with(:post, nil)
+    resource.post
 
-    @r.expects(:create_sinatra_route).with(:post, :action)
-    @r.post :action
+    resource.expects(:create_sinatra_route).with(:post, :action)
+    resource.post :action
   end
 
   def test_put
-    singleton!
+    resource = singleton(:project)
 
-    @r.expects(:create_sinatra_route).with(:put, nil)
-    @r.put
+    resource.expects(:create_sinatra_route).with(:put, nil)
+    resource.put
 
-    @r.expects(:create_sinatra_route).with(:put, :action)
-    @r.put :action
+    resource.expects(:create_sinatra_route).with(:put, :action)
+    resource.put :action
   end
 
   def test_delete
-    singleton!
+    resource = singleton(:project)
 
-    @r.expects(:create_sinatra_route).with(:delete, nil)
-    @r.delete
+    resource.expects(:create_sinatra_route).with(:delete, nil)
+    resource.delete
 
-    @r.expects(:create_sinatra_route).with(:delete, :action)
-    @r.delete :action
+    resource.expects(:create_sinatra_route).with(:delete, :action)
+    resource.delete :action
   end
 
   def test_child_resource
-    singleton!
-    r = @r.child_resource(:statistic, false, false, nil) { }
-    assert_equal :statistic, r.name
-    assert_equal false, r.instance_variable_get("@singleton")
-    assert_equal false, r.instance_variable_get("@collection")
-
-    singleton!
-    r = @r.child_resource(:statistic, true, false, nil) { }
-    assert_equal :statistic, r.name
-    assert_equal true, r.instance_variable_get("@singleton")
-    assert_equal false, r.instance_variable_get("@collection")
-
-    singleton!
-    r = @r.child_resource(:statistic, false, true, nil) { }
-    assert_equal :statistic, r.name
-    assert_equal false, r.instance_variable_get("@singleton")
-    assert_equal true, r.instance_variable_get("@collection")
-
-    singleton!
-    assert_raise Nested::SingletonAndCollectionError do
-      @r.child_resource(:statistic, true, true, nil) { }
-    end
+    resource = singleton(:project).child_resource(:statistic, false, false, nil) { }
+    assert_equal :statistic, resource.name
+    assert_equal false, resource.instance_variable_get("@singleton")
+    assert_equal false, resource.instance_variable_get("@collection")
+
+    resource = singleton(:project).child_resource(:statistic, true, false, nil) { }
+    assert_equal :statistic, resource.name
+    assert_equal true, resource.instance_variable_get("@singleton")
+    assert_equal false, resource.instance_variable_get("@collection")
+
+    resource = singleton(:project).child_resource(:statistic, false, true, nil) { }
+    assert_equal :statistic, resource.name
+    assert_equal false, resource.instance_variable_get("@singleton")
+    assert_equal true, resource.instance_variable_get("@collection")
   end
 
   def test_instance_variable_name
-    singleton!
-    assert_equal :project, @r.instance_variable_name
-
-    member!
-    assert_equal :project, @r.instance_variable_name
-
-    collection!
-    assert_equal :projects, @r.instance_variable_name
-
-    collection!
-    r2 = @r.one {}
-    assert_equal :project, r2.instance_variable_name
+    assert_equal :project, singleton(:project).instance_variable_name
+    assert_equal :projects, many(:projects).instance_variable_name
+    assert_equal :project, many(:projects).one.instance_variable_name
   end
 
   def test_parents
-    singleton!
-    assert_equal [], @r.parents
+    r1 = singleton(:project)
+    r2 = r1.many(:todos)
+    r3 = r2.one
 
-    r2 = @r.singleton(:statistic) { }
-    assert_equal [@r], r2.parents
-
-    r3 = r2.singleton(:statistic) { }
-    assert_equal [@r, r2], r3.parents
+    assert_equal [], r1.parents
+    assert_equal [r1], r2.parents
+    assert_equal [r1, r2], r3.parents
   end
 
   def test_self_and_parents
-    singleton!
-    assert_equal [@r], @r.self_and_parents
-
-    r2 = @r.singleton(:statistic) { }
-    assert_equal [r2, @r], r2.self_and_parents
+    r1 = singleton(:project)
+    r2 = r1.many(:todos)
+    r3 = r2.one
 
-    r3 = r2.singleton(:statistic) { }
-    assert_equal [r3, r2, @r], r3.self_and_parents
+    assert_equal [r1], r1.self_and_parents
+    assert_equal [r2, r1], r2.self_and_parents
+    assert_equal [r3, r2, r1], r3.self_and_parents
   end
 
   def test_create_sinatra_route
-    @sinatra.expects(:nested_config).at_least_once.returns({})
-
-    singleton!
+    # get
 
     @sinatra.expects(:send).with(:get, "/project")
-    block = ->{ }
-    @r.create_sinatra_route(:get, nil, &block)
-    assert_equal [{method: :get, action: nil, block: block}], @r.actions
+    singleton(:project).get
 
-    singleton!
+    @sinatra.expects(:send).with(:get, "/project/action")
+    singleton(:project).get(:action)
 
-    @sinatra.expects(:send).with(:post, "/project")
-    @r.create_sinatra_route(:post, nil, &block)
-    assert_equal [{method: :post, action: nil, block: block}], @r.actions
+    # post
 
-    singleton!
+    @sinatra.expects(:send).with(:post, "/project")
+    singleton(:project).post
 
     @sinatra.expects(:send).with(:post, "/project/action")
-    @r.create_sinatra_route(:post, :action, &block)
-    assert_equal [{method: :post, action: :action, block: block}], @r.actions
-  end
+    singleton(:project).post(:action)
 
-  def test_serializer
-    singleton!
+    # put
 
-    @r.serialize :name
+    @sinatra.expects(:send).with(:put, "/project")
+    singleton(:project).put
 
-    assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call({name: "joe"}))
-    assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call({name: "joe", boss: true}))
-    assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call(OpenStruct.new({name: "joe"})))
+    @sinatra.expects(:send).with(:put, "/project/action")
+    singleton(:project).put(:action)
 
-    @r.serialize :name, virtual: ->(o){ o[:name] + "!!" }
-    assert_equal({name: "joe", virtual: "joe!!"}, @r.instance_variable_get("@__serialize").call({name: "joe"}))
-  end
-
-  # ----
+    # delete
 
-  def test_sinatra_response_type
-    singleton!
-    assert_equal :error, @r.sinatra_response_type(ActiveModel::Errors.new({}))
-
-    obj = OpenStruct.new(errors: ActiveModel::Errors.new({}))
-    assert_equal :data, @r.sinatra_response_type(obj)
+    @sinatra.expects(:send).with(:delete, "/project")
+    singleton(:project).delete
 
-    obj.errors.add(:somefield, "some error")
-    assert_equal :error, @r.sinatra_response_type(obj)
-
-    assert_equal :data, @r.sinatra_response_type(nil)
-    assert_equal :data, @r.sinatra_response_type(123)
+    @sinatra.expects(:send).with(:delete, "/project/action")
+    singleton(:project).delete(:action)
   end
 
 
-  # ----
-
-
-  def test_function_name
-    singleton!
-    assert_equal "project", Nested::JsUtil::generate_function_name(@r, :get, nil)
-    assert_equal "updateProject", Nested::JsUtil::generate_function_name(@r, :put, nil)
-    assert_equal "createProject", Nested::JsUtil::generate_function_name(@r, :post, nil)
-    assert_equal "destroyProject", Nested::JsUtil::generate_function_name(@r, :delete, nil)
-
-    assert_equal "projectAction", Nested::JsUtil::generate_function_name(@r, :get, :action)
-    assert_equal "updateProjectAction", Nested::JsUtil::generate_function_name(@r, :put, :action)
-    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(@r, :post, :action)
-    assert_equal "destroyProjectAction", Nested::JsUtil::generate_function_name(@r, :delete, :action)
-
-    collection!
-    assert_equal "projects", Nested::JsUtil::generate_function_name(@r, :get, nil)
-    assert_equal "updateProjects", Nested::JsUtil::generate_function_name(@r, :put, nil)
-    assert_equal "createProject", Nested::JsUtil::generate_function_name(@r, :post, nil)
-    assert_equal "destroyProjects", Nested::JsUtil::generate_function_name(@r, :delete, nil)
-
-    assert_equal "projectsAction", Nested::JsUtil::generate_function_name(@r, :get, :action)
-    assert_equal "updateProjectsAction", Nested::JsUtil::generate_function_name(@r, :put, :action)
-    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(@r, :post, :action)
-    assert_equal "destroyProjectsAction", Nested::JsUtil::generate_function_name(@r, :delete, :action)
-
-    member!
-    assert_equal "project", Nested::JsUtil::generate_function_name(@r, :get, nil)
-    assert_equal "updateProject", Nested::JsUtil::generate_function_name(@r, :put, nil)
-    assert_equal "createProject", Nested::JsUtil::generate_function_name(@r, :post, nil)
-    assert_equal "destroyProject", Nested::JsUtil::generate_function_name(@r, :delete, nil)
+  # def test_serializer
+  #   singleton!
 
-    assert_equal "projectAction", Nested::JsUtil::generate_function_name(@r, :get, :action)
-    assert_equal "updateProjectAction", Nested::JsUtil::generate_function_name(@r, :put, :action)
-    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(@r, :post, :action)
-    assert_equal "destroyProjectAction", Nested::JsUtil::generate_function_name(@r, :delete, :action)
+  #   @r.serialize :name
 
+  #   assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call({name: "joe"}))
+  #   assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call({name: "joe", boss: true}))
+  #   assert_equal({name: "joe"}, @r.instance_variable_get("@__serialize").call(OpenStruct.new({name: "joe"})))
 
-    # with parent
+  #   @r.serialize :name, virtual: ->(o){ o[:name] + "!!" }
+  #   assert_equal({name: "joe", virtual: "joe!!"}, @r.instance_variable_get("@__serialize").call({name: "joe"}))
+  # end
 
-    singleton!
+  # # ----
 
-    r2 = @r.singleton(:statistic) {}
+  def test_sinatra_response_type
+    assert_equal :error, singleton(:project).sinatra_response_type(ActiveModel::Errors.new({}))
 
-    assert_equal "projectStatistic", Nested::JsUtil::generate_function_name(r2, :get, nil)
-    assert_equal "updateProjectStatistic", Nested::JsUtil::generate_function_name(r2, :put, nil)
-    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(r2, :post, nil)
-    assert_equal "destroyProjectStatistic", Nested::JsUtil::generate_function_name(r2, :delete, nil)
+    obj = OpenStruct.new(errors: ActiveModel::Errors.new({}))
+    assert_equal :data, singleton(:project).sinatra_response_type(obj)
 
-    assert_equal "projectStatisticAction", Nested::JsUtil::generate_function_name(r2, :get, :action)
-    assert_equal "updateProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :put, :action)
-    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :post, :action)
-    assert_equal "destroyProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :delete, :action)
+    obj.errors.add(:somefield, "some error")
+    assert_equal :error, singleton(:project).sinatra_response_type(obj)
 
-    member!
+    assert_equal :data, singleton(:project).sinatra_response_type(nil)
+    assert_equal :data, singleton(:project).sinatra_response_type(123)
+  end
 
-    r2 = @r.singleton(:statistic) {}
 
-    assert_equal "projectStatistic", Nested::JsUtil::generate_function_name(r2, :get, nil)
-    assert_equal "updateProjectStatistic", Nested::JsUtil::generate_function_name(r2, :put, nil)
-    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(r2, :post, nil)
-    assert_equal "destroyProjectStatistic", Nested::JsUtil::generate_function_name(r2, :delete, nil)
+  # # ----
 
-    assert_equal "projectStatisticAction", Nested::JsUtil::generate_function_name(r2, :get, :action)
-    assert_equal "updateProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :put, :action)
-    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :post, :action)
-    assert_equal "destroyProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :delete, :action)
+  def test_function_name
+    resource = singleton(:project)
 
-    collection!
+    assert_equal "project", Nested::JsUtil::generate_function_name(resource, :get, nil)
+    assert_equal "updateProject", Nested::JsUtil::generate_function_name(resource, :put, nil)
+    assert_equal "createProject", Nested::JsUtil::generate_function_name(resource, :post, nil)
+    assert_equal "destroyProject", Nested::JsUtil::generate_function_name(resource, :delete, nil)
 
-    r2 = @r.singleton(:statistic) {}
+    assert_equal "projectAction", Nested::JsUtil::generate_function_name(resource, :get, :action)
+    assert_equal "updateProjectAction", Nested::JsUtil::generate_function_name(resource, :put, :action)
+    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(resource, :post, :action)
+    assert_equal "destroyProjectAction", Nested::JsUtil::generate_function_name(resource, :delete, :action)
 
-    assert_equal "projectsStatistic", Nested::JsUtil::generate_function_name(r2, :get, nil)
-    assert_equal "updateProjectsStatistic", Nested::JsUtil::generate_function_name(r2, :put, nil)
-    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(r2, :post, nil)
-    assert_equal "destroyProjectsStatistic", Nested::JsUtil::generate_function_name(r2, :delete, nil)
+    resource = many(:projects)
 
-    assert_equal "projectsStatisticAction", Nested::JsUtil::generate_function_name(r2, :get, :action)
-    assert_equal "updateProjectsStatisticAction", Nested::JsUtil::generate_function_name(r2, :put, :action)
-    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(r2, :post, :action)
-    assert_equal "destroyProjectsStatisticAction", Nested::JsUtil::generate_function_name(r2, :delete, :action)
+    assert_equal "projects", Nested::JsUtil::generate_function_name(resource, :get, nil)
+    assert_equal "updateProjects", Nested::JsUtil::generate_function_name(resource, :put, nil)
+    assert_equal "createProject", Nested::JsUtil::generate_function_name(resource, :post, nil)
+    assert_equal "destroyProjects", Nested::JsUtil::generate_function_name(resource, :delete, nil)
 
-    singleton!
+    assert_equal "projectsAction", Nested::JsUtil::generate_function_name(resource, :get, :action)
+    assert_equal "updateProjectsAction", Nested::JsUtil::generate_function_name(resource, :put, :action)
+    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(resource, :post, :action)
+    assert_equal "destroyProjectsAction", Nested::JsUtil::generate_function_name(resource, :delete, :action)
 
-    r2 = @r.many(:statistics) {}
-    r3 = r2.one {}
+    resource = many(:projects).one
 
-    assert_equal "projectStatistic", Nested::JsUtil::generate_function_name(r3, :get, nil)
-    assert_equal "updateProjectStatistic", Nested::JsUtil::generate_function_name(r3, :put, nil)
-    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(r3, :post, nil)
-    assert_equal "destroyProjectStatistic", Nested::JsUtil::generate_function_name(r3, :delete, nil)
+    assert_equal "project", Nested::JsUtil::generate_function_name(resource, :get, nil)
+    assert_equal "updateProject", Nested::JsUtil::generate_function_name(resource, :put, nil)
+    assert_equal "createProject", Nested::JsUtil::generate_function_name(resource, :post, nil)
+    assert_equal "destroyProject", Nested::JsUtil::generate_function_name(resource, :delete, nil)
 
-    assert_equal "projectStatisticAction", Nested::JsUtil::generate_function_name(r3, :get, :action)
-    assert_equal "updateProjectStatisticAction", Nested::JsUtil::generate_function_name(r3, :put, :action)
-    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(r3, :post, :action)
-    assert_equal "destroyProjectStatisticAction", Nested::JsUtil::generate_function_name(r3, :delete, :action)
+    assert_equal "projectAction", Nested::JsUtil::generate_function_name(resource, :get, :action)
+    assert_equal "updateProjectAction", Nested::JsUtil::generate_function_name(resource, :put, :action)
+    assert_equal "createProjectAction", Nested::JsUtil::generate_function_name(resource, :post, :action)
+    assert_equal "destroyProjectAction", Nested::JsUtil::generate_function_name(resource, :delete, :action)
 
+    resource = singleton(:project).many(:statistics)
 
-    singleton!
-    r2 = @r.many(:statistics) {}
-    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(r2, :post, nil)
+    assert_equal "projectStatistics", Nested::JsUtil::generate_function_name(resource, :get, nil)
+    assert_equal "updateProjectStatistics", Nested::JsUtil::generate_function_name(resource, :put, nil)
+    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(resource, :post, nil)
+    assert_equal "destroyProjectStatistics", Nested::JsUtil::generate_function_name(resource, :delete, nil)
 
+    assert_equal "projectStatisticsAction", Nested::JsUtil::generate_function_name(resource, :get, :action)
+    assert_equal "updateProjectStatisticsAction", Nested::JsUtil::generate_function_name(resource, :put, :action)
+    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(resource, :post, :action)
+    assert_equal "destroyProjectStatisticsAction", Nested::JsUtil::generate_function_name(resource, :delete, :action)
 
-    singleton!
-    r2 = @r.many(:statistics) {}
-    r3 = r2.singleton(:user) {}
+    resource = singleton(:project).many(:statistics).one
 
-    assert_equal "projectStatisticsUser", Nested::JsUtil::generate_function_name(r3, :get, nil)
+    assert_equal "projectStatistic", Nested::JsUtil::generate_function_name(resource, :get, nil)
+    assert_equal "updateProjectStatistic", Nested::JsUtil::generate_function_name(resource, :put, nil)
+    assert_equal "createProjectStatistic", Nested::JsUtil::generate_function_name(resource, :post, nil)
+    assert_equal "destroyProjectStatistic", Nested::JsUtil::generate_function_name(resource, :delete, nil)
 
-    singleton!
-    r2 = @r.many(:statistics) {}
-    r3 = r2.one {}
-    r4 = r3.singleton(:user) {}
+    assert_equal "projectStatisticAction", Nested::JsUtil::generate_function_name(resource, :get, :action)
+    assert_equal "updateProjectStatisticAction", Nested::JsUtil::generate_function_name(resource, :put, :action)
+    assert_equal "createProjectStatisticAction", Nested::JsUtil::generate_function_name(resource, :post, :action)
+    assert_equal "destroyProjectStatisticAction", Nested::JsUtil::generate_function_name(resource, :delete, :action)
 
-    assert_equal "projectStatisticUser", Nested::JsUtil::generate_function_name(r4, :get, nil)
+    resource = singleton(:project).many(:statistics).one.many(:entries)
+    assert_equal "projectStatisticEntries", Nested::JsUtil::generate_function_name(resource, :get, nil)
   end
 
-  # -----------------
-
   def test_function_arguments
-    # --- singleton
-    singleton!
-    assert_equal [], Nested::JsUtil.function_arguments(@r)
-
-    singleton!
-    assert_equal [], Nested::JsUtil.function_arguments(@r.singleton(:statistic) {})
-
-    singleton!
-    assert_equal [], Nested::JsUtil.function_arguments(@r.many(:statistics) {})
-
-    singleton!
-    assert_equal ["statistic"], Nested::JsUtil.function_arguments(@r.one(:statistic) {})
-
-    singleton!
-    r2 = @r.one(:statistic) {}
-    r3 = r2.singleton(:test) {}
-    assert_equal ["statistic"], Nested::JsUtil.function_arguments(r3)
-
-    # --- member
-
-    member!
-    assert_equal ["project"], Nested::JsUtil.function_arguments(@r)
-
-    member!
-    assert_equal ["project"], Nested::JsUtil.function_arguments(@r.singleton(:statistic) {})
-
-    member!
-    assert_equal ["project"], Nested::JsUtil.function_arguments(@r.many(:statistics) {})
-
-    member!
-    assert_equal ["project", "statistic"], Nested::JsUtil.function_arguments(@r.one(:statistic) {})
-
-    # --- collection
-
-    collection!
-    assert_equal [], Nested::JsUtil.function_arguments(@r)
-
-    collection!
-    assert_equal [], Nested::JsUtil.function_arguments(@r.singleton(:statistic) {})
-
-    collection!
-    assert_equal ["project"], Nested::JsUtil.function_arguments(@r.one {})
-
-    collection!
-    r2 = @r.one {}
-    r3 = r2.one(:statistic) {}
-
-    assert_equal ["project", "statistic"], Nested::JsUtil.function_arguments(r3)
+    assert_equal [], Nested::JsUtil.function_arguments(singleton(:project))
+    assert_equal [], Nested::JsUtil.function_arguments(singleton(:project).singleton(:statistic))
+    assert_equal [], Nested::JsUtil.function_arguments(singleton(:project).many(:statistics))
+    assert_equal ["statistic"], Nested::JsUtil.function_arguments(singleton(:project).many(:statistics).one)
+
+    assert_equal [], Nested::JsUtil.function_arguments(many(:projects))
+    assert_equal [], Nested::JsUtil.function_arguments(many(:projects).singleton(:statistic))
+    assert_equal ["project"], Nested::JsUtil.function_arguments(many(:projects).one)
+
+    assert_equal ["project"], Nested::JsUtil.function_arguments(many(:projects).one.singleton(:today))
+    assert_equal [], Nested::JsUtil.function_arguments(many(:projects).singleton(:statistic).singleton(:today))
+    assert_equal ["project", "entry"], Nested::JsUtil.function_arguments(many(:projects).one.many(:entries).one)
   end
 
 end

data/test/serializer_field_test.rb

@@ -0,0 +1,13 @@
+require "test/unit"
+require "mocha/setup"
+require "active_support/all"
+require "active_model/errors"
+require "active_record"
+require "nested"
+
+class SerializerFieldTest < Test::Unit::TestCase
+  def test_initialize
+    assert_equal :name, Nested::SerializerField.new(:name, :condition).name
+    assert_equal :condition, Nested::SerializerField.new(:name, :condition).condition
+  end
+end

data/test/serializer_test.rb

@@ -0,0 +1,31 @@
+require "test/unit"
+require "mocha/setup"
+require "active_support/all"
+require "active_model/errors"
+require "active_record"
+require "nested"
+
+class SerializerTest < Test::Unit::TestCase
+
+  def test_initialize
+    assert_equal [], Nested::Serializer.new.includes
+    assert_equal [], Nested::Serializer.new.excludes
+
+    assert_equal [1,2,3], Nested::Serializer.new([1,2,3]).includes
+  end
+
+  def test_operator_plus
+    ser = Nested::Serializer.new
+    assert_equal ser, ser + :name
+    assert_equal 1, ser.includes.length
+    assert_equal :name, ser.includes[0].name
+  end
+
+  def test_operator_minus
+    ser = Nested::Serializer.new([:name])
+    assert_equal ser, ser - :name
+    assert_equal 1, ser.excludes.length
+    assert_equal :name, ser.excludes[0].name
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+module TestHelper
+  def singleton(name)
+    Nested::Resource.new(@sinatra, name, true, false, nil, nil)
+  end
+
+  def many(name)
+    Nested::Resource.new(@sinatra, name, false, true, nil, nil)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested
 version: !ruby/object:Gem::Version
-  version: 0.0.24
+  version: 0.0.25
 platform: ruby
 authors:
 - Jan Zimmek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-27 00:00:00.000000000 Z
+date: 2014-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -81,6 +81,9 @@ files:
 - lib/nested.rb
 - nested.gemspec
 - test/nested_test.rb
+- test/serializer_field_test.rb
+- test/serializer_test.rb
+- test/test_helper.rb
 homepage: 
 licenses: []
 metadata: {}
@@ -106,3 +109,6 @@ specification_version: 4
 summary: a nestable dsl to create a restful api
 test_files:
 - test/nested_test.rb
+- test/serializer_field_test.rb
+- test/serializer_test.rb
+- test/test_helper.rb