object_json_mapper 0.0.1

data/lib/object_json_mapper/base.rb

@@ -0,0 +1,163 @@
+module ObjectJSONMapper
+  class Base
+    include ActiveModel::Validations
+    include ActiveModel::Validations::Callbacks
+
+    include Local
+    include Conversion
+    include Serialization
+    include Errors
+    include Associations
+    include Persistence
+
+    extend ActiveModel::Callbacks
+
+    attr_accessor :persisted, :attributes
+
+    define_model_callbacks :save, :create, :update, :destroy, :validation
+
+    delegate :slice, :[], :[]=, to: :attributes
+
+    def initialize(attributes = {})
+      self.attributes = attributes
+      @persisted = false
+    end
+
+    alias persisted? persisted
+
+    def new_record?
+      !persisted?
+    end
+
+    def persist
+      @persisted = true
+    end
+
+    def reloadable?
+      to_key.any?
+    end
+
+    # @param value [Hash]
+    def attributes=(value)
+      @attributes = HashWithIndifferentAccess.new(value)
+
+      @attributes.each do |method_name, _|
+        define_singleton_method(method_name) do
+          @attributes[method_name]
+        end
+      end
+    end
+
+    def ==(other)
+      attributes == other.attributes && persisted == other.persisted
+    end
+
+    def client
+      self.class.client[id]
+    end
+
+    class << self
+      attr_accessor :associations, :relation, :root_url
+
+      def inherited(base)
+        base.root_url     = base.name.underscore.pluralize
+        base.associations = Associations::Registry.new
+        base.relation     = Relation.new(klass: base)
+      end
+
+      def client
+        RestClient::Resource.new(
+          URI.join(ObjectJSONMapper.base_url, root_url).to_s,
+          headers: ObjectJSONMapper.headers
+        )
+      end
+
+      def configure
+        yield self
+      end
+
+      def name=(value)
+        @name = value.to_s
+      end
+
+      def name
+        @name || super
+      end
+
+      # @param name [Symbol]
+      # @param type [Dry::Types::Constructor]
+      # @param default [Proc]
+      def attribute(name, type: nil, default: nil)
+        define_method(name) do
+          return default.call if attributes.exclude?(name) && default
+          return type.call(attributes[name]) if type
+
+          attributes[name]
+        end
+
+        define_method("#{name}=") do |value|
+          attributes[name] = value
+        end
+      end
+
+      # @param name [Symbol]
+      # @param block [Proc]
+      def scope(name, block)
+        define_singleton_method(name) do
+          relation.deep_clone.instance_exec(&block)
+        end
+
+        relation.define_singleton_method(name) do
+          instance_exec(&block)
+        end
+      end
+
+      def root(value)
+        clone.tap do |base|
+          base.name     = name
+          base.root_url = value.to_s
+        end
+      end
+
+      # Same as `new` but for persisted records
+      # @param attributes [Hash]
+      # @return [ObjectJSONMapper::Base]
+      def persist(attributes = {})
+        new(attributes).tap do |base|
+          base.persisted = true
+        end
+      end
+
+      # @param conditions [Hash]
+      # @return [ObjectJSONMapper::Relation<ObjectJSONMapper::Base>] collection of model instances
+      def where(conditions = {})
+        relation.tap { |relation| relation.klass = self }.where(conditions)
+      end
+      alias all where
+
+      # @param id [Integer]
+      # @return [ObjectJSONMapper::Base] current model instance
+      def find(id)
+        raise ActiveRecord::RecordNotFound if id.nil?
+
+        result = HTTP.parse_json(client[id].get.body)
+
+        persist(result)
+      rescue RestClient::ExceptionWithResponse
+        raise ActiveRecord::RecordNotFound
+      end
+
+      # rubocop:disable Rails/FindBy
+      #
+      # @param conditions [Hash]
+      # @return [ObjectJSONMapper::Base] current model instance
+      def find_by(conditions = {})
+        where(conditions).first
+      end
+
+      def none
+        NullRelation.new(klass: self)
+      end
+    end
+  end
+end

data/lib/object_json_mapper/conversion.rb

@@ -0,0 +1,24 @@
+module ObjectJSONMapper
+  module Conversion
+    def to_model
+      self
+    end
+
+    # @return [Array] all key attributes
+    def to_key
+      [].tap do |a|
+        a << id if respond_to?(:id)
+      end
+    end
+
+    # @return [String] object's key suitable for use in URLs
+    def to_param
+      id.to_s
+    end
+
+    def to_partial_path
+      name = self.class.name.underscore
+      [name.pluralize, name].join('/')
+    end
+  end
+end

data/lib/object_json_mapper/errors.rb

@@ -0,0 +1,37 @@
+module ObjectJSONMapper
+  module Errors
+    # @param messages [Hash]
+    # @example
+    #   load_errors(
+    #     {
+    #       "email": ["blank"]
+    #     }
+    #   )
+    def load_errors(messages)
+      errors.clear
+      messages.each do |key, values|
+        values.each do |value|
+          case value
+          when String
+            errors.add(key, value)
+          when Hash
+            errors.add(key, value[:error].to_sym, value.except(:error))
+          end
+        end
+      end
+    end
+
+    # In comparison with `ActiveModel::Validations#valid?`
+    # we should not clear errors because it would clear remote errors as well,
+    # but we can remove duplicates in the error messages
+    # @return [TrueClass,FalseClass]
+    def valid?(context = nil)
+      current_context, self.validation_context = validation_context, context
+      run_validations!
+    ensure
+      errors.messages.each { |_, v| v.uniq! }
+      self.validation_context = current_context
+    end
+    alias validate valid?
+  end
+end

data/lib/object_json_mapper/extensions/kaminari.rb

@@ -0,0 +1,48 @@
+module Kaminari
+  module ObjectJSONMapper
+    module ObjectJSONMapperExtension
+      include Kaminari::ConfigurationMethods
+
+      def self.included(base)
+        base.define_singleton_method(Kaminari.config.page_method_name) do |num|
+          where(page: num, per_page: Kaminari.config.default_per_page)
+        end
+      end
+    end
+
+    module ObjectJSONMapperCriteriaMethods
+      def limit_value
+        collection unless @limit_value
+        @limit_value
+      end
+
+      def total_count
+        collection unless @total_count
+        @total_count
+      end
+
+      def total_pages
+        return 1 if limit_value.zero?
+        (total_count.to_f / limit_value).ceil
+      end
+
+      def offset_value
+        limit_value * current_page
+      end
+
+      def current_page
+        page = conditions[:page].to_i
+        page > 0 ? page : 1
+      end
+
+      def max_pages
+        total_count / offset_value
+      end
+    end
+  end
+end
+
+ObjectJSONMapper::Base.send(:include, Kaminari::ObjectJSONMapper::ObjectJSONMapperExtension)
+ObjectJSONMapper::Relation.send(:include, Kaminari::ObjectJSONMapper::ObjectJSONMapperExtension)
+ObjectJSONMapper::Relation.send(:include, Kaminari::PageScopeMethods)
+ObjectJSONMapper::Relation.send(:include, Kaminari::ObjectJSONMapper::ObjectJSONMapperCriteriaMethods)

data/lib/object_json_mapper/http.rb

@@ -0,0 +1,9 @@
+module ObjectJSONMapper
+  module HTTP
+    def self.parse_json(json)
+      JSON.parse(json, symbolize_names: true)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/object_json_mapper/local.rb

@@ -0,0 +1,58 @@
+module ObjectJSONMapper
+  module Local
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def local
+      @local ||= self.class.local.find_or_initialize_by(id: id)
+      # sometimes local fetched before remote was saved, thus there is no id
+      @local.id ||= id
+      @local
+    end
+
+    def find_by_local(source, &scope)
+      self.class.find_by_local(source, &scope)
+    end
+
+    module ClassMethods
+      def local
+        return @local if @local
+        @local = Class.new(ActiveRecord::Base)
+        @local.table_name = name.underscore.pluralize
+        @local
+      end
+
+      # Allows you to apply filters from local model to remote data.
+      #
+      # @param source [ObjectJSONMapper::Relation]
+      # @param scope [Proc] scope to execute on local results
+      # @return [ObjectJSONMapper:Relation]
+      #
+      # @example
+      #   class User < ObjectJSONMapper::Base
+      #     def self.local
+      #       LocalUser
+      #     end
+      #   end
+      #
+      #   class LocalUser < ActiveRecord::Base
+      #   end
+      #
+      #   User.find_by_local(User.all) do
+      #     where(local_column: 'value')
+      #   end
+      #   # => SELECT * FROM local_users WHERE local_column = 'value'
+      #   # => GET http://example.com/users?id_in=1,2,3
+      def find_by_local(source, &scope)
+        source.where(
+          id_in: source.klass
+                       .local
+                       .all
+                       .instance_exec(&scope)
+                       .pluck(:id)
+        )
+      end
+    end
+  end
+end

data/lib/object_json_mapper/null_relation.rb

@@ -0,0 +1,7 @@
+module ObjectJSONMapper
+  class NullRelation < Relation
+    def collection
+      []
+    end
+  end
+end

data/lib/object_json_mapper/persistence.rb

@@ -0,0 +1,94 @@
+module ObjectJSONMapper
+  module Persistence
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # @return [ObjectJSONMapper::Base,FalseClass]
+    def save(*)
+      return update(attributes) if persisted?
+
+      response = self.class.client.post(attributes)
+
+      result = if response.headers[:location]
+                 RestClient.get(response.headers[:location], ObjectJSONMapper.headers)
+               else
+                 response.body
+               end
+
+      persist
+      errors.clear
+      attributes.merge!(HTTP.parse_json(result))
+
+      self
+    rescue RestClient::ExceptionWithResponse => e
+      raise e unless e.response.code == 422
+
+      load_errors(HTTP.parse_json(e.response.body))
+
+      false
+    ensure
+      validate
+    end
+    alias save! save
+
+    # @param params [Hash]
+    # @return [ObjectJSONMapper::Base,FalseClass]
+    def update(params = {})
+      return false if new_record?
+
+      client.patch(params)
+
+      reload
+      errors.clear
+
+      self
+    rescue RestClient::ExceptionWithResponse => e
+      raise e unless e.response.code == 422
+
+      load_errors(HTTP.parse_json(e.response.body))
+
+      false
+    end
+    alias update_attributes update
+
+    # @result [TrueClass,FalseClass]
+    def destroy
+      client.delete
+
+      true
+    rescue RestClient::ExceptionWithResponse
+      false
+    end
+    alias delete destroy
+
+    # @return [ObjectJSONMapper::Base]
+    def reload
+      tap do |base|
+        base.attributes = HTTP.parse_json(client.get.body) if reloadable?
+      end
+    end
+
+    module ClassMethods
+      # @param params [Hash]
+      # @return [ObjectJSONMapper::Base] current model instance
+      def create(params = {})
+        response = client.post(params)
+
+        result = if response.headers[:location]
+                   RestClient.get(response.headers[:location], ObjectJSONMapper.headers)
+                 else
+                   response.body
+                 end
+
+        persist(HTTP.parse_json(result))
+      rescue RestClient::ExceptionWithResponse => e
+        raise e unless e.response.code == 422
+
+        new.tap do |base|
+          base.load_errors(HTTP.parse_json(e.response.body))
+        end
+      end
+    end
+  end
+end

data/lib/object_json_mapper/relation.rb

@@ -0,0 +1,100 @@
+module ObjectJSONMapper
+  class Relation
+    include Enumerable
+
+    attr_accessor :collection, :conditions, :klass, :path
+
+    delegate :each,
+             :map,
+             :first,
+             :last,
+             :empty?,
+             :select,
+             :select!,
+             :to_ary,
+             :+,
+             :inspect,
+             :size,
+             to: :collection
+
+    def initialize(options = {})
+      @klass      ||= options[:klass]
+      @path       ||= options[:path]
+      @collection ||= options.fetch(:collection, [])
+      @conditions ||= options.fetch(:conditions, {})
+    end
+
+    def find_by(conditions = {})
+      collection.find do |record|
+        conditions.all? { |k, v| record.public_send(k) == v }
+      end
+    end
+
+    def find(id)
+      find_by(id: id.to_i)
+    end
+
+    def exists?(id)
+      find(id).present?
+    end
+
+    def where(conditions = {})
+      deep_clone.tap { |relation| relation.conditions.merge!(conditions) }
+    end
+
+    # @return [Array,Array<Array>]
+    def pluck(*attributes)
+      map { |record| record.slice(*attributes).values }
+        .tap { |result| result.flatten! if attributes.size == 1 }
+    end
+
+    # TODO: refactor
+    def collection
+      return @collection if @collection.any? && conditions.empty?
+
+      response = RestClient.get(path,
+        (ObjectJSONMapper.headers || {}).merge(params: prepare_params(conditions)))
+
+      @total_count = response.headers[:total].to_i
+      @limit_value = response.headers[:per_page].to_i
+
+      @collection = HTTP.parse_json(response.body)
+                        .map { |attributes| klass.persist(attributes) }
+    end
+
+    def deep_clone
+      clone.tap do |object|
+        object.conditions = conditions.clone
+        object.collection = @collection.clone
+      end
+    end
+
+    def none
+      NullRelation.new(klass: klass, conditions: conditions)
+    end
+
+    # Find and return relation of local records by `id`
+    # @return [ActiveRecord::Relation]
+    def locals
+      return [] if collection.empty?
+      klass.local.where(id: collection.map(&:id))
+    end
+
+    private
+
+      def prepare_params(conditions)
+        conditions.deep_merge(conditions) do |_, _, value|
+          case value
+          when Array
+            value.join(',')
+          else
+            value
+          end
+        end
+      end
+
+      def path
+        @path || klass.client.url
+      end
+  end
+end

data/lib/object_json_mapper/serialization.rb

@@ -0,0 +1,7 @@
+module ObjectJSONMapper
+  module Serialization
+    def serializable_hash
+      attributes
+    end
+  end
+end

data/lib/object_json_mapper/version.rb

@@ -0,0 +1,3 @@
+module ObjectJSONMapper
+  VERSION = '0.0.1'.freeze
+end

data/lib/object_json_mapper.rb

@@ -0,0 +1,37 @@
+require 'active_model'
+require 'rest-client'
+require 'json'
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/core_ext/enumerable'
+
+require 'object_json_mapper/version'
+
+require 'object_json_mapper/associations/association'
+require 'object_json_mapper/associations/has_many'
+require 'object_json_mapper/associations/has_one'
+require 'object_json_mapper/associations/registry'
+require 'object_json_mapper/associations'
+require 'object_json_mapper/conversion'
+require 'object_json_mapper/serialization'
+require 'object_json_mapper/persistence'
+require 'object_json_mapper/errors'
+require 'object_json_mapper/http'
+require 'object_json_mapper/local'
+
+require 'object_json_mapper/relation'
+require 'object_json_mapper/null_relation'
+require 'object_json_mapper/base'
+
+if defined?(Kaminari)
+  require 'object_json_mapper/extensions/kaminari'
+end
+
+module ObjectJSONMapper
+  mattr_accessor :base_url, :headers
+
+  def self.configure
+    yield self
+  end
+end

data/object_json_mapper.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'object_json_mapper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'object_json_mapper'
+  spec.version       = ObjectJSONMapper::VERSION
+  spec.authors       = ['droptheplot']
+  spec.email         = ['novikov359@gmail.com']
+
+  spec.summary       = 'ActiveResource for UMS.'
+  spec.homepage      = 'https://github.com/InspireNL/ObjectJSONMapper'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'awesome_print', '~> 1.7'
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'webmock', '~> 2.3'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+  spec.add_development_dependency 'kaminari', '~> 0.17'
+
+  spec.add_dependency 'activemodel', '>= 4.2'
+  spec.add_dependency 'activesupport', '>= 4.2'
+  spec.add_dependency 'rest-client', '~> 2.0'
+end