scopiform 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 394c2b67ce4035049ec008ebb55628c2ccff5b37f7bed36d3dee01b3ed16d7bf
+  data.tar.gz: 4e08965af4db81bd6694c999ab3718f1ad81bcfceebbcbb3f666e4faaf7eaef5
+SHA512:
+  metadata.gz: 7f412f41367de72362799423196deeb247926941e0d710faa4e94bd41f9af79b76182c52d0ba90f9b7366fb65c192848bbf94fe22ceede2bf5644b59f567b576
+  data.tar.gz: e955b4a42b3f4aea8ea456424e6b54e637cc8592448024a0c31ddf277acb7a219d1ab7577645aeff20dc1fd2892239fa4c674907f21adf02a0755f0164a9394d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 jayce.pulsipher
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# Scopiform
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'scopiform'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install scopiform
+```
+
+## Public ActiveRecord Methods
+:aliases_for
+:apply_filters
+:apply_orders
+:association
+:attribute_aliases_inverted
+:auto_scope_add
+:auto_scope?
+:auto_scopes_by_attribute
+:auto_scopes
+:column
+:reflection_added
+:resolve_alias
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Scopiform'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/scopiform/association_scopes.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module AssociationScopes
+    extend ActiveSupport::Concern
+
+    included do
+      setup_associations_auto_scopes
+    end
+
+    module ClassMethods
+      def reflection_added(_name, reflection)
+        setup_association_auto_scopes(reflection)
+      end
+
+      def scopiform_joins(*args, **kargs)
+        respond_to?(:left_outer_joins) ? left_outer_joins(*args, **kargs) : eager_load(*args, **kargs)
+      end
+
+      private
+
+      def setup_associations_auto_scopes
+        reflect_on_all_associations.each do |association|
+          setup_association_auto_scopes(association)
+        end
+      end
+
+      def setup_association_auto_scopes(association)
+        auto_scope_add(
+          association.name,
+          Proc.new { |value, joins: nil|
+            is_root = joins.nil?
+            joins = {} if is_root
+
+            joins[association.name] ||= {}
+            applied = association.klass.apply_filters(value, joins: joins[association.name])
+
+            if is_root
+              scopiform_joins(joins).merge(applied)
+            else
+              all.merge(applied)
+            end
+          },
+          suffix: '_is',
+          argument_type: :hash
+        )
+
+        # Ordering
+        auto_scope_add(
+          association.name,
+          Proc.new { |value| scopiform_joins(association.name).merge(association.klass.apply_orders(value)) },
+          prefix: 'order_by_',
+          argument_type: :hash,
+          type: :order
+        )
+      end
+    end
+  end
+end

data/lib/scopiform/common_scopes.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module CommonScopes
+    extend ActiveSupport::Concern
+
+    included do
+      setup_common_auto_scopes
+    end
+
+    module ClassMethods
+      private
+
+      def setup_common_auto_scopes
+        safe_columns.each do |column|
+          name = column.name
+          name_sym = name.to_sym
+          type = column.type
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(name_sym => value) },
+            suffix: '_is',
+            argument_type: type
+          )
+          auto_scope_add(
+            name,
+            Proc.new { |value| where.not(name_sym => value) },
+            suffix: '_not',
+            argument_type: type
+          )
+
+          # Ordering
+          auto_scope_add(
+            name,
+            ->(value = :asc) { order(name_sym => value) },
+            prefix: 'order_by_',
+            argument_type: :string,
+            type: :order
+          )
+        end
+      end
+    end
+  end
+end

data/lib/scopiform/core.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'scopiform/scope_definition'
+
+module Scopiform
+  module Core
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def auto_scopes
+        @auto_scopes || []
+      end
+
+      def auto_scopes_by_attribute(attribute)
+        attribute = attribute.to_sym
+        auto_scopes.select { |scope| scope.attribute == attribute }
+      end
+
+      def auto_scope?(name)
+        auto_scopes.find { |scope| scope.name == name }
+      end
+
+      def auto_scope_add(attribute, block, prefix: nil, suffix: nil, **options)
+        scope_name = "#{prefix}#{attribute}#{suffix}".underscore
+        scope_name_sym = scope_name.to_sym
+        scope scope_name_sym, block
+
+        scope_definition = auto_scope_add_definition(attribute, prefix: prefix, suffix: suffix, **options)
+
+        aliases_for(attribute).each do |alias_name|
+          auto_scope_for_alias(alias_name, scope_definition)
+        end
+      end
+
+      def alias_attribute(new_name, old_name)
+        super(new_name, old_name)
+
+        auto_scopes_by_attribute(old_name).each do |scope_definition|
+          auto_scope_for_alias(new_name, scope_definition)
+        end
+      end
+
+      private
+
+      def auto_scope_add_definition(attribute, **options)
+        definition = ScopeDefinition.new(attribute, **options)
+        @auto_scopes ||= []
+        @auto_scopes << definition
+
+        definition
+      end
+
+      def auto_scope_for_alias(alias_name, scope_definition)
+        scope_name = "#{scope_definition.prefix}#{scope_definition.attribute}#{scope_definition.suffix}".underscore
+        alias_method_name = "#{scope_definition.prefix}#{alias_name}#{scope_definition.suffix}".underscore
+        singleton_class.send(:alias_method, alias_method_name.to_sym, scope_name.to_sym)
+        auto_scope_add_definition(alias_name, prefix: scope_definition.prefix, suffix: scope_definition.suffix, **scope_definition.options)
+      end
+    end
+  end
+end

data/lib/scopiform/filters.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module Filters
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def apply_filters(filters_hash, injecting: all, joins: nil)
+        filters_hash.keys.inject(injecting) { |out, filter_name| resolve_filter(out, filter_name, filters_hash[filter_name], joins) }
+      end
+
+      def apply_orders(orders_hash, injecting = all)
+        orders_hash.keys.inject(injecting) { |out, order_name| resolve_order(out, order_name, orders_hash[order_name]) }
+      end
+
+      private
+
+      def resolve_filter(out, filter_name, filter_argument, joins)
+        if filter_name.to_s.casecmp('OR').zero?
+          or_joins = {}
+
+          return (
+            filter_argument
+              .map { |or_filters_hash| apply_filters(or_filters_hash, injecting: out, joins: or_joins) }
+              .map { |a| a.scopiform_joins(or_joins) }
+              .inject { |chain, applied| chain.or(applied) }
+          )
+        end
+        out.send(filter_name, filter_argument, joins: joins)
+      end
+
+      def resolve_order(out, order_name, order_argument)
+        method_name = "order_by_#{order_name}"
+        out.send(method_name, order_argument)
+      end
+    end
+  end
+end

data/lib/scopiform/helpers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module Helpers
+    extend ActiveSupport::Concern
+
+    STRING_TYPES = %i[string text].freeze
+    NUMBER_TYPES = %i[integer float decimal].freeze
+    DATE_TYPES = %i[date time datetime timestamp].freeze
+
+    module ClassMethods
+      def attribute_aliases
+        alias_hash = super
+
+        key = primary_key.to_s
+        alias_hash = alias_hash.merge('id' => key) if key != 'id'
+
+        alias_hash
+      end
+
+      def attribute_aliases_inverted
+        attribute_aliases.each_with_object({}) { |(k, v), o| (o[v] ||= []) << k }
+      end
+
+      def resolve_alias(name)
+        name_str = name.to_s
+        return attribute_aliases[name_str] if attribute_aliases[name_str].present?
+
+        name_str
+      end
+
+      def aliases_for(name)
+        attribute_aliases_inverted[name.to_s] || []
+      end
+
+      def column(name)
+        name = resolve_alias(name)
+        safe_columns_hash[name.to_s]
+      end
+
+      def association(name)
+        name = resolve_alias(name)
+        association = reflect_on_association(name)
+  
+        association.klass if association.present?
+        association
+      rescue NameError
+        logger.warn "Unable to load class for association `#{name}` in model `#{self.name}`"
+        nil
+      end
+
+      protected
+
+      def safe_columns
+        columns
+      rescue ActiveRecord::StatementInvalid, Mysql::Error, Mysql2::Error
+        []
+      end
+
+      def safe_columns_hash
+        columns_hash
+      rescue ActiveRecord::StatementInvalid, Mysql::Error, Mysql2::Error
+        {}
+      end
+    end
+  end
+end

data/lib/scopiform/reflection_plugin.rb

@@ -0,0 +1,9 @@
+module Scopiform
+  module ReflectionPlugin
+    def add_reflection(ar, name, reflection)
+      super(ar, name, reflection)
+
+      ar.reflection_added(name, reflection) if ar.respond_to? :reflection_added
+    end
+  end
+end

data/lib/scopiform/scope_definition.rb

@@ -0,0 +1,16 @@
+module Scopiform
+  class ScopeDefinition
+    attr_accessor :attribute, :prefix, :suffix, :options
+
+    def initialize(attribute, prefix: nil, suffix: nil, **options)
+      @attribute = attribute.to_sym
+      @prefix = prefix
+      @suffix = suffix
+      @options = options
+    end
+
+    def name
+      "#{prefix}#{attribute}#{suffix}".underscore
+    end
+  end
+end

data/lib/scopiform/string_number_date_scopes.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module StringNumberDateScopes
+    extend ActiveSupport::Concern
+
+    included do
+      setup_string_number_and_date_auto_scopes
+    end
+
+    module ClassMethods
+      private
+
+      def setup_string_number_and_date_auto_scopes
+        string_number_dates = Helpers::STRING_TYPES + Helpers::NUMBER_TYPES + Helpers::DATE_TYPES
+        string_number_date_columns = safe_columns.select { |column| string_number_dates.include? column.type }
+        string_number_date_columns.each do |column|
+          name = column.name
+          name_sym = name.to_sym
+          type = column.type
+          arel_column = arel_table[name]
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(name_sym => value) },
+            suffix: '_in',
+            argument_type: [type]
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where.not(name_sym => value) },
+            suffix: '_not_in',
+            argument_type: [type]
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.lt(value)) },
+            suffix: '_lt',
+            argument_type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.lteq(value)) },
+            suffix: '_lte',
+            argument_type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.gt(value)) },
+            suffix: '_gt',
+            argument_type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.gteq(value)) },
+            suffix: '_gte',
+            argument_type: type
+          )
+        end
+      end
+    end
+  end
+end

data/lib/scopiform/string_number_scopes.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Scopiform
+  module StringNumberScopes
+    extend ActiveSupport::Concern
+
+    included do
+      setup_string_and_number_auto_scopes
+    end
+
+    module ClassMethods
+      private
+
+      def setup_string_and_number_auto_scopes
+        string_numbers = Helpers::STRING_TYPES + Helpers::NUMBER_TYPES
+        string_number_columns = safe_columns.select { |column| string_numbers.include? column.type }
+        string_number_columns.each do |column|
+          name = column.name
+          type = column.type
+          arel_column = arel_table[name]
+
+          # Numeric values don't work properly with `.matches`.  Using workaround
+          # https://coderwall.com/p/qtgvdq/using-arel_table-for-ilike-yes-even-with-integers
+          if Helpers::NUMBER_TYPES.include? column.type
+            arel_column = Arel::Nodes::NamedFunction.new(
+              'CAST',
+              [arel_column.as('TEXT')]
+            )
+
+            type = :string
+          end
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            suffix: '_contains',
+            type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            suffix: '_not_contains',
+            type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            suffix: '_starts_with',
+            type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where.not(arel_column.matches("#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}%")) },
+            suffix: '_not_starts_with',
+            type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}")) },
+            suffix: '_ends_with',
+            type: type
+          )
+
+          auto_scope_add(
+            name,
+            Proc.new { |value| where.not(arel_column.matches("%#{ActiveRecord::Base.sanitize_sql_like(value.to_s)}")) },
+            suffix: '_not_ends_with',
+            type: type
+          )
+        end
+      end
+    end
+  end
+end

data/lib/scopiform/version.rb

@@ -0,0 +1,3 @@
+module Scopiform
+  VERSION = '0.1.1'
+end

data/lib/scopiform.rb

@@ -0,0 +1,24 @@
+require 'scopiform/helpers'
+require 'scopiform/core'
+require 'scopiform/common_scopes'
+require 'scopiform/string_number_scopes'
+require 'scopiform/string_number_date_scopes'
+require 'scopiform/association_scopes'
+require 'scopiform/reflection_plugin'
+require 'scopiform/filters'
+
+module Scopiform
+  def self.included(base)
+    base.class_eval do
+      include Scopiform::Helpers
+      include Scopiform::Core
+      include Scopiform::CommonScopes
+      include Scopiform::StringNumberScopes
+      include Scopiform::StringNumberDateScopes
+      include Scopiform::AssociationScopes
+      include Scopiform::Filters
+    end
+  end
+end
+
+ActiveRecord::Reflection.singleton_class.prepend Scopiform::ReflectionPlugin

data/lib/tasks/scopiform_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :scopiform do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: scopiform
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- jayce.pulsipher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.7
+- !ruby/object:Gem::Dependency
+  name: rails_or
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jayce.pulsipher@3-form.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/scopiform.rb
+- lib/scopiform/association_scopes.rb
+- lib/scopiform/common_scopes.rb
+- lib/scopiform/core.rb
+- lib/scopiform/filters.rb
+- lib/scopiform/helpers.rb
+- lib/scopiform/reflection_plugin.rb
+- lib/scopiform/scope_definition.rb
+- lib/scopiform/string_number_date_scopes.rb
+- lib/scopiform/string_number_scopes.rb
+- lib/scopiform/version.rb
+- lib/tasks/scopiform_tasks.rake
+homepage: https://github.com/3-form/scopiform
+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: Generate scope methods to ActiveRecord classes based on columns and associations
+test_files: []