nested 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab13bf160d76af854150cd009b1f59116a0c58bc
-  data.tar.gz: df0fe620f543a2f267634f88d86fde251ce9d2e4
+  metadata.gz: 530eebbefcb6b3078c4e10362b44bb5f86a18d3a
+  data.tar.gz: 782cad01102d3b0af2baf4f63ce0413228afec18
 SHA512:
-  metadata.gz: 5eebaafea98746566bfd1b60dda1f5cfeda99920d4d6e804d132b2e2ac236e233ce370168f7b1c08f1f85806b69b9e34f7717c8e4e2de732a5a09f2653f3b7ca
-  data.tar.gz: f79bea6564bd4c80fa2ef5bf7ae8df1c2a1617f8a5d11c48123ab6a2fdb31817b7c5e0fa4a30c2799a1ed403938fbd74ee48941049fb2587bb5d90ed02784c7e
+  metadata.gz: 7895a40cc84bc8068daea8d4c01b253dea34aac7e84bb0b94519003e9aa5c537261c7cdcfc28df839a8f55c674276076f89a62bf43b44ebde52af096196c591c
+  data.tar.gz: 55aa216d43349384134b38cbe7a6087610ca6508c3621d0075e40c2e1406bd801eac897104721048606f1857fbce6c8f6131e87895cdf82771954f013e19d0cb

data/README.md

@@ -47,7 +47,7 @@ Congrats! You just created your first nested API. Checkout the other sections to
 
 ## Nested:App
 
-In nested you implement your API as a normal ruby class which inherit from Nested::App
+In nested you implement your API as a normal ruby class which inherits from Nested::App
 
 ```
 class MyApi < Nested::App
@@ -170,7 +170,7 @@ class MyApi < Nested::App
 end
 ```
 
-The model is available in all http verb block. Except inpost. The post block has to return a new model.
+The model is available in all http verb blocks. Except in post. The post block has to return a new model.
 
 ```
 class MyApi < Nested::App
@@ -182,7 +182,7 @@ class MyApi < Nested::App
 end
 ```
 
-Nested gives you access to http parameters through the params method as known from other frameworks and addition to this a useful shorthand.
+Nested gives you access to http parameters through the params method as known from other frameworks and in addition to this a useful shorthand.
 
 ```
 class MyApi < Nested::App
@@ -201,3 +201,52 @@ class MyApi < Nested::App
   end
 end
 ```
+## Serialize
+
+Nested does not automatically serialize  and expose a attributes of the underlying model as resource fields. You have to list them explicitly. This allows you fine grain control over what and when something is exposed and gets you a decoupling from your model layer as well.
+
+Serialize a single field
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    serialize :email
+    get
+  end
+end
+```
+
+Serialize multiple fields
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    serialize :id, :email, :username
+    get
+  end
+end
+```
+
+You can invoke serialize multiple times.
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    serialize :id, :email
+    serialize :username
+    get
+  end
+end
+```
+
+In the previous examples we always serialize a 1:1 field value from the model. Sometimes you want to transform the model value or serialize some completly synthetic fields. This can be easily accomplished by passing a one entry Hash to serialize. The key will be used as serialized field name. The value of the hash is expected to be a block which gets invoked with the model as argument. The return value of the block will be used a serialization value.
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    serialize :id, :email
+    serialize username: ->(user){ "*** #{user.username} ***" }
+    get
+  end
+end
+```

data/lib/nested/app.rb

@@ -8,8 +8,8 @@ module Nested
       clazz.instance_variable_set("@config", {})
     end
 
-    def self.child_resource(name, clazz, resource_if_block, init_block, &block)
-       clazz.new(sinatra, name, nil, resource_if_block, init_block)
+    def self.child_resource(name, clazz, resource_if_block, model_block, &block)
+       clazz.new(sinatra, name, nil, resource_if_block, model_block)
             .tap{|r| r.instance_eval(&(block||Proc.new{ }))}
     end
 

data/lib/nested/many.rb

@@ -1,5 +1,15 @@
 module Nested
   class Many < Resource
+    include WithModelBlock
+
+    MODEL_BLOCK = Proc.new do
+      if @__resource.parent
+        instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name)
+      else
+        nil
+      end
+    end
+
     def one(&block)
       one_if(PROC_TRUE, &block)
     end
@@ -8,12 +18,8 @@ module Nested
       child_resource(self.name.to_s.singularize.to_sym, One, resource_if_block, nil, &block)
     end
 
-    def default_init_block
-      if parent
-        Proc.new{ instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name) }
-      else
-        Proc.new { nil }
-      end
+    def default_model_block
+      MODEL_BLOCK
     end
   end
 end

data/lib/nested/one.rb

@@ -2,20 +2,23 @@ module Nested
   class One < Resource
     include WithMany
 
+    MODEL_BLOCK = Proc.new do
+      if @__resource.parent
+        instance_variable_get("@#{@__resource.parent.instance_variable_name}")
+          .where(id: params[:"#{@__resource.parent.name.to_s.singularize.to_sym}_id"])
+          .first
+      else
+        nil
+      end
+    end
+
+
     def initialize_serializer_factory
       Serializer.new(parent.serializer.includes)
     end
 
-    def default_init_block
-      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
+    def default_model_block
+      MODEL_BLOCK
     end
 
     def to_route_part

data/lib/nested/resource.rb

@@ -1,10 +1,10 @@
 module Nested
   class Resource
-    attr_reader :name, :parent, :actions, :resources, :serializer, :init_block, :sinatra
+    attr_reader :name, :parent, :actions, :resources, :serializer, :model_block, :sinatra, :before_blocks, :after_blocks
 
     include WithSingleton
 
-    def initialize(sinatra, name, parent, resource_if_block, init_block)
+    def initialize(sinatra, name, parent, resource_if_block, model_block)
       raise "resource must be given a name" unless name
 
       @sinatra = sinatra
@@ -16,15 +16,15 @@ module Nested
       raise "resource_if_block is nil, pass Nested::PROC_TRUE instead" unless resource_if_block
       @resource_if_block = resource_if_block
 
-      unless @init_block = init_block
+      unless @model_block = model_block
         if is_a?(One)
-          @init_block = default_init_block
+          @model_block = default_model_block
         else
-          @init_block = resource_if_block != PROC_TRUE ? parent.try(:init_block) : default_init_block
+          @model_block = resource_if_block != PROC_TRUE ? parent.try(:model_block) : default_model_block
         end
       end
 
-      raise "no init_block passed and could not lookup any parent or default init_block" unless @init_block
+      raise "no model_block passed and could not lookup any parent or default model_block" unless @model_block
 
       @before_blocks = []
       @after_blocks = []
@@ -36,12 +36,16 @@ module Nested
       Serializer.new([])
     end
 
-    def child_resource(name, clazz, resource_if_block, init_block, &block)
-       clazz.new(@sinatra, name, self, resource_if_block, init_block)
+    def child_resource(name, clazz, resource_if_block, model_block, &block)
+       clazz.new(@sinatra, name, self, resource_if_block, model_block)
         .tap{|r| r.instance_eval(&(block||Proc.new{ }))}
         .tap{|r| @resources << r}
     end
 
+    def default_model_block
+      raise "implement me"
+    end
+
     def to_route_part
       "/#{@name}"
     end
@@ -58,15 +62,17 @@ module Nested
 
     def serialize(*args)
       args.each {|arg| serializer + arg }
-      serializer
+      self
     end
 
     def serialize_include_if(condition, *args)
       args.each {|arg| @serializer + SerializerField.new(arg, condition) }
+      self
     end
 
     def serialize_exclude_if(condition, *args)
       args.each {|arg| @serializer - SerializerField.new(arg, condition) }
+      self
     end
 
     def route_replace(route, args)
@@ -88,10 +94,12 @@ module Nested
       instance_eval do
         define_method method do |action=nil, &block|
           send(:"#{method}_if", PROC_TRUE, action, &block)
+          self
         end
 
         define_method :"#{method}_if" do |method_if_block, action=nil, &block|
           create_sinatra_route method, action, method_if_block, &(block||proc {})
+          self
         end
       end
     end
@@ -116,14 +124,28 @@ module Nested
     end
 
     def sinatra_init(sinatra)
-      sinatra.instance_variable_set("@__resource", self)
+      sinatra_init_set_resource(sinatra)
 
       raise "resource_if is false for resource: #{self.name} " unless sinatra.instance_exec(&@resource_if_block)
 
-      @before_blocks.each{|e| sinatra.instance_exec(&e)}
+      sinatra_init_before(sinatra)
+      sinatra_init_set_model(sinatra)
+      sinatra_init_after(sinatra)
+    end
 
-      sinatra.instance_variable_set("@#{self.instance_variable_name}", sinatra.instance_exec(&@init_block))
+    def sinatra_init_set_resource(sinatra)
+      sinatra.instance_variable_set("@__resource", self)
+    end
+
+    def sinatra_init_set_model(sinatra)
+      sinatra.instance_variable_set("@#{self.instance_variable_name}", sinatra.instance_exec(*(@model_block.parameters.empty? ? [] : [sinatra.instance_exec(&default_model_block)]), &@model_block))
+    end
+
+    def sinatra_init_before(sinatra)
+      @before_blocks.each{|e| sinatra.instance_exec(&e)}
+    end
 
+    def sinatra_init_after(sinatra)
       @after_blocks.each{|e| sinatra.instance_exec(&e)}
     end
 

data/lib/nested/serializer.rb

@@ -29,17 +29,21 @@ module Nested
 
         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)
+        if obj
+          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
-          memo
+        else
+          nil
         end
       end
     end

data/lib/nested/singleton.rb

@@ -1,13 +1,18 @@
 module Nested
   class Singleton < Resource
     include WithMany
+    include WithModelBlock
 
-    def default_init_block
-      if parent
-        Proc.new{ instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name) }
+    MODEL_BLOCK = Proc.new do
+      if @__resource.parent
+        instance_variable_get("@#{@__resource.parent.instance_variable_name}").send(@__resource.name)
       else
-        Proc.new { nil }
+        nil
       end
     end
+
+    def default_model_block
+      MODEL_BLOCK
+    end
   end
 end

data/lib/nested/with_many.rb

@@ -1,11 +1,11 @@
 module Nested
   module WithMany
-    def many(name, init_block=nil, &block)
-      many_if(PROC_TRUE, name, init_block, &block)
+    def many(name, model_block=nil, &block)
+      many_if(PROC_TRUE, name, model_block, &block)
     end
 
-    def many_if(resource_if_block, name, init_block=nil, &block)
-      child_resource(name, Many, resource_if_block, init_block, &block)
+    def many_if(resource_if_block, name, model_block=nil, &block)
+      child_resource(name, Many, resource_if_block, model_block, &block)
     end
   end
 end

data/lib/nested/with_model_block.rb

@@ -0,0 +1,9 @@
+module Nested
+  module WithModelBlock
+    def model(&block)
+      raise "do not use model() when you already set a model block" if @model_block != default_model_block && @model_block != Nested::PROC_NIL
+      @model_block = block
+      self
+    end
+  end
+end

data/lib/nested/with_singleton.rb

@@ -1,11 +1,11 @@
 module Nested
   module WithSingleton
-    def singleton(name, init_block=nil, &block)
-      singleton_if(PROC_TRUE, name, init_block, &block)
+    def singleton(name, model_block=nil, &block)
+      singleton_if(PROC_TRUE, name, model_block, &block)
     end
 
-    def singleton_if(resource_if_block, name, init_block=nil, &block)
-      child_resource(name, Singleton, resource_if_block, init_block, &block)
+    def singleton_if(resource_if_block, name, model_block=nil, &block)
+      child_resource(name, Singleton, resource_if_block, model_block, &block)
     end
   end
 end

data/lib/nested.rb

@@ -1,5 +1,6 @@
 module Nested
   PROC_TRUE = Proc.new{ true }
+  PROC_NIL = Proc.new{ nil }
 end
 
 require "json"
@@ -11,6 +12,7 @@ require "nested/redirect"
 
 require "nested/with_many"
 require "nested/with_singleton"
+require "nested/with_model_block"
 
 require "nested/resource"
 

data/nested.gemspec

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

data/test/nested_test.rb

@@ -14,18 +14,57 @@ class NestedTest < Test::Unit::TestCase
     @sinatra = mock
   end
 
+  def test_initialize
+    r = singleton(:project)
+
+    assert_equal :project, r.name
+    assert_equal nil, r.parent
+    assert_equal [], r.resources
+    assert_equal [], r.actions
+    assert_equal Nested::PROC_NIL, r.model_block
+
+
+    assert_equal [], r.before_blocks
+    assert_equal [], r.after_blocks
+
+    assert_equal Nested::Singleton::MODEL_BLOCK, singleton(:project, nil).model_block
+    assert_equal Nested::Many::MODEL_BLOCK, many(:projects, nil).model_block
+    assert_equal Nested::One::MODEL_BLOCK, many(:projects, nil).one.model_block
+  end
+
   def test_serialize
     serializer = mock()
 
     r = singleton(:project)
     r.stubs(:serializer).returns(serializer)
 
-    assert_equal serializer, r.serialize
+    assert_equal r, r.serialize
 
     serializer.expects(:+).with(:name)
     r.serialize :name
   end
 
+  def test_before
+    b = ->{}
+    r = singleton(:project)
+    assert_equal r, r.before(&b)
+    assert_equal [b], r.before_blocks
+  end
+
+  def test_after
+    b = ->{}
+    r = singleton(:project)
+    assert_equal r, r.after(&b)
+    assert_equal [b], r.after_blocks
+  end
+
+  def test_model_block
+    model_block = ->{ }
+    r = singleton(:project)
+    assert_equal r, r.model(&model_block)
+    assert_equal model_block, r.model_block
+  end
+
   def test_route_replace
     resource = many(:projects).one
 
@@ -177,52 +216,45 @@ class NestedTest < Test::Unit::TestCase
     # get
 
     @sinatra.expects(:send).with(:get, "/project")
-    singleton(:project).get
+    r = singleton(:project)
+    assert_equal r, r.get
 
     @sinatra.expects(:send).with(:get, "/project/action")
-    singleton(:project).get(:action)
+    r = singleton(:project)
+    assert_equal r, r.get(:action)
 
     # post
 
     @sinatra.expects(:send).with(:post, "/project")
-    singleton(:project).post
+    r = singleton(:project)
+    assert_equal r, r.post
 
     @sinatra.expects(:send).with(:post, "/project/action")
-    singleton(:project).post(:action)
+    r = singleton(:project)
+    assert_equal r, r.post(:action)
 
     # put
 
     @sinatra.expects(:send).with(:put, "/project")
-    singleton(:project).put
+    r = singleton(:project)
+    assert_equal r, r.put
 
     @sinatra.expects(:send).with(:put, "/project/action")
-    singleton(:project).put(:action)
+    r = singleton(:project)
+    assert_equal r, r.put(:action)
 
     # delete
 
     @sinatra.expects(:send).with(:delete, "/project")
-    singleton(:project).delete
+    r = singleton(:project)
+    assert_equal r, r.delete
 
     @sinatra.expects(:send).with(:delete, "/project/action")
-    singleton(:project).delete(:action)
+    r = singleton(:project)
+    assert_equal r, r.delete(:action)
   end
 
 
-  # def test_serializer
-  #   singleton!
-
-  #   @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"})))
-
-  #   @r.serialize :name, virtual: ->(o){ o[:name] + "!!" }
-  #   assert_equal({name: "joe", virtual: "joe!!"}, @r.instance_variable_get("@__serialize").call({name: "joe"}))
-  # end
-
-  # # ----
-
   def test_sinatra_response_type
     assert_equal :error, singleton(:project).sinatra_response_type(ActiveModel::Errors.new({}))
 
@@ -319,4 +351,84 @@ class NestedTest < Test::Unit::TestCase
     assert_equal ["project", "entry"], Nested::Js.function_arguments(many(:projects).one.many(:entries).one)
   end
 
+  def test_sinatra_init
+    @sinatra.stubs(:get)
+    r = singleton(:project, ->{ {name: "joe"} }).get
+
+    r.expects(:sinatra_init_set_resource).with(@sinatra)
+    r.expects(:sinatra_init_before).with(@sinatra)
+    r.expects(:sinatra_init_set_model).with(@sinatra)
+    r.expects(:sinatra_init_after).with(@sinatra)
+
+    r.sinatra_init(@sinatra)
+
+    r.expects(:sinatra_init_set_resource).with(@sinatra)
+
+    assert_raise RuntimeError do
+      r.instance_variable_set("@resource_if_block", ->{ false })
+      r.sinatra_init(@sinatra)
+    end
+  end
+
+  def test_sinatra_init_set_resource
+    @sinatra.stubs(:get)
+    r = singleton(:project, ->{ {name: "joe"} }).get
+    r.sinatra_init_set_resource(@sinatra)
+    assert_equal r, @sinatra.instance_variable_get("@__resource")
+  end
+
+  def test_sinatra_init_set_model
+    @sinatra.stubs(:get)
+    @sinatra.instance_variable_set("@some_value", 10)
+    r = singleton(:project, ->{ {name: "joe", some_value: @some_value} }).get
+    r.sinatra_init_set_model(@sinatra)
+    assert_equal ({name: "joe", some_value: 10}), @sinatra.instance_variable_get("@project")
+
+    @sinatra.stubs(:get)
+    @sinatra.instance_variable_set("@some_value", 10)
+    @sinatra.instance_variable_set("@other_value", 2)
+
+    r = singleton(:project, ->(default){ {name: "joe", some_value: @some_value * default} }).get
+    r.stubs(:default_model_block).returns(->{ @other_value })
+    r.sinatra_init_set_model(@sinatra)
+    assert_equal ({name: "joe", some_value: 20}), @sinatra.instance_variable_get("@project")
+  end
+
+  def test_sinatra_init_before
+    @sinatra.stubs(:get)
+    before_called = false
+
+    r = singleton(:project, ->{ {name: "joe"} }).get.before(&->{ before_called = true })
+    r.sinatra_init_before(@sinatra)
+
+    assert_equal true, before_called
+  end
+
+  def test_sinatra_init_after
+    @sinatra.stubs(:get)
+    after_called = false
+
+    r = singleton(:project, ->{ {name: "joe"} }).get.after(&->{ after_called = true })
+    r.sinatra_init_after(@sinatra)
+
+    assert_equal true, after_called
+  end
+
+  def test_default_model_block
+    assert_equal Nested::Singleton::MODEL_BLOCK, singleton(:project).default_model_block
+    assert_equal Nested::Many::MODEL_BLOCK, many(:projects).default_model_block
+    assert_equal Nested::One::MODEL_BLOCK, many(:projects).one.default_model_block
+  end
+
+  def test_model
+    model_block = ->{}
+    r = singleton(:project)
+    assert_equal r, r.model(&model_block)
+    assert_equal model_block, r.instance_variable_get("@model_block")
+
+    assert_raise RuntimeError do
+      singleton(:project, ->{ 10 }).model(&->{ 20 })
+    end
+  end
+
 end

data/test/serializer_test.rb

@@ -38,6 +38,8 @@ class SerializerTest < Test::Unit::TestCase
 
     ser + :name
     assert_equal({id: 2, name: "joe"}, obj.instance_eval(&ser.serialize))
+
+    assert_equal(nil, nil.instance_eval(&ser.serialize))
   end
 
   def test_serialize_with_symbolize_keys

data/test/test_helper.rb

@@ -1,9 +1,9 @@
 module TestHelper
-  def singleton(name)
-    Nested::Singleton.new(@sinatra, name, nil, Nested::PROC_TRUE, nil)
+  def singleton(name, model_block=Nested::PROC_NIL)
+    Nested::Singleton.new(@sinatra, name, nil, Nested::PROC_TRUE, model_block)
   end
 
-  def many(name)
-    Nested::Many.new(@sinatra, name, nil, Nested::PROC_TRUE, nil)
+  def many(name, model_block=Nested::PROC_NIL)
+    Nested::Many.new(@sinatra, name, nil, Nested::PROC_TRUE, model_block)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.28
 platform: ruby
 authors:
 - Jan Zimmek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-04 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -90,6 +90,7 @@ files:
 - lib/nested/serializer_field.rb
 - lib/nested/singleton.rb
 - lib/nested/with_many.rb
+- lib/nested/with_model_block.rb
 - lib/nested/with_singleton.rb
 - nested.gemspec
 - test/nested_test.rb