traim 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a3cd06341db0633e95bded7bd7e6a45a5348511
+  data.tar.gz: 3ab56f6e5470c5fe0cb5693619a8251be0f3bf0c
+SHA512:
+  metadata.gz: a1d83bcf7a6c86db7f0d61ee147d1bcfebe3d4f913361443aca879d679b46cd3f7838cbcf1d6d84aa860c16c21f009afd6dda120fb5c544c8a26b93c9c1b38bc
+  data.tar.gz: f7afe6353577ad2ac32e698bd7d4cc6584ac4110bf80ac5c86b1bbd94584bfaaea04e9aa9482e3881278d60b960ceb6495c9545f7f55a08f177f467ead290f5a

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+*.swp
+*.swo

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Travis Liu
+
+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.md

@@ -0,0 +1,272 @@
+# Traim
+
+Traim is a microframework for Building a RESTful API service from your existing ActiveRecord models.
+
+## Getting started
+
+### Installation
+``` ruby
+gem install train
+```
+
+### Usage
+Here's a simple application:
+``` ruby
+# cat hello_traim.rb
+
+Traim.config do |app|
+  app.logger = Logger.new(STDOUT)
+end
+
+class User < ActiveRecord::Base
+end
+
+Train.application do
+  resource :users do
+    # Inject user model
+    model User
+
+    # Response json: {id: 1, name: “example"}
+    attribute :id
+    attribute :name
+
+    # POST /users
+    action :create
+
+    # GET /users/:id
+    action :show
+
+    # PUT /users/:id
+    action :update
+
+    # DELETE /users/:id
+    action :destory
+  end
+end
+```
+put your activerecord config in
+` config/database.yml `
+
+To run it, you can create a config.ru file
+``` ruby
+# cat config.ru
+require 'hello_traim.rb'
+
+run Traim
+```
+
+Then run `rackup`.
+
+Now, you already get basic CURD RESTful API from the user ActiveRecord model.
+
+## Customizable action
+By default, `action` can be easily used to create an endpoint for CRUD operations. you can write your own endpoint as well.
+``` ruby
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    action :show do |params|
+      user = model.find_by_email params["payload"]["email"]
+      user.name = "[admin] #{user.name}"
+      user
+    end
+  end
+end
+```
+
+Response
+``` json
+{"id": 1, "name": "[admin] travis"}
+```
+
+## Associations
+create nestea json reponse with activerecord association
+``` ruby
+class User < ActiveRecord::Base
+  has_many :books
+end
+
+class Book < ActiveRecord::Base
+  belongs_to :user
+end
+
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    action :show
+
+    has_many: books
+  end
+
+  resources :books do
+    model Book
+
+    attribute :isbn
+  end
+end
+```
+
+Response
+``` json
+{
+  "id": 1,
+  "name": "travis"
+  "books": [
+    {"isbn": "978-1-61-729109-8"},
+    {"isbn": "561-6-28-209847-7"},
+    {"isbn": "527-3-83-394862-5"}
+  ]
+}
+```
+
+## Member
+Member block can add actions to a specific record with id
+``` Ruby
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    member :blurred do
+
+      # GET /users/1/blurred
+      show do |params|
+        record.name[1..2] = 'xx'
+        record
+      end
+    end
+  end
+end
+```
+
+## Collection
+Collection block can add actions to operate resources
+``` Ruby
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    collection :admin do
+
+      # GET /users/admin
+      show do |params|
+        model.all
+      end
+
+      # POST /users/admin
+      create do |params|
+        model.create(params["payload"])
+      end
+    end
+  end
+end
+```
+
+## Namespaces
+Organize groups of resources under a namespace. Most commonly, you might arrange resources for versioning.
+``` ruby
+Traim.application do
+  namespace :api do
+    namespace :v1 do
+      resources :users do
+        model User
+
+        attribute :id
+        attribute :name
+
+        # endpoint: /api/v1/users
+        action :show
+      end
+    end
+
+    namespace :v2 do
+      resources :users do
+        model User
+
+        attribute :id
+        attribute :name
+
+        # endpoint: /api/v2/users
+        action :show
+      end
+    end
+  end
+end
+```
+
+## Helpers
+You can define helper methods that your endpoints can use with the helpers to deal with some common flow controls, like authentication or authorization.
+``` ruby
+Traim.application do
+  resources :users do
+    helpers do
+      def auth(user_id) 
+        raise BadRequestError.new(message: "unauthenticated request") unless model.exists?(id: user_id)
+      end
+    end
+
+    model User
+
+    attribute :id
+    attribute :name
+
+    action :show do |params|
+      auth(params["id"])
+      model.find params["id"]
+      user
+    end
+  end
+end
+```
+
+## Visual attributes
+Built-in attribute is generate response fields from model. Visual can help you present fields outside of model attributes. 
+``` ruby
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    attribute :vattr do |record|
+      "#{record.id} : #{record.email}"
+    end
+
+    action :show
+  end
+end
+```
+
+Response
+``` json
+{"id": 1, "name": "travis", "vattr": "1 : travis"}
+```
+
+### Parameters whitelist
+Built-in model operations are using mass assignment. For security concern, Parameters can be whitelisted with permit option.
+``` ruby
+Traim.application do
+  resources :users do
+    model User
+
+    attribute :id
+    attribute :name
+
+    action :create, permit: ["name"]
+  end
+end
+```

data/lib/traim.rb

@@ -0,0 +1,372 @@
+require 'json'
+require 'rack'
+require 'seg'
+require 'yaml'
+require 'logger'
+require 'active_record'
+
+class Traim 
+  DEFAULT_HEADER = {"Content-Type" => 'application/json;charset=UTF-8'}
+  TRAIM_ENV = ENV['TRAIM_ENV'] || 'development'
+
+  def initialize(&block)
+    if self.class.logger == nil
+      self.class.logger = Logger.new(STDOUT)
+      self.class.logger.level = Logger::INFO
+    end
+
+    @app = Application.new
+    @app.compile(&block)
+  end
+
+  def self.settings; @settings ||= {} end
+
+  def self.application(&block)
+    @instance = new(&block) 
+  end
+
+  def self.logger=(logger); @logger = logger end
+  def self.logger; @logger end
+
+  def self.call(env)
+    @instance.dup.call(env)
+  end
+
+  def self.config(&block)
+    config_file = YAML.load_file("#{Dir.pwd}/config/database.yml")
+    ActiveRecord::Base.establish_connection(config_file[TRAIM_ENV])
+    yield self 
+  end
+
+  def logger; Traim.logger end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    logger.info("#{request.request_method} #{request.path_info} from #{request.ip}")
+    logger.debug("Parameters: #{request.params}")
+    
+    @app.route(request)
+  rescue Error => e
+    logger.error(e) 
+    [e.status, e.header, [JSON.dump(e.body)]]
+  rescue Exception => e
+    logger.error(e) 
+    error = Error.new
+    [error.status, error.header, [JSON.dump(error.body)]]
+  end
+
+  class Application 
+    def logger; Traim.logger end 
+
+    def initialize(name = :default)
+      @name         = name
+      @resources    = {}
+      @applications = {}
+    end
+
+    def resources(name, &block)
+      @resources[name] = Resource.new(block) 
+    end
+
+    def namespace(name, &block)
+      logger.debug("application namespace #{name}")
+      application(name).compile(&block)
+    end
+
+    def application(name = :default)
+      logger.debug("Lunch application #{name}")
+      app = @applications[name] ||= Application.new(name)
+    end
+
+    def helpers(&block)
+      @helpers_block = block
+    end
+
+    def route(request, seg = nil)
+      inbox = {}
+      seg ||= Seg.new(request.path_info) 
+      seg.capture(:segment, inbox)
+      segment = inbox[:segment].to_sym
+
+      if app = @applications[segment]
+        app.route(request, seg)
+      else 
+        router = Router.new(@resources)
+        router.instance_eval(&@helpers_block) unless @helpers_block.nil?
+        router.run(seg, inbox)
+        router.render(request)
+      end
+    end
+
+    def compile(&block)
+      logger.debug("Compile application: #{@name}")
+      instance_eval(&block)
+    end
+  end
+
+  class Error < StandardError
+
+    def initialize(options = {})
+      @message = options[:message] || error_message 
+      @body    = options[:body]    || error_message
+      super(@message)
+    end
+
+    def status; 500 end
+    def error_message; 'Internal Server Error' end
+    def header; DEFAULT_HEADER end
+    def body; {message: @body} end
+  end
+  class NotImplementedError < Error
+    def error_message; "Not Implemented Error" end
+    def status; 501 end
+  end
+  class BadRequestError < Error
+    def error_message; "Bad Request Error" end
+    def status; 400 end
+  end
+  class NotFoundError < Error
+    def error_message; "Not Found Error" end
+    def status; 404 end
+  end
+   
+  class Router
+
+    def status; @status || ok end
+    def logger; Traim.logger  end 
+
+    # status code sytax suger
+    def ok;        @status = 200 end
+    def created;   @status = 201 end
+    def no_cotent; @status = 204 end
+
+    def headers(key, value)
+      @headers[key] = value 
+    end
+
+    def initialize(resources) 
+      @status    = nil
+      @resources = resources
+      @headers   = {}
+    end
+
+    def self.resources; @resources ||= {} end
+
+    def resources(name)
+      @resources[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 run(seg, inbox)  
+      begin
+        segment = inbox[:segment].to_sym
+
+        if @resource.nil?
+          raise BadRequestError unless @resource = resources(segment)
+          next
+        end 
+
+        if @id.nil? && !defined?(@collection_name)
+          if collection = @resource.collections[segment]
+            @collection_name = segment
+            return instance_eval(&collection)
+          else
+            @id = segment.to_s.to_i
+            @record = @resource.model_delegator.show(@id)
+            next 
+          end
+        end
+
+        if !defined?(@member_name)
+          if member = @resource.members[segment]
+            @member_name = segment
+            return instance_eval(&member)
+          end
+        end
+
+        raise BadRequestError 
+      end while seg.capture(:segment, inbox) 
+    end
+    
+    def to_json
+      if @result.kind_of?(ActiveRecord::Relation)
+        hash = @result.map do |object|
+          @resource.to_hash(object, @resources) 
+        end
+        JSON.dump(hash)
+      else
+        new_hash = {}
+        if @result.errors.size == 0
+          new_hash = @resource.to_hash(@result, @resources)
+        else
+          new_hash = @result.errors.messages
+        end
+        JSON.dump(new_hash)
+      end
+    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 = {}
+        delegator = @resource.model_delegator
+        actions["POST"] = lambda do |params|
+          delegator.create(params["payload"])
+        end
+        actions["GET"] = lambda do |params|
+          delegator.show(params["id"])
+        end
+        actions["PUT"] = lambda do |params|
+          result = delegator.update(params["id"], params["payload"])
+          result
+        end
+        actions["DELETE"] = lambda do |params|
+          delegator.delete(@id)
+        end
+        actions
+      end
+    end
+
+    def model;  @resource.model end
+    def record; @record; end
+
+    def render(request)
+      method_block = action(request.request_method)
+      payload = request.params
+      if (method_block[:options][:permit])
+        if not_permmited_payload = payload.detect { |key, value| !method_block[:options][:permit].include?(key) }  
+          raise BadRequestError.new(message: "Not permitted payload: #{not_permmited_payload}") 
+        end
+      end
+      params = {"payload" => payload}
+      params["id"] = @id unless @id.nil?
+      @result = @resource.execute(params, &method_block[:block])
+
+      [status, @headers, [to_json]]
+    end
+  end
+
+  class Resource 
+    ACTION_METHODS = {create: 'POST', show: 'GET', update: 'PUT', destory: 'DELETE'}
+
+
+    def initialize(block) 
+      instance_eval(&block) 
+    end
+
+    def execute(params, &block)
+      yield params
+    end
+
+    def model(object = nil, options = {})
+      @model = object unless object.nil? 
+      @model
+    end
+
+    def model_delegator
+      @model_delegator ||= Model.new(model)
+    end
+
+    def actions; @actions ||= {} end
+    def action(name, options = {}, &block)
+      actions[ACTION_METHODS[name]] = {block: block, options: options}
+    end
+
+    def logger; Traim.logger  end 
+
+    def resource(object = nil)
+      @resource = object unless object.nil?
+      @resource
+    end
+
+    def collections; @collections ||= {} end
+
+    def collection(name, &block)
+      collections[name] = block
+    end
+    
+    def members; @members ||= {} end
+    
+    def member(name, &block)
+      members[name] = block
+    end
+
+    def fields; @fields ||= [] end
+    def attribute(name, &block)
+      fields << {name: name, type: 'attribute', block: block} 
+    end
+
+    def has_many(name)
+      fields << {name: name, type: 'association'}
+    end
+
+    def has_one(name)
+      fields << {name: name, type: 'connection'}
+    end
+
+    def to_hash(object, resources, nest_associations = []) 
+      fields.inject({}) do | hash, attr|
+        name = attr[:name]
+        hash[name] = if attr[:type] == 'attribute'
+          if attr[:block].nil?
+            object.attributes[name.to_s]
+          else
+            execute(object, &attr[:block])
+          end
+        elsif  attr[:type] == 'association'
+          raise Error if nest_associations.include?(name)
+          raise Error if object.class.reflections[name.to_s].blank?
+          nest_associations << name
+          object.send(name).map do |association|
+            resources[name].to_hash(association, nest_associations) 
+          end
+        else
+          resource_name = name.to_s.pluralize.to_sym
+          raise Error.new(message: "Inifinite Association") if nest_associations.include?(resource_name)
+          raise Error if object.class.reflections[name.to_s].blank?
+          nest_associations << resource_name 
+          resources[resource_name].to_hash(object.send(name), nest_associations)
+        end
+        hash
+      end
+    end
+  end
+
+  class Model
+
+    def initialize(model)
+      @model = model 
+    end
+
+    def create(params)
+      resource = @model.new(params)
+      resource.save
+      resource
+    end
+
+    def show(id)
+      @model.find id
+    end
+
+    def delete(id)
+      show(id).delete
+    end
+
+    def update(id, params)
+      resource = show(id)
+      resource.assign_attributes(params)
+      resource.save
+      resource 
+    end
+  end
+end

data/test/resource.rb

@@ -0,0 +1,379 @@
+require "cutest"
+require_relative "../lib/traim"
+
+Traim.config do |app| 
+  app.logger = Logger.new(STDOUT)
+  app.logger.level = Logger::DEBUG
+end
+
+class User < ActiveRecord::Base 
+  validates_presence_of :name
+
+  has_many :books
+end
+
+class Book < ActiveRecord::Base 
+  belongs_to :user
+end
+
+
+def mock_request(app, url, method, payload = nil)
+  env = Rack::MockRequest.env_for( url,
+    "REQUEST_METHOD" => method,
+    :input => payload
+  )
+  
+  app.call(env)
+end
+
+prepare do 
+end
+
+setup do
+  User.create(name: "kolo", email: "kolo@gmail.com")
+end
+
+test "basic create, read, update and destory functionality" do |params|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      action :create
+      action :show
+      action :update
+      action :destory
+    end
+  end
+  
+  _, _, response = mock_request(app, "/users", "POST", "name=kolo&email=kolo@gmail.com")
+  user = JSON.parse(response.first)
+  
+  _, _, response = mock_request(app, "/users/#{user["id"]}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kolo"
+
+  _, _, response = mock_request(app, "/users/#{user["id"]}?name=ivan", "PUT")
+  result = JSON.parse(response.first) 
+  model = User.find(user["id"].to_i)
+  assert model.name == "ivan"
+  
+  _, _, response = mock_request(app, "/users/#{user["id"]}?name=ivan", "DELETE")
+  result = JSON.parse(response.first) 
+  assert !User.exists?(user["id"])
+end
+
+test "customize functionality" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      action :show do |params|
+        user = model.find params["id"]
+        user.name = "[admin] #{user.name}"
+        user
+      end
+    end
+  end
+  
+  _, _, response = mock_request(app, "/users/#{user.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "[admin] kolo"
+end
+
+test "member create, read, update and destory functionality" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      member :blurred do 
+        show do |params|
+          logger.info("show blurred")
+          record.name[1..2] = "xx" 
+          record 
+        end
+
+        update do |params|
+          record.assign_attributes(params["payload"])
+          record.save
+          record 
+        end
+
+       destory do |params|
+          record.delete
+        end
+      end 
+    end
+  end
+ 
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kxxo"
+
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred?name=ivan", "PUT")
+  assert User.find(user.id).name == "ivan"
+
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred", "DELETE")
+  assert !User.exists?(user.id)
+
+end
+
+test "collection create, read, update and destory functionality" do |user|
+  User.create(name: 'Keven', email: 'keven@gmail.com')
+  User.create(name: 'Ivan', email: 'ivan@gmail.com')
+
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      collection :admin do
+        show do |params|
+          model.all
+        end
+
+        create do |params|
+          model.create(params["payload"])
+        end
+      end
+    end
+  end
+
+  _, _, response = mock_request(app, "/users/admin?a=123", "GET")
+  result = JSON.parse(response.first) 
+  assert result.size == User.all.size 
+
+  _, _, response = mock_request(app, "/users/admin", "POST", "name=carol&email=shesee@gmail.com")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "carol" 
+end
+
+test "error message" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      action :create
+      action :show
+      action :update
+      action :destory
+    end
+  end
+
+  _, _, response = mock_request(app, "/users", "POST", "email=kolo@gmail.com")
+  result = JSON.parse(response.first)
+  assert result["name"].first == "can't be blank"
+end
+
+test "has many functionality" do |user|
+  book = Book.create(user: user, isbn: 'abc')
+
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      has_many :books
+
+      action :show
+
+      collection :admin do
+        show do |params|
+          model.all
+        end
+
+        create do |params|
+          # what to response?   
+          model.create(params["payload"])
+        end
+      end
+    end
+    resources :books do
+      model Book 
+
+      attribute :isbn
+    end
+  end
+
+  _, _, response = mock_request(app, "/users/#{user.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["books"].size == user.books.size
+end
+
+test "has one functionality" do |user|
+  book = Book.create(user: user, isbn: 'abc')
+
+  app = Traim.application do 
+    resources :books do
+      model Book 
+      attribute :isbn
+     
+      action :show
+
+      has_one :user
+    end
+
+    resources :users do
+      model User
+
+      attribute :name
+    end
+  end
+
+  _, _, response = mock_request(app, "/books/#{book.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["user"]["name"] == user.name
+end
+
+test "namespace functionality" do |user|
+  book = Book.create(user: user, isbn: 'abc')
+
+  app = Traim.application do 
+    namespace :api do
+      namespace :v1 do
+        resources :books do
+          model Book 
+          attribute :isbn
+
+          has_one :user
+
+          action :show
+        end
+
+        resources :users do
+          model User
+
+          attribute :name
+        end
+      end
+    end
+  end
+
+  _, _, response = mock_request(app, "/api/v1/books/#{book.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["user"]["name"] == user.name
+end
+
+test "visual attributes functionality" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      attribute :vattr do |record|
+        record.email + " : " + record.id.to_s
+      end
+
+      action :show
+    end
+  end
+  
+  _, _, response = mock_request(app, "/users/#{user.id}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kolo"
+end
+
+test "strong parameters  functionality" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      action :create, permit: ["name"]
+    end
+  end
+  
+  _, _, response = mock_request(app, "/users", "POST", "name=kolo&email=kolo@gmail.com")
+  result = JSON.parse(response.first) 
+  assert result["message"] == "Bad Request Error"
+end
+
+test "helpers functionality" do |user|
+  app = Traim.application do 
+    helpers do 
+      def auth(params = nil)
+        logger.debug "auth: #{params}, all: #{model.all}"
+      end
+    end
+
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      member :blurred do 
+        show do |params|
+          auth('test')
+          record.name[1..2] = "xx" 
+          record 
+        end
+
+        update do |params|
+          record.assign_attributes(params["payload"])
+          record.save
+          record 
+        end
+
+       destory do |params|
+          record.delete
+        end
+      end 
+    end
+  end
+ 
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kxxo"
+
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred?name=ivan", "PUT")
+  assert User.find(user.id).name == "ivan"
+
+  _, _, response = mock_request(app, "/users/#{user.id}/blurred", "DELETE")
+  assert !User.exists?(user.id)
+
+end
+
+test "headers functionality" do |user|
+  app = Traim.application do 
+    resources :users do
+      model User
+
+      attribute :id
+      attribute :name
+
+      member :headers do 
+        show do |params|
+          headers("test", "yeah")
+          record 
+        end
+      end 
+    end
+  end
+ 
+  _, headers, response = mock_request(app, "/users/#{user.id}/headers", "GET")
+  assert headers["test"] == "yeah"
+end
+
+
+Book.delete_all
+User.delete_all

data/traim.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name = "traim"
+  s.version = "0.1.2"
+  s.summary = %{Resource-oriented microframework for RESTful API}
+  s.description = %Q{Resource-oriented microframework for RESTful API}
+  s.authors = ["Travis Liu"]
+  s.email = ["travisliu.tw@gmail.com"]
+  s.homepage = "https://github.com/travisliu/traim"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.rubyforge_project = "traim"
+  
+  s.add_dependency "rack", "~> 2.0"
+  s.add_dependency "seg", "~> 1.2"
+
+  s.add_development_dependency "cutest", "1.2.3"
+  s.add_development_dependency "rack-test", "0.6.3"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: traim
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Travis Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: seg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.3
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+description: Resource-oriented microframework for RESTful API
+email:
+- travisliu.tw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- lib/traim.rb
+- test/resource.rb
+- traim.gemspec
+homepage: https://github.com/travisliu/traim
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: traim
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Resource-oriented microframework for RESTful API
+test_files: []