api_client 0.5.24-java → 0.6.0-java

data/lib/api_client/resource/base.rb

@@ -0,0 +1,67 @@
+module ApiClient
+
+  module Resource
+
+    class Base < ApiClient::Base
+
+      class << self
+        extend ApiClient::Mixins::Delegation
+        extend ApiClient::Mixins::Configuration
+
+        delegate :find_all, :find, :create, :update, :destroy, :path, :to => :scope
+
+        dsl_accessor :prefix
+
+        def inherited(subclass)
+          super
+          small_name = NameResolver.resolve(subclass.name)
+          subclass.namespace small_name
+          subclass.prefix    self.prefix
+          subclass.always do
+            name    = small_name
+            pre_fix = prefix
+            path ["", prefix, "#{name}s"].compact.join('/')
+          end
+        end
+
+        def scope(options = {})
+          scope_in_thread || ApiClient::Resource::Scope.new(self).params(options)
+        end
+
+      end
+
+      def persisted?
+        !!self.id
+      end
+
+      def save
+        self.persisted? ? remote_update : remote_create
+      end
+
+      def destroy
+        get_scope.destroy(self.id)
+      end
+
+      def payload
+        hash = self.to_hash
+        hash.delete('id') # This key is never required
+        hash
+      end
+
+      def remote_update
+        get_scope.update(self.id, payload)
+      end
+
+      def remote_create
+        get_scope.create(payload)
+      end
+
+      def get_scope
+        original_scope || self.class
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/resource/name_resolver.rb

@@ -0,0 +1,37 @@
+module ApiClient
+  module Resource
+    class NameResolver
+      def self.resolve(ruby_path)
+        new(ruby_path).resolve
+      end
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def resolve
+        select_last_item
+        underscorize
+        lowercase
+        name
+      end
+
+      private
+      def select_last_item
+        @name = @name.split('::').last
+      end
+
+      #Inspired by ActiveSupport::Inflector#underscore
+      def underscorize
+        @name.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        @name.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      end
+
+      def lowercase
+        @name.downcase!
+      end
+    end
+  end
+end

data/lib/api_client/resource/scope.rb

@@ -0,0 +1,73 @@
+# This class includes methods for calling restful APIs
+module ApiClient
+
+  module Resource
+
+    class Scope < ApiClient::Scope
+
+      dsl_accessor :path, :return_self => true
+
+      def format
+        @scopeable.format
+      end
+
+      def append_format(path)
+        format ? [path, format].join('.') : path
+      end
+
+      def find(id)
+        path     = [@path, id].join('/')
+        path     = append_format(path)
+        response = get(path)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def find_all(params = {})
+        path     = append_format(@path)
+        response = get(path, params)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def create(params = {})
+        path = append_format(@path)
+        hash = if @scopeable.namespace
+          { @scopeable.namespace => params }
+        else
+          params
+        end
+        response = post(path, hash)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def update(id, params = {})
+        path = [@path, id].join('/')
+        path = append_format(path)
+        hash = if @scopeable.namespace
+          { @scopeable.namespace => params }
+        else
+          params
+        end
+        response = put(path, hash)
+        scoped(self) do
+          raw? ? response : @scopeable.build(response)
+        end
+      end
+
+      def destroy(id)
+        path = [@path, id].join('/')
+        path = append_format(path)
+        delete(path)
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/api_client/scope.rb

@@ -0,0 +1,125 @@
+module ApiClient
+
+  class Scope
+    extend ApiClient::Mixins::Configuration
+    extend ApiClient::Mixins::Delegation
+
+    delegate     :prefix, :scoped, :to => :scopeable
+
+    dsl_accessor :endpoint, :adapter, :return_self => true
+
+    attr_reader  :scopeable
+
+    def initialize(scopeable)
+      @scopeable  = scopeable
+      @params     = {}
+      @headers    = {}
+      @options    = {}
+      @scopeable.default_scopes.each do |default_scope|
+        self.instance_eval(&default_scope)
+      end
+    end
+
+    def connection
+      klass       = Connection.const_get((@adapter || Connection.default).to_s.capitalize)
+      @connection = klass.new(@endpoint , @options || {})
+      hooks      = @scopeable.connection_hooks || []
+      hooks.each { |hook| hook.call(@connection, self) }
+      @connection
+    end
+
+    def raw
+      @raw = true
+      self
+    end
+
+    def raw?
+      !!@raw
+    end
+
+    # 3 Pillars of scoping
+    # options - passed on the the adapter
+    # params  - converted to query or request body
+    # headers - passed on to the request
+    def options(new_options = nil)
+      return @options if new_options.nil?
+      ApiClient::Utils.deep_merge(@options, new_options)
+      self
+    end
+
+    def params(options = nil)
+      return @params if options.nil?
+      ApiClient::Utils.deep_merge(@params, options)  if options
+      self
+    end
+    alias :scope :params
+
+    def headers(options = nil)
+      return @headers if options.nil?
+      ApiClient::Utils.deep_merge(@headers, options) if options
+      self
+    end
+
+    def raw_body(options = nil)
+      return @raw_body if options.nil?
+      @raw_body = options
+      self
+    end
+
+    def clone_only_headers
+      self.class.new(self.scopeable).headers(self.headers)
+    end
+
+    # Half-level :)
+    # This is a swiss-army knife kind of method, extremely useful
+    def fetch(path, options = {})
+      scoped(self) do
+        @scopeable.build get(path, options)
+      end
+    end
+
+    # Low-level connection methods
+
+    def request(method, path, options = {})
+      options = options.dup
+
+      raw = raw? || options.delete(:raw)
+      params(options)
+      response = connection.send method, path, (@raw_body || @params), @headers
+      raw ? response : @scopeable.parse(response)
+    end
+
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    def patch(path, options = {})
+      request(:patch, path, options)
+    end
+
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    # Dynamic delegation of scopeable methods
+    def method_missing(method, *args, &block)
+      if @scopeable.respond_to?(method)
+        @scopeable.scoped(self) do
+          @scopeable.send(method, *args, &block)
+        end
+      else
+        super
+      end
+    end
+
+  end
+
+end

data/lib/api_client/utils.rb

@@ -0,0 +1,18 @@
+module ApiClient
+
+  module Utils
+
+    def self.deep_merge(hash, other_hash)
+      other_hash.each_pair do |key,v|
+        if hash[key].is_a?(::Hash) and v.is_a?(::Hash)
+          deep_merge hash[key], v
+        else
+          hash[key] = v
+        end
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/api_client/version.rb

@@ -0,0 +1,3 @@
+module ApiClient
+  VERSION = '0.6.0'
+end

data/spec/api_client/base/connection_hook_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe '.connection' do
+
+    it "registers a new connection_hook" do
+      ConnectionHookTestProc = lambda {}
+      class ConnectionHookTest < ApiClient::Base
+        connection &ConnectionHookTestProc
+      end
+      ConnectionHookTest.connection_hooks.size.should == 1
+      ConnectionHookTest.connection_hooks.should == [ConnectionHookTestProc]
+    end
+
+  end
+
+end

data/spec/api_client/base/delegation_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  it "delegates methods to scope" do
+    scope = double
+    ApiClient::Base.stub(:scope).and_return(scope)
+    [:fetch, :get, :put, :post, :patch, :delete, :headers, :endpoint, :options, :adapter, :params, :raw].each do |method|
+      scope.should_receive(method)
+      ApiClient::Base.send(method)
+    end
+
+  end
+
+end

data/spec/api_client/base/inheritance_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe "subclasses" do
+
+    it "inherit scopes, hooks, namespace and format" do
+
+      class Level1InheritanceTest < ApiClient::Base
+      end
+
+      Level1InheritanceTest.default_scopes.should   == []
+      Level1InheritanceTest.connection_hooks.should == []
+      Level1InheritanceTest.namespace.should        == nil
+      Level1InheritanceTest.format.should           == :json
+
+      Level1InheritanceTest.default_scopes   = ['scope1']
+      Level1InheritanceTest.connection_hooks = ['hook1']
+      Level1InheritanceTest.namespace        'level1'
+      Level1InheritanceTest.format           :xml
+
+      ApiClient::Base.default_scopes.should   == []
+      ApiClient::Base.connection_hooks.should == []
+      ApiClient::Base.namespace.should        == nil
+      ApiClient::Base.format.should           == :json
+
+      class Level2InheritanceTest < Level1InheritanceTest
+        namespace "level2"
+        format    :yaml
+      end
+
+      Level2InheritanceTest.default_scopes.should   == ['scope1']
+      Level2InheritanceTest.connection_hooks.should == ['hook1']
+      Level2InheritanceTest.namespace.should        == 'level2'
+      Level2InheritanceTest.format.should           == :yaml
+
+      Level1InheritanceTest.namespace.should == 'level1'
+      Level1InheritanceTest.format.should    == :xml
+
+    end
+
+  end
+
+end

data/spec/api_client/base/instantiation_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe "build" do
+
+    it "instantiates an array of objects and returns an array if passed an array" do
+      result = ApiClient::Base.build [{ :id => 1 }, { :id => 2}]
+      result.should be_an_instance_of(Array)
+      result.first.should be_an_instance_of(ApiClient::Base)
+      result.last.should  be_an_instance_of(ApiClient::Base)
+    end
+
+    it "instantiates an object and returns an object if passed an object" do
+      result = ApiClient::Base.build({ :id => 1 })
+      result.should be_an_instance_of(ApiClient::Base)
+    end
+
+  end
+
+  describe "build_one" do
+
+    it "extracts the attributes from a namespace if a namespace is provided" do
+      ApiClient::Base.stub(:namespace).and_return("base")
+      result = ApiClient::Base.build({ "base" => { :id => 1 } })
+      result.should be_an_instance_of(ApiClient::Base)
+      result.keys.should == ['id']
+      result.id.should   == 1
+    end
+
+  end
+
+  describe "sub hashes" do
+
+    it "are Hashie::Mashes" do
+      result = ApiClient::Base.build({ :id => 1, :subhash => { :foo => 1 } })
+      result.subhash.should be_a(Hashie::Mash)
+    end
+
+  end
+
+  describe "original_scope" do
+
+    it "holds the original scope it was created from" do
+      scope = ApiClient::Base.params(:foo => 1).headers('token' => 'aaa').options("some" => "option")
+
+      instance = scope.build :key => 'value'
+      instance.original_scope.headers.should == {'token' => 'aaa'}
+      instance.original_scope.params.should be_empty
+      instance.original_scope.options.should be_empty
+    end
+
+  end
+
+end

data/spec/api_client/base/marshalling_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "Marshaling of ApiClient objects" do
+  ConnectionProc = Proc.new {}
+  AlwaysProc = Proc.new {}
+
+  class Entity < ApiClient::Base
+    connection &ConnectionProc
+    always &AlwaysProc
+
+    def mutated_state?
+      @state == "mutated"
+    end
+
+    def mutate_state!
+      @state = "mutated"
+    end
+  end
+
+  it "is marshallable by default" do
+    scope = Entity.params(:foo => 1).headers("token" => "aaa").options("some" => "option")
+    entity = scope.build :key => "value"
+
+    entity.mutated_state?.should == false
+    entity.mutate_state!
+    entity.mutated_state?.should == true
+
+    reloaded = Marshal.load(Marshal.dump(entity))
+
+    reloaded.should == entity
+    reloaded.mutated_state?.should == true
+  end
+end

data/spec/api_client/base/parsing_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+require "multi_xml"
+
+describe ApiClient::Base do
+
+  it "parses json if json is set as format" do
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse('{"a":"1"}')
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "parses xml if xml is set as format" do
+    ApiClient::Base.stub(:format).and_return(:xml)
+    parsed = ApiClient::Base.parse('<a>1</a>')
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "returns the string if parser is not found" do
+    ApiClient::Base.stub(:format).and_return(:unknown)
+    parsed = ApiClient::Base.parse('a:1')
+    parsed.should == "a:1"
+  end
+
+  it "extracts the body of a Faraday::Response if it is provided" do
+    response = Faraday::Response.new(:body => '{"a": "1"}')
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse(response)
+    parsed.should == {"a"=> "1"}
+  end
+
+  it "returns nil if the response is 204" do
+    response = Faraday::Response.new(:body => nil, :status => 204)
+    ApiClient::Base.stub(:format).and_return(:json)
+    parsed = ApiClient::Base.parse(response)
+    parsed.should == nil
+  end
+end

data/spec/api_client/base/scoping_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  describe '.always' do
+
+    it "registers a new default_scope" do
+      AlwaysTestProc = lambda {}
+      class AlwaysTest < ApiClient::Base
+        always &AlwaysTestProc
+      end
+      AlwaysTest.default_scopes.size.should == 1
+      AlwaysTest.default_scopes.should == [AlwaysTestProc]
+    end
+
+  end
+
+  describe '.scope' do
+
+    it "returns a ApiClient::Scope instance" do
+      ApiClient::Base.scope.should be_an_instance_of(ApiClient::Scope)
+    end
+
+  end
+
+  describe '.scope_thread_attribute_name' do
+
+    it "returns the key under which all .scoped calls should be stored" do
+      ApiClient::Base.scope_thread_attribute_name.should == "ApiClient::Base_scope"
+    end
+
+  end
+
+  describe '.scoped' do
+
+    it "stores the scope in the thread context, attached to class name" do
+      mock_scope3 = double
+      ApiClient::Base.scoped(mock_scope3) do
+        Thread.new {
+          mock_scope2 = double
+          ApiClient::Base.scoped(mock_scope2) do
+            ApiClient::Base.scope.should == mock_scope2
+            Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope2]
+          end
+        }
+        ApiClient::Base.scope.should == mock_scope3
+        Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope3]
+      end
+      Thread.new {
+        mock_scope = double
+        ApiClient::Base.scoped(mock_scope) do
+          ApiClient::Base.scope.should == mock_scope
+          Thread.current[ApiClient::Base.scope_thread_attribute_name].should == [mock_scope]
+        end
+      }
+    end
+
+  end
+
+end

data/spec/api_client/base_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+
+describe ApiClient::Base do
+
+  it "is a subclass of Hashie::Mash" do
+    ApiClient::Base.should inherit_from(Hashie::Mash)
+  end
+
+  it "responds to #id" do
+    subject.should respond_to("id")
+  end
+
+  class StrictApi < ApiClient::Base
+    def accessor_of_x
+      self.x
+    end
+
+    def strict_attr_reader?
+      true
+    end
+  end
+
+  class StrictDescendant < StrictApi
+  end
+
+  context "when used in an array" do
+
+    subject { [StrictApi.new] }
+
+    it "does not break Array#flatten" do
+      lambda { subject.flatten }.should_not raise_error
+    end
+
+  end
+
+  describe "#inspect" do
+
+    it "has a nice inspect" do
+      subject.update(:id => 1).inspect.should == '#<ApiClient::Base id: 1>'
+    end
+
+    it "presents all fields in inspect" do
+      subject.update(:id => 1, :foo => 'OMG')
+      subject.inspect.should == '#<ApiClient::Base id: 1, foo: "OMG">'
+    end
+
+    it "inspects subobjects properly" do
+      subject.update(:id => 1, :sub => [1,2])
+      subject.inspect.should == '#<ApiClient::Base id: 1, sub: #<Hashie::Array [1, 2]>>'
+    end
+
+    it "makes sure id is the first key" do
+
+      subject.update(:foo => 'OMG', :id => 1)
+      subject.inspect.should == '#<ApiClient::Base id: 1, foo: "OMG">'
+    end
+
+  end
+
+  describe "strict_read" do
+    it "fails if the key is missing and strict_read is set" do
+      api = StrictApi.new
+      lambda { api.missing }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+
+    it "doesn't fail if strict_read is not set" do
+      api = ApiClient::Base.new
+      api.missing
+    end
+
+    it "doesn't fail if the key was set after object was created" do
+      api = StrictApi.new
+      lambda { api.not_missing = 1 }.should_not raise_error
+      api.not_missing.should == 1
+    end
+
+    it "doesn't fail for predicate methods if key is not set" do
+      api = StrictApi.new
+      lambda { api.missing? }.should_not raise_error
+      api.missing?.should be_false
+    end
+
+    it "allows to call methods" do
+      api = StrictApi.new(:x => 14)
+      api.accessor_of_x.should == 14
+    end
+
+    it "calling method which asks for missing attribute fails" do
+      api = StrictApi.new
+      lambda { api.accessor_of_x }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+
+    it "passes strict api configuration to subclasses" do
+      api = StrictDescendant.new
+      lambda { api.missing }.should raise_error do |error|
+        error_type = error.class.to_s
+        error_type.should match(/KeyError|IndexError/)
+      end
+    end
+  end
+end