shutl_resource 0.8.0

data/lib/shutl/resource/rest_class_methods.rb

@@ -0,0 +1,225 @@
+module Shutl::Resource
+  module RestClassMethods
+    def find(args, params = {})
+      unless args.kind_of?(Hash)
+        id = args
+        args = { resource_id_name => id }
+      end
+      token = params.delete :auth
+      url = member_url args.dup, params
+      response = get url, headers_with_auth(token)
+
+      check_fail response, "Failed to find #{name} with the id #{id}"
+
+      parsed = response.parsed_response
+
+      including_parent_attributes = parsed[@resource_name].merge args
+
+      new_object including_parent_attributes, response
+    end
+
+    def create attributes = {}, options = {}
+      url = generate_collection_url attributes
+      attributes.delete "response"
+
+      response = post(url,
+        {body: {@resource_name => attributes}.to_json}.
+          merge(headers_with_auth options[:auth]))
+
+      check_fail response, "Create failed"
+
+      parsed = response.parsed_response || {}
+
+      attributes = parsed[@resource_name] || {}
+      new_object attributes, response
+    end
+
+    def destroy instance, options = {}
+      message =  "Failed to destroy #{name.downcase.pluralize}"
+
+      perform_action(
+        instance,
+        :delete,
+        headers_with_auth(options[:auth]),
+        message
+      ).success?
+    end
+
+    def save instance, options = {}
+      #TODO: this is sometimes a hash and sometimes a Rest - need to rethink this
+      attributes = instance.attributes rescue instance
+
+      response = perform_action instance, :put,
+        {body: {@resource_name => convert_new_id(attributes)}.to_json}.merge(headers_with_auth options[:auth]),
+      "Save failed"
+
+      response.success?
+    end
+
+    def update args, options = {}
+      save args, options
+    end
+
+
+    def all(args = {})
+      token = args.delete :auth
+      partition = args.partition {|key,value| !remote_collection_url.index(":#{key}").nil? }
+
+      url_args = partition.first.inject({}) { |h,pair| h[pair.first] = pair.last ; h }
+      params   = partition.last. inject({}) { |h,pair| h[pair.first] = pair.last ; h }
+
+      url = generate_collection_url url_args, params
+      response = get url, headers_with_auth(token)
+
+      check_fail response, "Failed to find all #{name.downcase.pluralize}"
+
+      response.parsed_response[@resource_name.pluralize].map do |h|
+        new_object(args.merge(h), response)
+      end
+    end
+
+    def resource_name(name)
+      instance_variable_set :@resource_name, name
+    end
+
+    def resource_id(variable_name)
+      instance_variable_set :@resource_id, variable_name
+    end
+
+    def resource_id_name
+      instance_variable_get(:@resource_id).to_sym
+    end
+
+    def remote_collection_url
+      @remote_collection_url ||= "/#{@resource_name.pluralize}"
+    end
+
+    def remote_resource_url
+      @remote_resource_url ||= "#{remote_collection_url}/:#{resource_id_name}"
+    end
+
+    def collection_url(url)
+      @remote_collection_url = url
+    end
+
+    def resource_url(url)
+      @remote_resource_url = url
+    end
+
+    def convert_new_id attributes
+      if attributes[:new_id]
+        attributes = attributes.clone.tap {|h| h[:id] = h[:new_id]; h.delete(:new_id)}
+      end
+
+      attributes
+    end
+
+    def add_resource_id_to args={}
+      args = args.dup.with_indifferent_access
+      unless args.has_key? "id"
+        args.merge!({"id" => args[resource_id_name]})
+      end
+      args
+    end
+
+    def member_url *args
+      attributes = args.first.with_indifferent_access
+      unless attributes[resource_id_name] ||= attributes[:id]
+        raise ArgumentError, "Missing resource id with name: `#{resource_id_name}' for #{self}"
+      end
+
+      args[0] = attributes
+
+      generate_url! remote_resource_url, *(args.dup)
+    end
+
+    def generate_collection_url *args
+      generate_url! remote_collection_url, *args
+    end
+
+
+    private
+
+    def headers_with_auth token
+      { headers: headers.merge('Authorization' => "Bearer #{token}") }
+    end
+
+    def perform_action instance, verb, args, failure_message
+      attributes = instance.is_a?(Hash) ?  instance : instance.attributes
+      attributes.delete "response" #used in debugging requests/responses
+
+      url = member_url attributes
+      response = send verb, url, args
+
+      check_fail response, failure_message
+
+      response
+    end
+
+    def new_object(args={}, response=nil)
+      instance = new add_resource_id_to(args), response
+
+      instance.tap do |i|
+        parsed_response = response.parsed_response
+
+        if errors = (parsed_response and parsed_response["errors"])
+          i.errors = errors
+        end
+      end
+    end
+
+    def check_fail response, message
+      c = response.code
+      failure_klass = case c
+                      when 299 then Shutl::NoQuotesGenerated
+                      when 400 then Shutl::BadRequest
+                      when 401 then Shutl::UnauthorizedAccess
+                      when 403 then Shutl::ForbiddenAccess
+                      when 404 then Shutl::ResourceNotFound
+                      when 409 then Shutl::ResourceConflict
+                      when 410 then Shutl::ResourceGone
+                      when 422
+                        if Shutl::Resource.raise_exceptions_on_validation
+                          Shutl::ResourceInvalid
+                        else
+                          nil #handled as validation failure
+                        end
+
+                      when 411..499
+                        Shutl::BadRequest
+                      when 500 then Shutl::ServerError
+                      when 503 then Shutl::ServiceUnavailable
+                      when 501..Float::INFINITY
+                        Shutl::ServerError
+                      end
+
+      raise failure_klass.new message, response if failure_klass
+    end
+
+    protected
+
+    def generate_url!(url_pattern, args, params = {})
+      url = url_pattern.dup
+
+      args, url = replace_args_from_pattern! args, url
+
+      url = URI.escape url
+      unless params.empty?
+        url += '?'
+        params.each { |key, value| url += "#{key}=#{value}&" }
+      end
+      url
+    end
+
+    private
+    def replace_args_from_pattern! args, url
+      args = args.reject! do |key,value|
+        if s = url[":#{key}"]
+          url.gsub!(s, value.to_s)
+        end
+      end
+
+      return args, url
+    end
+  end
+end

data/lib/shutl/resource/version.rb

@@ -0,0 +1,5 @@
+module Shutl
+  module Resource
+    VERSION = '0.8.0'
+  end
+end

data/lib/shutl_resource.rb

@@ -0,0 +1,20 @@
+module Shutl
+end
+
+require 'shutl_auth'
+require 'shutl/resource/configuration'
+require 'shutl/resource/rest'
+require 'shutl/resource/rest_class_methods'
+require 'shutl/resource/errors'
+
+module Shutl::Resource
+  extend self
+
+  delegate :logger, :logger=, to: Configuration
+
+  def configure(*args, &block)
+    Configuration.configure(*args, &block)
+  end
+end
+
+

data/script/ci

@@ -0,0 +1,2 @@
+bundle install --path vendor/bundle
+bundle exec rspec spec

data/shutl_resource.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/shutl/resource/version', __FILE__)
+
+$platform ||= RUBY_PLATFORM[/java/] || 'ruby'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["David Rouchy", "Volker Pacher", "Mark Burns"]
+  gem.email         = ["davidr@shutl.co.uk", "volker@shutl.com", "mark@shutl.com"]
+  gem.description   = %q{Shutl Rest resource}
+  gem.summary       = %q{Manage Shutl Rest resource. Parse/Serialize JSON}
+  gem.homepage      = ""
+  gem.platform       = $platform
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "shutl_resource"
+  gem.require_paths = ["lib"]
+  gem.version       = Shutl::Resource::VERSION
+
+  gem.add_dependency 'httparty', '~> 0.10.0'
+  gem.add_dependency 'shutl_auth', '0.8.0'
+  gem.add_dependency 'activemodel'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec', '~> 2.11.0'
+  gem.add_development_dependency 'debugger'   if $platform.to_s == 'ruby'
+  gem.add_development_dependency 'ruby-debug' if $platform.to_s == 'java'
+  gem.add_development_dependency 'vcr'
+
+  gem.add_development_dependency 'webmock', '~> 1.8.7'
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Shutl::Resource do
+  describe '#configure' do
+    let(:logger) { Shutl::Resource.logger }
+
+    it 'should configure the logger' do
+      logger = stub('logger')
+
+      Shutl::Resource.configure do |config|
+        config.logger = logger
+      end
+
+      Shutl::Resource.logger.should == logger
+    end
+  end
+end

data/spec/dynamic_resource_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Shutl::Resource::Rest do
+
+  class TestResource
+    include Shutl::Resource::Rest
+  end
+
+  class TestOverride
+    include Shutl::Resource::Rest
+    resource_name 'a_other_prefix'
+  end
+
+  let(:resource) { TestResource.new({ a: 'a', b: 'b' }) }
+
+  describe '#initalize' do
+    it 'should assign the instance variable value for the entries in the hash' do
+      resource.instance_variable_get(:@a).should == 'a'
+      resource.instance_variable_get(:@b).should == 'b'
+    end
+
+    it 'should create a attribute reader' do
+      resource.a().should == 'a'
+    end
+
+    it 'should keep the method not found behaviour' do
+      lambda { resource.notfound() }.should raise_error(NameError)
+    end
+  end
+
+  describe '#to_json' do
+
+    it 'should "prefix" the json with the name of the class' do
+      json = resource.to_json
+
+      JSON.parse(json, symbolize_names: true)[:test_resource].should_not be_nil
+    end
+
+    it 'should serialize in json based on the instance variables' do
+      json = resource.to_json
+
+      JSON.parse(json, symbolize_names: true).should == { test_resource: { a: 'a', b: 'b' } }
+    end
+
+    it 'should be able to overribe the prefix' do
+      json = TestOverride.new({ a: 'a'}).to_json
+
+      JSON.parse(json, symbolize_names: true)[:a_other_prefix].should_not be_empty
+
+    end
+  end
+
+  describe 'udpate_attributes' do
+
+    it 'should replace the attributes' do
+      resource.update_attributes(a: 'c')
+
+      resource.instance_variable_get(:@a).should == 'c'
+
+    end
+
+    it 'should use a white list permission'
+
+  end
+end

data/spec/remote_url_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Shutl::Resource::Rest do
+  let(:headers) do
+    {'Accept'=>'application/json', 'Authorization'=>'Bearer', 'Content-Type'=>'application/json'}
+  end
+
+
+  class OverrideUrlResource
+    include Shutl::Resource::Rest
+    collection_url '/api/resources'
+    resource_url '/api/resources/:name'
+  end
+
+  module Namespace
+    class Resource
+      include Shutl::Resource::Rest
+    end
+  end
+
+  describe '#remote_collection_url' do
+    it 'should be based on the resource name by default' do
+      TestRest.remote_collection_url.should == '/test_rests'
+    end
+
+    it 'should use the override if defined' do
+      OverrideUrlResource.remote_collection_url.should == '/api/resources'
+    end
+
+    it 'only uses the specific object to infer the resource name' do
+      Namespace::Resource.remote_collection_url.should == '/resources'
+    end
+  end
+
+  describe '#remote_resource_url' do
+    it 'should be base on the resource name and the resource id name by default' do
+      TestRest.remote_resource_url.should == '/test_rests/:a'
+    end
+
+    it 'should use the override if defined' do
+      OverrideUrlResource.remote_resource_url.should == '/api/resources/:name'
+    end
+  end
+
+  context 'nested resource' do
+    class NestedResource
+      include Shutl::Resource::Rest
+      base_uri 'http://host'
+      collection_url '/nested/:parent_id/resources'
+      resource_url '/nested/:parent_id/resources/:id'
+    end
+
+    let(:resource) { NestedResource.new(id: 2, parent_id: 10) }
+
+    describe '#all' do
+      it 'should query the correct endpoint' do
+        request = stub_request(:get, 'http://host/nested/10/resources').
+          to_return(body: '{"nested_resources": []}', headers: headers)
+
+        NestedResource.all(parent_id: 10)
+
+        request.should have_been_requested
+      end
+
+      it 'should add the nested params to the attributes' do
+        stub_request(:get, 'http://host/nested/10/resources').
+          to_return(body: '{"nested_resources": [{}, {}]}', headers: headers)
+
+        resources = NestedResource.all(parent_id: 10)
+
+        resources.each { |r| r.parent_id.should == 10 }
+      end
+
+      it 'should support the params' do
+        request = stub_request(:get, 'http://host/nested/10/resources?arg1=val1&arg2=val2').
+          to_return(body: '{"nested_resources": []}', headers: headers)
+
+        NestedResource.all(parent_id: 10, arg1: 'val1', arg2: 'val2')
+
+        request.should have_been_requested
+      end
+    end
+
+    describe '#find' do
+      it 'should query the correct endpoint' do
+        request = stub_request(:get, 'http://host/nested/10/resources/2').
+          to_return(body: '{"nested_resource": {}}', headers: headers)
+
+        NestedResource.find(id: 2, parent_id: 10)
+
+        request.should have_been_requested
+      end
+
+      it 'should add the nested params to the attributes' do
+        stub_request(:get, 'http://host/nested/10/resources/2').
+          to_return(body: '{"nested_resource": {}}', headers: headers)
+
+        resource = NestedResource.find(id: 2, parent_id: 10)
+
+        resource.parent_id.should == 10
+      end
+    end
+
+    describe 'update' do
+      it 'should query the correct endpoint' do
+        request = stub_request(:put, 'http://host/nested/10/resources/2').
+          to_return(body: '{"nested_resource": {}}', headers: headers)
+
+        resource.save
+
+        request.should have_been_requested
+      end
+    end
+
+    describe '#create' do
+      it 'should query the correct endpoint' do
+        request = stub_request(:post, 'http://host/nested/10/resources').
+          to_return(body: '{"nested_resource": {}}', headers: headers)
+
+        NestedResource.create(parent_id: 10)
+
+        request.should have_been_requested
+      end
+    end
+
+    describe '#delete' do
+      it 'should query the correct endpoint' do
+        request = stub_request(:delete, 'http://host/nested/10/resources/2').
+          to_return(body: '{"nested_resource": {}}', headers: headers)
+
+        NestedResource.destroy(parent_id: 10, id: 2)
+
+        request.should have_been_requested
+      end
+
+      specify do
+        request = stub_request(:delete, 'http://host/nested/10/resources/2').
+          to_return(body: '{"nested_resource": {}}',
+                    headers: {"Content-Type" => "application/json"})
+
+        resource.destroy auth: 'TOKEN'
+
+        request.should have_been_requested
+
+      end
+
+    end
+  end
+end