squad 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76376e0bcb5c1cf8a66971357f1a961cc548d902
+  data.tar.gz: 4564cd114ea26fe051f2357344b0d67c9295377c
+SHA512:
+  metadata.gz: d38c696b93a71646f5ee586b2c9e0c2c809bcbe32040a4891a2c6deee58e3e1f158b0a65f7e482018a72656c267c9e641adf2be36ead3181496e1d9f34f13a39
+  data.tar.gz: 9a3aba78a2696d06c346957f4adb9e2f21dee539fa133faee2f8c9d1bb569b806fd7bafa691094e58f9a6711d85196428eb96b198daec8ee61a7786a593804e9

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,146 @@
+# Squad 
+
+Simple, efficient RESTful framework in Ruby with Redis.
+
+Squad uses Redis to store resources inspired by [Ohm](https://github.com/soveran/ohm), and provides a simple DSL to easily develop APIs.
+
+## Getting started 
+### Installation
+``` conosle
+gem install Squad
+```
+
+### Usage
+
+Squad assumes Redis was started with address `localhost` and port `6379`. If you need to connect to a remote server or different port, try: 
+``` ruby 
+Squad.settings[:redis] = Redic.new 'redis://10.1.0.1:6379'
+```
+
+Hear's an example that has two resources users and products. 
+``` ruby
+# cat hello_squad.rb
+require "squad"
+
+Squad.application do 
+  resources :users do
+    attribute :name
+    attribute :email
+   
+    collection :posts
+  end
+
+  resources :posts do
+    attribute :title
+    attribute :content
+
+    reference :users
+  end
+end
+```
+All resources have the id attribute built in, you don't need to declare it. 
+
+To run it, you can create a `config.ru` file
+``` ruby
+# cat config.ru
+require 'hello_squad.rb'
+
+run Squad 
+```
+Then run `rackup`. 
+
+Now, you already get basic CURD and relation functionality as RESTful API.
+``` 
+GET /users
+POST /users
+GET /users/:id
+PUT /users/:id
+DELETE /users/:id
+GET /users/:id/posts
+```
+
+### Custom action
+You can operate the single element in custom action.
+``` ruby
+require "squad"
+
+Squad.application do
+  resources :users do
+    attribute :name
+    attribute :email
+
+    element :showcase do
+      # GET /users/:id/showcase
+      show do |params|
+        self.email[1..3] = 'xxx' 
+      end
+
+      # PUT /users/:id/showcase
+      update do |params|
+        self.email = params["email"]
+        save
+      end
+
+      # DELETE /users/:id/showcase
+      destory do |params|
+        delete if self.email == params["email"]
+      end
+    end
+
+    bulk :signup do
+      # POST /users/signup
+      create do |params|
+        if params["email"].include?("@gmail.com")
+          update_attributes(params)
+          save
+          created
+        else
+          bad_request 
+        end
+      end
+    end
+  end
+end
+```
+
+### Index
+Index helps you quick lookup elements.
+
+``` ruby
+require "squad"
+
+Squad.application do
+  resources :users do
+    attribute :name
+    attribute :email
+
+    # GET /users/?name=travis
+    index :name
+  end
+end
+```
+
+You can have a customize query as well. 
+``` ruby
+require "squad"
+
+Squad.application do
+  resources :users do
+    attribute :name
+    attribute :email
+
+    index :name
+
+    bulk :gmail do
+      # There is `all` method can be used here to get all user elements.
+      # GET /users/gmail
+      show do |params|
+        query("name", params["name"]).select |e|
+          e.email.include?("@gmail.com") 
+        end
+      end
+    end
+  end
+end
+```
+

data/lib/squad.rb

@@ -0,0 +1,350 @@
+require 'json'
+require 'rack'
+require 'nest'
+require 'seg'
+require 'ohm_util'
+
+class Squad 
+  DEFAULT_HEADER = {"Content-Type" => 'application/json;charset=UTF-8'}
+
+  def initialize(&block)
+    instance_eval(&block)
+  end
+
+  def self.redis; @redis = settings[:redis] || Redic.new end
+  def self.settings; @settings ||= {} end
+
+  def self.application(&block)
+    @app = new(&block) 
+  end
+
+  def self.call(env)
+    @app.call(env)
+  end
+
+  def self.routes; @routes ||= {} end
+
+  def resources(name, &block)
+    self.class.routes[name] = Resource.factor(&block)
+  end
+
+  def call(env); dup.call!(env) end
+
+  def call!(env)
+    request = Rack::Request.new(env)
+    seg = Seg.new(request.path_info)
+    
+    inbox = {}
+    seg.capture(:segment, inbox)  
+    segment = inbox[:segment].to_sym
+    raise BadRequestError unless klass = self.class.routes[segment]
+
+    resource = klass.new(segment)
+    resource.run(seg)
+    resource.render(request)
+    [resource.status, resource.header, [resource.to_json]]
+  rescue Error => e
+    [e.status, e.header, [JSON.dump(e.body)]]
+  rescue Exception => e
+    puts "message: #{e.message}, b: #{e.backtrace}"
+    error = Error.new
+    [error.status, error.header, [JSON.dump(error.body)]]
+  end
+
+  class Error < StandardError
+    def status; 500 end
+    def header; DEFAULT_HEADER end
+    def body; {message: 'error'} end
+  end
+  class NotImplementedError < Error
+    def status; 501 end
+  end
+  class BadRequestError < Error
+    def status; 400 end
+  end
+  class NotFoundError < Error
+    def status; 404 end
+  end
+
+  class Resource 
+    attr :header
+    attr :id
+
+    def status; @status || ok end
+
+    # status code sytax suger
+    def ok;                    @status = 200 end
+    def created;               @status = 201 end
+    def no_cotent;             @status = 204 end
+    def bad_request;           @status = 400 end
+    def not_found;             @status = 404 end
+    def internal_server_error; @status = 500 end
+    def not_implemented;       @status = 501 end
+    def bad_gateway;           @status = 502 end
+
+    def run(seg)  
+      inbox = {}
+      default_actions
+
+      while seg.capture(:segment, inbox)
+        segment = inbox[:segment].to_sym
+        @request_methods = {}
+
+        if new? && !defined?(@bulk_name)
+          if bulk = self.class.bulks[segment]
+            @bulk_name = segment
+            return instance_eval(&bulk)
+          else
+            @id = segment
+            load!
+            default_element_action
+            next 
+          end
+        end
+
+        if !defined?(@element_name) && !defined?(@collection_name)
+          if element = self.class.elements[segment]
+            @element_name = segment
+            return instance_eval(&element)
+          elsif collection = self.class.collections[segment]
+            @collection_name = segment
+            return instance_eval(&collection)
+          end
+        end
+
+        raise BadRequestError 
+      end
+    end
+
+    def render(request)
+      raise NotImplementedError unless method_block = @request_methods[request.request_method]
+      load! unless id.nil?
+      execute(request.params, &method_block)
+    end
+
+    def execute(params, &block)
+      @results = yield params
+    end
+
+    def element_type?; !defined?(@results) || !@results.kind_of?(Collection) end 
+
+    def self.factor(&block)
+      klass = dup
+      klass.class_eval(&block)
+      klass 
+    end
+
+    def initialize(name, attributes = {}) 
+      @attributes = Hash[self.class.attributes.map{|key| [key, nil]}]
+      @resource_name = name
+      update_attributes(attributes)
+      @status = nil 
+      @header = DEFAULT_HEADER
+    end
+
+    def self.attribute(name)
+      attributes << name unless attributes.include? name
+      define_method(name) do 
+        @attributes[name]
+      end
+      define_method(:"#{name}=") do |value|
+        @attributes[name] = value
+      end
+    end
+    
+    def self.attributes; @attributes ||= [] end
+    
+    def self.bulks; @bulks ||= {} end
+
+    def self.bulk(name, &block)
+      bulks[name] = block
+    end
+    
+    def self.elements; @elements ||= {} end
+    
+    def self.element(name, &block)
+      elements[name] = block
+    end
+
+    def self.indices; @indices ||= [] end
+    def self.index(attribute)
+      indices << attribute unless indices.include?(attribute)
+    end
+
+    def self.collections; @collections ||= {} end
+    def self.collection(name)
+      collections[name] = Proc.new do 
+        show do |params|
+          resource = Squad.routes[name].new(name)
+          resource.query("#{@resource_name}_id", @id)
+        end 
+      end
+    end
+
+    def self.reference(name)
+      field = :"#{name}_id" 
+      attribute field 
+      index field 
+    end
+    
+    def resource; self.class end
+
+    def find(id)
+      resource.new(@resource_name, {"id" => id}).load!
+    end
+    
+    def all; Collection.new(self, key[:all].call("SMEMBERS")) end
+
+    def query(attribute, value)
+      ids = key[:indices][attribute][value].call("SMEMBERS")
+      Collection.new(self, ids)
+    end
+
+    def load!
+      result = key[id].call("HGETALL") 
+      raise NotFoundError if result.size == 0
+      update_attributes(Hash[*result])
+      return self
+    end
+
+    def update_attributes(atts)
+      @attributes.each do |attribute, value|
+        send(:"#{attribute}=", atts[attribute.to_s]) if atts.has_key?(attribute.to_s)
+      end
+      @id = atts["id"] if atts["id"]
+    end
+
+    def save
+      feature = {name: @resource_name}
+      feature["id"] = @id unless new? 
+      
+      indices = {}
+      resource.indices.each do |field|
+        next unless (value = send(field))
+        indices[field] = Array(value).map(&:to_s)
+      end
+
+      @id = OhmUtil.script(redis,
+        OhmUtil::LUA_SAVE,
+        0,
+        feature.to_json,
+        serialize_attributes.to_json,
+        indices.to_json,
+        {}.to_json
+      )
+    end  
+
+    def delete
+      OhmUtil.script(redis,
+        OhmUtil::LUA_DELETE, 0, {
+          "name" => @resource_name,
+          "id" => id,
+          "key" => key[id].to_s
+        }.to_json,
+        {}.to_json,
+        {}.to_json
+      )
+
+      @attributes.each do |key, value|
+        attributes[key] = nil 
+      end
+      @id = nil
+    end
+
+    def attributes; @attributes end
+
+    def reproduce(attributes)
+      self.class.new(@resource_name, OhmUtil.dict(attributes))
+    end
+
+    def to_hash
+      hash = attributes
+      hash[:id] = @id unless @id.nil?
+
+      return hash
+    end
+
+    def to_json
+      if element_type?
+        JSON.dump(self.to_hash)
+      else
+        @results.to_json
+      end
+    end
+
+    def key;   @key ||= Nest.new(@resource_name, redis) end
+    def redis; Squad.redis end
+
+    private 
+      attr_writer :id
+
+      def new?; !defined?(@id) end
+      def serialize_attributes
+        result = []
+        
+        attributes.each do |key, value| 
+          result.push(key, value.to_s) if value
+        end
+
+        result
+      end
+
+      def show(&block);    @request_methods['GET']    = block end
+      def create(&block);  @request_methods['POST']   = block end
+      def update(&block);  @request_methods['PUT']    = block end
+      def destory(&block); @request_methods['DELETE'] = block end
+      
+      def default_actions
+        @request_methods = {} 
+
+        show do |params| 
+          if params.size == 0
+            all
+          else
+            query(*params.first)
+          end
+        end
+
+        create do |params|
+          update_attributes(params)
+          save
+          created
+        end
+      end
+
+      def default_element_action
+        show { |params| }
+
+        update do |params|
+          update_attributes(params)
+          save
+        end
+
+        destory { |params| delete }
+      end
+  end
+  
+  class Collection
+    include Enumerable
+
+    def initialize(resource, ids)
+      @resource = resource 
+      @ids      = ids
+    end
+
+    def each
+      @ids.each { |id| @resource.redis.queue("HGETALL", @resource.key[id])}
+
+      data = @resource.redis.commit
+      return if data.nil?
+
+      data.each_with_index do |atts, idx|
+        yield @resource.reproduce(atts + ['id', @ids[idx]])
+      end
+    end
+
+    def to_json
+      JSON.dump(self.map { |e| e.to_hash })
+    end
+  end
+end

data/makefile

@@ -0,0 +1,6 @@
+.PHONY: all test examples
+
+all: test
+
+test:
+	cutest ./test/*.rb

data/squad.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name = "squad"
+  s.version = "0.1.2"
+  s.summary = %{Simple, efficient RESTful framework in Ruby with Redis}
+  s.description = %Q{Squad uses Redis to store resources inspired by Ohm, and provides a simple DSL to easily develop APIs.}
+  s.authors = ["Travis Liu"]
+  s.email = ["travisliu.tw@gmail.com"]
+  s.homepage = "https://github.com/travisliu/squad"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.rubyforge_project = "squad"
+  
+  s.add_dependency "rack", "~> 2.0"
+  s.add_dependency "redic", "~> 1.5"
+  s.add_dependency "nest", "~> 3"
+  s.add_dependency "stal"
+  s.add_dependency "seg", "~> 1.2"
+  s.add_dependency "ohm_util", "~> 0.1"
+
+  s.add_development_dependency "cutest"
+  s.add_development_dependency "rack-test"
+end

data/test/resource.rb

@@ -0,0 +1,148 @@
+require "cutest"
+require_relative "../lib/squad"
+
+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 
+  Squad.settings[:redis] = Redic.new 'redis://database:6379/2'
+end
+
+setup do
+  Squad.settings[:redis].call "FLUSHDB"
+end
+
+test "basic create, read, update and destory functionality" do |params|
+  app = Squad.application do 
+    resources :users do
+      attribute :name
+      attribute :email
+    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"
+  
+  mock_request(app, "/users/#{user["id"]}?name=kolo2&email=kolo@gmail.com", "PUT")
+  _, _, response = mock_request(app, "/users/#{user["id"]}", "GET")
+  result = JSON.parse(response.first) 
+  assert result["name"] == "kolo2"
+  
+  mock_request(app, "/users/#{user["id"]}", "DELETE")
+  status_code, _, response = mock_request(app, "/users/#{user["id"]}", "GET")
+  assert status_code == 404
+end
+
+test "can be queried with index" do |params|
+  app = Squad.application do 
+    resources :users do
+      attribute :name
+      attribute :email
+
+      index :name
+    end
+  end
+ 
+  mock_request(app, "/users", "POST", "name=kolo&email=kolo@gmail.com")
+  mock_request(app, "/users", "POST", "name=kolo&email=kolo2@gmail.com")
+  mock_request(app, "/users", "POST", "name=scott&email=scott@gmail.com")
+  
+  _, _, response = mock_request(app, "/users?name=kolo", "GET")
+  users = JSON.parse(response.first)
+
+  assert users.size == 2
+end
+
+test "find collection" do
+  app = Squad.application do 
+    resources :users do
+      attribute :name
+      attribute :email
+
+      collection :posts
+    end
+
+    resources :posts do
+      attribute :title
+      attribute :content
+
+      reference :users
+    end
+  end
+ 
+  _, _, response = mock_request(app, "/users", "POST", "name=kolo&email=kolo@gmail.com")
+  users = JSON.parse(response.first)
+
+  mock_request(app, "/posts", "POST", "users_id=#{users["id"]}&title=title1&content=content1")
+  mock_request(app, "/posts", "POST", "users_id=#{users["id"]}&title=title2&content=content2")
+  _, _, response = mock_request(app, "/users/#{users["id"]}/posts", "GET")
+
+  posts = JSON.parse(response.first)
+  assert posts.size == 2
+end
+
+test "custom action" do
+  app = Squad.application do
+    resources :users do
+      attribute :name
+      attribute :email
+
+      element :showcase do
+        # GET /users/:id/showcase
+        show do |params|
+          self.email[1..3] = 'xxx' 
+        end
+
+        # PUT /users/:id/showcase
+        update do |params|
+          self.email = params["email"]
+        	save
+        end
+
+        # DELETE /users/:id/showcase
+        destory do |params|
+          delete if self.email == params["email"]
+        end
+      end
+
+      bulk :signup do
+       	# POST /users/signup
+       	create do |params|
+          if params["email"].include?("@gmail.com")
+            update_attributes(params)
+            save
+            created
+          else
+            bad_request 
+          end
+        end
+      end
+    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"]}/showcase", "GET")
+  showcase_user = JSON.parse(response.first)
+  assert showcase_user["email"] = "kxxx@gmail.com"
+
+  mock_request(app, "/users/#{user["id"]}/showcase?email=newkolo@gmail.com", "PUT")
+  _, _, response = mock_request(app, "/users/#{user["id"]}", "GET")
+  showcase_user = JSON.parse(response.first)
+  assert showcase_user["email"] = "newkolo@gmail.com"
+  
+  _, _, response = mock_request(app, "/users/#{user["id"]}/showcase?email=newkolo@gmail.com", "DELETE")
+  code, _, response = mock_request(app, "/users/#{user["id"]}", "GET")
+  assert code == 404 
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: squad
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Travis Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-24 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: redic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: nest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: stal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '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: ohm_util
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Squad uses Redis to store resources inspired by Ohm, and provides a simple
+  DSL to easily develop APIs.
+email:
+- travisliu.tw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- lib/squad.rb
+- makefile
+- squad.gemspec
+- test/resource.rb
+homepage: https://github.com/travisliu/squad
+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: squad
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Simple, efficient RESTful framework in Ruby with Redis
+test_files: []