apitizer 0.0.1

data/lib/apitizer/processing.rb

@@ -0,0 +1,8 @@
+require_relative 'processing/parser'
+require_relative 'processing/translator'
+
+module Apitizer
+  module Processing
+    Error = Class.new(Apitizer::Error)
+  end
+end

data/lib/apitizer/processing/parser.rb

@@ -0,0 +1,14 @@
+require_relative 'parser/json'
+require_relative 'parser/yaml'
+
+module Apitizer
+  module Processing
+    module Parser
+      def self.build(format)
+        self.const_get(format.to_s.upcase).new
+      rescue NameError
+        raise Error, 'Unknown format'
+      end
+    end
+  end
+end

data/lib/apitizer/processing/parser/json.rb

@@ -0,0 +1,15 @@
+require 'json'
+
+module Apitizer
+  module Processing
+    module Parser
+      class JSON
+        def process(data)
+          ::JSON.parse(data)
+        rescue
+          raise Error, 'Unable to parse'
+        end
+      end
+    end
+  end
+end

data/lib/apitizer/processing/parser/yaml.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+
+module Apitizer
+  module Processing
+    module Parser
+      class YAML
+        def process(data)
+          ::YAML.load(data)
+        rescue
+          raise Error, 'Unable to parse'
+        end
+      end
+    end
+  end
+end

data/lib/apitizer/processing/translator.rb

@@ -0,0 +1,13 @@
+module Apitizer
+  module Processing
+    class Translator
+      def initialize(format:)
+        @parser = Parser.build(format)
+      end
+
+      def process(response)
+        @parser.process(response.body)
+      end
+    end
+  end
+end

data/lib/apitizer/result.rb

@@ -0,0 +1,15 @@
+module Apitizer
+  class Result < SimpleDelegator
+    extend Forwardable
+
+    def_delegator :@request, :path
+    def_delegator :@response, :code
+    def_delegators :__getobj__, :is_a?, :kind_of?, :instance_of?
+
+    def initialize(request:, response:, content:)
+      super(content)
+      @request = request
+      @response = response
+    end
+  end
+end

data/lib/apitizer/routing.rb

@@ -0,0 +1,10 @@
+require_relative 'routing/path'
+require_relative 'routing/node'
+require_relative 'routing/proxy'
+require_relative 'routing/mapper'
+
+module Apitizer
+  module Routing
+    Error = Class.new(Apitizer::Error)
+  end
+end

data/lib/apitizer/routing/mapper.rb

@@ -0,0 +1,47 @@
+module Apitizer
+  module Routing
+    class Mapper
+      extend Forwardable
+
+      def_delegator :@root, :define_address
+
+      def initialize(&block)
+        @root = Node::Root.new
+        define(&block) if block_given?
+      end
+
+      def trace(action, *arguments)
+        path = @root.trace(*arguments)
+        raise Error, 'Not permitted' unless path.permitted?(action)
+        path
+      end
+
+      def define(&block)
+        proxy = Proxy.new(self)
+        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)
+        return unless block_given?
+        proxy = Proxy.new(self, parent: child)
+        proxy.instance_eval(&block)
+      end
+
+      Apitizer.actions.each do |action|
+        define_method "define_#{ action }" do |name, parent:, **options|
+          child = Node::Operation.new(name, action: action, **options)
+          parent.append(child)
+        end
+      end
+    end
+  end
+end

data/lib/apitizer/routing/node.rb

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,44 @@
+module Apitizer
+  module Routing
+    module Node
+      class Base
+        def append(child)
+          children << child
+        end
+
+        def trace(steps, path = Path.new)
+          process(path, steps)
+          advance(path)
+
+          return path if steps.empty?
+
+          child = lookup(steps.first) or raise Error, 'Not found'
+          child.trace(steps, path)
+        end
+
+        def match(name)
+        end
+
+        def process(path, steps)
+        end
+
+        def permitted?(action, path)
+        end
+
+        protected
+
+        def children
+          @children ||= []
+        end
+
+        def lookup(name)
+          children.find { |c| c.match(name) }
+        end
+
+        def advance(path)
+          path.advance(self)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Apitizer
+  module Routing
+    module Node
+      class Collection < Base
+        def initialize(name, only: nil)
+          @name = name
+          @actions = only && Array(only) || Apitizer.actions
+          unless (@actions - Apitizer.actions).empty?
+            raise Error, 'Not supported'
+          end
+        end
+
+        def match(name)
+          @name == name
+        end
+
+        def process(path, steps)
+          path << steps.shift # @name
+          return path if steps.empty?
+          path << steps.shift # id
+        end
+
+        def permitted?(action, path)
+          return false unless @actions.include?(action)
+
+          id_present = path.steps.last != @name
+          member_action = Helper.member_action?(action)
+
+          id_present == member_action
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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
+          @name = name
+          @action = action
+        end
+
+        def match(name)
+          if @name.is_a?(String) && @name =~ /^:/
+            true
+          else
+            @name == name
+          end
+        end
+
+        def process(path, steps)
+          path << steps.shift # @name
+        end
+
+        def permitted?(action, path)
+          @action == action
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Apitizer
+  module Routing
+    module Node
+      class Root < Base
+        def define_address(address, *_)
+          @address = address
+        end
+
+        def process(path, steps)
+          path << @address unless @address.nil?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Apitizer
+  module Routing
+    module Node
+      class Scope < Base
+        def initialize(steps)
+          @steps = Array(steps)
+        end
+
+        def match(name)
+          not lookup(name).nil?
+        end
+
+        def process(path, steps)
+          @steps.each { |step| path << step }
+        end
+      end
+    end
+  end
+end

data/lib/apitizer/routing/path.rb

@@ -0,0 +1,26 @@
+module Apitizer
+  module Routing
+    class Path
+      extend Forwardable
+
+      attr_reader :steps, :node
+      def_delegators :steps, :<<
+
+      def initialize
+        @steps = []
+      end
+
+      def address
+        @steps.map(&:to_s).join('/')
+      end
+
+      def advance(node)
+        @node = node
+      end
+
+      def permitted?(action)
+        @node && @node.permitted?(action, self)
+      end
+    end
+  end
+end

data/lib/apitizer/routing/proxy.rb

@@ -0,0 +1,17 @@
+module Apitizer
+  module Routing
+    class Proxy
+      def initialize(owner, **options)
+        @owner = owner
+        @options = options
+      end
+
+      def method_missing(name, *arguments, **options, &block)
+        name = :"define_#{ name }"
+        return super unless @owner.respond_to?(name)
+        # NOTE: https://bugs.ruby-lang.org/issues/9776
+        @owner.send(name, *arguments, **options, **@options, &block)
+      end
+    end
+  end
+end

data/lib/apitizer/version.rb

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

data/spec/apitizer/base_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+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 }").
+      to_return(code: '200', body: '{}')
+  end
+
+  describe '#new' do
+    it 'does not require any arguments' do
+      expect { subject_class.new }.not_to raise_error
+    end
+
+    it 'draws a routing map when a block is given' do
+      scope_name = address
+      subject = subject_class.new { scope(scope_name) { resources(:articles) } }
+      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
+      subject = subject_class.new(dictionary: { update: :delete }) do
+        scope(scope_name) { resources(:articles) }
+      end
+      stub = stub_request(:delete, 'articles/xxx')
+      subject.process(:update, :articles, 'xxx')
+      expect(stub).to have_been_requested
+    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
+      end
+
+      it "is capable of #{ action } actions via alias" do
+        stub_request(method, 'articles')
+        expect { subject.send(action, :articles) }.not_to raise_error
+      end
+    end
+
+    restful_member_actions.each do |action|
+      method = rest_http_dictionary[action]
+
+      it "is capable of #{ action } actions" do
+        stub_request(method, 'articles/xxx')
+        expect { subject.process(action, :articles, 'xxx') }.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
+      end
+    end
+  end
+end

data/spec/apitizer/connection/adaptor_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Apitizer::Connection::Adaptor do
+  let(:parent_module) { Apitizer::Connection }
+  let(:address) { 'https://service.com/api/v1/json/articles' }
+
+  [ 'Standard' ].each do |adaptor|
+    subject { parent_module::Adaptor.const_get(adaptor).new }
+
+    describe "#{ adaptor }.process" do
+      it 'returns the code, headers, and body of the response' do
+        stub_http_request(:get, address).to_return(
+          code: '200', body: 'Hej!', headers: { 'a' => 'b' } )
+        response = subject.process(:get, address)
+        expect(response).to eq([ '200', { 'a' => [ 'b' ] }, 'Hej!' ])
+      end
+
+      it 'raises exceptions when encounters unknown methods' do
+        expect { subject.process(:smile, address) }.to \
+          raise_error(parent_module::Error, /Invalid method/i)
+      end
+    end
+  end
+end