smooth_operator 1.10.13 → 1.10.14

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZmY5YjcxMjdiMTMzZGM1OTAwNGZhNmY4Mjc4MzRhZGQwNDk0OWY5Mw==
+    ZGUwNjgxZDAyZTJmMDg3ZTRhZWMwZjFhY2UxYjhjYTIyOTBlZWNlOQ==
   data.tar.gz: !binary |-
-    ZGJlMTk3MTAxMWM5MmM1ZGIxNzliZjYxMTBjNjhmNjE3MjczYWRlMQ==
+    YWRiNzFhZjlmYTI2MTRjYzM0MTU2NGMzZjJkNTgwZGI5NzdmOTJjZg==
 SHA512:
   metadata.gz: !binary |-
-    NzVjN2JlOTI0OTllZDlmYTNlNzkxYjAzODU0NGEyNTQ5ZmY1YTQ1ZjRlYTMy
-    Yzg2YTEwYWM3ZTU1OTJhMDk1M2I0ODk2NWU2M2VlMzY2MDUxMDlkMDU2YTU5
-    MTZmMjgyNjhkZGY0NzdhOTgwYzExNzFhY2VlMTBkYTA1NmFhNWU=
+    MjI2ZTFjNjUyZTMwMWE0MWIyNDk2MTU1ZDEwZmU1OTBlNjAxMjRhZDhhNzZi
+    ZDljMmI5OTQyZDIzNDQ4ZDFkNjFhYWVlNTE0Y2YzMDAyZDdjYzA0ZWE3MTc0
+    MDY5YjM0NjcyOGIzNzNkMDdkYmY4MzA4MTEzNTE5MmYxNTUyMDQ=
   data.tar.gz: !binary |-
-    MDUyMGNiMDllZDI5NjExNWEzMzMyYzY4YTQ1MGUzYjU3M2I2M2UwNzM2OTNm
-    YTYwMDAwOWEwMjM2YjViY2JhMDFkNzE4MGU4ODc5OWViMTFiZjFhMmVkZmY3
-    MWZkZjhhYmIzNzQ5N2Q2MjFkNGE5ZTE1NDk5YTM5ODYyOTA4MzE=
+    NDc2NWQ4Mzk2ZDk3YWFkMjZjZDI0MGYzZThkNmY4NzE0MDUyN2Y1NmQ2M2Rh
+    OGUyMWQ2MmU2ZTQxMzM2ODk4Mjk3YmE3MWRlODBkMmEwMjQzOTAyYTMxZjEx
+    YjQ4MmViM2VhYTViMzU2MTZjMzI0MTU3ODc2NTVkMTc0YjUzYjA=

data/Gemfile

@@ -9,6 +9,7 @@ group :development, :test do
   gem "pry"
   gem "sinatra"
   gem "typhoeus"
+  gem "activesupport"
   gem "sinatra-contrib"
   gem "rspec", "~> 3.0.0.beta1"
   gem "factory_girl", "~> 4.0"

data/README.md

@@ -274,8 +274,5 @@ Methods | Behaviour | Arguments | Return
 ## 4) TODO
 
 1. Finish "Methods" and "Behaviours" documentation;
-2. Allow changing the HTTP verb for a specific connection;
-3. FinderMethods specs;
-4. serialization_specs to test the json options for nested classes;
-5. model_schema_specs;
-6. Cache.
+2. ModelSchema specs;
+3. Cache.

data/console.rb

@@ -7,7 +7,7 @@ require 'spec/require_helper'
 
 FactoryGirl.find_definitions
 
-LocalhostServer.new(TestServer.new, 4567)
+# LocalhostServer.new(TestServer.new, 4567)
 
 #User::Base.post('', { user: { age: 1, posts: [{ body: 'post1' }, 2] } })
 

data/lib/smooth_operator/attributes/base.rb

@@ -42,12 +42,6 @@ module SmoothOperator
         end
       end
 
-      def to_int(string)
-        return string if string.is_a?(Fixnum)
-
-        to_float(string).to_i
-      end
-
       def to_date(string)
         return string if string.is_a?(Date)
 
@@ -66,12 +60,18 @@ module SmoothOperator
         ['1', 'true'].include?(value) ? true : ['0', 'false'].include?(value) ? false : nil
       end
 
+      def to_int(string)
+        return string if string.is_a?(Fixnum)
+
+        to_float(string).to_i
+      end
+
       def to_float(string)
         return string if string.is_a?(Float)
 
-        return 0 if string.nil? || !string.is_a?(String)
+        return 0 if string.nil? || !(string.is_a?(String) || string.is_a?(Fixnum))
         
-        value = string.scan(/-*\d+[,.]*\d*/).flatten.map(&:to_f).first
+        value = string.to_s.gsub(',', '.').scan(/-*\d+[.]*\d*/).flatten.map(&:to_f).first
 
         value.nil? ? 0 : value
       end

data/lib/smooth_operator/helpers.rb

@@ -56,4 +56,4 @@ module SmoothOperator
     
   end
   
-end
+end

data/lib/smooth_operator/operator.rb

@@ -1,4 +1,3 @@
-require "smooth_operator/operators/base"
 require "smooth_operator/remote_call/base"
 require "smooth_operator/operators/faraday"
 require "smooth_operator/operators/typhoeus"
@@ -9,16 +8,19 @@ module SmoothOperator
 
   module Operator
 
-    HTTP_VERBS = [:get, :post, :put, :patch, :delete]
-
     OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
 
+    OPTIONS.each do |option|
+      define_method(option) { Helpers.get_instance_variable(self, option, '') }
+    end
 
     attr_writer *OPTIONS
 
-    OPTIONS.each { |option| define_method(option) { Helpers.get_instance_variable(self, option, '') } }
+    HTTP_VERBS = [:get, :post, :put, :patch, :delete]
 
-    HTTP_VERBS.each { |http_verb| define_method(http_verb) { |relative_path = '', params = {}, options = {}| make_the_call(http_verb, relative_path, params, options) } }
+    HTTP_VERBS.each do |http_verb|
+      define_method(http_verb) { |relative_path = '', params = {}, options = {}| make_the_call(http_verb, relative_path, params, options) }
+    end
 
     def headers
       Helpers.get_instance_variable(self, :headers, {})
@@ -26,33 +28,19 @@ module SmoothOperator
 
     attr_writer :headers
 
-    
-    def generate_parallel_connection
-      generate_connection(:typhoeus)
-    end
-
-    def generate_connection(adapter = nil, options = nil)
-      adapter ||= :net_http
-      options ||= {}
-      url, timeout = (options[:endpoint] || self.endpoint), (options[:timeout] || self.timeout)
-
-      ::Faraday.new(url: url) do |builder|
-        builder.options[:timeout] = timeout unless Helpers.blank?(timeout)
-        builder.request :url_encoded
-        builder.adapter adapter
-      end
-    end
 
     def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-      if Helpers.present?(options[:hydra])
-        operator_call = Operators::Typhoeus.new(self, http_verb, relative_path, data, options)
+      operator_args = operator_method_args(http_verb, relative_path, data, options)
+
+      if Helpers.present?(operator_args[4][:hydra])
+        operator_call = Operators::Typhoeus
       else
-        operator_call = Operators::Faraday.new(self, http_verb, relative_path, data, options)
+        operator_call = Operators::Faraday
       end
-
+      
       remote_call = {}
 
-      operator_call.make_the_call do |_remote_call|
+      operator_call.make_the_call(*operator_args) do |_remote_call|
         remote_call = _remote_call
 
         yield(remote_call) if block_given?
@@ -65,6 +53,48 @@ module SmoothOperator
       params
     end
 
+
+    protected #################### PROTECTED ##################
+
+    def operator_method_args(http_verb, relative_path, data, options)
+      options = populate_options(options)
+
+      [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
+    end
+
+
+    private #################### PRIVATE ##################
+
+    def populate_options(options)
+      options ||= {}
+
+      OPTIONS.each { |option| options[option] ||= send(option) }
+
+      options[:headers] = headers.merge(options[:headers] || {})
+      
+      options
+    end
+
+    def resource_path(relative_path, options)
+      table_name = options[:table_name] || self.table_name
+
+      if Helpers.present?(table_name)
+        Helpers.present?(relative_path) ? "#{table_name}/#{relative_path}" : table_name
+      else
+        relative_path.to_s
+      end
+    end
+
+    def strip_params(http_verb, data)
+      data ||= {}
+      
+      if [:get, :head, :delete].include?(http_verb)
+        [query_string(data), nil]
+      else
+        [query_string({}), data]
+      end
+    end
+
   end
 
 end

data/lib/smooth_operator/operators/faraday.rb

@@ -6,13 +6,33 @@ module SmoothOperator
 
   module Operators
 
-    class Faraday < Base
+    module Faraday
+
+      extend self
+
+      # def generate_parallel_connection
+      #   generate_connection(:typhoeus)
+      # end
+
+      def generate_connection(adapter = nil, options = nil)
+        adapter ||= :net_http
+
+        ::Faraday.new(url: options[:endpoint]) do |builder|
+          builder.options[:timeout] = options[:timeout].to_i unless Helpers.blank?(options[:timeout])
+          builder.request :url_encoded
+          builder.adapter adapter
+        end
+      end
+
+      def make_the_call(http_verb, resource_path, params, body, options)
+        connection, request_options, options = strip_options(options)
 
-      def make_the_call
         remote_call = begin
-          set_basic_authentication
+          set_basic_authentication(connection, options)
 
-          response = connection.send(http_verb, relative_path) { |request| request_configuration(request) }
+          response = connection.send(http_verb, resource_path) do |request|
+            request_configuration(request, request_options, options, params, body)
+          end
 
           RemoteCall::Faraday.new(response)
         rescue ::Faraday::Error::ConnectionFailed
@@ -29,12 +49,20 @@ module SmoothOperator
 
       protected ################ PROTECTED ################
 
-      def set_basic_authentication
-        connection.basic_auth(endpoint_user, endpoint_pass) if Helpers.present?(endpoint_user)
+      def strip_options(options)
+        request_options = options.delete(:request_options) || {}
+        
+        connection = options.delete(:connection) || generate_connection(nil, options)
+
+        [connection, request_options, options]
+      end
+
+      def set_basic_authentication(connection, options)
+        connection.basic_auth(options[:endpoint_user], options[:endpoint_pass]) if Helpers.present?(options[:endpoint_user])
       end
 
-      def request_configuration(request)
-        operator_options.each { |key, value| request.options.send("#{key}=", value) }
+      def request_configuration(request, request_options, options, params, body)
+        request_options.each { |key, value| request.options.send("#{key}=", value) }
         
         options[:headers].each { |key, value| request.headers[key] = value }
         

data/lib/smooth_operator/operators/typhoeus.rb

@@ -5,70 +5,72 @@ module SmoothOperator
 
   module Operators
 
-    class Typhoeus < Base
+    module Typhoeus
 
-      def make_the_call
-        set_basic_authentication
+      extend self
 
-        request = ::Typhoeus::Request.new(url, typhoeus_options)
+      def make_the_call(http_verb, resource_path, params, body, options)
+        request = ::Typhoeus::Request.new *typhoeus_request_args(http_verb, resource_path, params, body, options)
         
-        remote_call = {}
-
-        # hydra.queue(request)
-
-        request.on_complete do |typhoeus_response|
-          remote_call_class = if typhoeus_response.return_code == :couldnt_connect
-            RemoteCall::Errors::ConnectionFailed
-          elsif typhoeus_response.timed_out?
-            RemoteCall::Errors::Timeout
-          else
-            RemoteCall::Typhoeus
-          end
-          
-          remote_call = remote_call_class.new(typhoeus_response)
-
-          yield(remote_call) if block_given?
+        hydra = options[:hydra] || ::Typhoeus::Hydra::hydra
+
+        _remote_call = {}
+
+        hydra.queue(request)
+
+        request.on_complete do |typhoeus_response|          
+          _remote_call = remote_call(typhoeus_response)
+
+          yield(_remote_call) if block_given?
         end
 
-        # hydra.run
+        hydra.run
 
-        request.run
+        # request.run
 
-        remote_call
+        _remote_call
       end
 
 
       protected ################ PROTECTED ################
 
-      def set_basic_authentication
-        typhoeus_options[:userpwd] = "#{endpoint_user}:#{endpoint_pass}" if Helpers.present?(endpoint_user)
+      def typhoeus_request_args(http_verb, relative_path, params, body, options)
+        [url(options, relative_path), build_typhoeus_options(http_verb, params, body, options)]
       end
 
-      def url
-        url = (options[:endpoint] || operator_class.endpoint)
-        
-        slice = url[-1] != '/' ? '/' : ''
-
-        url = "#{url}#{slice}#{relative_path}" if Helpers.present?(relative_path)
+      def remote_call(typhoeus_response)
+        if typhoeus_response.return_code == :couldnt_connect
+          RemoteCall::Errors::ConnectionFailed
+        elsif typhoeus_response.timed_out?
+          RemoteCall::Errors::Timeout
+        else
+          RemoteCall::Typhoeus
+        end.new(typhoeus_response)
       end
 
-      def typhoeus_options
-        return @typhoeus_options if defined?(@typhoeus_options)
-        
-        @typhoeus_options = { method: http_verb, headers: options[:headers].merge({ "Content-type" => "application/x-www-form-urlencoded" }) }
 
-        timeout = (options[:timeout] || operator_class.timeout)
+      private ################### PRIVATE ###############
+
+      def build_typhoeus_options(http_verb, params, body, options)
+        typhoeus_options = { method: http_verb, headers: options[:headers].merge({ "Content-type" => "application/x-www-form-urlencoded" }) }
 
-        @typhoeus_options[:timeout] = timeout if Helpers.present?(timeout)
+        typhoeus_options[:timeout] = options[:timeout] if Helpers.present?(options[:timeout])
+
+        typhoeus_options[:body] = body if Helpers.present?(body)
+        
+        typhoeus_options[:params] = params if Helpers.present?(params)
 
-        @typhoeus_options[:body] = body if Helpers.present?(body)
-        # @typhoeus_options[:params] = params if Helpers.present?(params)
+        typhoeus_options[:userpwd] = "#{options[:endpoint_user]}:#{options[:endpoint_pass]}" if Helpers.present?(options[:endpoint_user])
 
-        @typhoeus_options
+        typhoeus_options
       end
 
-      def hydra
-        @hydra ||= operator_options[:hydra] || ::Typhoeus::Hydra::hydra
+      def url(options, relative_path)
+        url = options[:endpoint]
+        
+        slice = url[-1] != '/' ? '/' : ''
+
+        url = "#{url}#{slice}#{relative_path}" if Helpers.present?(relative_path)
       end
 
     end

data/lib/smooth_operator/serialization.rb

@@ -3,7 +3,7 @@ module SmoothOperator
   module Serialization
 
     def to_hash(options = nil)
-      Helpers.symbolyze_keys serializable_hash(options)
+      Helpers.symbolyze_keys(serializable_hash(options) || {})
     end
     
     # alias :attributes :to_hash
@@ -12,7 +12,7 @@ module SmoothOperator
     def to_json(options = nil)
       require 'json' unless defined? JSON
       
-      JSON(serializable_hash(options))
+      JSON(serializable_hash(options) || {})
     end
 
     def read_attribute_for_serialization(attribute)

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.10.13"
+  VERSION = "1.10.14"
 end

data/smooth_operator.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["João Gonçalves"]
   spec.email         = ["goncalves.joao@gmail.com"]
   spec.description   = %q{ActiveResource alternative}
-  spec.summary       = %q{Simple and fully customizable alternative to ActiveResource, using faraday gem to stablish parallel remote calls"}
+  spec.summary       = %q{Simple and fully customizable alternative to ActiveResource, using faraday gem to stablish remote calls"}
   spec.homepage      = "https://github.com/goncalvesjoao/smooth_operator"
   spec.license       = "MIT"
 

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -157,6 +157,50 @@ describe SmoothOperator::AttributeAssignment do
 
       end
 
+      context "that is declared (in schema) as an float" do
+
+        it "when the attributes's value is '1', should be converted to 1" do
+          expect(subject.new(price: '1').price).to eq(1.0)
+        end
+
+        it "when the attributes's value is '-1', should be converted to -1" do
+          expect(subject.new(price: '-1').price).to eq(-1.0)
+        end
+
+        it "when the attributes's value is 's-10s', should be converted to -10" do
+          expect(subject.new(price: 's-10s').price).to eq(-10.0)
+        end
+
+        it "when the attributes's value is ' 10s', should be converted to 10" do
+          expect(subject.new(price: ' 10s').price).to eq(10.0)
+        end
+
+        it "when the attributes's value is 123, should be converted to 123" do
+          expect(subject.new(price: 123).price).to eq(123.0)
+        end
+
+        it "when the attributes's value is -5, should be converted to -5" do
+          expect(subject.new(price: -5).price).to eq(-5.0)
+        end
+
+        it "when the attributes's value is '12.3', should be converted to 12.3" do
+          expect(subject.new(price: '12.3').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 's12.3s', should be converted to 12.3" do
+          expect(subject.new(price: 's12.3s').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 's12,3s', should be converted to 12.3" do
+          expect(subject.new(price: 's12,3s').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 1.2, should be converted to 1.2" do
+          expect(subject.new(price: 1.2).price).to eq(1.2)
+        end
+
+      end
+
       context "that is declared (in schema) as an boolean" do
 
         it "when the attributes's value is true, should be converted to true" do
@@ -245,6 +289,33 @@ describe SmoothOperator::AttributeAssignment do
 
       end
 
+      context "that is declared (in schema) as a datetime" do
+
+        it "if the attribute's value is a valid datetime string" do
+          date = subject.new(date: '2-2-2222 12:30').date
+
+          expect(date).to be_instance_of(DateTime)
+          expect(date.day).to be(2)
+          expect(date.month).to be(2)
+          expect(date.year).to be(2222)
+          expect(date.hour).to be(12)
+          expect(date.min).to be(30)
+        end
+
+        it "if the attribute's value is a valid datetime" do
+          date_now = DateTime.now
+          date = subject.new(date: date_now).date
+
+          expect(date).to be_instance_of(DateTime)
+          expect(date).to eq(date_now)
+        end
+
+        it "if the attribute's value is an invalid datetime string, the returning value should be nil" do
+          expect(subject.new(date: '2s-2-2222').date).to be_nil
+        end
+
+      end
+
     end
 
   end

data/spec/smooth_operator/persistence_spec.rb

@@ -123,7 +123,7 @@ end
 
 describe SmoothOperator::Persistence, helpers: :persistence do
 
-  describe "#reload", current: true do
+  describe "#reload" do
     subject { new_user }
     let(:method_to_execute) { :reload }
 

data/spec/smooth_operator/serialization_spec.rb

@@ -20,9 +20,33 @@ describe SmoothOperator::Serialization do
   describe "#to_hash" do
     subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
 
+    it 'it should call #serializable_hash with the same arguments' do
+      options = { option1: 'option1', option2: 'option2' }
+
+      expect(subject).to receive(:serializable_hash).with(options)
+
+      subject.to_hash(options)
+    end
+  end
+
+  describe "#to_json" do
+    subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
+
+    it 'it should call #serializable_hash with the same arguments' do
+      options = { option1: 'option1', option2: 'option2' }
+
+      expect(subject).to receive(:serializable_hash).with(options)
+
+      subject.to_json(options)
+    end
+  end
+
+  describe "#serializable_hash" do
+    subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }
+
     context "when no options are given" do
       it 'it should return all attributes' do
-        expect(subject.to_hash).to eq(attributes_for(:user_with_address_and_posts))
+        expect(subject.serializable_hash).to eq(SmoothOperator::Helpers.stringify_keys(attributes_for(:user_with_address_and_posts)))
       end
     end
 
@@ -30,7 +54,7 @@ describe SmoothOperator::Serialization do
       let(:options_with_only) { { only: [:id, :first_name] } }
 
       it 'it should only return the filtered options' do
-        expect(subject.to_hash(options_with_only)).to eq(attributes_for(:white_list))
+        expect(subject.serializable_hash(options_with_only)).to eq(SmoothOperator::Helpers.stringify_keys(attributes_for(:white_list)))
       end
     end
 
@@ -38,7 +62,7 @@ describe SmoothOperator::Serialization do
       let(:options_with_except) { { except: [:last_name, :admin] } }
 
       it 'it should return all fields except for the filtered options' do
-        expect(subject.to_hash(options_with_except)).not_to include(attributes_for(:black_list))
+        expect(subject.serializable_hash(options_with_except)).not_to include(attributes_for(:black_list))
       end
     end
 
@@ -47,7 +71,7 @@ describe SmoothOperator::Serialization do
       subject(:user_with_my_method) { UserWithAddressAndPosts::UserWithMyMethod.new(attributes_for(:user_with_address_and_posts)) }
 
       it 'it should return all fields including the expected method and its returning value' do
-        expect(user_with_my_method.to_hash(options_with_method)).to eq(attributes_for(:user_with_my_method))
+        expect(user_with_my_method.serializable_hash(options_with_method)).to eq(SmoothOperator::Helpers.stringify_keys(attributes_for(:user_with_my_method)))
       end
     end
 

data/spec/support/models/user.rb

@@ -35,7 +35,7 @@ module User
   end
 
   class TimeoutConnection < Base
-    self.timeout = 0
+    self.timeout = 1
     self.model_name = 'user'
   end
 

data/spec/support/models/user_with_address_and_posts.rb

@@ -18,7 +18,10 @@ module UserWithAddressAndPosts
     schema(
       age: :int,
       dob: :date,
-      manager: :bool
+      price: :float,
+      manager: :bool,
+      date: :datetime,
+      first_name: :string
     )
 
   end

data/spec/support/test_server.rb

@@ -79,7 +79,7 @@ class TestServer < Sinatra::Base
   end
   
   post '/users/timeout' do
-    sleep 1
+    sleep 2
     json 'ok'
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.10.13
+  version: 1.10.14
 platform: ruby
 authors:
 - João Gonçalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-10 00:00:00.000000000 Z
+date: 2014-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,7 +92,6 @@ files:
 - lib/smooth_operator/model_schema.rb
 - lib/smooth_operator/open_struct.rb
 - lib/smooth_operator/operator.rb
-- lib/smooth_operator/operators/base.rb
 - lib/smooth_operator/operators/faraday.rb
 - lib/smooth_operator/operators/typhoeus.rb
 - lib/smooth_operator/persistence.rb
@@ -150,7 +149,7 @@ rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: Simple and fully customizable alternative to ActiveResource, using faraday
-  gem to stablish parallel remote calls"
+  gem to stablish remote calls"
 test_files:
 - spec/factories/user_factory.rb
 - spec/require_helper.rb

data/lib/smooth_operator/operators/base.rb

@@ -1,55 +0,0 @@
-module SmoothOperator
-
-  module Operators
-
-    class Base
-
-      attr_reader :operator_class, :http_verb, :params, :body, :connection, :operator_options, :options, :relative_path, :endpoint_user, :endpoint_pass
-
-      def initialize(operator_class, http_verb, relative_path, data, options)
-        @operator_class, @http_verb = operator_class, http_verb
-
-        @params, @body = strip_params(http_verb, data)
-
-        @connection, @operator_options, @options = strip_options(options)
-
-        @relative_path = resource_path(relative_path, options)
-
-        @endpoint_user = options[:endpoint_user] || @operator_class.endpoint_user
-        
-        @endpoint_pass = options[:endpoint_pass] || @operator_class.endpoint_pass
-      end
-
-
-      protected ################# PROTECTED ###################
-
-      def strip_params(http_verb, data)
-        data ||= {}
-        
-        ([:get, :head, :delete].include?(http_verb) ? [@operator_class.query_string(data), nil] : [@operator_class.query_string({}), data])
-      end
-
-      def strip_options(options)
-        options ||= {}
-
-        options[:headers] = @operator_class.headers.merge(options[:headers] || {})
-        operator_options = options.delete(:operator_options) || {}
-        connection = options.delete(:connection) || @operator_class.generate_connection(nil, operator_options)
-
-        [connection, operator_options, options]
-      end
-
-      def resource_path(relative_path, options)
-        table_name = options[:table_name] || @operator_class.table_name
-
-        if Helpers.present?(table_name)
-          Helpers.present?(relative_path) ? "#{table_name}/#{relative_path}" : table_name
-        else
-          relative_path
-        end
-      end
-    
-    end
-
-  end
-end