traim 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5f204ffc2cdf698726f079e91eb5db19350b444d
-  data.tar.gz: 47425e6be45b76c807203f0ccf9aa44634286769
+  metadata.gz: c7f9d2dc6a750a774b11b5d3902146d3a5b7cbb7
+  data.tar.gz: fa2d4cb1d990e357481b137d9c1797c6f25ffe3f
 SHA512:
-  metadata.gz: 0aae8da56d68a5445902b91a94127360fb6b4729d494a049d497af3dde6e0ac9f327400bf60de975a61e4556dbc67f7767b1684290505d3aa81107c082875c20
-  data.tar.gz: 6262dd3d799c091b151aa341ac5c77fa901b76313b529a5b06714f1b6c7e756225766512e69f3c11cbf0dcc486157a1005b19bf8c0d2d6668ed9e0cf2c72ad3d
+  metadata.gz: 042f77d48d944dad9f3c3bd641a942efe5343aa96b890f37169eca4fc8a772bbef47a643a1ac8bf76fb9c315203e06ee7125739fd2cfdcbf872d63ae890b7b2d
+  data.tar.gz: d69f5b48785ea17cf80b6c62260ad75371b6d68a742d2558551239c1d4fec7449c8959a4162086bed8ae29530adf4e2ff594593f9f0455d388a16349f6b8bdb5

data/README.md

@@ -67,13 +67,18 @@ Traim.application do
     model User
 
     attribute :id
-    attribute :name
 
     action :show do
+
+      # attribute for single action
+      attribute :name
+
       user = model.find_by_email params["email"]
       user.name = "[admin] #{user.name}"
       user
     end
+
+    action :create
   end
 end
 ```

data/lib/traim.rb

@@ -65,7 +65,7 @@ class Traim
     end
 
     def resources(name, &block)
-      @resources[name] = Resource.new(block) 
+      @resources[name] = Resource.new(block, @helper) 
     end
 
     def namespace(name, &block)
@@ -78,13 +78,8 @@ class Traim
       app = @applications[name] ||= Application.new(name)
     end
 
-    def show(&block);    @resource.action(:show,  &block) end
-    def create(&block);  @resource.action(:create,  &block) end
-    def update(&block);  @resource.action(:update,  &block) end
-    def destory(&block); @resource.action(:destory, &block) end
-
     def helpers(&block)
-      @helpers_block = block
+      @helper = Helper.new(block)
     end
 
     def route(request, seg = nil)
@@ -96,90 +91,83 @@ class Traim
       if app = @applications[segment]
         app.route(request, seg)
       else 
-        model = run(seg, inbox, request)
-        render(request, model)
+        controller = run(seg, inbox, request)
+        render(request, controller)
       end
     end
 
     def run(seg, inbox, request) 
-      model = nil 
+      controller = nil 
       begin
         segment = inbox[:segment].to_sym
 
-        if model.nil?
+        if controller.nil?
           raise BadRequestError unless @resource = @resources[segment]
-          model = Model.new(@resource.model, request) 
+          controller = @resource.build_controller(request)
           next
         end 
 
-        if model.id.nil?
+        if controller.id.nil?
           if collection = @resource.collections[segment]
-            instance_eval(&collection)
+            controller.instance_eval(&collection)
             break
           else
-            model.id = segment.to_s.to_i
+            controller.id = segment.to_s.to_i
             next 
           end
         end
 
         if member = @resource.members[segment]
-          instance_eval(&member)
+          controller.instance_eval(&member)
           break
         end
 
         raise BadRequestError 
       end while seg.capture(:segment, inbox) 
 
-      model.instance_eval(&@helpers_block)  unless @helpers_block.nil?
-      model
+      controller 
     end
     
-    def action(name)
-      raise NotImplementedError unless action = @resource.actions[name] 
-
-      action[:block] = default_actions[name] if action[:block].nil?
-      action
-    end
-
     def default_actions
       @default_actions ||= begin 
         actions = {}
         actions["POST"] = lambda do 
-          create(params)
+          create_record(params)
         end
         actions["GET"] = lambda do 
-          show(id)
+          find_record(id)
         end
         actions["PUT"] = lambda do 
-          result = update(id, params)
+          result = update_record(id, params)
           result
         end
         actions["DELETE"] = lambda do 
-          delete(id)
+          delete_record(id)
         end
         actions
       end
     end
 
-    def to_json(resources, model)
-      if @result.kind_of?(ActiveRecord::Relation)
-        hash = @result.map do |object|
-          @resource.to_hash(object, resources, model) 
+    def to_json(resources, controller)
+      if controller.is_collection?
+        hash = controller.map_record do |object, controller|
+          @resource.to_hash(controller, resources) 
         end
         JSON.dump(hash)
       else
         new_hash = {}
-        if @result.errors.size == 0
-          new_hash = @resource.to_hash(@result, resources, model)
+        if controller.errors.size == 0
+          new_hash = @resource.to_hash(controller, resources)
         else
-          new_hash = @result.errors.messages
+          new_hash = controller.errors.messages
         end
         JSON.dump(new_hash)
       end
     end
 
-    def render(request, model)
-      method_block = action(request.request_method)
+    def render(request, controller)
+      raise NotImplementedError unless method_block = controller.actions(request.request_method) 
+      method_block[:block] = default_actions[request.request_method] if method_block[:block].nil?
 
       if (method_block[:options][:permit])
         if not_permmited_payload = request.params.detect { |key, value| !method_block[:options][:permit].include?(key) }  
@@ -187,9 +175,9 @@ class Traim
         end
       end
 
-      model.params = request.params 
-      @result = model.instance_eval(&method_block[:block])
-      [model.status, model.headers, [to_json(@resources, model)]]
+      controller.params = request.params 
+      controller.execute(method_block[:block])
+      [controller.status, controller.headers, [to_json(@resources, controller)]]
     end
 
     def compile(&block)
@@ -243,8 +231,9 @@ class Traim
     ACTION_METHODS = {create: 'POST', show: 'GET', update: 'PUT', destory: 'DELETE'}
 
 
-    def initialize(block) 
+    def initialize(block, helper) 
       instance_eval(&block) 
+      @helper = helper
     end
 
     def model(object = nil, options = {})
@@ -252,6 +241,11 @@ class Traim
       @model
     end
 
+    def controller(object = nil)
+      @controller = object unless object.nil?
+      @controller || ArController
+    end
+
     def actions; @actions ||= {} end
     def action(name, options = {}, &block)
       actions[ACTION_METHODS[name]] = {block: block, options: options}
@@ -281,57 +275,88 @@ class Traim
       fields << {name: name, type: 'attribute', block: block} 
     end
 
-    def has_many(name)
-      fields << {name: name, type: 'association'}
+    def has_many(name, options={}, &block)
+      fields << {name: name, type: 'association', resource: options[:resource], block: block}
     end
 
-    def has_one(name)
-      fields << {name: name, type: 'connection'}
+    def has_one(name, options={}, &block)
+      fields << {name: name, type: 'connection', resource: options[:resource], block: block}
     end
 
-    def to_hash(object, resources, model, nested_associations = []) 
-      return if object.nil?
+    def build_controller(request)
+      controller.new(model, actions.dup, @helper.clone, request)
+    end
+
+    def to_hash(controller, resources, nested_associations = []) 
+      return if controller.nil?
 
-      fields.inject({}) do | hash, attr|
+      hash_fields = fields
+      hash_fields += controller.fields if controller.respond_to? :fields
+      hash_fields.inject({}) do | hash, attr|
         name = attr[:name]
+
         hash[name] = if attr[:type] == 'attribute'
           if attr[:block].nil?
-            object.attributes[name.to_s]
+            controller.attributes[name.to_s]
           else
-            model.instance_exec(object, &attr[:block])
+            attribute_controller = build_controller(controller.request)
+            attribute_controller.record = controller.record
+            attribute_controller.execute(attr[:block])
           end
         elsif  attr[:type] == 'association'
           raise Error if nested_associations.include?(name)
           nested_associations << name
-          object.send(name).map do |association|
-            resources[name].to_hash(association, resources, model, nested_associations.dup) 
+          resource = resources[attr[:resource] || name]
+          associated_controller = resource.build_controller(controller.request)
+          associated_controller.record = if attr[:block].nil?
+            controller.send(name)
+          else
+            controller.dup.execute(attr[:block])
+          end
+          associated_controller.map_record do |item, controller|
+            resource.to_hash(controller, resources, nested_associations.dup) 
           end
         else
           resource_name = name.to_s.pluralize.to_sym
           raise Error.new(message: "Inifinite Association") if nested_associations.include?(resource_name)
-          raise Error if object.class.reflections[name.to_s].blank?
           nested_associations << resource_name 
-          resources[resource_name].to_hash(object.send(name), resources, model, nested_associations.dup)
+          resource = resources[attr[:resource] || resource_name]
+          connected_controller = resource.build_controller(controller.request)
+          connected_controller.record = if attr[:block].nil?
+            controller.send(name) 
+          else
+            controller.dup.execute(attr[:block])
+          end
+          resource.to_hash(connected_controller, resources, nested_associations.dup)
         end
         hash
       end
     end
   end
 
-  class Model
+  class Controller 
 
-    def initialize(model, request = nil)
+    def initialize(model, actions, helper = nil, request = nil)
       @model   = model 
       @request = request
       @headers = {}
+      @actions = actions
+
       ok
+
+      unless helper.nil?
+        @helper = helper
+        @helper.request = @request
+        @helper.status  = @status
+        @helper.model   = @model
+      end
     end
 
     attr_accessor :id
     attr_accessor :model
-    attr_accessor :record
     attr_accessor :params
     attr_accessor :request
+    attr_accessor :helper
     attr_accessor :status
 
     def logger; Traim.logger  end 
@@ -341,9 +366,27 @@ class Traim
     def created;   @status = 201 end
     def no_cotent; @status = 204 end
 
+    def show(options = {}, &block);    @actions["GET"]    = {block: block, options: options} end
+    def create(options = {}, &block);  @actions["POST"]  = {block: block, options: options} end
+    def update(options = {}, &block);  @actions["PUT"]  = {block: block, options: options} end
+    def destory(options = {}, &block); @actions["DELETE"] = {block: block, options: options} end
+    
+    def actions(name); @actions[name] end
+
+    def fields; @fields ||= [] end
+    def attribute(name, &block)
+      fields << {name: name, type: 'attribute', block: block} 
+    end
+    def has_many(name, options={}, &block)
+      fields << {name: name, type: 'association', resource: options[:resource], block: block}
+    end
+    def has_one(name, options={}, &block)
+      fields << {name: name, type: 'connection', resource: options[:resource], block: block}
+    end
+
     def instance_record(id)
       @id     = id
-      @record = show(@id)
+      @record = find_record(@id)
     end
 
     def headers(key = nil, value = nil)
@@ -351,27 +394,62 @@ class Traim
       @headers[key] = value 
     end
 
-    def record; @record ||= show(id) end
+    def record=(record); @record = record end
+    def record; @record ||= find_record(id) end
 
-    def create(params)
+    def create_record(params)
       resource = @model.new(params)
       resource.save
       resource
     end
 
-    def show(id)
+    def find_record(id)
       @model.find id
     end
 
-    def delete(id)
-      show(id).delete
+    def delete_record(id)
+      find_record(id).delete
     end
 
-    def update(id, params)
-      resource = show(id)
+    def method_missing(m, *args, &block)
+      record.send(m, *args, &block)
+    end
+
+    def update_record(id, params)
+      resource = find_record(id)
       resource.assign_attributes(params)
       resource.save
       resource 
     end
+
+    def is_collection?; record.is_a?(Enumerable) end
+
+    def map_record
+      @record.map do |item|
+        new_controller = self.class.new(@model, @actions)
+        new_controller.record = item 
+        yield item, new_controller 
+      end
+    end
+
+    def execute(block)
+      @record = instance_eval(&block) 
+    end
+  end
+
+  # A controller design for ActiveRecord
+  class ArController < Controller 
+  end 
+
+  class Helper
+    def initialize(block)
+      instance_eval(&block)
+    end
+    def logger; Traim.logger  end 
+
+    attr_accessor :request
+    attr_accessor :status
+    attr_accessor :model
+
   end
 end

data/test/resource.rb

@@ -10,6 +10,10 @@ class User < ActiveRecord::Base
   validates_presence_of :name
 
   has_many :books
+
+  def limited_books
+    books.limit(2)
+  end
 end
 
 class Book < ActiveRecord::Base 
@@ -95,8 +99,6 @@ test "member create, read, update and destory functionality" do |user|
 
       member :blurred do 
         show do 
-          logger.info("show blurred")
-          logger.info("class #{self.class.name}")
           record.name[1..2] = "xx" 
           record 
         end
@@ -199,7 +201,7 @@ test "has many functionality" do |user|
 
         create do 
           # what to response?   
-          model.create(params)
+          model.create_record(params)
         end
       end
     end
@@ -269,7 +271,7 @@ test "namespace functionality" do |user|
   assert result["user"]["name"] == user.name
 end
 
-test "visual attributes functionality" do |user|
+test "virtual attributes functionality" do |user|
   app = Traim.application do 
     resources :users do
       model User
@@ -290,6 +292,47 @@ test "visual attributes functionality" do |user|
   assert result["name"] == "kolo"
 end
 
+test "attributes in action" do |user|
+  book = Book.create(user: user, isbn: 'abc')
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+
+      action :show do 
+        attribute :name
+        record
+      end
+
+      member :books do
+        show do
+          has_many :books
+
+          record
+        end
+      end
+    end
+
+    resources :books do
+      model Book 
+      attribute :isbn
+
+      has_one :user
+
+      action :show
+    end
+  end
+  
+  _, _, response = mock_request(app, "/users/#{user.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kolo"
+
+  _, _, response = mock_request(app, "/users/#{user.id}/books", "GET")
+  result = JSON.parse(response.first) 
+  assert result["books"].first["isbn"] == book.isbn
+end
+
 test "strong parameters  functionality" do |user|
   app = Traim.application do 
     resources :users do
@@ -323,7 +366,7 @@ test "helpers functionality" do |user|
 
       member :blurred do 
         show do
-          auth('test')
+          helper.auth('test')
           record.name[1..2] = "xx" 
           record 
         end
@@ -374,6 +417,41 @@ test "headers functionality" do |user|
   assert headers["test"] == "yeah"
 end
 
+test "custom resource for association" do |user|
+  Book.create(user: user, isbn: 'isbn_1')
+  Book.create(user: user, isbn: 'isbn_2')
+  Book.create(user: user, isbn: 'isbn_3')
+
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+
+      action :show
+      
+      has_many :limited_books, resource: :books do
+        record.limited_books
+      end 
+
+      has_one :second_book, resource: :books do
+        record.books.second
+      end
+    end
+
+    resources :books do
+      model Book
+
+      attribute :isbn
+    end
+  end
+
+  _, headers, response = mock_request(app, "/users/#{user.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["limited_books"].length == 2 
+  assert result["second_book"]["isbn"] == "isbn_2"
+end
+
 
 Book.delete_all
 User.delete_all

data/traim.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "traim"
-  s.version = "0.2.1"
+  s.version = "0.3.0"
   s.summary = %{Resource-oriented microframework for RESTful API}
   s.description = %Q{Resource-oriented microframework for RESTful API}
   s.authors = ["Travis Liu"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: traim
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Travis Liu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-14 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack