smooth_operator 1.3.0 → 1.8.0

data/lib/smooth_operator/associations/association_reflection.rb

@@ -1,79 +0,0 @@
-require "smooth_operator/associations/reflection"
-
-module SmoothOperator
-  module Associations
-    class AssociationReflection < Reflection
-
-      attr_reader :related_reflection, :macro
-
-      def initialize(association, related_reflection, options)
-        super(association, options)
-
-        @related_reflection, @macro = related_reflection, options[:macro]
-      end
-
-      def primary_key
-        @primary_key ||= options[:primary_key] || :id
-      end
-
-      def foreign_key
-        @foreign_key ||= options[:foreign_key] || foreign_key_default
-      end
-
-      def set_relational_keys(origin, destination)
-        return nil if options[:standalone] == true
-
-        if has_many? || has_one?
-          set_foreign_key(destination, primary_key_of(origin))
-        elsif belongs_to?
-          set_foreign_key(origin, primary_key_of(destination))
-        end
-      end
-
-      def set_foreign_key(object, id)
-        setter = "#{foreign_key}="
-
-        if object.respond_to?(setter)
-          object.send(setter, id)
-        elsif object.respond_to?("send_to_representative")
-          object.send_to_representative(setter, id)
-        end
-      end
-
-      def primary_key_of(object)
-        object.send(primary_key)
-      end
-
-      def has_many?
-        macro == :has_many
-      end
-
-      def has_one?
-        macro == :has_one
-      end
-
-      def belongs_to?
-        macro == :belongs_to
-      end
-
-      def collection?
-        has_many?
-      end
-
-      def rails_serialization?
-        options[:rails_serialization] == true
-      end
-
-      private ################################# private
-
-      def foreign_key_default
-        if has_many? || has_one?
-          "#{related_reflection.single_name}_id"
-        elsif belongs_to?
-          "#{single_name}_id"
-        end.to_sym
-      end
-
-    end
-  end
-end

data/lib/smooth_operator/associations/has_many_relation.rb

@@ -1,45 +0,0 @@
-module SmoothOperator
-  module Associations
-    class HasManyRelation < SimpleDelegator
-
-      attr_reader :object, :association
-
-      def initialize(object, association)
-        @object, @association = object, association
-      end
-
-      def reload
-        "TODO"
-      end
-
-      def new(attributes = {})
-        object.class.reflect_on_association(association).klass.new(attributes)
-      end
-
-      def build(attributes = {})
-        new_array, new_array_entry = get_array, new(attributes)
-
-        new_array.push new_array_entry
-
-        object.send("#{association}=", new_array)
-
-        new_array_entry
-      end
-
-      undef :is_a?
-
-      protected ############### PROTECTED ###############
-
-      def get_array
-        data = object.internal_data_get(association.to_s)
-
-        data.nil? ? [] : [*data]
-      end
-
-      def refresh
-        __setobj__ get_array
-      end
-
-    end
-  end
-end

data/lib/smooth_operator/associations/reflection.rb

@@ -1,41 +0,0 @@
-module SmoothOperator
-  module Associations
-    class Reflection
-
-      attr_reader :name, :klass, :options
-
-      def initialize(class_name, options)
-        options = options.is_a?(Hash) ? options : {}
-
-        @name, @options = class_name, options
-
-        @klass = options[:class_name] || klass_default(@name)
-
-        if options.include?(:class_name) && options[:class_name].nil?
-          @klass = nil
-        elsif @klass.is_a?(String)
-          @klass = @klass.constantize rescue OpenStruct
-        end
-      end
-
-      def single_name
-        @single_name ||= options[:single_name] || name.to_s.singularize
-      end
-
-      def plural_name
-        @plural_name ||= options[:plural_name] || name.to_s.pluralize
-      end
-
-      private ################################# private
-
-      def klass_default(class_name)
-        if Helpers.plural?(class_name)
-          class_name.to_s.singularize.camelize
-        else
-          class_name.to_s.camelize
-        end
-      end
-
-    end
-  end
-end

data/lib/smooth_operator/cookie_jar.rb

@@ -1,21 +0,0 @@
-module SmoothOperator
-  class CookieJar < Hash
-
-    def to_s
-      self.map { |key, value| "#{key}=#{value}"}.join("; ")
-    end
-
-    def parse(*cookie_strings)
-      cookie_strings.each do |cookie_string|
-        next unless cookie_string.is_a?(String)
-
-        key, value = cookie_string.split('; ').first.split('=', 2)
-
-        self[key] = value
-      end
-
-      self
-    end
-
-  end
-end

data/lib/smooth_operator/http_methods.rb

@@ -1,17 +0,0 @@
-module SmoothOperator
-  module HttpMethods
-
-    HTTP_VERBS = %w[get post put patch delete]
-
-    HTTP_VERBS.each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(relative_path = '', params = {}, options = {})
-          make_the_call(:#{method}, relative_path, params, options) do |remote_call|
-            block_given? ? yield(remote_call) : remote_call
-          end
-        end
-      RUBY
-    end
-
-  end
-end

data/lib/smooth_operator/internal_data.rb

@@ -1,45 +0,0 @@
-require 'smooth_operator/type_casting'
-
-module SmoothOperator
-  module InternalData
-
-    def internal_data
-      @internal_data ||= {}
-    end
-
-    def known_attributes
-      return @known_attributes if defined?(@known_attributes)
-
-      schema_attributes = if self.class.respond_to?(:internal_structure)
-        self.class.internal_structure.keys
-      else
-        []
-      end
-
-      @known_attributes = Set.new(schema_attributes)
-    end
-
-    def known_attribute?(attribute)
-      known_attributes.include?(attribute.to_s)
-    end
-
-    def internal_data_get(attribute_name)
-      internal_data[attribute_name]
-    end
-
-    def internal_data_push(attribute_name, attribute_value)
-      attribute_name = attribute_name.to_s
-
-      known_attributes.add attribute_name
-
-      internal_data[attribute_name] = TypeCasting.cast_to_type(attribute_name, attribute_value, self)
-
-      if self.class.respond_to?(:smooth_operator?)
-        marked_for_destruction?(attribute_value) if attribute_name == self.class.destroy_key
-
-        new_record?(true) if attribute_name == self.class.primary_key
-      end
-    end
-
-  end
-end

data/lib/smooth_operator/operators/connection_wrapper.rb

@@ -1,15 +0,0 @@
-module SmoothOperator
-  class ConnectionWrapper
-
-    attr_reader :connection
-
-    def initialize(connection)
-      @connection = connection
-    end
-
-    def run
-      connection.run
-    end
-
-  end
-end

data/lib/smooth_operator/operators/faraday.rb

@@ -1,75 +0,0 @@
-require 'faraday'
-require 'typhoeus/adapters/faraday'
-require "smooth_operator/remote_call/faraday"
-
-module SmoothOperator
-
-  module Operators
-
-    module Faraday
-
-      extend self
-
-      # def generate_parallel_connection
-      #   generate_connection(:typhoeus)
-      # end
-
-      def generate_connection(adapter = nil, options = nil)
-        adapter ||= :net_http
-
-        ConnectionWrapper.new(::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)
-
-        remote_call = begin
-          set_basic_authentication(connection, options)
-
-          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
-          RemoteCall::Errors::ConnectionFailed.new(response)
-        rescue ::Faraday::Error::TimeoutError
-          RemoteCall::Errors::Timeout.new(response)
-        end
-
-        block_given? ? yield(remote_call) : remote_call
-      end
-
-
-      protected ################ PROTECTED ################
-
-      def strip_options(options)
-        request_options = options.delete(:request_options) || {}
-
-        connection = (options.delete(:connection) || generate_connection(nil, options)).connection
-
-        [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, request_options, options, params, body)
-        request_options.each { |key, value| request.options.send("#{key}=", value) }
-
-        options[:headers].each { |key, value| request.headers[key] = value }
-
-        params.each { |key, value| request.params[key] = value }
-
-        request.body = body
-      end
-
-    end
-
-  end
-end

data/lib/smooth_operator/operators/typhoeus.rb

@@ -1,87 +0,0 @@
-require 'typhoeus'
-require "smooth_operator/remote_call/typhoeus"
-
-module SmoothOperator
-
-  module Operators
-
-    module Typhoeus
-
-      extend self
-
-      def generate_parallel_connection
-        generate_connection
-      end
-
-      def generate_connection(adapter = nil, options = nil)
-        ConnectionWrapper.new(::Typhoeus::Hydra::hydra)
-      end
-
-      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)
-
-        hydra = (options[:connection] || generate_connection).connection
-
-        request_result = nil
-
-        hydra.queue(request)
-
-        request.on_complete do |typhoeus_response|
-          remote_call = remote_call(typhoeus_response)
-
-          if block_given?
-            request_result = yield(remote_call)
-          else
-            request_result = remote_call
-          end
-        end
-
-        hydra.run if Helpers.blank?(options[:connection])
-
-        request_result
-      end
-
-      protected ################ PROTECTED ################
-
-      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 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
-
-      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] = 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[:userpwd] = "#{options[:endpoint_user]}:#{options[:endpoint_pass]}" if Helpers.present?(options[:endpoint_user])
-
-        typhoeus_options
-      end
-
-      def url(options, relative_path)
-        url = options[:endpoint]
-
-        slice = url[-1] != '/' ? '/' : ''
-
-        url = "#{url}#{slice}#{relative_path}" if Helpers.present?(relative_path)
-      end
-
-    end
-
-  end
-end

data/lib/smooth_operator/options.rb

@@ -1,30 +0,0 @@
-module SmoothOperator
-  module Options
-
-    def get_option(option, default, *args)
-      return default unless config_options.include?(option)
-
-      _option = config_options[option]
-
-      case _option
-      when Symbol
-        respond_to?(_option) ? send(_option, *args) : _option
-      when Proc
-        _option.call(*args)
-      else
-        _option
-      end
-    end
-
-    def config_options
-      Helpers.get_instance_variable(self, :config_options, {})
-    end
-
-    def smooth_operator_options(options = {})
-      config_options.merge!(options)
-    end
-
-    alias_method :options, :smooth_operator_options
-
-  end
-end