graphiti 1.0.alpha.1

data/lib/graphiti/adapters/active_record.rb

@@ -0,0 +1,6 @@
+require 'graphiti/adapters/active_record/base'
+require 'graphiti/adapters/active_record/inferrence'
+require 'graphiti/adapters/active_record/has_many_sideload'
+require 'graphiti/adapters/active_record/belongs_to_sideload'
+require 'graphiti/adapters/active_record/has_one_sideload'
+require 'graphiti/adapters/active_record/many_to_many_sideload'

data/lib/graphiti/adapters/active_record/base.rb

@@ -0,0 +1,249 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord
+      class Base < ::Graphiti::Adapters::Abstract
+        def filter_string_eq(scope, attribute, value, is_not: false)
+          column = scope.klass.arel_table[attribute]
+          clause = column.lower.eq_any(value.map(&:downcase))
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_eql(scope, attribute, value, is_not: false)
+          clause = { attribute => value }
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_not_eq(scope, attribute, value)
+          filter_string_eq(scope, attribute, value, is_not: true)
+        end
+
+        def filter_string_not_eql(scope, attribute, value)
+          filter_string_eql(scope, attribute, value, is_not: true)
+        end
+
+        def filter_string_prefix(scope, attribute, value, is_not: false)
+          column = scope.klass.arel_table[attribute]
+          map = value.map { |v| "#{v}%" }
+          clause = column.lower.matches_any(map)
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_not_prefix(scope, attribute, value)
+          filter_string_prefix(scope, attribute, value, is_not: true)
+        end
+
+        def filter_string_suffix(scope, attribute, value, is_not: false)
+          column = scope.klass.arel_table[attribute]
+          map = value.map { |v| "%#{v}" }
+          clause = column.lower.matches_any(map)
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_not_suffix(scope, attribute, value)
+          filter_string_suffix(scope, attribute, value, is_not: true)
+        end
+
+        def filter_string_match(scope, attribute, value, is_not: false)
+          column = scope.klass.arel_table[attribute]
+          map = value.map { |v| "%#{v.downcase}%" }
+          clause = column.lower.matches_any(map)
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_not_match(scope, attribute, value)
+          filter_string_match(scope, attribute, value, is_not: true)
+        end
+
+        def filter_integer_eq(scope, attribute, value, is_not: false)
+          clause = { attribute => value }
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+        alias :filter_float_eq :filter_integer_eq
+        alias :filter_big_decimal_eq :filter_integer_eq
+        alias :filter_date_eq :filter_integer_eq
+        alias :filter_boolean_eq :filter_integer_eq
+
+        def filter_integer_not_eq(scope, attribute, value)
+          filter_integer_eq(scope, attribute, value, is_not: true)
+        end
+        alias :filter_float_not_eq :filter_integer_not_eq
+        alias :filter_big_decimal_not_eq :filter_integer_not_eq
+        alias :filter_date_not_eq :filter_integer_not_eq
+
+        def filter_integer_gt(scope, attribute, value)
+          column = scope.klass.arel_table[attribute]
+          scope.where(column.gt_any(value))
+        end
+        alias :filter_float_gt :filter_integer_gt
+        alias :filter_big_decimal_gt :filter_integer_gt
+        alias :filter_datetime_gt :filter_integer_gt
+        alias :filter_date_gt :filter_integer_gt
+
+        def filter_integer_gte(scope, attribute, value)
+          column = scope.klass.arel_table[attribute]
+          scope.where(column.gteq_any(value))
+        end
+        alias :filter_float_gte :filter_integer_gte
+        alias :filter_big_decimal_gte :filter_integer_gte
+        alias :filter_datetime_gte :filter_integer_gte
+        alias :filter_date_gte :filter_integer_gte
+
+        def filter_integer_lt(scope, attribute, value)
+          column = scope.klass.arel_table[attribute]
+          scope.where(column.lt_any(value))
+        end
+        alias :filter_float_lt :filter_integer_lt
+        alias :filter_big_decimal_lt :filter_integer_lt
+        alias :filter_datetime_lt :filter_integer_lt
+        alias :filter_date_lt :filter_integer_lt
+
+        def filter_integer_lte(scope, attribute, value)
+          column = scope.klass.arel_table[attribute]
+          scope.where(column.lteq_any(value))
+        end
+        alias :filter_float_lte :filter_integer_lte
+        alias :filter_big_decimal_lte :filter_integer_lte
+        alias :filter_date_lte :filter_integer_lte
+
+        # Ensure fractional seconds don't matter
+        def filter_datetime_eq(scope, attribute, value, is_not: false)
+          ranges = value.map { |v| (v..v+1.second-0.00000001) }
+          clause = { attribute => ranges }
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_datetime_not_eq(scope, attribute, value)
+          filter_datetime_eq(scope, attribute, value, is_not: true)
+        end
+
+        def filter_datetime_lte(scope, attribute, value)
+          value = value.map { |v| v + 1.second-0.00000001 }
+          column = scope.klass.arel_table[attribute]
+          scope.where(column.lteq_any(value))
+        end
+
+        def base_scope(model)
+          model.all
+        end
+
+        # (see Adapters::Abstract#order)
+        def order(scope, attribute, direction)
+          scope.order(attribute => direction)
+        end
+
+        # (see Adapters::Abstract#paginate)
+        def paginate(scope, current_page, per_page)
+          scope.page(current_page).per(per_page)
+        end
+
+        # (see Adapters::Abstract#count)
+        def count(scope, attr)
+          if attr.to_sym == :total
+            scope.distinct.count
+          else
+            scope.distinct.count(attr)
+          end
+        end
+
+        # (see Adapters::Abstract#average)
+        def average(scope, attr)
+          scope.average(attr).to_f
+        end
+
+        # (see Adapters::Abstract#sum)
+        def sum(scope, attr)
+          scope.sum(attr)
+        end
+
+        # (see Adapters::Abstract#maximum)
+        def maximum(scope, attr)
+          scope.maximum(attr)
+        end
+
+        # (see Adapters::Abstract#minimum)
+        def minimum(scope, attr)
+          scope.minimum(attr)
+        end
+
+        # (see Adapters::Abstract#resolve)
+        def resolve(scope)
+          scope.to_a
+        end
+
+        # Run this write request within an ActiveRecord transaction
+        # @param [Class] model_class The ActiveRecord class we are saving
+        # @return Result of yield
+        # @see Adapters::Abstract#transaction
+        def transaction(model_class)
+          model_class.transaction do
+            yield
+          end
+        end
+
+        def sideloading_classes
+          {
+            has_many: HasManySideload,
+            has_one: HasOneSideload,
+            belongs_to: BelongsToSideload,
+            many_to_many: ManyToManySideload
+          }
+        end
+
+        def associate_all(parent, children, association_name, association_type)
+          association = parent.association(association_name)
+          association.loaded!
+
+          children.each do |child|
+            if association_type == :many_to_many &&
+                !parent.send(association_name).exists?(child.id) &&
+                [:create, :update].include?(Graphiti.context[:namespace])
+              parent.send(association_name) << child
+            else
+              target = association.instance_variable_get(:@target)
+              target |= [child]
+              association.instance_variable_set(:@target, target)
+            end
+          end
+        end
+
+        def associate(parent, child, association_name, association_type)
+          association = parent.association(association_name)
+          association.loaded!
+          association.instance_variable_set(:@target, child)
+        end
+
+        # When a has_and_belongs_to_many relationship, we don't have a foreign
+        # key that can be null'd. Instead, go through the ActiveRecord API.
+        # @see Adapters::Abstract#disassociate
+        def disassociate(parent, child, association_name, association_type)
+          if association_type == :many_to_many
+            parent.send(association_name).delete(child)
+          else
+            # Nothing to do here, happened when we merged foreign key
+          end
+        end
+
+        # (see Adapters::Abstract#create)
+        def create(model_class, create_params)
+          instance = model_class.new(create_params)
+          instance.save
+          instance
+        end
+
+        # (see Adapters::Abstract#update)
+        def update(model_class, update_params)
+          instance = model_class.find(update_params.delete(:id))
+          instance.update_attributes(update_params)
+          instance
+        end
+
+        # (see Adapters::Abstract#destroy)
+        def destroy(model_class, id)
+          instance = model_class.find(id)
+          instance.destroy
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/belongs_to_sideload.rb

@@ -0,0 +1,17 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord
+      class BelongsToSideload < Sideload::BelongsTo
+        include Inferrence
+
+        def default_base_scope
+          resource_class.model.all
+        end
+
+        def scope(parent_ids)
+          base_scope.where(primary_key => parent_ids)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/has_many_sideload.rb

@@ -0,0 +1,17 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord # todo change
+      class HasManySideload < Sideload::HasMany
+        include Inferrence
+
+        def default_base_scope
+          resource_class.model.all
+        end
+
+        def scope(parent_ids)
+          base_scope.where(foreign_key => parent_ids)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/has_one_sideload.rb

@@ -0,0 +1,17 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord
+      class HasOneSideload < Sideload::HasOne
+        include Inferrence
+
+        def default_base_scope
+          resource_class.model.all
+        end
+
+        def scope(parent_ids)
+          base_scope.where(foreign_key => parent_ids)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/inferrence.rb

@@ -0,0 +1,12 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord
+      module Inferrence
+        def infer_foreign_key
+          parent_model = parent_resource_class.model
+          parent_model.reflections[association_name.to_s].foreign_key.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/many_to_many_sideload.rb

@@ -0,0 +1,30 @@
+module Graphiti
+  module Adapters
+    module ActiveRecord
+      class ManyToManySideload < Sideload::ManyToMany
+        def default_base_scope
+          resource_class.model.all
+        end
+
+        def through_table_name
+          @through_table_name ||= parent_resource_class.model
+            .reflections[through.to_s].klass.table_name
+        end
+
+        def scope(parent_ids)
+          base_scope
+            .includes(through)
+            .where(through_table_name => { true_foreign_key => parent_ids })
+            .distinct
+        end
+
+        def infer_foreign_key
+          parent_model = parent_resource_class.model
+          key = parent_model.reflections[name.to_s].options[:through]
+          value = parent_model.reflections[key.to_s].foreign_key.to_sym
+          { key => value }
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/null.rb

@@ -0,0 +1,236 @@
+module Graphiti
+  module Adapters
+    # The Null adapter is a 'pass-through' adapter. It won't modify the scope.
+    # Useful when your customization does not support all possible
+    # configuration (e.g. the service you hit does not support sorting)
+    class Null < Abstract
+      def filter_string_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_eql(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_eql(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_prefix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_prefix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_suffix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_suffix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_match_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_match_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_boolean_eq(scope, attribute, value)
+        scope
+      end
+
+      def base_scope(model)
+        raise 'Null adapter has no base scope!'
+      end
+
+      # (see Adapters::Abstract#order)
+      def order(scope, attribute, direction)
+        scope
+      end
+
+      # (see Adapters::Abstract#paginate)
+      def paginate(scope, current_page, per_page)
+        scope
+      end
+
+      # (see Adapters::Abstract#count)
+      def count(scope, attr)
+        scope
+      end
+
+      # (see Adapters::Abstract#average)
+      def average(scope, attr)
+        scope
+      end
+
+      # (see Adapters::Abstract#sum)
+      def sum(scope, attr)
+        scope
+      end
+
+      # (see Adapters::Abstract#sum)
+      def maximum(scope, attr)
+        scope
+      end
+
+      # (see Adapters::Abstract#minimum)
+      def minimum(scope, attr)
+        scope
+      end
+
+      # Since this is a null adapter, just yield
+      # @see Adapters::ActiveRecord#transaction
+      # @return Result of yield
+      # @param [Class] model_class The class we're operating on
+      def transaction(model_class)
+        yield
+      end
+
+      # (see Adapters::Abstract#resolve)
+      def resolve(scope)
+        scope
+      end
+    end
+  end
+end