smooth_operator 0.4.4 → 1.2.0

data/lib/smooth_operator/http_handlers/typhoeus/base.rb

@@ -1,58 +0,0 @@
-require 'typhoeus'
-require "smooth_operator/http_handlers/typhoeus/remote_call"
-
-module SmoothOperator
-  module HttpHandlers
-    module Typhoeus
-    
-      class Base
-    
-        def self.make_the_call(http_verb, url, options, basic_auth_credentials)
-          hydra = get_hydra_and_remove_it_from options
-          options = { (http_verb == :get ? :params : :body) => options, :method => http_verb, :headers => { "Content-type" => "application/x-www-form-urlencoded" } }.merge auth_credentials(basic_auth_credentials)
-          
-          if hydra.present?
-            make_asynchronous_request(url, options, hydra)
-          else
-            make_synchronous_request(url, options)
-          end
-        end
-        
-        private ###################### PRIVATE ##################
-
-        def self.auth_credentials(basic_auth_credentials)        
-          basic_auth_credentials.blank? ? {} : { userpwd: "#{basic_auth_credentials[:username]}:#{basic_auth_credentials[:password]}" }
-        end
-        
-        def self.get_hydra_and_remove_it_from(options)
-          options.delete(:hydra)
-        end
-
-        def self.make_synchronous_request(url, options)
-          hydra = ::Typhoeus::Hydra::hydra
-          remote_call = make_asynchronous_request(url, options, hydra)
-
-          remote_call.request.on_complete do |response|
-            remote_call.raw_response = response
-            remote_call.response = remote_call.parsed_response
-          end
-
-          hydra.run
-          remote_call
-        end
-
-        def self.make_asynchronous_request(url, options, hydra)
-          request = ::Typhoeus::Request.new(url, options)
-          
-          remote_call = SmoothOperator::HttpHandlers::Typhoeus::RemoteCall.new(request)
-
-          hydra.queue(request)
-
-          remote_call
-        end
-
-      end
-
-    end
-  end
-end

data/lib/smooth_operator/http_handlers/typhoeus/orm.rb

@@ -1,34 +0,0 @@
-module SmoothOperator
-  module HttpHandlers
-    module Typhoeus
-
-      class ORM
-
-        attr_reader :object_class
-
-        def initialize(object_class)
-          @object_class = object_class
-        end
-
-        def make_the_call(http_verb, options, relative_path, &block)
-          injected_hydra = options[:hydra]
-          hydra = injected_hydra || ::Typhoeus::Hydra::hydra
-          options[:hydra] = hydra
-
-          remote_call = @object_class.make_the_call(http_verb, relative_path, options)
-
-          remote_call.request.on_complete do |typhoeus_response|
-            remote_call.raw_response = typhoeus_response
-            yield(remote_call)
-          end
-          
-          hydra.run if injected_hydra.blank?
-
-          remote_call
-        end
-        
-      end
-
-    end
-  end
-end

data/lib/smooth_operator/http_handlers/typhoeus/remote_call.rb

@@ -1,28 +0,0 @@
-require "smooth_operator/operator/remote_call"
-
-module SmoothOperator
-  module HttpHandlers
-    module Typhoeus
-
-      class RemoteCall < SmoothOperator::Operator::RemoteCall
-
-        attr_reader :request
-
-        def initialize(request)
-          @request = request
-        end
-
-        def parse_response
-          begin
-            @parse_response ||= ::HTTParty::Parser.call(@raw_response.body, :json)
-          rescue
-            nil
-          end
-        end
-
-      end
-
-    end
-
-  end
-end

data/lib/smooth_operator/operator/base.rb

@@ -1,43 +0,0 @@
-module SmoothOperator
-  module Operator
-
-    module Base
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-
-        def get(relative_path, options = {})
-          make_the_call(:get, relative_path, options)
-        end
-
-        def post(relative_path, options = {})
-          make_the_call(:post, relative_path, options)
-        end
-
-        def put(relative_path, options = {})
-          make_the_call(:put, relative_path, options)
-        end
-
-        def delete(relative_path, options = {})
-          make_the_call(:delete, relative_path, options)
-        end
-
-        def make_the_call(http_verb, relative_path, options = {})
-          url = build_url(relative_path)
-          options = query_string(options || {})
-          http_handler_base.make_the_call(http_verb, url, options, get_basic_auth_credentials)
-        end
-
-        def query_string(options)
-          options
-        end
-
-      end
-
-    end
-
-  end
-end

data/lib/smooth_operator/operator/exceptions.rb

@@ -1,64 +0,0 @@
-module SmoothOperator
-  module Operator
-    
-  	module Exceptions
-
-    	extend self
-
-    	def raise_proper_exception(response, code)
-    		return nil if CODES_TO_IGNORE.include?(code)
-    		exception_to_raise = (CODE_VS_EXCEPTIONS[code] || SmoothOperator::Operator::Exceptions::Unknown).new(response)
-    		#raise exception_to_raise, exception_to_raise.message
-    	end
-
-  		class Base < StandardError
-  			attr_reader :response
-
-  	  	def initialize(response)
-  		    @response = response
-  		  end
-  		end
-
-  		class Unknown < SmoothOperator::Operator::Exceptions::Base
-  			def message
-  	  		'Unknown Error'
-  	  	end
-  		end
-
-    	class	NotFound < SmoothOperator::Operator::Exceptions::Base
-    		def message
-  	  		'NotFound'
-  	  	end
-    	end
-
-    	class	EntityNotProcessed < SmoothOperator::Operator::Exceptions::Base
-    		def message
-  	  		'EntityNotProcessed'
-  	  	end
-    	end
-
-    	class	ServerError < SmoothOperator::Operator::Exceptions::Base
-    		def message
-  	  		'ServerError'
-  	  	end
-    	end
-    	
-    	class	AuthorizationRequired < SmoothOperator::Operator::Exceptions::Base
-    		def message
-  	  		'AuthorizationRequired'
-  	  	end
-    	end
-
-  		CODES_TO_IGNORE = [200]
-
-    	CODE_VS_EXCEPTIONS = {
-    		401 => AuthorizationRequired,
-    		422 => EntityNotProcessed,
-    	 	404 => NotFound,
-    	 	500 => ServerError
-    	}
-
-  	end
-
-  end
-end

data/lib/smooth_operator/operator/orm.rb

@@ -1,118 +0,0 @@
-module SmoothOperator
-  module Operator
-
-    module ORM
-
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.send(:attr_reader, :last_response)
-        base.send(:attr_reader, :exception)
-      end
-
-      module ClassMethods
-
-        def find(id, options = {})
-          if id == :all
-            find_each('', options)
-          else
-            find_one(id, options)
-          end
-        end
-
-        def safe_find(id, options = {})
-          begin
-            find(id, options)
-          rescue Exception => exception #exception.response contains the server response
-            id == :all ? [] : nil
-          end
-        end
-
-        def create(options = {})
-          new_object = new(options)
-
-          http_handler_orm.make_the_call(:post, { model_name_downcase => new_object.safe_table_hash }, '') do |remote_call|
-            new_object.send('after_create_update_or_destroy', remote_call)
-          end
-
-          new_object
-        end
-
-        def find_each(relative_path, options)
-          http_handler_orm.make_the_call(:get, options, relative_path) do |remote_call|
-            objects_list = remote_call.get_attributes(table_name)
-            
-            if objects_list.kind_of?(Array)
-              remote_call.response = objects_list.map { |attributes| new remote_call.get_attributes(model_name_downcase, attributes) }
-            else
-              remote_call.response = objects_list
-            end
-          end
-        end
-
-        def find_one(relative_path, options)
-          http_handler_orm.make_the_call(:get, options, relative_path) do |remote_call|
-            remote_call.response = new remote_call.get_attributes(model_name_downcase)
-          end
-        end
-
-      end
-
-      def save(options = {})
-        begin
-          save!(options)
-        rescue Exception => exception
-          send("exception=", exception)
-          false
-        end
-      end
-
-      def save!(options = {})
-        options = build_options_for_save(options)
-
-        if new_record?
-          http_handler_orm.make_the_call(:post, options, '') { |remote_call| after_create_update_or_destroy(remote_call) }
-        else
-          http_handler_orm.make_the_call(:put, options, id) { |remote_call| after_create_update_or_destroy(remote_call) }
-        end
-      end
-
-      def destroy(options = {})
-        return true if new_record?
-        
-        http_handler_orm.make_the_call(:delete, options, id) do |remote_call|
-          after_create_update_or_destroy(remote_call)
-        end
-      end
-
-      private ####################### private #######################
-
-      def build_options_for_save(options = {})
-        options ||= {}
-        options[self.class.model_name_downcase] ||= safe_table_hash
-        options
-      end
-
-      def after_create_update_or_destroy(remote_call)
-        new_attributes = remote_call.get_attributes(self.class.model_name_downcase)
-        assign_attributes(new_attributes)
-        set_raw_response_exception_and_build_proper_response(remote_call)
-      end
-
-      def set_raw_response_exception_and_build_proper_response(remote_call)
-        send("last_response=", remote_call.raw_response)
-        send("exception=", remote_call.exception)
-        remote_call.response = remote_call.successful_response?
-      end
-
-      def last_response=(response)
-        @last_response = response
-      end
-
-      def exception=(exception)
-        @exception = exception
-      end
-
-    end
-    
-  end
-end

data/lib/smooth_operator/operator/remote_call.rb

@@ -1,84 +0,0 @@
-require "smooth_operator/operator/exceptions"
-
-module SmoothOperator
-  module Operator
-
-    class RemoteCall
-
-      attr_reader :protocol_handler, :raw_response, :parsed_response, :exception
-      attr_writer :response
-
-      HTTP_SUCCESS_CODES = [200, 201, 202, 203, 204]
-
-      def parse_response # TO BE OVERWRITTEN IF NECESSARY
-        @raw_response
-      end
-
-      def successful_response? # TO BE OVERWRITTEN IF NECESSARY
-        @raw_response.blank? || HTTP_SUCCESS_CODES.include?(code)
-      end
-
-      def code # TO BE OVERWRITTEN IF NECESSARY
-        @raw_response.code
-      end
-
-      def ok?; successful_response?; end
-
-      def error?; !ok? && exception.present?; end
-
-      def raw_response=(response)
-        @raw_response = response
-        @parsed_response = parse_response_and_set_exception_if_necessary
-      end
-
-      def response
-        exception.present? ? false : @response
-      end
-
-      def ==(object_to_compare)
-        response == object_to_compare
-      end
-
-      def <<(object)
-        if response.is_a? Array
-          response << object
-        else
-          response += object
-        end
-      end
-
-      def respond_to?(symbol, include_priv = false)
-        response.respond_to?(symbol, include_priv)
-      end
-
-      def to_s
-        response
-      end
-
-      def get_attributes(key, attributes = nil)
-        attributes ||= @parsed_response
-        
-        if attributes.kind_of?(Hash)
-          attributes.include?(key) ? attributes[key] : attributes
-        else
-          attributes
-        end
-      end
-
-      protected ####################### protected ##################
-
-      def parse_response_and_set_exception_if_necessary
-        @exception = successful_response? ? nil : SmoothOperator::Operator::Exceptions.raise_proper_exception(@raw_response, code)
-        parse_response
-      end
-
-      private ####################### private ######################
-
-      def method_missing(method, *args, &block)
-        response.send(method, *args, &block)
-      end
-
-    end
-    
-  end
-end