active_record_seek 0.0.1

data/lib/active_record_seek/query.rb

@@ -0,0 +1,68 @@
+module ActiveRecordSeek
+  class Query
+
+    include Concerns::InstanceVariableConcern
+
+    delegate(*%w[ table_name arel_table reflect_on_association ], to: :model)
+    attr_reader(*%w[ active_record_query ])
+
+    def active_record_query=(new_active_record_query)
+      instance_variable_reset(:@where_sql)
+      @active_record_query = new_active_record_query
+    end
+    alias_method(:to_active_record_query, :active_record_query)
+
+    def to_seek_query
+      self
+    end
+
+    def model
+      to_active_record_query.klass
+    end
+
+    def adapter_name
+      model.connection.adapter_name
+    end
+
+    def arel_column(column_name)
+      arel_table[column_name]
+    end
+
+    def merge_where_sql(other_query)
+      to_active_record_query.where(other_query.to_seek_query.to_where_sql(enclose_with_parentheses: false))
+    end
+
+    def to_where_sql(enclose_with_parentheses: true)
+      if !instance_variable_defined?(:@where_sql)
+        @where_sql = active_record_query.reorder(nil).to_sql.split(" WHERE ", 2)[1].to_s.strip
+      end
+      return "" if @where_sql.blank?
+      enclose_with_parentheses ? "(#{@where_sql})" : @where_sql
+    end
+
+    def has_where_sql?
+      to_where_sql.present?
+    end
+
+    def apply(components)
+      to_active_record_query.seek_or(self) do |this|
+        components.group_by(&:namespace).each do |namespace, namespace_components|
+          case namespace
+          when "unscoped"
+            namespace_components.each do |component|
+              add_query { component.apply(self) }
+            end
+          else
+            add_query do |namespace_query|
+              namespace_components.each do |component|
+                namespace_query = component.apply(namespace_query)
+              end
+              namespace_query
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/active_record_seek/scopes/association_scope.rb

@@ -0,0 +1,98 @@
+module ActiveRecordSeek
+  module Scopes
+    class AssociationScope < BaseScope
+
+      attr_accessor(*%w[ components base_query association ])
+
+      class JumpPlan
+        include Concerns::InstanceVariableConcern
+
+        attr_accessor(*%w[ reflection ])
+        delegate(:each, to: :jumps)
+
+        def after_initialize
+          add_reflection_jump(reflection)
+        end
+
+        def jumps
+          @jumps ||= []
+        end
+
+        def add_jump(model, association)
+          jumps.push(Jump.new(model: model, association: association))
+        end
+
+        def add_reflection_jump(jump_reflection)
+          # used to protect against infinite loop
+          association = jump_reflection.source_reflection.name
+          through_ref = jump_reflection.through_reflection
+          if through_ref
+            throughception = through_ref.klass.reflect_on_association(association)
+            # check for throughception (jump through another association)
+            # normal example:
+            #   GroupProperty.has_many(:member_groups, through: :group)
+            #   GroupProperty.has_many(:members, through: :member_groups)
+            # throughception example:
+            #   GroupProperty.has_many(:members, through: :group)
+            if throughception && throughception.through_reflection
+              add_reflection_jump(throughception) # add all throughception jumps
+              add_reflection_jump(through_ref) # continue
+            else
+              add_jump(through_ref.klass, association)
+              add_reflection_jump(through_ref)
+            end
+          else
+            add_jump(jump_reflection.active_record, jump_reflection.name)
+          end
+        end
+      end
+
+      class Jump
+        include Concerns::InstanceVariableConcern
+
+        attr_accessor(*%w[ model association query ])
+
+        def reflection
+          model.reflect_on_association(association)
+        end
+
+        def primary_key
+          reflection.macro == :belongs_to ? reflection.foreign_key : reflection.active_record_primary_key
+        end
+
+        def foreign_key
+          reflection.macro == :belongs_to ? reflection.active_record_primary_key : reflection.foreign_key
+        end
+
+        def to_s
+          "#{model}.where(#{primary_key} => #{query.model}.#{foreign_key})"
+        end
+
+        def apply
+          model.unscoped.where(primary_key => query.to_active_record_query.select(foreign_key)).to_seek_query
+        end
+      end
+
+      # Group => Member
+      # jump through MemberGroup.group
+      # jump base Member.member_groups
+      # MemberGroup.where_group_id(in: Group.select_id)
+      def apply
+        association_reflection = base_query.model.reflect_on_association(association)
+        if !association_reflection
+          raise(
+            ArgumentError,
+            "#{base_query.model} does not have an association with the name: #{association.inspect}"
+          )
+        end
+        association_query = association_reflection.klass.unscoped.to_seek_query
+        association_query = association_query.apply(components).to_seek_query
+        JumpPlan.new(reflection: association_reflection).each do |jump|
+          association_query = jump.set(query: association_query).apply
+        end
+        association_query
+      end
+
+    end
+  end
+end

data/lib/active_record_seek/scopes/base_scope.rb

@@ -0,0 +1,10 @@
+# WHERE (clause) has many conditions (predicates)
+module ActiveRecordSeek
+  module Scopes
+    class BaseScope
+
+      include Concerns::InstanceVariableConcern
+
+    end
+  end
+end

data/lib/active_record_seek/scopes/seek_or_scope.rb

@@ -0,0 +1,53 @@
+module ActiveRecordSeek
+  module Scopes
+    class SeekOrScope < BaseScope
+
+      attr_accessor(*%w[ context_block ])
+
+      def apply(query, *context_arguments, &context_block)
+        query = query.to_seek_query
+        context = Context.new(query.model)
+        context.instance_exec(*context_arguments, &context_block)
+        context.apply(query)
+      end
+
+      class Context
+        attr_accessor(*%w[ model queries ])
+
+        def initialize(model)
+          self.model   = model
+          self.queries = []
+        end
+
+        def add_query(&block)
+          unscoped_query = model.unscoped
+          query = unscoped_query.instance_exec(unscoped_query, &block).to_seek_query
+          queries.push(query) if query.has_where_sql?
+          self
+        end
+
+        # combine queries into single OR clause
+        def apply(query)
+          queries_sql = queries.map do |context_query|
+            context_query.to_where_sql(enclose_with_parentheses: queries.size > 1)
+          end.join(" OR ")
+          query.to_active_record_query.where(queries_sql).to_seek_query
+        end
+      end
+
+      module ActiveRecordScopeConcern
+
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def seek_or(*params, &block)
+            SeekOrScope.new.apply(all, *params, &block).to_active_record_query
+          end
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/active_record_seek/scopes/seek_scope.rb

@@ -0,0 +1,54 @@
+module ActiveRecordSeek
+  module Scopes
+    class SeekScope < BaseScope
+
+      attr_reader(*%w[ seek_query active_record_query components components_hash ])
+
+      def query=(new_query)
+        @seek_query          = new_query.to_seek_query
+        @active_record_query = @seek_query.to_active_record_query
+        @seek_query
+      end
+
+      def components_hash=(new_components_hash)
+        @components = new_components_hash.stringify_keys.map do |key, value|
+          Component.new(base_query: self, key: key, value: value)
+        end
+      end
+
+      def apply
+        components_for_base_query = components.select(&:is_base_query_component?)
+        components_by_association = components.reject(&:is_base_query_component?).group_by(&:association)
+        self.query = seek_query.apply(components_for_base_query)
+        self.query = active_record_query.seek_or(self) do |this|
+          components_by_association.each do |association, association_components|
+            add_query do
+              AssociationScope.new(
+                base_query:  to_seek_query,
+                association: association,
+                components:  association_components,
+              ).apply
+            end
+          end
+        end
+        seek_query
+      end
+
+      module ActiveRecordScopeConcern
+
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def seek(components_hash = {}, &block)
+            raise(ArgumentError, "#{self.class}#seek does not accept a block") if block
+            SeekScope.new(
+              query: all,
+              components_hash: components_hash,
+            ).apply.to_active_record_query
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_record_seek/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordSeek
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: active_record_seek
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Griffith Chaffee
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+description: Build complex ActiveRecord queries using hash syntax. Includes support
+  for Arel operators, OR queries, and assocition subqueries.
+email:
+- griffithchaffee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record_seek.gemspec
+- bin/console
+- bin/setup
+- gemfiles/mysql.gemfile
+- gemfiles/mysql.gemfile.lock
+- gemfiles/postgresql.gemfile
+- gemfiles/postgresql.gemfile.lock
+- gemfiles/sqlite.gemfile
+- gemfiles/sqlite.gemfile.lock
+- lib/active_record_seek.rb
+- lib/active_record_seek/component.rb
+- lib/active_record_seek/concerns/active_record_concern.rb
+- lib/active_record_seek/concerns/instance_variable_concern.rb
+- lib/active_record_seek/middleware.rb
+- lib/active_record_seek/operators/base_operator.rb
+- lib/active_record_seek/operators/ci_base_operator.rb
+- lib/active_record_seek/operators/ci_matches_base_operator.rb
+- lib/active_record_seek/operators/ci_regexp_base_operator.rb
+- lib/active_record_seek/operators/matches_base_operator.rb
+- lib/active_record_seek/operators/regexp_base_operator.rb
+- lib/active_record_seek/query.rb
+- lib/active_record_seek/scopes/association_scope.rb
+- lib/active_record_seek/scopes/base_scope.rb
+- lib/active_record_seek/scopes/seek_or_scope.rb
+- lib/active_record_seek/scopes/seek_scope.rb
+- lib/active_record_seek/version.rb
+homepage: https://github.com/griffithchaffee/active_record_seek
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Build complex ActiveRecord queries using hash syntax.
+test_files: []