boosted-rails 0.1.0

data/lib/boosted/queries/filter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "boosted/services/base"
+
+module Boosted
+  module Queries
+    ##
+    # Filter a scope by a set of conditions
+    #
+    # This class provides a simple interface for filtering a scope by a set of conditions.
+    # The conditions are passed as an array of hashes, where each hash contains the following
+    # keys:
+    # - +relation+: the relation to use for the filter (e.g. "=", ">", "in", etc.)
+    # - +field+: the field to filter by
+    # - +value+: the value to filter by
+    #
+    #
+    # @example Filter a scope by a set of conditions
+    #   Boosted::Queries::Filter.call(User.all, filter_conditions: [
+    #     { relation: "=", field: :first_name, value: "John" },
+    #     { relation: ">", field: :age, value: 18 }
+    #   ])
+    #   # => #<ActiveRecord::Relation [...]>
+    #
+    # @see RELATIONS
+    # To see the list of available relations, check the +RELATIONS+ constant.
+    class Filter
+      RELATIONS = %w[= != > >= < <= between in not_in starts_with ends_with contains is_null is_not_null].freeze
+
+      # @param scope [ActiveRecord::Relation] the scope to filter
+      # @param filter_conditions [Array<Hash>] the conditions to filter by
+      # @return [ActiveRecord::Relation] the filtered scope
+      def self.call(scope, filter_conditions:)
+        new(scope, filter_conditions:).call
+      end
+
+      # @param scope [ActiveRecord::Relation] the scope to filter
+      # @param filter_conditions [Array<Hash>] the conditions to filter by
+      # @return [ActiveRecord::Relation] the filtered scope
+      def initialize(scope, filter_conditions:)
+        super()
+        @scope = scope
+        @filter_conditions = filter_conditions
+      end
+
+      def call
+        filter_conditions.reduce(scope) do |scope, filter_condition|
+          relation = filter_condition[:relation].to_s
+          field = filter_condition[:field]
+          value = filter_condition[:value]
+
+          validate_relation!(relation)
+          filtered_scope(scope, relation, field, value)
+        end
+      end
+
+      private
+
+      attr_reader :scope, :filter_conditions
+
+      def validate_relation!(relation)
+        return if RELATIONS.include?(relation)
+
+        raise ArgumentError, "relation must be one of: #{RELATIONS.join(", ")}"
+      end
+
+      def filtered_scope(scope, relation, field, value)
+        case relation
+        when "=", "in"
+          scope.where(field => value)
+        when "!=", "not_in"
+          scope.where.not(field => value)
+        when "between"
+          scope.where("#{field} BETWEEN ? AND ?", value.first, value.last)
+        when "starts_with"
+          scope.where("#{field} LIKE ?", "#{value}%")
+        when "ends_with"
+          scope.where("#{field} LIKE ?", "%#{value}")
+        when "contains"
+          scope.where("#{field} LIKE ?", "%#{value}%")
+        when "is_null"
+          scope.where(field => nil)
+        when "is_not_null"
+          scope.where.not(field => nil)
+        else # '>', '>=', '<', '<='
+          scope.where("#{field} #{relation} ?", value)
+        end
+      end
+    end
+  end
+end

data/lib/boosted/queries/paginate.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "boosted/services/base"
+
+module Boosted
+  module Queries
+    ##
+    # Paginate a scope
+    #
+    # This class provides a way to paginate a scope and return the metadata.
+    #
+    # @example
+    #   Boosted::Queries::Paginate.call(User.all, page: 2, per_page: 10)
+    #   # => [{ total_count: 100, total_pages: 10, next_page: 3, prev_page: 1, page: 2, per_page: 10 }, <ActiveRecord::Relation [...]>]
+    #
+    # @see MAX_PER_PAGE
+    # @see DEFAULT_PER_PAGE
+    # To see the maximum number of records per page and the default number of records per page,
+    # check the +MAX_PER_PAGE+ and +DEFAULT_PER_PAGE+ constants.
+    class Paginate
+      MAX_PER_PAGE = 100
+      DEFAULT_PER_PAGE = 10
+
+      # @param scope [ActiveRecord::Relation] the scope to paginate
+      # @param page [Integer] the page number
+      # @param per_page [Integer] the number of records per page
+      # @return [Array<Hash, ActiveRecord::Relation>] the metadata and the paginated scope
+      def self.call(scope, page: nil, per_page: nil)
+        new(scope, page:, per_page:).call
+      end
+
+      # @param scope [ActiveRecord::Relation] the scope to paginate
+      # @param page [Integer] the page number
+      # @param per_page [Integer] the number of records per page
+      # @return [Array<Hash, ActiveRecord::Relation>] the metadata and the paginated scope
+      def initialize(scope, page: nil, per_page: nil)
+        super()
+        @scope = scope
+        @page = page
+        @per_page = per_page
+      end
+
+      def call
+        offset = (page - 1) * per_page
+        paginated_scope = scope.limit(per_page).offset(offset)
+
+        [metadata(scope), paginated_scope]
+      end
+
+      private
+
+      attr_reader :scope
+
+      def page
+        @page.present? ? @page.to_i : 1
+      end
+
+      def per_page
+        @per_page.present? ? [@per_page.to_i, MAX_PER_PAGE].min : DEFAULT_PER_PAGE
+      end
+
+      def collection_count(scope)
+        if scope.group_values.empty?
+          scope.count(:all)
+        else
+          sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
+          scope.unscope(:order).pick(sql).to_i
+        end
+      end
+
+      def metadata(scope)
+        total_count = collection_count(scope)
+        total_pages = pages(total_count, per_page)
+        next_page = next_page(page, total_pages)
+        prev_page = prev_page(page)
+
+        {
+          total_count:,
+          total_pages:,
+          next_page:,
+          prev_page:,
+          page:,
+          per_page:
+        }
+      end
+
+      def pages(count, per_page)
+        (count.to_f / per_page).ceil
+      end
+
+      def next_page(page, pages)
+        page < pages ? page + 1 : nil
+      end
+
+      def prev_page(page)
+        page > 1 ? page - 1 : nil
+      end
+    end
+  end
+end

data/lib/boosted/queries/search.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "boosted/services/base"
+
+module Boosted
+  module Queries
+    ##
+    # Search for records in a scope
+    #
+    # This class provides a way to search for records in a scope.
+    # It uses a scope in the model to perform the search.
+    #
+    # @example
+    #   Boosted::Queries::Search.call(User.all, search_term: "John")
+    #   # => #<ActiveRecord::Relation [...]>
+    #
+    # By default, it uses the +search+ scope in the model to perform the search.
+    # You can also specify a different scope to use for searching, like so:
+    # @example
+    #   Boosted::Queries::Search.call(User.all, search_term: "John", model_search_scope: :search_by_name)
+    #   # => #<ActiveRecord::Relation [...]>
+    #
+    class Search
+      # @param scope [ActiveRecord::Relation] the scope to search in
+      # @param search_term [String] the term to search for
+      # @param model_search_scope [String, Symbol] the name of the scope to use for searching in the model
+      # @return [ActiveRecord::Relation] the searched scope
+      def self.call(scope, search_term:, model_search_scope: :search)
+        new(scope, search_term:, model_search_scope:).call
+      end
+
+      # @param scope [ActiveRecord::Relation] the scope to search in
+      # @param search_term [String] the term to search for
+      # @param model_search_scope [String, Symbol] the name of the scope to use for searching in the model
+      # @return [ActiveRecord::Relation] the searched scope
+      def initialize(scope, search_term:, model_search_scope: :search)
+        super()
+        @scope = scope
+        @search_term = search_term
+        @model_search_scope = model_search_scope
+      end
+
+      def call
+        return scope if search_term.blank?
+
+        validate_model_search_scope!
+
+        scope.public_send(model_search_scope, search_term)
+      end
+
+      private
+
+      attr_reader :scope, :search_term, :model_search_scope
+
+      def validate_model_search_scope!
+        return if scope.respond_to?(model_search_scope)
+
+        raise ArgumentError, "#{scope.klass} does not respond to #{model_search_scope}"
+      end
+    end
+  end
+end

data/lib/boosted/queries/sort.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "boosted/services/base"
+
+module Boosted
+  module Queries
+    ##
+    # Sorts a scope by a given key and direction
+    #
+    # This class provides a way to sort a scope by a given key and direction.
+    # It uses the +reorder+ method to sort the scope, so it will remove any existing order.
+    #
+    # @example Sort a scope by a key and direction
+    #   Boosted::Queries::Sort.call(User.all, sort_key: "name", sort_direction: "asc")
+    #   # => #<ActiveRecord::Relation [...]>
+    #
+    # @example Sort a scope by a key with format +table.column+ and direction
+    #   Boosted::Queries::Sort.call(User.join(:accounts), sort_key: "accounts.updated_at", sort_direction: "asc")
+    #   # => #<ActiveRecord::Relation [...]>
+    class Sort
+      SORT_DIRECTIONS = %w[asc desc].freeze
+      NULLS_SORT_DIRECTION = %w[asc_nulls_first asc_nulls_last desc_nulls_first desc_nulls_last].freeze
+
+      # @param scope [ActiveRecord::Relation] the scope to sort
+      # @param sort_key [String, Symbol] the key to sort by
+      # @param sort_direction [String, Symbol] the direction to sort by
+      # @return [ActiveRecord::Relation] the sorted scope
+      def self.call(scope, sort_key:, sort_direction: :desc)
+        new(scope, sort_key:, sort_direction:).call
+      end
+
+      # @param scope [ActiveRecord::Relation] the scope to sort
+      # @param sort_key [String, Symbol] the key to sort by
+      # @param sort_direction [String, Symbol] the direction to sort by
+      # @return [ActiveRecord::Relation] the sorted scope
+      def initialize(scope, sort_key:, sort_direction: :desc)
+        super()
+        @scope = scope
+        @sort_key = sort_key.to_s
+        @sort_direction = sort_direction.to_s.downcase
+      end
+
+      # @return [ActiveRecord::Relation]
+      def call
+        validate_sort_direction!(sort_direction)
+
+        order = if NULLS_SORT_DIRECTION.include?(sort_direction)
+                  arel_order
+                else
+                  { sort_key => sort_direction }
+                end
+
+        scope.reorder(order)
+      end
+
+      private
+
+      attr_reader :scope, :sort_key, :sort_direction
+
+      def validate_sort_direction!(sort_direction)
+        return if SORT_DIRECTIONS.include?(sort_direction) || NULLS_SORT_DIRECTION.include?(sort_direction)
+
+        raise ArgumentError, "Invalid sort direction: #{sort_direction}, must be one of #{SORT_DIRECTIONS}"
+      end
+
+      def arel_order
+        arel_table.send(order_nulls_direction.first).send("nulls_#{order_nulls_direction.last}")
+      end
+
+      def arel_table
+        sort_key_arr = sort_key.split(".")
+
+        if sort_key_arr.size == 1
+          # sort_key has format 'column'
+          scope.klass.arel_table[sort_key]
+        else
+          # sort_key has format 'table.column'
+          Arel::Table.new(sort_key_arr.first)[sort_key_arr.last]
+        end
+      end
+
+      def order_nulls_direction
+        @order_nulls_direction ||= begin
+          order_nulls_dir = sort_direction.split("_")
+          [order_nulls_dir.first, order_nulls_dir.last]
+        end
+      end
+    end
+  end
+end

data/lib/boosted/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Boosted
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "boosted/tasks/boosted.rake"
+    end
+  end
+end

data/lib/boosted/services/base.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "boosted/jobs/base"
+
+module Boosted
+  module Services
+    # Base class for all services
+    #
+    # This class provides a simple interface for creating services.
+    # It also provides a way to call services asynchronously using +ActiveJob+.
+    #
+    # @example Create a service
+    #   class PrintService < Boosted::Services::Base
+    #     def call(message)
+    #       puts message
+    #     end
+    #   end
+    #
+    #   SomeService.call('Hello World') # => "Hello World"
+    #   SomeService.new('Hello World').call # => "Hello World"
+    #
+    # @example Call a service asynchronously
+    #  class SlowService < Boosted::Services::Base
+    #    enable_job!
+    #
+    #    def call(message)
+    #      sleep 5
+    #      puts message
+    #    end
+    #  end
+    #
+    #  SlowService.call_later('Hello World') # => "Hello World" after 5 seconds
+    #  SlowService::Job.perform_later('Hello World') # => "Hello World" after 5 seconds
+    class Base
+      def self.call(...)
+        new(...).call
+      end
+
+      def self.call_later(...)
+        unless @job_enabled
+          message = "#{self.class.name}::Job is not implemented, make sure to call enable_job! in the service"
+          raise NotImplementedError, message
+        end
+
+        self::Async.perform_later(...)
+      end
+
+      def call
+        raise NotImplementedError, "#{self.class.name}#call not implemented"
+      end
+
+      # This method is used to create a Job class that inherits from +Boosted::Jobs::Base+
+      # and calls the service asynchronously.
+      # @example Enable async for a service
+      #   class SomeService < Bosted::Services::Base
+      #     enable_job!
+      #
+      #     def call(...)
+      #       # service logic
+      #     end
+      #   end
+      #
+      #   # SomeService.call_later(...)
+      #   # SomeService::Job.perform_later(...)
+      def self.enable_job!
+        @job_enabled = true
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          # class SomeService
+          #   class Job < Boosted::Jobs::Base
+          #
+          #     def perform(...)
+          #       SomeService.call(...)
+          #     end
+          #   end
+          #
+          #   def self.call_later(...)
+          #     Job.perform_later(...)
+          #   end
+          # end
+          class Job < Boosted::Jobs::Base
+            def perform(...)
+              #{name}.call(...)
+            end
+          end
+
+          def self.call_later(...)
+            Job.perform_later(...)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/boosted/tasks/bosted.rake

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+namespace :boosted do
+  task :install do
+    initializer_file = File.join(File.dirname(__FILE__), "templates", "boosted.rb.tt")
+    destination = "config/initializers/boosted.rb"
+
+    FileUtils.cp(initializer_file, destination)
+  end
+end

data/lib/boosted/tasks/templates/initializer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+Boosted.configure do |config|
+  # Change the parent class of Boosted::Job::Base.
+  # This is useful if you want to use a different ActiveJob parent class.
+  # Default: 'ActiveJob::Base'
+  # config.base_job_parent_class = 'ActiveJob::Base'
+end

data/lib/boosted/version.rb

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

data/lib/boosted.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "active_support/configurable"
+
+##
+# The main module for the Boosted gem.
+#
+# This module is used to provide configuration options for the gem.
+#
+# @example Configurations
+#   # config/initializers/boosted.rb
+#
+#   Boosted.configure do |config|
+#     config.base_job_parent_class = "ApplicationJob" # Default: "ActiveJob::Base"
+#   end
+#
+# @see https://api.rubyonrails.org/classes/ActiveSupport/Configurable.html
+#
+module Boosted
+  include ActiveSupport::Configurable
+
+  config_accessor :base_job_parent_class, instance_accessor: false, default: "ActiveJob::Base"
+end
+
+# load all files in lib/boosted except for the tasks
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+loader.ignore("lib/boosted/tasks")
+loader.ignore("lib/boosted/railtie.rb") unless defined?(Rails::Railtie)
+loader.eager_load

data/sig/boosted.rbs

@@ -0,0 +1,4 @@
+module Boosted
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: boosted-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Aparicio
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description:
+email:
+- apariciojuan30@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- boosted.gemspec
+- lib/boosted.rb
+- lib/boosted/controllers/filterable.rb
+- lib/boosted/controllers/pageable.rb
+- lib/boosted/controllers/searchable.rb
+- lib/boosted/controllers/sortable.rb
+- lib/boosted/controllers/tabulatable.rb
+- lib/boosted/emails/.keep
+- lib/boosted/jobs/base.rb
+- lib/boosted/queries/filter.rb
+- lib/boosted/queries/paginate.rb
+- lib/boosted/queries/search.rb
+- lib/boosted/queries/sort.rb
+- lib/boosted/railtie.rb
+- lib/boosted/services/base.rb
+- lib/boosted/tasks/bosted.rake
+- lib/boosted/tasks/templates/initializer.rb
+- lib/boosted/version.rb
+- sig/boosted.rbs
+homepage: https://github.com/gogrow-dev/boosted
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gogrow-dev/boosted
+  source_code_uri: https://github.com/gogrow-dev/boosted
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Set of modules to boost your Ruby on Rails development
+test_files: []