smooth_operator 0.4.4 → 1.2.0

data/lib/smooth_operator/attributes/base.rb

@@ -0,0 +1,107 @@
+module SmoothOperator
+  module Attributes
+
+    class Base
+
+      protected ##################### PROTECTED ########################
+
+      def cast_to_type(name, value, parent_object)
+        known_by_schema, type, unknown_hash_class = parent_object.known_by_schema?(name), parent_object.get_attribute_type(name), parent_object.class.unknown_hash_class
+
+        return Helpers.duplicate(value) if known_by_schema && type.nil?
+
+        case value
+        when Array
+          value.map { |array_entry| self.class.new(name, array_entry, parent_object).value }
+        when Hash
+          type.nil? ? new_unknown_hash(value, unknown_hash_class, parent_object) : type.new(value, parent_object: parent_object)
+        else
+          convert(value, type)
+        end
+      end
+
+      def convert(value, type)
+        case type
+
+        when :string, :text, String
+          value.to_s
+
+        when :int, :integer, Integer, Fixnum
+          to_int(value)
+
+        when :date, Date
+          to_date(value)
+
+        when :float, Float
+          to_float(value)
+
+        when :bool, :boolean
+          to_boolean(value)
+
+        when :datetime, :date_time, DateTime
+          to_datetime(value)
+
+        else
+          Helpers.duplicate(value)
+        end
+      end
+
+      def to_date(string)
+        return string if string.is_a?(Date)
+
+        Date.parse(string) rescue nil
+      end
+
+      def to_datetime(string)
+        return string if string.is_a?(DateTime)
+
+        DateTime.parse(string) rescue nil
+      end
+
+      def to_boolean(string)
+        value = string.to_s.downcase
+
+        ['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) || string.is_a?(Fixnum))
+
+        value = string.to_s.gsub(',', '.').scan(/-*\d+[.]*\d*/).flatten.map(&:to_f).first
+
+        value.nil? ? 0 : value
+      end
+
+      def new_unknown_hash(hash, unknown_hash_class, parent_object)
+        if unknown_hash_class == :none
+          hash
+        else
+          unknown_hash_class.new(cast_params(hash, unknown_hash_class, parent_object))
+        end
+      end
+
+
+      private ################### PRIVATE #####################
+
+      def cast_params(attributes, unknown_hash_class, parent_object)
+        hash = {}
+
+        attributes.each do |key, value|
+          hash[key] = cast_to_type(key, value, parent_object)
+        end
+
+        hash
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/attributes/dirty.rb

@@ -0,0 +1,29 @@
+module SmoothOperator
+  module Attributes
+
+    class Dirty < Base
+
+      attr_reader :original_name, :original_value, :first_value, :value
+
+      def initialize(name, value, parent_object)
+        @original_name, @original_value = name, value
+
+        @first_value = set_value(value, parent_object)
+      end
+
+      def set_value(new_value, parent_object)
+        @value = cast_to_type(original_name, new_value, parent_object)
+      end
+
+      def changed?
+        @first_value != @value
+      end
+
+      def was
+        @first_value
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/attributes/normal.rb

@@ -0,0 +1,15 @@
+module SmoothOperator
+  module Attributes
+
+    class Normal < Base
+
+      attr_reader :value
+
+      def initialize(name, value, parent_object)
+        @value = cast_to_type(name, value, parent_object)
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/delegation.rb

@@ -0,0 +1,60 @@
+module SmoothOperator
+
+  module Delegation
+
+    def respond_to?(method)
+      if known_attribute?(method)
+        true
+      else
+        self.class.reflect_on_association(method) ? true : super
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      method_type, method_name = *parse_method(method)
+
+      result = case method_type
+      when :was
+        get_internal_data(method_name, :was)
+      when :changed
+        get_internal_data(method_name, :changed?)
+      when :setter
+        return push_to_internal_data(method_name, args.first)
+      else
+        if Helpers.safe_call(self.class, :reflect_on_association, method)
+          return get_relation(method_name)
+        elsif !self.class.strict_behaviour || known_attribute?(method_name)
+          return get_internal_data(method_name)
+        end
+      end
+
+      result.nil? ? super : result
+    end
+
+
+    protected #################### PROTECTED ################
+
+    def parse_method(method)
+      method = method.to_s
+
+      if method?(method, /=$/)
+        [:setter, method[0..-2]]
+      elsif method?(method, /_was$/)
+        [:was, method[0..-5]]
+      elsif method?(method, /_changed\?$/)
+        [:changed, method[0..-10]]
+      else
+        [nil, method]
+      end
+    end
+
+
+    private #################### PRIVATE ################
+
+    def method?(method, regex)
+      !! ((method.to_s) =~ regex)
+    end
+
+  end
+
+end

data/lib/smooth_operator/finder_methods.rb

@@ -0,0 +1,43 @@
+require 'smooth_operator/array_with_meta_data'
+
+module SmoothOperator
+  
+  module FinderMethods
+
+    def find(relative_path, data = {}, options = {})
+      relative_path = '' if relative_path == :all
+
+      get(relative_path, data, options) do |remote_call|
+        remote_call.object = build_object(remote_call.parsed_response, options) if remote_call.ok?
+
+        block_given? ? yield(remote_call) : remote_call
+      end
+    end
+
+
+    protected #################### PROTECTED ##################
+
+    def build_object(parsed_response, options, from_array = false)
+      if parsed_response.is_a?(Array)
+        parsed_response.map { |array_entry| build_object(array_entry, options, true) }
+      elsif parsed_response.is_a?(Hash)
+        if parsed_response.include?(object_class.resources_name) && !from_array
+          ArrayWithMetaData.new(parsed_response, object_class)
+        else
+          object_class.new(parsed_response, from_server: true)
+        end
+      else
+        parsed_response
+      end
+    end
+
+
+    private #################### PRIVATE ##################
+
+    def object_class
+      @object_class ||= self.class == Class ? self : self.class
+    end
+
+  end
+  
+end

data/lib/smooth_operator/helpers.rb

@@ -0,0 +1,79 @@
+module SmoothOperator
+
+  module Helpers
+
+    extend self
+
+    def safe_call(object, method, *args)
+      if object.respond_to?(method)
+        object.send(method, *args)
+      else
+        false
+      end
+    end
+
+    def super_method(object, method_name, *args)
+      object.superclass.send(method_name, *args) if object.superclass.respond_to?(method_name)
+    end
+
+    def get_instance_variable(object, variable, default_value)
+      instance_var = object.instance_variable_get("@#{variable}")
+
+      return instance_var unless instance_var.nil?
+
+      instance_var = (super_method(object, variable) || default_value)
+
+      if instance_var.class == Class
+        object.instance_variable_set("@#{variable}", instance_var)
+      else
+        object.instance_variable_set("@#{variable}", duplicate(instance_var))
+      end
+    end
+
+    def stringify_keys(hash)
+      stringified_hash = {}
+      hash.keys.each { |key| stringified_hash[key.to_s] = hash[key] }
+      stringified_hash
+    end
+
+    def symbolyze_keys(hash)
+      hash.keys.reduce({}) do |cloned_hash, key|
+        cloned_hash[key.to_sym] = hash[key]
+        cloned_hash
+      end
+    end
+
+    def plural?(string)
+      string = string.to_s
+      string == string.pluralize
+    end
+
+    def duplicate(object)
+      object.dup rescue object
+    end
+
+    def blank?(object)
+      case object
+      when String
+        object.to_s == ''
+      when Array
+        object.empty?
+      else
+        object.nil?
+      end
+    end
+
+    def present?(object)
+      !blank?(object)
+    end
+
+    def absolute_path?(string)
+      present?(string) && string[0] == '/'
+    end
+
+    def remove_initial_slash(string)
+      string[1..-1]
+    end
+
+  end
+end

data/lib/smooth_operator/model_schema.rb

@@ -0,0 +1,81 @@
+module SmoothOperator
+  module ModelSchema
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def known_attribute?(attribute)
+      known_attributes.include?(attribute.to_s)
+    end
+
+    def known_by_schema?(attribute)
+      self.class.internal_structure.include?(attribute.to_s)
+    end
+
+    def known_attributes
+      @known_attributes ||= self.class.known_attributes.dup
+    end
+
+    module ClassMethods
+
+      def resources_name(default_bypass = nil)
+        return @resources_name if defined?(@resources_name)
+
+        (Helpers.super_method(self, :resources_name, true) || (default_bypass ? nil : self.resource_name.pluralize))
+      end
+      attr_writer :resources_name
+
+      def resource_name(default_bypass = nil)
+        return @resource_name if defined?(@resource_name)
+
+        (Helpers.super_method(self, :resource_name, true) || (default_bypass ? nil : self.model_name.to_s.underscore))
+      end
+      attr_writer :resource_name
+
+      def schema(structure)
+        internal_structure.merge! Helpers.stringify_keys(structure)
+
+        known_attributes.merge internal_structure.keys
+      end
+
+      def internal_structure
+        Helpers.get_instance_variable(self, :internal_structure, { "errors" => nil })
+      end
+
+      def known_attributes
+        Helpers.get_instance_variable(self, :known_attributes, Set.new)
+      end
+
+      def model_name
+        return '' if @_model_name == :none
+
+        if defined? ActiveModel
+          rails_model_name_method
+        else
+          @_model_name ||= name.split('::').last.underscore.capitalize
+        end
+      end
+
+      def model_name=(name)
+        @_model_name = name
+      end
+
+      protected ############## PROTECTED #############
+
+      def rails_model_name_method
+        @model_name ||= begin
+          namespace ||= self.parents.detect do |n|
+            n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+          end
+
+          ActiveModel::Name.new(self, namespace, @_model_name).tap do |model_name|
+            def model_name.human(options = {}); @klass.send(:_translate, "models.#{i18n_key}", options); end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/open_struct.rb

@@ -0,0 +1,37 @@
+require "smooth_operator/delegation"
+require "smooth_operator/validations"
+require "smooth_operator/model_schema"
+require "smooth_operator/serialization"
+require "smooth_operator/attribute_methods"
+require "smooth_operator/attribute_assignment"
+
+module SmoothOperator
+  module OpenStruct
+
+    class Base
+
+      include Delegation
+      include Validations
+      include ModelSchema
+      include Serialization
+      include AttributeMethods
+      include AttributeAssignment
+
+      def self.strict_behaviour=(value)
+        @strict_behaviour = value
+      end
+
+      def self.strict_behaviour
+        Helpers.get_instance_variable(self, :strict_behaviour, false)
+      end
+
+    end
+
+    class Dirty < Base
+
+      dirty_attributes
+
+    end
+
+  end
+end

data/lib/smooth_operator/operator.rb

@@ -0,0 +1,145 @@
+require "smooth_operator/remote_call/base"
+require "smooth_operator/operators/faraday"
+require "smooth_operator/operators/typhoeus"
+require "smooth_operator/remote_call/errors/timeout"
+require "smooth_operator/remote_call/errors/connection_failed"
+
+module SmoothOperator
+
+  module Operator
+
+    def make_the_call(http_verb, relative_path = '', data = {}, options = {})
+      options ||= {}
+      
+      relative_path = resource_path(relative_path)
+      
+      if !parent_object.nil? && options[:ignore_parent] != true
+        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{parent_object.get_primary_key}/#{self.class.resources_name}"
+      end
+      
+      self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
+        yield(remote_call)
+      end
+    end
+
+    protected ######################## PROTECTED ###################
+
+    def resource_path(relative_path)
+      if Helpers.absolute_path?(relative_path)
+        Helpers.remove_initial_slash(relative_path)
+      elsif persisted?
+        Helpers.present?(relative_path) ? "#{get_primary_key}/#{relative_path}" : get_primary_key.to_s
+      else
+        relative_path
+      end
+    end
+
+
+    ########################### MODULES BELLOW ###############################
+
+    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
+
+    module ClassMethods
+
+      OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
+
+      OPTIONS.each do |option|
+        define_method(option) { Helpers.get_instance_variable(self, option, '') }
+      end
+
+      attr_writer *OPTIONS
+
+      def headers
+        Helpers.get_instance_variable(self, :headers, {})
+      end
+
+      attr_writer :headers
+
+
+      def make_the_call(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
+        end
+        
+        operator_call.make_the_call(*operator_args) do |remote_call|
+          block_given? ? yield(remote_call) : remote_call
+        end
+      end
+
+      def query_string(params)
+        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)
+        _resources_name = options[:resources_name] || self.resources_name
+
+        if Helpers.present?(_resources_name)
+          Helpers.present?(relative_path) ? "#{_resources_name}/#{relative_path}" : _resources_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
+
+    
+    include HttpMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.extend(HttpMethods)
+    end
+
+  end
+
+end

data/lib/smooth_operator/operators/faraday.rb

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