apitizer 0.0.1 → 0.0.2

data/lib/apitizer/connection/request.rb

@@ -3,11 +3,11 @@ module Apitizer
     class Request
       extend Forwardable
 
-      attr_reader :action, :path, :parameters
+      attr_reader :method, :path, :parameters
       def_delegator :path, :address
 
-      def initialize(action:, path:, parameters: {})
-        @action = action
+      def initialize(method:, path:, parameters: {})
+        @method = method
         @path = path
         @parameters = parameters
       end

data/lib/apitizer/connection/response.rb

@@ -1,11 +1,11 @@
 module Apitizer
   module Connection
     class Response
-      attr_reader :code, :body
+      attr_reader :code, :content
 
-      def initialize(code:, body:)
+      def initialize(code:, content:)
         @code = code
-        @body = body
+        @content = content
       end
     end
   end

data/lib/apitizer/core.rb

@@ -12,11 +12,11 @@ module Apitizer
       :delete => :delete
     },
     headers: {}
-  }.freeze
+  }
 
-  @actions = [ :index, :show, :create, :update, :delete ].freeze
-  @collection_actions = [ :index, :create ].freeze
-  @member_actions = [ :show, :update, :delete ].freeze
+  @actions = [ :index, :show, :create, :update, :delete ]
+  @collection_actions = [ :index, :create ]
+  @member_actions = [ :show, :update, :delete ]
 
   singleton_class.class_eval do
     attr_reader :defaults, :actions, :collection_actions, :member_actions

data/lib/apitizer/helper.rb

@@ -14,6 +14,10 @@ module Apitizer
       end
     end
 
+    def self.action_scope(action)
+      member_action?(action) ? :member : :collection
+    end
+
     def self.deep_merge(one, two)
       merger = Proc.new do |key, v1, v2|
         Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
@@ -22,25 +26,45 @@ module Apitizer
     end
 
     def self.build_query(parameters)
-      Rack::Utils.build_nested_query(prepare_parameters(parameters))
+      query = Rack::Utils.build_nested_query(prepare_parameters(parameters))
+      query.encode!('UTF-8')
     end
 
     private
 
-    def self.prepare_parameters(parameters)
-      # PATCH: https://github.com/rack/rack/issues/557
-      Hash[
-        parameters.map do |key, value|
-          case value
-          when Integer, TrueClass, FalseClass
-            [ key, value.to_s ]
-          when Hash
-            [ key, prepare_parameters(value) ]
-          else
-            [ key, value ]
-          end
+    def self.prepare_parameters(value)
+      # PATCH 1: https://github.com/rack/rack/issues/557
+      # PATCH 2: https://github.com/rack/rack/pull/698
+      case value
+      when NilClass, String
+        value
+      when Symbol, Integer, TrueClass, FalseClass
+        value.to_s
+      when Array
+        value = value.map { |v| prepare_parameters(v) }.compact
+        if value.any? { |v| v.is_a?(Hash) }
+          value = Hash[(0...value.length).to_a.zip(value)]
+        end
+        value.empty? ? nil : value
+      when Hash
+        value = Hash[
+          value.map do |k, v|
+            v = prepare_parameters(v)
+            v.nil? ? nil : [ k, v ]
+          end.compact
+        ]
+        value.empty? ? nil : value
+      else
+        if value.respond_to?(:to_a)
+          prepare_parameters(value.to_a)
+        elsif value.respond_to?(:to_h)
+          prepare_parameters(value.to_h)
+        else
+          raise ArgumentError, 'Unknown parameter class'
         end
-      ]
+      end
     end
+
+    private_class_method :prepare_parameters
   end
 end

data/lib/apitizer/result.rb

@@ -6,8 +6,8 @@ module Apitizer
     def_delegator :@response, :code
     def_delegators :__getobj__, :is_a?, :kind_of?, :instance_of?
 
-    def initialize(request:, response:, content:)
-      super(content)
+    def initialize(request:, response:)
+      super(response.content)
       @request = request
       @response = response
     end

data/lib/apitizer/routing.rb

@@ -1,7 +1,7 @@
 require_relative 'routing/path'
 require_relative 'routing/node'
 require_relative 'routing/proxy'
-require_relative 'routing/mapper'
+require_relative 'routing/map'
 
 module Apitizer
   module Routing

data/lib/apitizer/routing/{mapper.rb → map.rb}

@@ -1,6 +1,6 @@
 module Apitizer
   module Routing
-    class Mapper
+    class Map
       extend Forwardable
 
       def_delegator :@root, :define_address
@@ -11,8 +11,8 @@ module Apitizer
       end
 
       def trace(action, *arguments)
-        path = @root.trace(*arguments)
-        raise Error, 'Not permitted' unless path.permitted?(action)
+        path = @root.trace(*arguments) or raise Error, 'Not found'
+        raise Error, 'Not permitted' unless path.permit?(action)
         path
       end
 
@@ -21,13 +21,6 @@ module Apitizer
         proxy.instance_eval(&block)
       end
 
-      def define_scope(path, parent: @root, &block)
-        child = Node::Scope.new(path)
-        parent.append(child)
-        proxy = Proxy.new(self, parent: child)
-        proxy.instance_eval(&block)
-      end
-
       def define_resources(name, parent: @root, **options, &block)
         child = Node::Collection.new(name, **options)
         parent.append(child)

data/lib/apitizer/routing/node.rb

@@ -1,5 +1,4 @@
 require_relative 'node/base'
 require_relative 'node/root'
-require_relative 'node/scope'
 require_relative 'node/collection'
 require_relative 'node/operation'

data/lib/apitizer/routing/node/base.rb

@@ -7,36 +7,34 @@ module Apitizer
         end
 
         def trace(steps, path = Path.new)
-          process(path, steps)
-          advance(path)
+          return nil unless recognize?(steps)
 
+          steps, path = steps.clone, path.clone
+
+          walk(steps, path)
           return path if steps.empty?
 
-          child = lookup(steps.first) or raise Error, 'Not found'
-          child.trace(steps, path)
-        end
+          children.each do |child|
+            branch = child.trace(steps, path)
+            return branch if branch
+          end
 
-        def match(name)
+          nil
         end
 
-        def process(path, steps)
+        def recognize?(steps)
         end
 
-        def permitted?(action, path)
+        def permit?(action, on:)
         end
 
-        protected
-
-        def children
-          @children ||= []
-        end
+        private
 
-        def lookup(name)
-          children.find { |c| c.match(name) }
+        def walk(steps, path)
         end
 
-        def advance(path)
-          path.advance(self)
+        def children
+          @children ||= []
         end
       end
     end

data/lib/apitizer/routing/node/collection.rb

@@ -2,31 +2,32 @@ module Apitizer
   module Routing
     module Node
       class Collection < Base
-        def initialize(name, only: nil)
+        def initialize(name, only: nil, except: [])
           @name = name
-          @actions = only && Array(only) || Apitizer.actions
-          unless (@actions - Apitizer.actions).empty?
-            raise Error, 'Not supported'
-          end
+          @actions = (only && Array(only) || Apitizer.actions) - Array(except)
         end
 
-        def match(name)
-          @name == name
+        def recognize?(steps)
+          @name == steps.first
         end
 
-        def process(path, steps)
-          path << steps.shift # @name
-          return path if steps.empty?
-          path << steps.shift # id
+        def permit?(action, on:)
+          @actions.include?(action) && on == Helper.action_scope(action)
         end
 
-        def permitted?(action, path)
-          return false unless @actions.include?(action)
+        private
+
+        def walk(steps, path)
+          path.advance(steps.shift, node: self, on: :collection)
 
-          id_present = path.steps.last != @name
-          member_action = Helper.member_action?(action)
+          return if steps.empty?
+
+          children.each do |child|
+            next unless child.respond_to?(:on?) && child.on?(:collection)
+            return if child.recognize?(steps)
+          end
 
-          id_present == member_action
+          path.advance(steps.shift, node: self, on: :member)
         end
       end
     end

data/lib/apitizer/routing/node/operation.rb

@@ -2,29 +2,28 @@ module Apitizer
   module Routing
     module Node
       class Operation < Base
-        def initialize(name, action:, on:, **options)
-          # TODO: how about on == :collection?
-          unless Apitizer.actions.include?(action) && on == :member
-            raise Error, 'Not supported'
-          end
+        def initialize(name, action:, on:)
           @name = name
           @action = action
+          @on = on
         end
 
-        def match(name)
-          if @name.is_a?(String) && @name =~ /^:/
-            true
-          else
-            @name == name
-          end
+        def recognize?(steps)
+          @name == steps.first || @name.to_s =~ /^:/
         end
 
-        def process(path, steps)
-          path << steps.shift # @name
+        def permit?(action, on:)
+          @action == action && @on == on
         end
 
-        def permitted?(action, path)
-          @action == action
+        def on?(on)
+          @on == on
+        end
+
+        private
+
+        def walk(steps, path)
+          path.advance(steps.shift, node: self, on: @on)
         end
       end
     end

data/lib/apitizer/routing/node/root.rb

@@ -2,12 +2,18 @@ module Apitizer
   module Routing
     module Node
       class Root < Base
+        def recognize?(steps)
+          true
+        end
+
         def define_address(address, *_)
           @address = address
         end
 
-        def process(path, steps)
-          path << @address unless @address.nil?
+        private
+
+        def walk(steps, path)
+          path.advance(@address, node: self) if @address
         end
       end
     end

data/lib/apitizer/routing/path.rb

@@ -1,25 +1,33 @@
 module Apitizer
   module Routing
     class Path
-      extend Forwardable
-
       attr_reader :steps, :node
-      def_delegators :steps, :<<
 
-      def initialize
-        @steps = []
+      def initialize(steps: [], node: nil)
+        @steps = steps
+        @node = node
       end
 
       def address
         @steps.map(&:to_s).join('/')
       end
 
-      def advance(node)
+      def advance(step, node:, on: nil)
+        @steps << step
         @node = node
+        @on = on
+      end
+
+      def permit?(action)
+        @node && @node.permit?(action, on: @on)
+      end
+
+      def on?(on)
+        @on == on
       end
 
-      def permitted?(action)
-        @node && @node.permitted?(action, self)
+      def clone
+        self.class.new(steps: @steps.clone, node: @node)
       end
     end
   end

data/lib/apitizer/version.rb

@@ -1,3 +1,3 @@
 module Apitizer
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/apitizer/base_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Apitizer::Base do
+RSpec.describe Apitizer::Base do
   extend ResourceHelper
 
   let(:subject_class) { Apitizer::Base }
   let(:address) { 'https://service.com/api' }
 
-  def stub_request(method, address)
-    stub_http_request(method, "https://service.com/api/#{ address }").
+  def stub_request(method, path)
+    stub_http_request(method, "#{ address }/#{ path }").
       to_return(code: '200', body: '{}')
   end
 
@@ -17,16 +17,20 @@ describe Apitizer::Base do
     end
 
     it 'draws a routing map when a block is given' do
-      scope_name = address
-      subject = subject_class.new { scope(scope_name) { resources(:articles) } }
+      prefix = address
+      subject = subject_class.new do
+        address(prefix)
+        resources(:articles)
+      end
       stub_request(:get, 'articles')
       expect { subject.process(:index, :articles) }.not_to raise_error
     end
 
     it 'customizes the mapping between the REST actions and HTTP verbs' do
-      scope_name = address
+      prefix = address
       subject = subject_class.new(dictionary: { update: :delete }) do
-        scope(scope_name) { resources(:articles) }
+        address(prefix)
+        resources(:articles)
       end
       stub = stub_request(:delete, 'articles/xxx')
       subject.process(:update, :articles, 'xxx')
@@ -34,37 +38,41 @@ describe Apitizer::Base do
     end
   end
 
-  describe '#process' do
-    subject do
-      scope_name = address
-      subject_class.new { scope(scope_name) { resources(:articles) } }
-    end
-
-    restful_collection_actions.each do |action|
-      method = rest_http_dictionary[action]
-
-      it "is capable of #{ action } actions" do
-        stub_request(method, 'articles')
-        expect { subject.process(action, :articles) }.not_to raise_error
+  describe '#define' do
+    it 'is another way of drawing a routing map' do
+      prefix = address
+      subject = subject_class.new
+      subject.define do
+        address(prefix)
+        resources(:articles)
       end
+      stub_request(:get, 'articles')
+      expect { subject.process(:index, :articles) }.not_to raise_error
+    end
+  end
 
-      it "is capable of #{ action } actions via alias" do
-        stub_request(method, 'articles')
-        expect { subject.send(action, :articles) }.not_to raise_error
+  describe '#process' do
+    subject do
+      prefix = address
+      subject_class.new do
+        address(prefix)
+        resources(:articles)
       end
     end
 
-    restful_member_actions.each do |action|
+    restful_actions.each do |action|
       method = rest_http_dictionary[action]
+      steps = [ :articles ]
+      steps << 'xxx' if restful_member_actions.include?(action)
 
       it "is capable of #{ action } actions" do
-        stub_request(method, 'articles/xxx')
-        expect { subject.process(action, :articles, 'xxx') }.not_to raise_error
+        stub_request(method, steps.join('/'))
+        expect { subject.process(action, *steps) }.not_to raise_error
       end
 
-      it "is capable of #{ action } actions via alias" do
-        stub_request(method, 'articles/xxx')
-        expect { subject.send(action, :articles, 'xxx') }.not_to raise_error
+      it "is capable of #{ action } actions via the corresponding alias" do
+        stub_request(method, steps.join('/'))
+        expect { subject.send(action, *steps) }.not_to raise_error
       end
     end
   end