activerecord-query 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fdf9b2ff6e244407f97068227e4db1514e85e4a6912178845a12123ad4f952af
+  data.tar.gz: d0b9acdfb57e77f20e82fe34d36b7158c9ae3c667af80807c1659d78269b5669
+SHA512:
+  metadata.gz: '06893476dc21302c35ca1db93973abaf91dc8e1bcc58a27d4ae83a66a68e9ac7f87d2054f0d9ec31a9d76ec4a638a5b01054877d3d911561916a477d1c010740'
+  data.tar.gz: 83bd2598980986b424f694b06cf49acf609764030dbb226f326fc34f389143f59d77497d1fde0b7c497881b9cd5c6bcf49bc36c2976c5727bdd7da762cd19b90

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## Changes in 0.1.0 
+
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in active_record_query.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/README.md

@@ -0,0 +1,425 @@
+# ActiveRecordQuery
+
+![example workflow](https://github.com/marcosfelipe/activerecord-query/actions/workflows/ruby.yml/badge.svg)
+
+
+ActiveRecordQuery is a DSL buit on top of [ActiveRecord](https://github.com/rails/rails/tree/main/activerecord) 
+to help you write complex SQL queries 
+in the cleanest way possible. The lib provides a base class to 
+build a query pattern in your object oriented project.
+
+Quick usage sample:
+
+```ruby
+# verbose
+query = Post.joins(:author).where(Post.arel_table[:created_at].gt(Date.new(2000, 1, 2))).order(title: :asc)
+
+# clean ;)
+class Query < ActiveRecordQuery::Base
+  from Post
+  join :author
+  where created_at > Date.new(2000, 1, 2)
+  order_by title.asc, author.name.asc
+end
+query = Query.execute
+```
+
+The main goal is to turn your queries (or scopes) into classes.
+These classes will be written naturally like a SQL query using a ruby DSL.
+The common problem with the actual design of activerecord is that 
+the users tend to write the query features in chain, like this:
+
+```ruby
+Post.select(:title)
+    .where(title: 'A title')
+    .where('created_at > ?', Date.today)
+    .order(:title)
+```
+
+You can refactor with scopes, I guess..
+
+```ruby
+class Post < ActiveRecord::Base
+  scope :titled, -> { where(title: 'A title') }
+  scope :created, -> { where('created_at < ?', Date.today) }
+  scope :titled_created, -> { titled.created }
+  
+  def self.a_query
+    select(:title).titled_created.order(:title)
+  end
+end
+```
+
+Very messy...
+When arel table features comes in, it becomes even worst.
+
+```ruby
+is_fixed = Post[:fixed].eq(true)
+is_coming = Post[:coming].eq(true).and(Post[:activated_at].not_eq(nil))
+Post.where(is_fixed.or(is_coming))
+```
+
+Now, let's try the ActiveRecordQuery:
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  where fixed == true
+  wor do |other|
+    other.where coming == true
+    other.where actived_at != nil
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-query'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install activerecord-query
+
+## Usage
+
+ActiveRecordQuery adds the ActiveRecord::Base class to your project, 
+so we can easily create query classes by extending it.
+
+### Queries
+The concept is given by the notion of query pattern classes. 
+The suggestion is that you put these classes in app/queries folder. 
+
+### The query setup
+
+Consider to have a Post model:
+
+```ruby
+class Post < ActiveRecord::Base
+end
+```
+
+Now, you have to create a classe extending `ActiveRecordQuery::Base` class, 
+and then add the reference for the `Post` activerecord type 
+on `from` method.
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+end
+```
+
+Once you have defined the from resource, the columns from Post will be available 
+as methods in the class scope. 
+E.g. the method `title` will be defined as a `Arel::Attributes::Attribute` object.
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  select title # the 'title' method was defined from 'from'
+end
+```
+
+The public method `execute` will return the `ActiveRecord_Relation` object.
+```ruby
+PostQuery.execute # => ActiveRecord_Relation 
+```
+
+Or you can instantiate it also:
+```ruby
+PostQuery.new.execute # => ActiveRecord_Relation 
+```
+
+### Query Features
+
+#### Conditions
+The methods `where` and `wor` are available to set the query conditions.
+The argument must be a `Arel::Node` object. 
+To a cleaner experience, you can use the generated methods for columns 
+generated from the `from` method.
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base 
+  from Post
+  
+  # and operation
+  where title == 'something' # using title helper
+  where Post.arel_table[:title].eq('something') # using arel
+    
+  # or operation
+  wor title == 'something else'
+end
+```
+
+The Arel predications are available:
+
+```ruby
+# between
+where column.between 1..10
+
+# matches
+where column.matches '%something%'
+
+# not in all
+where column.not_in_all %w[something]
+```
+
+You can nest the conditions:
+```ruby
+where column == 'c1'
+wor do |nested|
+  nested.where column == 'c2'
+  nested.where other == 'c3'
+  nested.wor do |deep_nested|
+    deep_nested.where other == 'c1'
+    deep_nested.where column == 'c4'
+  end
+end
+```
+It Generates:
+```sql
+column = "c1" or (column = "c2" and other = "c3" or (other = 'c1' and column = 'c4'))
+```
+
+The dynamic values for conditions can be add as a symbol to reference 
+a method or can be a proc. The values will be evaluate when the `execute` is called.
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  where title == :a_dynamic_method # references a method
+  where title == proc { 'a title' } # the value will be evaluate on execute
+  
+  def a_dynamic_method
+    'a title'
+  end
+end
+```
+
+#### Conditional where
+The `where/wor` state can be conditioned by passing the option `if:`.
+The value must be a symbol referencing a method.
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  where title == 'test', if: :a_method?
+  
+  def a_method?
+    false
+  end
+end
+```
+
+#### Selects
+Selects can be done by passing a list of columns to the `select` method.
+The args must be a list of `Arel::Attributes::Attribute`. 
+If no select is defined in the query, then the `*` selection will be taken.
+Every call of `select` the attrs will be added to the selection. 
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  
+  # simple select
+  select title, created_at
+  
+  # can do a math op (it's just a arel attr)
+  select id + id   
+  
+  # plain arel attr
+  select Post.arel_table[:id]
+end
+```
+
+#### Order by
+Much like the select method, you shall pass a list of attributes to the method `order_by`.
+Every call of `order_by` the attrs will be added to the selection.
+
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  
+  # list of arel attrs
+  order_by title.asc, created_at.desc
+end
+```
+
+#### Limits
+The `limit` method is available to define a query limit.
+An integer value is the only arg acceptable.
+Every time the limit method is called, the limit will be redefined.
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  limit 10
+end
+```
+
+#### Offsets
+The `offset` method is available to define a query offset.
+An integer value is the only arg acceptable.
+Every time the offset method is called, the offset will be redefined.
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  offset 10
+end
+```
+
+#### Joins
+The `join` method defines one/many relationships with the current resource (`from` state).
+The following example has a Post and Author models, the way we define a join is the same as 
+defining a `joins` on activerecord (check the active record querying doc.).
+Right after defined the join a new method will be available for retrieve the columns 
+from the new resource, the `author` method on this example. Every relationship listed in 
+the args will be converted to a method with the same name.
+```ruby
+# models
+class Post < ActiveRecord::Base
+  belongs_to :author
+end
+
+class Author < ActiveRecord::Base
+  has_many :posts
+end
+
+# query
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  join :author
+  
+  # the author helper will be available
+  where author.name == 'John'
+end
+```
+
+
+#### Group by
+To apply a GROUP BY clause to the query, you can use the `group_by` method.
+The method accepts a list of columns.
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  group_by title
+end
+```
+
+#### Having
+You can add the HAVING clause to the query by defining a `having` method.
+A column condition can be done by calling the Arel predication methods like `gt`. 
+```ruby
+class PostQuery < ActiveRecordQuery::Base
+  from Post
+  group_by title
+  having id.gt 5
+end
+```
+
+
+### Scopes
+There are at least to ways to scope your query class. The first one is the use of 
+class inheritance. The second one is extract features to modules. 
+
+#### Class inheritance
+You can merge queries by extending the class. 
+Let's say that you have a base query definition `AScopeQuery`.
+
+```ruby
+class AScopeQuery < ApplicationQuery
+  from Post
+  where title != nil
+end
+```
+And then you extend this query:
+```ruby
+class AQuery < AScopeQuery
+  where id > 5
+  order_by title
+end
+```
+The result will be the merge of the two queries:
+```sql
+SELECT * FROM posts WHERE title NOT NULL AND id > 5 ORDER BY title 
+```
+
+#### Modules
+Another way to scope a query, would be including modules into yours 
+query class. Let's define a module with activesupport concern.
+
+```ruby
+module AScope
+  extend ActiveSupport::Concern
+  
+  included do
+    where title == 'a scope'
+  end
+end
+```
+Note that we called the `where` macro inside the included method just like the 
+"activemodel concerns style". And then we can simply include the scope module into 
+the query class:
+```ruby
+class AQuery < ApplicationQuery
+  from Post
+  include AScope
+end
+```
+It is important to notice that the module must be included after the `from` definition
+due to the scope dependency on the `from` builds.
+
+### Query Parameters
+The query class can be instantiate/execute with user parameters. 
+The `options` method will be available on the instance context of the class.
+This data can be part of the query dynamic solutions in their features.
+```ruby
+class PostQuery < ApplicationQuery
+  from Post
+  where title == :title_value
+  
+  def title_value
+    options[:title]
+  end
+end
+
+# execute with option :title
+PostQuery.execute(title: 'A Title') # => select * from posts where title = "A Title"
+```
+On this example, the value for title condition is dynamic set by 
+the `options` parameter. A proc can be used also:
+```ruby
+where title == proc { options[:title] }
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at 
+https://github.com/marcosfelipe/activerecord-query. 
+This project is intended to be a safe, 
+welcoming space for collaboration, and contributors are 
+expected to adhere to the [code of conduct](https://github.com/rubygems/rubygems/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveRecordQuery project's codebases, issue trackers, chat rooms and mailing lists is 
+expected to follow the [code of conduct](https://github.com/rubygems/rubygems/blob/master/CODE_OF_CONDUCT.md).
+
+## Author
+
+Marcos Felipe (marcosfelipesilva54@gmail.com)

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/activerecord-query.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/active_record_query/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "activerecord-query"
+  spec.version = ActiveRecordQuery::VERSION
+  spec.authors = ["Marcos Felipe"]
+  spec.email = ["marcosfelipesilva54@gmail.com"]
+  spec.summary = "Small DSL for query build with Active Record."
+  spec.description = "The DSL provides a nice and clean way to write ActiveRecord queries better than model scopes."
+  spec.homepage = "https://github.com/marcosfelipe/activerecord-query"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage + '/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir['README.md', 'LICENSE',
+                   'CHANGELOG.md', 'lib/**/*.rb',
+                   'lib/**/*.rake',
+                   '*.gemspec', '.github/*.md',
+                   'Gemfile', 'Rakefile']
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4.0", "< 8.0"
+  spec.add_dependency "activesupport", ">= 4.0", "< 8.0"
+
+  spec.add_development_dependency "bundler", '>= 1.3', '< 3.0'
+  spec.add_development_dependency "rake", '>= 1.0', '< 14.0'
+  spec.add_development_dependency "rspec",   "~> 3.0"
+  spec.add_development_dependency "pry", '~> 0.14.0'
+  spec.add_development_dependency "sqlite3", '~> 1.0'
+  spec.add_development_dependency "simplecov", '~> 0.21.0'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/active_record_query/arel/nodes.rb

@@ -0,0 +1,15 @@
+module Arel # :nodoc: all
+  module Nodes
+    # The setter for value is necessary to evaluate
+    # when a symbol or proc is passed to it
+    class Casted
+      attr_writer :value
+    end
+
+    # The setter for expr is necessary to evaluate
+    # when a symbol or proc is passed to it
+    class Unary
+      alias :value= :expr=
+    end
+  end
+end

data/lib/active_record_query/argument_stacker.rb

@@ -0,0 +1,42 @@
+module ActiveRecordQuery
+  # The stacker class receives a class as context
+  # to define instance methods ordered to collect
+  # a list of data in the class instance
+  class ArgumentStacker
+    def initialize(context, stack_name)
+      @context = context
+      @stack_name = stack_name
+    end
+
+    def add(args)
+      context.define_method(next_method_name) do
+        args
+      end
+    end
+
+    def list
+      stacked_methods.map { |method| context.send(method) }.flatten
+    end
+
+    private
+
+    attr_reader :context, :stack_name
+
+    def next_method_name
+      current_number = last_stacked_method.to_s.scan(/\d+$/).first.to_i
+      "_#{stack_name}_#{current_number + 1}"
+    end
+
+    def last_stacked_method
+      stacked_methods.last
+    end
+
+    def stacked_methods
+      context_methods.grep(/^_#{stack_name}_/).sort
+    end
+
+    def context_methods
+      context.send(context.respond_to?(:instance_methods) ? :instance_methods : :methods)
+    end
+  end
+end

data/lib/active_record_query/column.rb

@@ -0,0 +1,15 @@
+module ActiveRecordQuery
+  # Extends the Arel attribute class.
+  # It sets some aliases for syntactic sugar.
+  class Column < Arel::Attributes::Attribute
+    alias_method :==, :eq
+    alias_method :!=, :not_eq
+    alias_method :=~, :matches
+    alias_method :>=, :gteq
+    alias_method :>, :gt
+    alias_method :<, :lt
+    alias_method :<=, :lteq
+  end
+end
+
+

data/lib/active_record_query/concerns/conditionable.rb

@@ -0,0 +1,16 @@
+module ActiveRecordQuery
+  module Conditionable
+    extend ActiveSupport::Concern
+
+    included do
+      include Conditions::Conditionable
+
+      add_feature :build_conditions
+    end
+
+    def build_conditions(scope)
+      conditions = Conditions::Builder.new(resource, self).build(self)
+      conditions ? scope.where(conditions) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/featureable.rb

@@ -0,0 +1,16 @@
+module ActiveRecordQuery
+  module Featureable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def _query_features
+        @@_query_features
+      end
+
+      def add_feature(feature)
+        @@_query_features ||= []
+        @@_query_features << feature
+      end
+    end
+  end
+end

data/lib/active_record_query/concerns/groupable.rb

@@ -0,0 +1,22 @@
+module ActiveRecordQuery
+  module Groupable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def group_by(*args)
+        arg_stacker = ArgumentStacker.new(self, :group_by)
+        arg_stacker.add(args)
+      end
+    end
+
+    included do
+      add_feature :build_group_by
+    end
+
+    def build_group_by(scope)
+      arg_stacker = ArgumentStacker.new(self, :group_by)
+      args = arg_stacker.list
+      args.present? ? scope.group(*args.flatten) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/havingable.rb

@@ -0,0 +1,24 @@
+module ActiveRecordQuery
+  module Havingable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      attr_reader :_having
+
+      def having(*args)
+        arg_stacker = ArgumentStacker.new(self, :having)
+        arg_stacker.add(args)
+      end
+    end
+
+    included do
+      add_feature :build_having
+    end
+
+    def build_having(scope)
+      arg_stacker = ArgumentStacker.new(self, :having)
+      args = ExpressionParser.new(self).parse(arg_stacker.list)
+      args.present? ? scope.having(*args) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/identifiable.rb

@@ -0,0 +1,20 @@
+module ActiveRecordQuery
+  module Identifiable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def from(model_class)
+        raise(ArgumentError, 'Resource must be a ActiveRecord::Base object.') unless model_class.new.is_a?(ActiveRecord::Base)
+        define_method(:resource) do
+          model_class
+        end
+
+        model_class.column_names.each do |column|
+          define_singleton_method(column) do
+            Column.new(model_class.arel_table, column)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_query/concerns/joinable.rb

@@ -0,0 +1,43 @@
+module ActiveRecordQuery
+  module Joinable
+    extend ActiveSupport::Concern
+
+    class JoinedResource
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def method_missing(m, *args, &block)
+        Column.new(Arel::Table.new(resource), m)
+      end
+
+      private
+
+      attr_reader :resource
+    end
+
+    class_methods do
+      def join(*args)
+        arg_stacker = ArgumentStacker.new(self, :join)
+        arg_stacker.add(args)
+        args.to_s.split(/\W+/).compact.each do |resource_name|
+          define_singleton_method(resource_name) do
+            JoinedResource.new(resource_name.pluralize)
+          end
+        end
+      end
+    end
+
+    included do
+      add_feature :build_joins
+    end
+
+    def build_joins(scope)
+      arg_stacker = ArgumentStacker.new(self, :join)
+      arg_stacker.list.each do |join_params|
+        scope = scope.joins(join_params)
+      end
+      scope
+    end
+  end
+end

data/lib/active_record_query/concerns/limitable.rb

@@ -0,0 +1,21 @@
+module ActiveRecordQuery
+  module Limitable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def limit(value)
+        define_method('limit') do
+          value
+        end
+      end
+    end
+
+    included do
+      add_feature :build_limit
+    end
+
+    def build_limit(scope)
+      respond_to?(:limit) ? scope.limit(limit) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/offsetable.rb

@@ -0,0 +1,21 @@
+module ActiveRecordQuery
+  module Offsetable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def offset(value)
+        define_method('offset') do
+          value
+        end
+      end
+    end
+
+    included do
+      add_feature :build_offset
+    end
+
+    def build_offset(scope)
+      respond_to?(:offset) ? scope.offset(offset) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/orderable.rb

@@ -0,0 +1,22 @@
+module ActiveRecordQuery
+  module Orderable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def order_by(*args)
+        arg_stacker = ArgumentStacker.new(self, :order_by)
+        arg_stacker.add(args)
+      end
+    end
+
+    included do
+      add_feature :build_order
+    end
+
+    def build_order(scope)
+      arg_stacker = ArgumentStacker.new(self, :order_by)
+      args = arg_stacker.list
+      args.present? ? scope.order(args) : scope
+    end
+  end
+end

data/lib/active_record_query/concerns/selectable.rb

@@ -0,0 +1,22 @@
+module ActiveRecordQuery
+  module Selectable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def select(*args)
+        arg_stacker = ArgumentStacker.new(self, :select)
+        arg_stacker.add(args)
+      end
+    end
+
+    included do
+      add_feature :build_select
+    end
+
+    def build_select(scope)
+      arg_stacker = ArgumentStacker.new(self, :select)
+      args = arg_stacker.list
+      args.present? ? scope.select(*args) : scope
+    end
+  end
+end

data/lib/active_record_query/conditions/builder.rb

@@ -0,0 +1,36 @@
+module ActiveRecordQuery
+  module Conditions
+    class Builder
+      def initialize(resource, context)
+        @resource = resource
+        @context = context
+      end
+
+      def build(group)
+        chain_conditions = nil
+        arg_stacker = ArgumentStacker.new(group, :condition)
+        arg_stacker.list.each do |chain_link|
+          next unless executable?(chain_link)
+          if chain_link.respond_to?(:where)
+            group = chain_link.new
+            chain_conditions = chain_conditions.present? ? chain_conditions.send(chain_link::glue, build(group)) : build(group)
+          else
+            arel_condition = ExpressionParser.new(context).parse(chain_link.condition)
+            chain_conditions = chain_conditions.present? ? chain_conditions.send(chain_link.type, arel_condition) : arel_condition
+          end
+        end
+        resource.arel_table.grouping(chain_conditions) if chain_conditions
+      end
+
+      private
+
+      attr_reader :resource, :context
+
+      def executable?(chain_link)
+        condition_options = chain_link.options.to_h
+        return true unless condition_options[:if].present?
+        context.send(condition_options[:if])
+      end
+    end
+  end
+end

data/lib/active_record_query/conditions/chain_link.rb

@@ -0,0 +1,5 @@
+module ActiveRecordQuery
+  # Conditions (where or wor) work linking each other,
+  # this class identify what are the rules for a link
+  ChainLink = Struct.new(:type, :condition, :options)
+end

data/lib/active_record_query/conditions/condition_group.rb

@@ -0,0 +1,10 @@
+require_relative 'conditionable'
+
+module ActiveRecordQuery
+  # ConditionGroup stacks ChainLink, WhereGroup and WorGroup when
+  # 'where' and 'wor' methods are called
+  class ConditionGroup
+    include Conditions::Conditionable
+    cattr_reader :options
+  end
+end

data/lib/active_record_query/conditions/conditionable.rb

@@ -0,0 +1,29 @@
+module ActiveRecordQuery
+  module Conditions
+    module Conditionable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def where(*args, &block)
+          chain_link_definer(Class.new(WhereGroup), args, &block)
+        end
+
+        def wor(*args, &block)
+          chain_link_definer(Class.new(WorGroup), args, &block)
+        end
+
+        def chain_link_definer(group_type, args)
+          arg_stacker = ArgumentStacker.new(self, :condition)
+          if block_given?
+            yield group_type
+            arg_stacker.add(group_type)
+          else
+            condition = args[0]
+            options = args[1]
+            arg_stacker.add(ChainLink.new(group_type.glue, condition, options))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_query/conditions/where_group.rb

@@ -0,0 +1,9 @@
+module ActiveRecordQuery
+  # Identifies a type of ConditionGroup with glue set to 'and' operator
+  # This class is used whenever a 'where' condition is called with a block
+  class WhereGroup < ConditionGroup
+    def self.glue
+      :and
+    end
+  end
+end

data/lib/active_record_query/conditions/wor_group.rb

@@ -0,0 +1,9 @@
+module ActiveRecordQuery
+  # Identifies a type of ConditionGroup with glue set to 'or' operator
+  # This class is used whenever a 'wor' condition is called with a block
+  class WorGroup < ConditionGroup
+    def self.glue
+      :or
+    end
+  end
+end

data/lib/active_record_query/expression_parser.rb

@@ -0,0 +1,40 @@
+module ActiveRecordQuery
+  # It evaluates an expression to execute on the context
+  # whenever a symbol or a proc is passed as value on the expression.
+  class ExpressionParser
+    def initialize(context)
+      @context = context
+    end
+
+    def parse(expression)
+      if expression.respond_to?(:each)
+        expression = expression.map(&:clone)
+        expression.each { |arg| parse_arg(arg) }
+      else
+        expression = expression.clone
+        parse_arg(expression)
+      end
+      expression
+    end
+
+    private
+
+    attr_reader :context
+
+    def parse_arg(arg)
+      if arg.respond_to?(:right) && arg.right.respond_to?(:value)
+        arg.right.value = parse_dynamic_values(arg.right.value)
+      end
+    end
+
+    def parse_dynamic_values(value)
+      if value.is_a?(Symbol)
+        context.send(value)
+      elsif value.is_a?(Proc)
+        context.instance_exec(&value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/active_record_query/version.rb

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

data/lib/activerecord-query.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'arel'
+Dir.glob(File.join(__dir__, 'active_record_query/**/*.rb')) do |f|
+  require f
+end
+
+module ActiveRecordQuery
+  # The base class collects all the activerecord query features
+  # and the execute method processes all the features.
+  # The api user must inherit from this class in order to build
+  # a new query definition.
+  class Base
+    include Identifiable
+    include Featureable
+    include Selectable
+    include Orderable
+    include Limitable
+    include Joinable
+    include Groupable
+    include Offsetable
+    include Havingable
+    include Conditionable
+
+    class << self
+      def execute(options = {})
+        new(options).execute
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def execute
+      query = resource.all
+      self.class._query_features.each do |query_feature|
+        query = send(query_feature, query)
+      end
+      query
+    end
+
+    private
+
+    attr_reader :options
+  end
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-query
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Marcos Felipe
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '14.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+description: The DSL provides a nice and clean way to write ActiveRecord queries better
+  than model scopes.
+email:
+- marcosfelipesilva54@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- activerecord-query.gemspec
+- lib/active_record_query/arel/nodes.rb
+- lib/active_record_query/argument_stacker.rb
+- lib/active_record_query/column.rb
+- lib/active_record_query/concerns/conditionable.rb
+- lib/active_record_query/concerns/featureable.rb
+- lib/active_record_query/concerns/groupable.rb
+- lib/active_record_query/concerns/havingable.rb
+- lib/active_record_query/concerns/identifiable.rb
+- lib/active_record_query/concerns/joinable.rb
+- lib/active_record_query/concerns/limitable.rb
+- lib/active_record_query/concerns/offsetable.rb
+- lib/active_record_query/concerns/orderable.rb
+- lib/active_record_query/concerns/selectable.rb
+- lib/active_record_query/conditions/builder.rb
+- lib/active_record_query/conditions/chain_link.rb
+- lib/active_record_query/conditions/condition_group.rb
+- lib/active_record_query/conditions/conditionable.rb
+- lib/active_record_query/conditions/where_group.rb
+- lib/active_record_query/conditions/wor_group.rb
+- lib/active_record_query/expression_parser.rb
+- lib/active_record_query/version.rb
+- lib/activerecord-query.rb
+homepage: https://github.com/marcosfelipe/activerecord-query
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/marcosfelipe/activerecord-query
+  source_code_uri: https://github.com/marcosfelipe/activerecord-query
+  changelog_uri: https://github.com/marcosfelipe/activerecord-query/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key: 
+specification_version: 4
+summary: Small DSL for query build with Active Record.
+test_files: []