smooth_operator 0.0.2 → 0.3.2

data/lib/smooth_operator.rb

@@ -3,4 +3,6 @@ module SmoothOperator
 end
 
 require "smooth_operator/version"
+require "smooth_operator/core"
 require "smooth_operator/base"
+require "smooth_operator/rollback"

data/lib/smooth_operator/base.rb

@@ -1,62 +1,30 @@
-require "smooth_operator/operator"
-require "smooth_operator/orm"
+require "smooth_operator/operator/base"
+require "smooth_operator/operator/orm"
 
-module SmoothOperator
-  class Base < OpenStruct
-
-    include SmoothOperator::Operator
-    include SmoothOperator::ORM
-
-    def hash_of_full_content
-      @table
-    end
-
-    def as_json(options = nil)
-	    @table.as_json(options)
-	  end
-
-    def self.nested_objects_classes(hash)
-      hash.each do |nested_object_symbol, nested_object_class|
-        define_method(nested_object_symbol.to_s) do
-          get_nested_object_variable(nested_object_symbol, nested_object_class)
-        end
-      end
-    end
+require "smooth_operator/http_handlers/typhoeus/base"
+require "smooth_operator/http_handlers/typhoeus/orm"
 
-    private #---------------------------- private
-
-    def get_nested_object_variable(nested_object_symbol, nested_object_class)
-      nested_object_variable = instance_variable_get("@#{nested_object_symbol}")
-
-      return nested_object_variable if nested_object_variable.present?
-
-      nested_object_variable = initialize_nested_object_variable(hash_of_full_content[nested_object_symbol], nested_object_class, nested_object_symbol)
+module SmoothOperator
 
-      instance_variable_set("@#{nested_object_symbol}", nested_object_variable)
+  class Base < OpenStruct
+    include SmoothOperator::Core
+    include SmoothOperator::Operator::Base
+    include SmoothOperator::Operator::ORM
 
-      nested_object_variable
-    end
+    protected ################### PROTECTED ###################
 
-    def initialize_nested_object_variable(attributes, nested_object_class, nested_object_symbol)
-      if attributes.kind_of? Array
-        attributes.map { |_attributes| get_nested_object(_attributes, nested_object_class, nested_object_symbol) }
-      else
-        get_nested_object(attributes, nested_object_class, nested_object_symbol)
-      end
+    def self.http_handler_base
+      SmoothOperator::HttpHandlers::Typhoeus::Base
     end
 
-    def get_nested_object(nested_objects_attributes, nested_object_class, nested_object_symbol)
-      if nested_objects_attributes.blank?
-        plural?(nested_object_symbol) ? [] : nil
-      else
-        nested_object_class.new(nested_objects_attributes)
-      end
+    def self.http_handler_orm
+      @http_handler_orm ||= SmoothOperator::HttpHandlers::Typhoeus::ORM.new(self)
     end
 
-    def plural?(string)
-      string = string.to_s
-      string == string.pluralize
+    def http_handler_orm
+      self.class.http_handler_orm
     end
 
   end
+
 end

data/lib/smooth_operator/core.rb

@@ -0,0 +1,162 @@
+module SmoothOperator
+  module Core
+
+    def table_hash
+      @table
+    end
+
+    def as_json(options = nil)
+      @table.as_json(options)
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    def persisted?
+      try(:id).present?
+    end
+
+    def to_partial_path
+      class_name_plural = self.class.table_name
+      "#{class_name_plural}/#{class_name_plural.singularize}"
+    end
+
+    def valid?
+      errors.blank?
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def assign_attributes(attributes = {})
+      return if attributes.blank?
+
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def safe_table_hash
+      safe_hash = table_hash.dup
+
+      if self.class.save_attr_white_list.present?
+        safe_hash.slice!(*self.class.save_attr_white_list)
+      else
+        self.class.save_attr_black_list.each { |attribute| safe_hash.delete(attribute) }
+      end
+
+      safe_hash
+    end
+
+
+    private ######################### PRIVATE ###############################
+
+    def get_nested_object_variable(nested_object_symbol, nested_object_class)
+      nested_object_variable = instance_variable_get("@#{nested_object_symbol}")
+
+      return nested_object_variable if nested_object_variable.present?
+
+      nested_object_variable = initialize_nested_object_variable(table_hash[nested_object_symbol], nested_object_class, nested_object_symbol)
+
+      instance_variable_set("@#{nested_object_symbol}", nested_object_variable)
+
+      nested_object_variable
+    end
+
+    def initialize_nested_object_variable(attributes, nested_object_class, nested_object_symbol)
+      if attributes.kind_of? Array
+        attributes.map { |_attributes| get_nested_object(_attributes, nested_object_class, nested_object_symbol) }
+      else
+        get_nested_object(attributes, nested_object_class, nested_object_symbol)
+      end
+    end
+
+    def get_nested_object(nested_objects_attributes, nested_object_class, nested_object_symbol)
+      if nested_objects_attributes.blank?
+        plural?(nested_object_symbol) ? [] : nil
+      else
+        nested_object_class.new(nested_objects_attributes)
+      end
+    end
+
+    def plural?(string)
+      string = string.to_s
+      string == string.pluralize
+    end
+
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      
+      def nested_objects_classes(hash)
+        hash.each do |nested_object_symbol, nested_object_class|
+          define_method(nested_object_symbol.to_s) do
+            get_nested_object_variable(nested_object_symbol, nested_object_class)
+          end
+        end
+      end
+
+      attr_writer :endpoint
+      def endpoint
+        @endpoint ||= ENV["API_ENDPOINT"]
+      end
+
+      attr_writer :endpoint_user
+      def endpoint_user
+        @endpoint_user ||= ENV["API_USER"]
+      end
+
+      attr_writer :endpoint_pass
+      def endpoint_pass
+        @endpoint_pass ||= ENV["API_PASS"]
+      end
+
+      attr_writer :save_attr_black_list
+      def save_attr_black_list
+        @save_attr_black_list ||= [:id, :created_at, :updated_at, :errors]
+      end
+
+      attr_writer :save_attr_white_list
+      def save_attr_white_list
+        @save_attr_white_list ||= []
+      end
+
+      attr_writer :model_name
+      def model_name
+        @model_name ||= name.split('::').last.underscore.capitalize
+      end
+
+      def model_name_downcase
+        model_name.downcase
+      end
+
+      attr_writer :table_name
+      def table_name
+        @table_name ||= model_name_downcase.to_s.pluralize
+      end
+
+      private ################################ PRIVATE #########################
+
+      def build_url(relative_path)
+        slash = '/' if relative_path.present?
+        extention = '.json'
+        [endpoint, table_name, slash, relative_path.to_s, extention].join
+      end
+
+      def get_basic_auth_credentials
+        if endpoint_user.present? || endpoint_pass.present?
+          { username: endpoint_user, password: endpoint_pass }
+        else
+          nil
+        end
+      end
+
+    end
+    
+  end
+end

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

@@ -0,0 +1,58 @@
+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 = { params: options, method: http_verb }.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)
+          request = ::Typhoeus::Request.new(url, options)
+          remote_call = SmoothOperator::HttpHandlers::Typhoeus::RemoteCall.new(request)
+
+          request.on_complete do |response|
+            remote_call.raw_response = response
+            remote_call.response = remote_call.parsed_response
+          end
+
+          request.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

@@ -0,0 +1,33 @@
+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, id, &block)
+          injected_hydra = options[:hydra]
+          options[:hydra] = injected_hydra || ::Typhoeus::Hydra.hydra
+
+          remote_call = @object_class.make_the_call(http_verb, id, options)
+
+          remote_call.request.on_complete do |typhoeus_response|
+            remote_call.raw_response = typhoeus_response
+            yield(remote_call)
+          end
+          
+          remote_call.request.run if injected_hydra.blank?
+
+          remote_call
+        end
+        
+      end
+
+    end
+  end
+end

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

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

@@ -0,0 +1,38 @@
+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)
+          http_handler_base.make_the_call(http_verb, url, (options || {}), get_basic_auth_credentials)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/operator/exceptions.rb

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

@@ -0,0 +1,120 @@
+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
+
+        protected ####################### protected #######################
+
+        def find_each(options)
+          http_handler_orm.make_the_call(:get, options, '') 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(id, options)
+          http_handler_orm.make_the_call(:get, options, id) 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

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

data/lib/smooth_operator/rollback.rb

@@ -0,0 +1,16 @@
+module SmoothOperator
+
+	class Rollback < SmoothOperator::Base
+    
+    def rollback(options = {}, dont_update = false)
+    	http_handler_orm.make_the_call(:delete, options, "#{version_id}/rollback") do |remote_call|
+        set_raw_response_exception_and_build_proper_response(remote_call)
+        
+        new_attributes = remote_call.get_attributes(self.class.model_name_downcase)
+        assign_attributes(new_attributes.slice("id", "version_id"))
+      end
+    end
+
+  end
+
+end

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "0.0.2"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-02 00:00:00.000000000 Z
+date: 2013-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,11 +73,15 @@ files:
 - Rakefile
 - lib/smooth_operator.rb
 - lib/smooth_operator/base.rb
-- lib/smooth_operator/exceptions.rb
-- lib/smooth_operator/open_struct.rb
-- lib/smooth_operator/operator.rb
-- lib/smooth_operator/orm.rb
-- lib/smooth_operator/protocol_handler.rb
+- lib/smooth_operator/core.rb
+- lib/smooth_operator/http_handlers/typhoeus/base.rb
+- lib/smooth_operator/http_handlers/typhoeus/orm.rb
+- lib/smooth_operator/http_handlers/typhoeus/remote_call.rb
+- lib/smooth_operator/operator/base.rb
+- lib/smooth_operator/operator/exceptions.rb
+- lib/smooth_operator/operator/orm.rb
+- lib/smooth_operator/operator/remote_call.rb
+- lib/smooth_operator/rollback.rb
 - lib/smooth_operator/version.rb
 - smooth_operator.gemspec
 homepage: https://github.com/goncalvesjoao/smooth_operator

data/lib/smooth_operator/exceptions.rb

@@ -1,60 +0,0 @@
-module SmoothOperator
-	module Exceptions
-
-  	extend self
-
-  	def raise_proper_exception(response)
-  		return nil if CODES_TO_IGNORE.include?(response.code)
-  		exception_to_raise = (CODE_VS_EXCEPTIONS[response.code] || SmoothOperator::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::Exceptions::Base
-			def message
-	  		'Unknown Error'
-	  	end
-		end
-
-  	class	NotFound < SmoothOperator::Exceptions::Base
-  		def message
-	  		'NotFound'
-	  	end
-  	end
-
-  	class	EntityNotProcessed < SmoothOperator::Exceptions::Base
-  		def message
-	  		'EntityNotProcessed'
-	  	end
-  	end
-
-  	class	ServerError < SmoothOperator::Exceptions::Base
-  		def message
-	  		'ServerError'
-	  	end
-  	end
-  	
-  	class	AuthorizationRequired < SmoothOperator::Exceptions::Base
-  		def message
-	  		'AuthorizationRequired'
-	  	end
-  	end
-
-		CODES_TO_IGNORE = [200]
-
-  	CODE_VS_EXCEPTIONS = {
-  		401 => AuthorizationRequired,
-  		422 => EntityNotProcessed,
-  	 	404 => NotFound,
-  	 	500 => ServerError
-  	}
-
-	end
-end

data/lib/smooth_operator/open_struct.rb

@@ -1,16 +0,0 @@
-module SmoothOperator
-  module OpenStruct
-
-    extend self # extends the module Class with its instance methods and
-                # makes it possible do 'SmoothOperator::OpenStruct.new'
-
-    def new(attributes = {})
-      ::OpenStruct.new(attributes).extend(SmoothOperator::OpenStruct)
-    end
-
-    def to_hash
-      @table
-    end
-
-  end
-end

data/lib/smooth_operator/operator.rb

@@ -1,100 +0,0 @@
-require "smooth_operator/protocol_handler"
-
-module SmoothOperator
-  module Operator
-
-    HTTP_SUCCESS_CODES = [200, 201, 202, 203, 204]
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      attr_writer :endpoint
-      def endpoint
-        @endpoint ||= ENV["API_ENDPOINT"]
-      end
-
-      attr_writer :endpoint_user
-      def endpoint_user
-        @endpoint_user ||= ENV["API_USER"]
-      end
-
-      attr_writer :endpoint_pass
-      def endpoint_pass
-        @endpoint_pass ||= ENV["API_PASS"]
-      end
-
-      def get(relative_path, options = {})
-        make_the_call(:get, relative_path, SmoothOperator::ProtocolHandler.get_options(options))
-      end
-
-      def post(relative_path, options = {})
-        make_the_call(:post, relative_path, SmoothOperator::ProtocolHandler.post_options(options))
-      end
-
-      def put(relative_path, options = {})
-        make_the_call(:put, relative_path, SmoothOperator::ProtocolHandler.put_options(options))
-      end
-
-      def delete(relative_path, options = {})
-        make_the_call(:delete, relative_path, SmoothOperator::ProtocolHandler.delete_options(options))
-      end
-
-
-      def safe_get(relative_path, options = {})
-        safe_response(get(relative_path, options)) rescue nil
-      end
-
-      def safe_post(relative_path, options = {})
-        safe_response(post(relative_path, options)) rescue nil
-      end
-
-      def safe_put(relative_path, options = {})
-        safe_response(put(relative_path, options)) rescue nil
-      end
-
-      def safe_delete(relative_path, options = {})
-        safe_response(delete(relative_path, options)) rescue nil
-      end
-
-      def safe_response(response)
-        successful_response?(response) ? response.parsed_response : nil
-      end
-      
-
-      def make_the_call(http_verb, relative_path, options = {})
-        url = build_url(relative_path)
-        options = build_options(options)
-        response = SmoothOperator::ProtocolHandler.send(http_verb, url, options)
-        response
-      end
-
-      def build_url(relative_path)
-        slash = '/' if relative_path.present?
-        extention = '.json'
-        [endpoint, table_name, slash, relative_path.to_s, extention].join
-      end
-
-      def set_basic_auth_credentials(options)
-        if endpoint_user.present? || endpoint_pass.present? && !options.include?(:basic_auth)
-          options.merge({ basic_auth: { username: endpoint_user, password: endpoint_pass } })
-        else
-          options
-        end
-      end
-
-      def build_options(options)
-        options = {} if options.blank?
-        set_basic_auth_credentials(options)
-      end
-
-      def successful_response?(response)
-        HTTP_SUCCESS_CODES.include?(response.code) || response.blank?
-      end
-
-    end
-
-  end
-end

data/lib/smooth_operator/orm.rb

@@ -1,154 +0,0 @@
-require "smooth_operator/exceptions"
-
-module SmoothOperator
-  module ORM
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:attr_reader, :last_response)
-    end
-
-    module ClassMethods
-
-      attr_writer :save_attr_black_list
-      def save_attr_black_list
-        @save_attr_black_list ||= [:id, :created_at, :updated_at]
-      end
-
-      attr_writer :save_attr_white_list
-      def save_attr_white_list
-        @save_attr_white_list ||= []
-      end
-
-      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
-
-      attr_writer :model_name
-      def model_name
-        @model_name ||= name.split('::').last.underscore.capitalize
-      end
-
-      def model_name_downcase
-        model_name.downcase
-      end
-
-      attr_writer :table_name
-      def table_name
-        @table_name ||= model_name_downcase.to_s.pluralize
-      end
-
-      private #------------------------------------------------ private
-
-      def instantiate_each(objects)
-        objects.map { |object| new(object) }
-      end
-
-      def find_each(options)
-        response = get(nil, options)
-        parsed_response = parse_response_or_raise_proper_exception(response)
-        parsed_response.kind_of?(Array) ? instantiate_each(parsed_response) : parsed_response
-      end
-
-      def find_one(id, options)
-        response = get(id, options)
-        parsed_response = parse_response_or_raise_proper_exception(response)
-        new(parsed_response)
-      end
-
-      def parse_response_or_raise_proper_exception(response)
-        if successful_response?(response)
-          response.parsed_response
-        else
-          SmoothOperator::Exceptions.raise_proper_exception(response)
-        end
-      end
-
-    end
-
-    def save
-      begin
-        save!
-      rescue Exception => exception
-        false
-      end
-    end
-
-    def save!
-      @last_response = create_or_update
-      import_response_errors(@last_response)
-      SmoothOperator::Exceptions.raise_proper_exception(@last_response) unless self.class.successful_response?(@last_response)
-      true
-    end
-
-    def destroy
-      return true if new_record?
-      
-      @last_response = self.class.delete(self.id)
-      import_response_errors(@last_response)
-      self.class.successful_response?(@last_response)
-    end
-
-    def new_record?
-      !persisted?
-    end
-
-    def persisted?
-      try(:id).present?
-    end
-
-    def to_partial_path
-      class_name_plural = self.class.table_name
-      "#{class_name_plural}/#{class_name_plural.singularize}"
-    end
-
-    def valid?
-      errors.blank?
-    end
-
-    def invalid?
-      !valid?
-    end
-
-    def hash_of_safe_content
-      safe_hash = hash_of_full_content.dup
-
-      if self.class.save_attr_white_list.present?
-        safe_hash.slice!(*self.class.save_attr_white_list)
-      else
-        self.class.save_attr_black_list.each { |attribute| safe_hash.delete(attribute) }
-      end
-
-      safe_hash
-    end
-
-    private #-------------------------------------- private
-
-    def create_or_update
-      if new_record?
-        self.class.post('', { self.class.model_name_downcase => hash_of_safe_content })
-      else
-        self.class.put(self.id, { self.class.model_name_downcase => hash_of_safe_content })
-      end
-    end
-
-    def import_response_errors(response)
-      if response.present? && response.parsed_response.include?('errors')
-        self.errors = response.parsed_response['errors']
-      end
-    end
-
-  end
-end

data/lib/smooth_operator/protocol_handler.rb

@@ -1,26 +0,0 @@
-require 'httparty'
-
-module SmoothOperator
-  class ProtocolHandler
-  
-    include ::HTTParty
-    format :json
-
-    def self.get_options(options)
-    	{ query: options }
-    end
-
-    def self.post_options(options)
-    	{ body: options }
-    end
-
-    def self.put_options(options)
-    	{ body: options }
-    end
-
-    def self.delete_options(options)
-    	{ body: options }
-    end
-    
-  end
-end