nested 0.0.26 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f3204fac8586400602f52773cfa5cd557acaaf15
-  data.tar.gz: 4e017941f4c4bbc7ae02ee77df82a9b2944d26fd
+  metadata.gz: ab13bf160d76af854150cd009b1f59116a0c58bc
+  data.tar.gz: df0fe620f543a2f267634f88d86fde251ce9d2e4
 SHA512:
-  metadata.gz: 781858c122e8512d79e0fde3f0753ff97e473636c38e3bd5f4c5146a05b5954d0874ffb2a7980fbc04b944653b751026bc6506179d4732b2833d5b8325951b8f
-  data.tar.gz: db049be70b1b9899c2a08301c34534f6bdca917f470fe3af50bf3d6f9a73b0851c473618e8d54f38a296838c9353c3cbba6a960c84c64ec31b6f7574ded308ac
+  metadata.gz: 5eebaafea98746566bfd1b60dda1f5cfeda99920d4d6e804d132b2e2ac236e233ce370168f7b1c08f1f85806b69b9e34f7717c8e4e2de732a5a09f2653f3b7ca
+  data.tar.gz: f79bea6564bd4c80fa2ef5bf7ae8df1c2a1617f8a5d11c48123ab6a2fdb31817b7c5e0fa4a30c2799a1ed403938fbd74ee48941049fb2587bb5d90ed02784c7e

data/README.md

@@ -1,4 +1,203 @@
-nested
-======
+# Nested
 
-a nestable dsl to create a restful api
+Nested is a DSL to create a restful API in a declarative way. It is implemented in ruby. The author has some strong opinions about REST/API.
+
+## Quickstart
+
+Nested provides you a bunch of keywords to declare the resources of your API. Most important are "singleton", "many" and "one".
+
+```
+class MyApi < Nested::App
+  singleton :user
+end
+```
+
+You just declared your first resource! But it does not do much right, so lets add a HTTP verb to make it accessible.
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    get
+  end
+end
+```
+
+Now our resource is reachable by issuing a GET request to "/user". It still does not return any useful data. A resources is always backed by a model. Mostly you will use an array, hash or orm-instances (e.g. activerecord) as underlying model. The easiest way is to provide a block to your resource.
+
+```
+class MyApi < Nested::App
+  singleton :user, ->{ {name: "joe"} } do
+    get
+  end
+end
+```
+
+The model block will be invoked each time the resource is requested. We still do not get back the underlying model from our resource. In nested you have to explicitly whitelist which fields your want to expose for a resource.
+
+```
+class MyApi < Nested::App
+  singleton :user, ->{ {id: 99, name: "joe"} } do
+    serialize :id, :name
+    get
+  end
+end
+```
+
+Congrats! You just created your first nested API. Checkout the other sections to get more information about different resource types, verbs, serialization and conditionals.
+
+## Nested:App
+
+In nested you implement your API as a normal ruby class which inherit from Nested::App
+
+```
+class MyApi < Nested::App
+end
+```
+
+## Resources
+
+### Singleton
+
+A unique value.
+
+```
+class MyApi < Nested::App
+  # the current user
+  singleton :user do
+    serialize :id, :email, :username
+
+    # GET /user
+    get
+  end
+
+  # session which is used to login/logout
+  singleton :session do
+    # perform login, POST /session
+    post
+
+    # perform logout, DELETE /session
+    delete
+  end
+end
+```
+
+### Many
+
+A list of values.
+
+```
+class MyApi < Nested::App
+  many :tasks do
+    serialize :id, :title, :description
+
+    # GET /tasks
+    get
+  end
+end
+```
+
+### One
+
+A specific value of many resource.
+
+```
+class MyApi < Nested::App
+  many :tasks do
+    serialize :id, :title, :description
+
+    # GET /tasks
+    get
+
+    one do
+      # GET /tasks/:id
+      get
+    end
+  end
+end
+```
+
+One can only be used within a enclosing Many. One inherits its name and serialization information from the Many.
+
+## Http Verbs
+
+Nested supports all commonly used http verbs used in a resftul API. Call the verb as method inside the resource block to make the resource respond to that http verb.
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    # respond to GET /user
+    get
+
+    # respond to POST /user
+    post
+
+    # respond to DELETE /user
+    delete
+
+    # respond to PUT /user
+    put
+
+    # respond to PATCH /user
+    patch
+end
+```
+
+You can pass a block to each http verb to impement the concret behavior.
+
+```
+class MyApi < Nested::App
+  singleton :user, ->{ {name: "joe" } } do
+    get do
+      puts "i am a GET request"
+    end
+
+    delete do
+      puts "and i am a DELETE one"
+    end
+  end
+end
+```
+
+The http verb block can access the model of the resource as an instance variable.
+
+```
+class MyApi < Nested::App
+  singleton :user, ->{ {name: "joe" } } do
+    get do
+      puts "my name is #{@user.name}"
+    end
+  end
+end
+```
+
+The model is available in all http verb block. Except inpost. The post block has to return a new model.
+
+```
+class MyApi < Nested::App
+  singleton :user do
+    post do
+      {name: "joe"}
+    end
+  end
+end
+```
+
+Nested gives you access to http parameters through the params method as known from other frameworks and addition to this a useful shorthand.
+
+```
+class MyApi < Nested::App
+  singleton :user, ->{ {name: "joe", age: 33 } } do
+    put do
+      @user.name = params[:new_name]
+      @user.age = params[:age]
+    end
+
+    # same as
+
+    put do |new_name, age|
+      @user.name = new_name
+      @user.age = age
+    end
+  end
+end
+```

data/lib/nested/serializer.rb

@@ -25,6 +25,8 @@ module Nested
     def serialize
       this = self
       ->(obj) do
+        obj = ::HashWithIndifferentAccess.new(obj) if obj.is_a?(Hash)
+
         excludes = this.excludes.select{|e| instance_exec(&e.condition)}
 
         this.includes.reject{|e| excludes.detect{|e2| e2.name == e.name}}.inject({}) do |memo, field|

data/nested.gemspec

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

data/test/serializer_test.rb

@@ -28,4 +28,28 @@ class SerializerTest < Test::Unit::TestCase
     assert_equal :name, ser.excludes[0].name
   end
 
+  def test_serialize
+    ser = Nested::Serializer.new()
+    ser + :id
+
+    obj = {id: 2, name: "joe"}
+
+    assert_equal({id: 2}, obj.instance_eval(&ser.serialize))
+
+    ser + :name
+    assert_equal({id: 2, name: "joe"}, obj.instance_eval(&ser.serialize))
+  end
+
+  def test_serialize_with_symbolize_keys
+    ser = Nested::Serializer.new()
+    ser + :id
+
+    obj = {"id" => 2, "name" => "joe"}
+
+    assert_equal({id: 2}, obj.instance_eval(&ser.serialize))
+
+    ser + :name
+    assert_equal({id: 2, name: "joe"}, obj.instance_eval(&ser.serialize))
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.27
 platform: ruby
 authors:
 - Jan Zimmek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-02 00:00:00.000000000 Z
+date: 2014-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport