active_record_extended 0.1.1

data/lib/active_record_extended/arel/nodes.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "arel/nodes/binary"
+
+module Arel
+  module Nodes
+    class Overlap < Arel::Nodes::Binary
+      def operator
+        :"&&"
+      end
+    end
+
+    class Contains < Arel::Nodes::Binary
+      def operator
+        :>>
+      end
+    end
+
+    class ContainsHStore < Arel::Nodes::Binary
+      def operator
+        :"@>"
+      end
+    end
+
+    class ContainsArray < Arel::Nodes::Binary
+      def operator
+        :"@>"
+      end
+    end
+
+    class ContainedInArray < Arel::Nodes::Binary
+      def operator
+        :"<@"
+      end
+    end
+
+    class ContainsEquals < Arel::Nodes::Binary
+      def operator
+        :">>="
+      end
+    end
+
+    class ContainedWithin < Arel::Nodes::Binary
+      def operator
+        :<<
+      end
+    end
+
+    class ContainedWithinEquals < Arel::Nodes::Binary
+      def operator
+        :"<<="
+      end
+    end
+
+    class Node
+      def group_or(right)
+        Arel::Nodes::Or.new self, Arel::Nodes::Grouping.new(right)
+      end
+    end
+  end
+end

data/lib/active_record_extended/arel/predications.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "arel/predications"
+
+module Arel
+  module Predications
+    def overlap(other)
+      Nodes::Overlap.new(self, Nodes.build_quoted(other, self))
+    end
+
+    def contains(other)
+      Nodes::Contains.new self, Nodes.build_quoted(other, self)
+    end
+
+    def contained_within(other)
+      Nodes::ContainedWithin.new self, Nodes.build_quoted(other, self)
+    end
+
+    def contained_within_or_equals(other)
+      Nodes::ContainedWithinEquals.new self, Nodes.build_quoted(other, self)
+    end
+
+    def contained_in_array(other)
+      Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
+    end
+
+    def contains_or_equals(other)
+      Nodes::ContainsEquals.new self, Nodes.build_quoted(other, self)
+    end
+
+    def any(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new("ANY", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
+    end
+
+    def all(other)
+      any_tags_function = Arel::Nodes::NamedFunction.new("ALL", [self])
+      Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), any_tags_function)
+    end
+  end
+end

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "arel/visitors/postgresql"
+
+module ActiveRecordExtended
+  module Visitors
+    module PostgreSQLDecorator
+      private
+
+      # rubocop:disable Naming/MethodName
+
+      def visit_Arel_Nodes_Overlap(object, collector)
+        infix_value object, collector, " && "
+      end
+
+      def visit_Arel_Nodes_Contains(object, collector)
+        left_column = object.left.relation.name.classify.constantize.columns.detect do |col|
+          matchable_column?(col, object)
+        end
+
+        if %i[hstore jsonb].include?(left_column&.type)
+          visit_Arel_Nodes_ContainsHStore(object, collector)
+        elsif left_column.try(:array)
+          visit_Arel_Nodes_ContainsArray(object, collector)
+        else
+          infix_value object, collector, " >> "
+        end
+      end
+
+      def visit_Arel_Nodes_ContainsArray(object, collector)
+        infix_value object, collector, " @> "
+      end
+
+      def visit_Arel_Nodes_ContainsHStore(object, collector)
+        infix_value object, collector, " @> "
+      end
+
+      def visit_Arel_Nodes_ContainedWithin(object, collector)
+        infix_value object, collector, " << "
+      end
+
+      def visit_Arel_Nodes_ContainedWithinEquals(object, collector)
+        infix_value object, collector, " <<= "
+      end
+
+      def visit_Arel_Nodes_ContainedInHStore(object, collector)
+        infix_value object, collector, " <@ "
+      end
+
+      def visit_Arel_Nodes_ContainedInArray(object, collector)
+        infix_value object, collector, " <@ "
+      end
+
+      def visit_Arel_Nodes_ContainsEquals(object, collector)
+        infix_value object, collector, " >>= "
+      end
+
+      def visit_Arel_Nodes_AnyOf(object, collector)
+        pp object
+        pp collector
+        collector
+      end
+
+      def matchable_column?(col, object)
+        col.name == object.left.name.to_s || col.name == object.left.relation.name.to_s
+      end
+
+      # rubocop:enable Naming/MethodName
+    end
+  end
+end
+
+Arel::Visitors::PostgreSQL.prepend(ActiveRecordExtended::Visitors::PostgreSQLDecorator)

data/lib/active_record_extended/arel.rb

@@ -0,0 +1,6 @@
+
+# frozen_string_literal: true
+
+require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/predications"
+require "active_record_extended/arel/visitors/postgresql_decorator"

data/lib/active_record_extended/patch/5_1/where_clause.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module WhereClause
+    def modified_predicates(&block)
+      ::ActiveRecord::Relation::WhereClause.new(predicates.map(&block), binds)
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::WhereClause)

data/lib/active_record_extended/patch/5_2/where_clause.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module WhereClause
+    def modified_predicates(&block)
+      ::ActiveRecord::Relation::WhereClause.new(predicates.map(&block))
+    end
+  end
+end
+
+ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::WhereClause)

data/lib/active_record_extended/predicate_builder/array_handler_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_record/relation/predicate_builder"
+require "active_record/relation/predicate_builder/array_handler"
+
+module ActiveRecordExtended
+  module ArrayHandlerDecorator
+    def call(attribute, value)
+      cache = ActiveRecord::Base.connection.schema_cache
+      if cache.data_source_exists?(attribute.relation.name)
+        column = cache.columns(attribute.relation.name).detect { |col| col.name.to_s == attribute.name.to_s }
+        return attribute.eq(value) if column.try(:array)
+      end
+
+      super(attribute, value)
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder::ArrayHandler.prepend(ActiveRecordExtended::ArrayHandlerDecorator)

data/lib/active_record_extended/query_methods/either.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "ar_outer_joins"
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Either
+      XOR_FIELD_SQL  = "(CASE WHEN %<t1>s.%<c1>s IS NULL THEN %<t2>s.%<c2>s ELSE %<t1>s.%<c1>s END) "
+      XOR_FIELD_KEYS = %i[t1 c1 t2 c2].freeze
+
+      def either_join(initial_association, fallback_association)
+        associations        = [initial_association, fallback_association]
+        association_options = xor_field_options_for_associations(associations)
+        condition__query    = xor_field_sql(association_options) + "= #{table_name}.#{primary_key}"
+        outer_joins(associations).where(Arel.sql(condition__query))
+      end
+
+      def either_order(direction, **associations_and_columns)
+        reflected_columns = map_columns_to_tables(associations_and_columns)
+        conditional_query = xor_field_sql(reflected_columns) + sort_order_sql(direction)
+        outer_joins(associations_and_columns.keys).order(Arel.sql(conditional_query))
+      end
+
+      private
+
+      def xor_field_sql(options)
+        XOR_FIELD_SQL % Hash[xor_field_options(options)]
+      end
+
+      def sort_order_sql(dir)
+        %w[asc desc].include?(dir.to_s) ? dir.to_s : "asc"
+      end
+
+      def xor_field_options(options)
+        str_args = options.flatten.take(XOR_FIELD_KEYS.size).map(&:to_s)
+        Hash[XOR_FIELD_KEYS.zip(str_args)]
+      end
+
+      def map_columns_to_tables(associations_and_columns)
+        if associations_and_columns.respond_to?(:transform_keys)
+          associations_and_columns.transform_keys { |assc| reflect_on_association(assc).table_name }
+        else
+          associations_and_columns.each_with_object({}) do |(assc, value), key_table|
+            reflect_table            = reflect_on_association(assc).table_name
+            key_table[reflect_table] = value
+          end
+        end
+      end
+
+      def xor_field_options_for_associations(associations)
+        associations.each_with_object({}) do |association_name, options|
+          reflection = reflect_on_association(association_name)
+          options[reflection.table_name] = reflection.foreign_key
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(ActiveRecordExtended::QueryMethods::Either)

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module WhereChain
+    def overlap(opts, *rest)
+      substitute_comparisons(opts, rest, Arel::Nodes::Overlap, "overlap")
+    end
+
+    def contained_within(opts, *rest)
+      substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithin, "contained_within")
+    end
+
+    def contained_within_or_equals(opts, *rest)
+      substitute_comparisons(opts, rest, Arel::Nodes::ContainedWithinEquals, "contained_within_or_equals")
+    end
+
+    def contains_or_equals(opts, *rest)
+      substitute_comparisons(opts, rest, Arel::Nodes::ContainsEquals, "contains_or_equals")
+    end
+
+    def any(opts, *rest)
+      equality_to_function("ANY", opts, rest)
+    end
+
+    def all(opts, *rest)
+      equality_to_function("ALL", opts, rest)
+    end
+
+    def contains(opts, *rest)
+      build_where_chain(opts, rest) do |arel|
+        case arel
+        when Arel::Nodes::In, Arel::Nodes::Equality
+          column = left_column(arel) || column_from_association(arel)
+
+          if %i[hstore jsonb].include?(column.type)
+            Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
+          elsif column.try(:array)
+            Arel::Nodes::ContainsArray.new(arel.left, arel.right)
+          else
+            raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+          end
+        else
+          raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+        end
+      end
+    end
+
+    private
+
+    def matchable_column?(col, arel)
+      col.name == arel.left.name.to_s || col.name == arel.left.relation.name.to_s
+    end
+
+    def column_from_association(arel)
+      assoc = assoc_from_related_table(arel)
+      assoc.klass.columns.detect { |col| matchable_column?(col, arel) } if assoc
+    end
+
+    def assoc_from_related_table(arel)
+      @scope.klass.reflect_on_association(arel.left.relation.name.to_sym) ||
+        @scope.klass.reflect_on_association(arel.left.relation.name.singularize.to_sym)
+    end
+
+    def left_column(arel)
+      @scope.klass.columns_hash[arel.left.name] || @scope.klass.columns_hash[arel.left.relation.name]
+    end
+
+    def equality_to_function(function_name, opts, rest)
+      build_where_chain(opts, rest) do |arel|
+        case arel
+        when Arel::Nodes::Equality
+          Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
+        else
+          raise ArgumentError, "Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}"
+        end
+      end
+    end
+
+    def substitute_comparisons(opts, rest, arel_node_class, method)
+      build_where_chain(opts, rest) do |arel|
+        case arel
+        when Arel::Nodes::In, Arel::Nodes::Equality
+          arel_node_class.new(arel.left, arel.right)
+        else
+          raise ArgumentError, "Invalid argument for .where.#{method}(), got #{arel.class}"
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module QueryMethods
+    class WhereChain
+      prepend ActiveRecordExtended::WhereChain
+
+      def build_where_chain(opts, rest, &block)
+        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+        @scope.tap do |scope|
+          scope.references!(PredicateBuilder.references(opts)) if opts.is_a?(Hash)
+          scope.where_clause += where_clause.modified_predicates(&block)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_extended/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  VERSION = "0.1.1"
+end

data/lib/active_record_extended.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "active_record_extended/version"
+
+require "active_record_extended/active_record"
+require "active_record_extended/arel"
+
+module ActiveRecordExtended
+end

data/spec/active_record_extended_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe ActiveRecordExtended do
+  it "has a version number" do
+    expect(ActiveRecordExtended::VERSION).not_to be nil
+  end
+end

data/spec/query_methods/array_query_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Array Query Methods" do
+  let!(:one)   { Person.create!(tags: [1, 2, 3],  personal_id: 33) }
+  let!(:two)   { Person.create!(tags: [3, 1, 5],  personal_id: 88) }
+  let!(:three) { Person.create!(tags: [2, 8, 20], personal_id: 33) }
+
+  describe "#overlap" do
+    it "Should return matched records" do
+      query = Person.where.overlap(tags: [1])
+      expect(query).to include(one, two)
+      expect(query).to_not include(three)
+
+      query = Person.where.overlap(tags: [2, 3])
+      expect(query).to include(one, two, three)
+    end
+  end
+
+  describe "#contains" do
+    it "returns records that contain elements in an array" do
+      query = Person.where.contains(tags: [1, 3])
+      expect(query).to include(one, two)
+      expect(query).to_not include(three)
+
+      query = Person.where.overlap(tags: [8, 2])
+      expect(query).to include(one, three)
+      expect(query).to_not include(two)
+    end
+  end
+
+  describe "#any" do
+    it "should return any records that match" do
+      query = Person.where.any(tags: 3)
+      expect(query).to include(one, two)
+      expect(query).to_not include(three)
+    end
+
+    it "allows chaining" do
+      query = Person.where.any(tags: 3).where(personal_id: 33)
+      expect(query).to include(one)
+      expect(query).to_not include(two, three)
+    end
+  end
+
+  describe "#all" do
+    let!(:contains_all)     { Person.create!(tags: [1], personal_id: 1) }
+    let!(:contains_all_two) { Person.create!(tags: [1], personal_id: 2) }
+    let!(:contains_some)    { Person.create!(tags: [1, 2], personal_id: 2) }
+
+    it "should return any records that match" do
+      query = Person.where.all(tags: 1)
+      expect(query).to include(contains_all, contains_all_two)
+      expect(query).to_not include(contains_some)
+    end
+
+    it "allows chaining" do
+      query = Person.where.all(tags: 1).where(personal_id: 1)
+      expect(query).to include(contains_all)
+      expect(query).to_not include(contains_all_two, contains_some)
+    end
+  end
+end

data/spec/query_methods/either_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Either Methods" do
+  let!(:one)       { Person.create! }
+  let!(:two)       { Person.create! }
+  let!(:three)     { Person.create! }
+  let!(:profile_l) { ProfileL.create!(person_id: one.id, likes: 100) }
+  let!(:profile_r) { ProfileR.create!(person_id: two.id, dislikes: 50) }
+
+  describe ".either_join/2" do
+    it "Should only only return records that belong to profile L or profile R" do
+      query = Person.either_join(:profile_l, :profile_r)
+      expect(query).to include(one, two)
+      expect(query).to_not include(three)
+    end
+  end
+
+  describe ".either_order/2" do
+    it "Should not exclude anyone who does not have a relationship" do
+      query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes)
+      expect(query).to include(one, two, three)
+    end
+
+    it "Should order people based on their likes and dislikes in ascended order" do
+      query = Person.either_order(:asc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
+      expect(query).to match_array([two, one])
+    end
+
+    it "Should order people based on their likes and dislikes in descending order" do
+      query = Person.either_order(:desc, profile_l: :likes, profile_r: :dislikes).where(id: [one.id, two.id])
+      expect(query).to match_array([one, two])
+    end
+  end
+end

data/spec/query_methods/hash_query_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Hash Related Query Methods" do
+  let!(:one)   { Person.create!(data: { nickname: "george" }, jsonb_data: { payment: "zip" }) }
+  let!(:two)   { Person.create!(data: { nickname: "dan"    }, jsonb_data: { payment: "zipper" }) }
+  let!(:three) { Person.create!(data: { nickname: "georgey" }) }
+
+  describe "#contains" do
+    context "HStore Column Type" do
+      it "returns records that contain hash elements in joined tables" do
+        tag_one = Tag.create!(person_id: one.id)
+        tag_two = Tag.create!(person_id: two.id)
+
+        query = Tag.joins(:person).where.contains(people: { data: { nickname: "george" } })
+        expect(query).to include(tag_one)
+        expect(query).to_not include(tag_two)
+      end
+
+      it "returns records that contain hash value" do
+        query = Person.where.contains(data: { nickname: "george" })
+        expect(query).to include(one)
+        expect(query).to_not include(two, three)
+      end
+    end
+
+    context "JSONB Column Type" do
+      it "returns records that contains a json hashed value" do
+        query = Person.where.contains(jsonb_data: { payment: "zip" })
+        expect(query).to include(one)
+        expect(query).to_not include(two, three)
+      end
+
+      it "returns records that contain jsonb elements in joined tables" do
+        tag_one = Tag.create!(person_id: one.id)
+        tag_two = Tag.create!(person_id: two.id)
+
+        query = Tag.joins(:person).where.contains(people: { jsonb_data: { payment: "zip" } })
+        expect(query).to include(tag_one)
+        expect(query).to_not include(tag_two)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+unless ENV["DATABASE_URL"]
+  require "dotenv"
+  Dotenv.load
+end
+
+ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require File.expand_path(f) }
+Dir["#{File.dirname(__FILE__)}/**/*examples.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+# Gem files must be loaded last
+require "active_record_extended"

data/spec/sql_inspections/arel/array_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Array Column Predicates" do
+  let(:arel_table) { Person.arel_table }
+
+  describe "Array Overlap" do
+    it "converts Arel overlap statement" do
+      query = arel_table.where(arel_table[:tags].overlap(["tag", "tag 2"])).to_sql
+      expect(query).to match_regex(/&& '\{"?tag"?,"tag 2"\}'/)
+    end
+
+    it "converts Arel overlap statement" do
+      query = arel_table.where(arel_table[:tag_ids].overlap([1, 2])).to_sql
+      expect(query).to match_regex(/&& '\{1,2\}'/)
+    end
+
+    it "works with count (and other predicates)" do
+      expect(Person.where(arel_table[:tag_ids].overlap([1, 2])).count).to eq 0
+    end
+  end
+
+  describe "Array Contains" do
+    it "converts Arel contains statement and escapes strings" do
+      query = arel_table.where(arel_table[:tags].contains(["tag", "tag 2"])).to_sql
+      expect(query).to match_regex(/@> '\{"?tag"?,"tag 2"\}'/)
+    end
+
+    it "converts Arel contains statement with numbers" do
+      query = arel_table.where(arel_table[:tag_ids].contains([1, 2])).to_sql
+      expect(query).to match_regex(/@> '\{1,2\}'/)
+    end
+
+    it "works with count (and other predicates)" do
+      expect(Person.where(arel_table[:tag_ids].contains([1, 2])).count).to eq 0
+    end
+  end
+
+  describe "Any Array Element" do
+    it "creates any predicates that contain a string value" do
+      query = arel_table.where(arel_table[:tags].any("tag")).to_sql
+      expect(query).to match_regex(/'tag' = ANY\("people"\."tags"\)/)
+    end
+
+    it "creates any predicates that contain a integer value" do
+      query = arel_table.where(arel_table[:tags].any(2)).to_sql
+      expect(query).to match_regex(/2 = ANY\("people"\."tags"\)/)
+    end
+  end
+
+  describe "All Array Elements" do
+    it "create all predicates that contain a string value" do
+      query = arel_table.where(arel_table[:tags].all("tag")).to_sql
+      expect(query).to match_regex(/'tag' = ALL\("people"\."tags"\)/)
+    end
+
+    it "create all predicates that contain a interger value" do
+      query = arel_table.where(arel_table[:tags].all(2)).to_sql
+      expect(query).to match_regex(/2 = ALL\("people"\."tags"\)/)
+    end
+  end
+end