quiver 0.21.0

data/lib/quiver/adapter/arec_low_level_creator.rb

@@ -0,0 +1,82 @@
+module Quiver
+  module Adapter
+    module ActiveRecord
+      class ARecLowLevelCreator
+        attr_reader :primary_key
+
+        def initialize(adapter_klass, original_attributes)
+          self.adapter_klass = adapter_klass
+          self.failed = false
+          self.original_attributes = original_attributes
+          self.attrs = {}
+        end
+
+        def map(attributes, opts)
+          if opts[:foreign_key]
+            attributes.merge!(opts[:foreign_key])
+          end
+
+          if opts[:primary] && original_attributes[:__type__]
+            attributes.merge!(
+              original_attributes[:__type__][:name] => original_attributes[:__type__][:value]
+            )
+          end
+
+          record = record_class(opts[:to]).create(attributes)
+
+          if record.persisted?
+            attrs.merge!(record.attributes)
+
+            if opts[:primary]
+              self.primary_key = record.send(adapter_klass.primary_key_name)
+            end
+          else
+            self.failed = true
+          end
+        end
+
+        def map_array(h, opts)
+          h.each do |key, items|
+            attrs[key] = items.map do |attributes|
+              if opts[:foreign_key]
+                attributes.merge!(opts[:foreign_key])
+              end
+
+              record = record_class(opts[:to]).create(attributes)
+
+              if record.persisted?
+                attributes.merge(id: record.id)
+              else
+                self.failed = true
+                {}
+              end
+            end
+          end
+        end
+
+        def success?
+          !failed
+        end
+
+        def failed!
+          self.failed = true
+        end
+
+        def result
+          original_attributes.symbolize_keys.merge(attrs.merge(
+            adapter_klass.primary_key_name => primary_key
+          ).symbolize_keys)
+        end
+
+        private
+
+        attr_accessor :adapter_klass, :failed, :original_attributes, :attrs, :mapper_klass
+        attr_writer :primary_key
+
+        def record_class(name)
+          adapter_klass.record_classes[name]
+        end
+      end
+    end
+  end
+end

data/lib/quiver/adapter/arec_low_level_deleter.rb

@@ -0,0 +1,74 @@
+module Quiver
+  module Adapter
+    module ActiveRecord
+      class ARecLowLevelDeleter
+        def initialize(adapter_klass, original_attributes)
+          self.adapter_klass = adapter_klass
+          self.failed = false
+          self.original_attributes = original_attributes
+          self.attrs = {}
+          self.calls = []
+        end
+
+        def map(attributes, opts)
+          record = record_class(opts[:to])
+
+          if opts[:foreign_key]
+            record = record.where(opts[:foreign_key])
+          end
+
+          if opts[:primary]
+            record = record.where(
+              adapter_klass.primary_key_name => primary_key
+            )
+          end
+
+          calls.unshift -> {
+            record.delete_all == 1
+          }
+        end
+
+        def map_array(h, opts)
+          raise ArgumentError, 'map_array requires opts[foreign_key] to be set' unless opts[:foreign_key]
+
+          h.each do |key, items|
+            record = record_class(opts[:to])
+            query = record.where(opts[:foreign_key])
+
+            remove_ids = record.pluck(:id)
+
+            calls.unshift -> {
+              query.where(id: remove_ids).delete_all == remove_ids.count
+            }
+          end
+        end
+
+        def success?
+          calls.all? do |call|
+            call.call
+          end && !failed
+        end
+
+        def failed!
+          self.failed = true
+        end
+
+        def result
+          {}
+        end
+
+        def primary_key
+          original_attributes[adapter_klass.primary_key_name]
+        end
+
+        private
+
+        attr_accessor :adapter_klass, :failed, :mapper_klass, :original_attributes, :attrs, :calls
+
+        def record_class(name)
+          adapter_klass.record_classes[name]
+        end
+      end
+    end
+  end
+end

data/lib/quiver/adapter/arec_low_level_updater.rb

@@ -0,0 +1,105 @@
+module Quiver
+  module Adapter
+    module ActiveRecord
+      class ARecLowLevelUpdater
+        def initialize(adapter_klass, original_attributes)
+          self.adapter_klass = adapter_klass
+          self.failed = false
+          self.original_attributes = original_attributes
+          self.attrs = {}
+        end
+
+        def map(attributes, opts)
+          record = record_class(opts[:to])
+
+          if opts[:foreign_key]
+            record = record.where(opts[:foreign_key])
+          end
+
+          if opts[:primary]
+            record = record.where(
+              adapter_klass.primary_key_name => primary_key
+            )
+          end
+
+          result = record.update_all(attributes)
+
+          if result == 0
+            self.failed = true
+          end
+        end
+
+        def map_array(h, opts)
+          raise ArgumentError, 'map_array requires opts[foreign_key] to be set' unless opts[:foreign_key]
+
+          h.each do |key, items|
+            record = record_class(opts[:to])
+            query = record.where(opts[:foreign_key])
+
+            ids = record.pluck(:id)
+            remaining_ids = items.map { |i| i[:id] }.compact
+            remove_ids = ids - remaining_ids
+
+            query.where(id: remove_ids).delete_all
+
+            attrs[key] = items.map do |item|
+              item = item.merge(opts[:foreign_key])
+
+              if item[:id]
+                result = query.where(id: item[:id]).update_all(item)
+
+                if result != 1
+                  self.failed = true
+                else
+                  item
+                end
+              else
+                result = record.create(item)
+
+                if !result.persisted?
+                  self.failed = true
+                else
+                  result.attributes.symbolize_keys
+                end
+              end
+            end
+          end
+        end
+
+        def success?
+          !failed
+        end
+
+        def failed!
+          self.failed = true
+        end
+
+        def result
+          r = original_attributes.symbolize_keys.merge(attrs.merge(
+            adapter_klass.primary_key_name => primary_key
+          ).symbolize_keys)
+
+          if original_attributes[:__type__]
+            r.merge!(
+              original_attributes[:__type__][:name] => original_attributes[:__type__][:value]
+            )
+          end
+
+          r
+        end
+
+        def primary_key
+          original_attributes[adapter_klass.primary_key_name]
+        end
+
+        private
+
+        attr_accessor :adapter_klass, :failed, :mapper_klass, :original_attributes, :attrs
+
+        def record_class(name)
+          adapter_klass.record_classes[name]
+        end
+      end
+    end
+  end
+end

data/lib/quiver/adapter/filter_helpers.rb

@@ -0,0 +1,58 @@
+module Quiver
+  module Adapter
+    module FilterHelpers
+      def initialize(memo, filter)
+        self.memo = memo
+        self.filter_params = filter
+      end
+
+      def filter
+        filter_params.inject(memo) do |memo, (attr, filter)|
+          filter_attributes = filter.is_a?(Hash) ? filter : filter.filter_attributes
+          filter_attributes.inject(memo) do |memo, (comparator, value)|
+            if value.nil?
+              memo
+            else
+              case comparator.to_s.downcase
+              when 'eq'
+                equal_filter(memo, attr, value)
+              when 'not_eq'
+                not_equal_filter(memo, attr, value)
+              when 'in'
+                in_filter(memo, attr, value)
+              when 'not_in'
+                not_in_filter(memo, attr, value)
+              when 'lt'
+                less_than_filter(memo, attr, value)
+              when 'gt'
+                greater_than_filter(memo, attr, value)
+              when 'lte'
+                less_than_or_equal_filter(memo, attr, value)
+              when 'gte'
+                greater_than_or_equal_filter(memo, attr, value)
+              when 'not_lt'
+                greater_than_or_equal_filter(memo, attr, value)
+              when 'not_gt'
+                less_than_or_equal_filter(memo, attr, value)
+              when 'not_lte'
+                greater_than_filter(memo, attr, value)
+              when 'not_gte'
+                less_than_filter(memo, attr, value)
+              else
+                if respond_to?("#{comparator.to_s.downcase}_filter", true)
+                  send("#{comparator.to_s.downcase}_filter", memo, attr, value)
+                else
+                  memo
+                end
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :memo, :filter_params
+    end
+  end
+end

data/lib/quiver/adapter/helpers_helpers.rb

@@ -0,0 +1,53 @@
+module Quiver
+  module Adapter
+    module HelpersHelpers
+      def self.included(host)
+        host.send(:extend, SelfMethods)
+      end
+
+      module SelfMethods
+        def included(host)
+          if !host.is_a?(Quiver::Adapter)
+            host.send(:include, Quiver::Adapter)
+          end
+        end
+      end
+
+      private
+
+      def mapper_name
+        @mapper_name ||= self.class.parent.name.split('::').last.underscore
+      end
+
+      def when_valid(model, adapter_op)
+        raise ArgumentError, "requires block" unless block_given?
+
+        errors = model.validate(
+          tags: [adapter_op],
+          mapper: mapper_klass.new,
+          model: model,
+          adapter: self
+        )
+
+        if errors.success?
+          current_time = Time.now.utc
+          model.updated_at = current_time if model.respond_to?(:updated_at=)
+
+          if adapter_op == :create
+            model.created_at ||= current_time if model.respond_to?(:created_at)
+          end
+
+          object = yield(model, errors)
+        end
+
+        Quiver::Mapper::MapperResult.new(object, errors, adapter_op: adapter_op)
+      end
+
+      def hydrate(attributes)
+        mapper_klass.hydrate(attributes).tap do |obj|
+          obj.persisted_by!(adapter_type)
+        end
+      end
+    end
+  end
+end

data/lib/quiver/adapter/memory_adapter_filter.rb

@@ -0,0 +1,71 @@
+module Quiver
+  module Adapter
+    module MemoryAdapterFilterDefaults
+      include FilterHelpers
+
+      def equal_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] == value
+        end
+      end
+
+      def not_equal_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] != value
+        end
+      end
+
+      def in_filter(memo, attr, value)
+        memo.select do |obj|
+          value.include?(obj[attr.to_sym])
+        end
+      end
+
+      def not_in_filter(memo, attr, value)
+        memo.select do |obj|
+          !value.include?(obj[attr.to_sym])
+        end
+      end
+
+      def less_than_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] < value
+        end
+      end
+
+      def greater_than_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] > value
+        end
+      end
+
+      def less_than_or_equal_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] <= value
+        end
+      end
+
+      def greater_than_or_equal_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym] >= value
+        end
+      end
+
+      def nil_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym].nil? == (value == 'true' || value == true)
+        end
+      end
+
+      def not_nil_filter(memo, attr, value)
+        memo.select do |obj|
+          obj[attr.to_sym].nil? != (value == 'true' || value == true)
+        end
+      end
+    end
+
+    class MemoryAdapterFilter
+      include MemoryAdapterFilterDefaults
+    end
+  end
+end