rad_core_rails 0.5.1 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ceead2841d732a837cd792358174211cd357da39c2f72b1435fdd47a68cc354
-  data.tar.gz: f3fc5c87d4e9a9769b13354b3b1f6594936f54d97221c56910e1d9a4c677eb07
+  metadata.gz: 797ce809d45ddaf19fb1814c794efa557aaeea953fc3738934cdd439bd03c2ac
+  data.tar.gz: bb5da6af47c850baff2f6b441f63fce2941c3abedfd6edb7466781bf7be6e82d
 SHA512:
-  metadata.gz: 343d979caca6c5ef32a443720983111ef7c4b1f9d1f5bfe58517929ddba0d0c3dcafaa9f8d87b62f1a307259f3af2be829e78e9e9bbf942975bc8544cdfbe7e8
-  data.tar.gz: 9b0205167f8736b088c68ab4eefba1aae2997480bd1fd4eb427924287985bbc0bbb7b4eb84e4633b1a596634d758674e779574b9a1e7a63b8484a4d667fb9665
+  metadata.gz: 1dfeb36f7c9ee7a7be931c744e2c52ed0c22a61120196b65e367413c68ad9a48f1898d4ab2a93ac1591d919b6226463e91d997a8ff637638c8340effa3eb571f
+  data.tar.gz: 9160fa81a7777235ddd45c9ecea26565ae1fc3ee798074547dc07f723374a0cfe850af678fdc2cd1e23c05824c9595f38e1359481c6a4bb600e2146e7c38171e

data/.gitignore

@@ -8,9 +8,10 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
-bin
+/bin/
 *.gem
 .rspec_status
 .ruby-gemset
 .ruby-version
 /.byebug_history
+.robocop.yml

data/.rubocop.yml

@@ -0,0 +1,4 @@
+AllCops:
+  SuggestExtensions: false
+Style/FrozenStringLiteralComment:
+  Enabled: false

data/README.md

@@ -1,44 +1,104 @@
-# RadCoreRails
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rad_core_rails`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'rad_core_rails'
-```
-
-And then execute:
-
-    $ bundle install
-
-Or install it yourself as:
-
-    $ gem install rad_core_rails
-
-## Usage
-
-TODO: Write usage instructions here
-
-## 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 tags, 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/[USERNAME]/rad_core_rails. 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/[USERNAME]/rad_core_rails/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 RadCoreRails project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rad_core_rails/blob/master/CODE_OF_CONDUCT.md).
+# RadCoreRails
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/rad_core_rails`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rad_core_rails'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rad_core_rails
+
+## Usage
+
+For basic functionality just include `RadCoreRails` to your `ActiveRecord` model.
+
+```ruby
+class Job < ActiveRecord::Base
+  include RadCoreRails
+  ...
+end
+```
+
+For using Zip Codes by Radius filter follow the steps below:
+
+Step 1 - generate migration: 
+
+```shell script
+rails generate rad_core_rails:zip_codes_migration
+```
+
+Step 2 - migrate DB:
+
+```shell script
+rails db:migrate
+```
+
+Step 3 - import all US zip-codes to your DB:
+> this gem has built in JSON file with all US zip-codes
+
+```shell script
+rails rad_core_rails:import_zip_codes
+```
+
+Step 4 - add new filter to `filter_manifest` method like on example:
+
+> OLD Syntax
+```ruby
+class Job < ActiveRecord::Base
+  include RadCoreRails
+
+  def self.filter_manifest
+    { 
+      zip_codes: ->(filter) { generate_zip_codes_clauses('addresses.zip', filter) } 
+    }.with_indifferent_access
+  end
+end
+```  
+
+> NEW Syntax starting from v0.7.0
+
+```ruby
+class Job < ActiveRecord::Base
+  include RadCoreRails
+
+  filterable zip_codes: [:zip_codes, 'addresses.zip']
+end
+```
+
+Step 5 - filter params example
+
+```ruby
+{ key: 'zip_codes', option: '15', values: ['85001'] }
+```
+
+
+## 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 tags, 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/[USERNAME]/rad_core_rails. 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/[USERNAME]/rad_core_rails/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 RadCoreRails project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rad_core_rails/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,6 +1,11 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require './support/active_record_rake_tasks'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+# Stub the :environment task for tasks like db:migrate & db:seed. Since this is a Gem we've explicitly required all
+# dependent files in the needed places and we don't have to load the entire environment.
+task :environment

data/lib/generators/rad_core_rails/templates/migration.rb.tt

@@ -0,0 +1,17 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :zip_codes do |t|
+      t.string :city
+      t.string :state
+      t.string :zip
+      t.decimal :latitude, precision: 10, scale: 6
+      t.decimal :longitude, precision: 10, scale: 6
+
+      t.timestamps
+    end
+
+    add_index :zip_codes, :zip, unique: true
+    add_index :zip_codes, :latitude, unique: true
+    add_index :zip_codes, :longitude, unique: true
+  end
+end

data/lib/generators/rad_core_rails/zip_codes_migration_generator.rb

@@ -0,0 +1,18 @@
+require "rails/generators/active_record"
+
+module RadCoreRails
+  module Generators
+    class ZipCodesMigrationGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+      source_root File.join(__dir__, "templates")
+
+      def copy_migration
+        migration_template "migration.rb", "db/migrate/create_zip_codes.rb", migration_version: migration_version
+      end
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/rad_core_rails.rb

@@ -1,15 +1,18 @@
-require "rad_core_rails/version"
-require "active_support/concern"
-require "active_support/core_ext"
+# Need some refactoring: https://ankane.org/gem-patterns
 require "active_record"
-require 'rad_core_rails/query_generator'
-require 'rad_core_rails/search_terms'
-require 'rad_core_rails/sortable'
+
+require "rad_core_rails/railtie" if defined?(Rails)
+require "rad_core_rails/version"
+require "rad_core_rails/query_generator"
+require "rad_core_rails/search_terms"
+require "rad_core_rails/sortable"
 
 module RadCoreRails
+  autoload :ZipCode, 'rad_core_rails/zip_code'
+
   def self.included(receiver)
     receiver.send :include, Sortable, SearchTerms, QueryGenerator
   end
 
   class Error < StandardError; end
-end
+end

data/lib/rad_core_rails/query_generator.rb

@@ -11,13 +11,17 @@ module RadCoreRails
         @searchable_columns = handle_columns(columns)
       end
 
+      def filterable(filters_data = [])
+        @filter_manifest = handle_filterable(filters_data)
+      end
+
       def joins_clause
         <<-SQL
         SQL
       end
 
       def filter_manifest
-        {}.with_indifferent_access
+        @filter_manifest || {}.with_indifferent_access
       end
 
       def create_filters(search, filters)
@@ -29,28 +33,102 @@ module RadCoreRails
           args << arg
         end
         filters.map do |filter|
-          clause, arguments = filter_manifest[filter[:key]].call(filter)
-          query << clause
-          arguments.each do |arg|
-            args << arg
+          begin
+            clause, arguments = filter_manifest[filter[:key]].call(filter)
+            query << clause
+            arguments.each do |arg|
+              args << arg
+            end
+          rescue NoMethodError
+            raise NoMethodError.new("Filter with the name `#{filter[:key]}` doesn't exist.")
           end
         end
         [query.reject(&:blank?).join(' AND '), args]
       end
 
+      # def generate_search_clause(search)
+      #   and_args = []
+      #   or_args = []
+      #   if search.present? && searchable_columns.is_a?(Array)
+      #     # search_term_size = search.split(' ').length
+      #     and_terms = search.split(' ').select { |term| !term.include?('+') }
+      #     or_terms = search.split(' ').select { |term| term.include?('+') }
+      #     and_columns = []
+      #     or_columns = []
+      #     # just_ors = search_term_size == or_term_size
+      #     # operand = just_ors ? 'OR' : 'AND'
+      #     # search_terms = just_ors == true ? search.split(' ') : search.split(' ').select { |term| !term.include?('+') }
+      #     and_terms.each do |term|
+      #       columns = []
+      #       and_terms.each do |col|
+      #         and_columns.push("(LOWER(#{col}) ILIKE ?)")
+      #         and_args.push '%' + term.downcase.strip + '%'
+      #       end
+      #       or_terms.each do |col|
+      #         columns.push("(LOWER(#{col}) ILIKE ?)")
+      #         or_args.push '%' + term[1, term.length].downcase.strip + '%'
+      #       end
+      #       clause = if or_columns.empty?
+      #                  '(' + and_columns.join(' OR ') + ')'
+      #                else
+      #                  '(' + '(' + and_columns.join(' OR ') + ')' + 'AND' + '(' + or_columns.join(' OR ') + ')' + ')'
+      #                         end
+      #     end
+      #     [clause, and_args + or_args]
+      #   else
+      #     ['', []]
+      #   end
+      # end
+
+      # @searchable_columns, is an array of column names that you can compare to your terms.
+      #
       def generate_search_clause(search)
-        args = []
         if search.present? && searchable_columns.is_a?(Array)
-          clause = []
-          search.split(' ').each do |term|
+          # holds all of the sql from sanitized_and_terms
+          and_args = []
+          # holds all the table columns sql for all the AND terms
+          and_clause = []
+          # holds all of the sql from sanitized_or_terms
+          or_args = []
+          # holds all the table columns sql for all the OR terms
+          or_clause = []
+          # extract and terms, remove casing, and add ILIKE '%' comparisions
+          sanitized_and_terms = search.split(' ')
+                                      .reject { |term| term.include?('+') }
+                                      .map { |term| '%' + term.downcase.strip + '%' }
+          # extract or terms, remove casing, and add ILIKE '%' comparisions
+          sanitized_or_terms = search.split(' ')
+                                     .select { |term| term.include?('+') }
+                                     .map { |term| '%' + term[1, term.length].downcase.strip + '%' }
+          # loop through sanitized_and_terms to find all possible columns.
+          sanitized_and_terms.each do |sanitized_term|
             columns = []
+            # all possible columns where this should be searched
             searchable_columns.each do |col|
               columns.push("(LOWER(#{col}) ILIKE ?)")
-              args.push '%' + term.downcase.strip + '%'
+              and_args.push sanitized_term
             end
-            clause.push '(' + columns.join(' OR ') + ')'
+            and_clause.push '(' + columns.join(' OR ') + ')'
+          end
+          # loop through sanitized_or_terms to find all possible columns.
+          sanitized_or_terms.each do |sanitized_term|
+            columns = []
+            # all possible columns where this should be searched
+            searchable_columns.each do |col|
+              columns.push("(LOWER(#{col}) ILIKE ?)")
+              or_args.push sanitized_term
+            end
+            or_clause.push '(' + columns.join(' OR ') + ')'
+          end
+          if or_clause.empty? && and_clause.empty?
+            ['', []]
+          elsif or_clause.empty?
+            ['(' + and_clause.join(' AND ') + ')', and_args]
+          elsif and_clause.empty?
+            ['(' + or_clause.join(' OR ') + ')', or_args]
+          else
+            ['((' + and_clause.join(' AND ') + ') AND (' + or_clause.join(' OR ') + '))', and_args + or_args]
           end
-          ['(' + clause.join(' AND ') + ')', args]
         else
           ['', []]
         end
@@ -65,13 +143,26 @@ module RadCoreRails
         [str, args]
       end
 
-      def generate_model_clause(column_name, filter)
-        str = "(#{column_name} = ANY(ARRAY[?]))"
+      def generate_model_clause(column_name, filter, optional_exclusion_clause = nil)
+        str = if optional_exclusion_clause.present? && filter[:option] == '!='
+                optional_exclusion_clause
+              else
+                # probably should fix this.
+                # somtimes we arent sending a filter option, so just default it to =
+                "(#{column_name} #{filter[:option] || '='} ANY(ARRAY[?]))"
+              end
         args = [filter[:values]]
 
         [str, args]
       end
 
+      def generate_zip_codes_clause(column_name, filter)
+        str = "(#{column_name} = ANY(#{zip_code_class.distance_query}))"
+        args = zip_code_class.distance_args(filter)
+
+        [str, args]
+      end
+
       def generate_array_clause(column_name, filter)
         str = "(#{column_name} && ARRAY[?])"
         args = [filter[:values]]
@@ -148,9 +239,7 @@ module RadCoreRails
       private
 
       def handle_columns(columns)
-        if columns.empty?
-          return self.columns.select { |c| c.type == :string }.map { |c| "#{table_name}.#{c.name}" }
-        end
+        return self.columns.select { |c| c.type == :string }.map { |c| "#{table_name}.#{c.name}" } if columns.empty?
 
         columns.map do |c|
           splitted_c = c.split('.')
@@ -162,6 +251,27 @@ module RadCoreRails
           end
         end
       end
+
+      def handle_filterable(filters_data)
+        return nil if filters_data.empty?
+        @zip_code_class = filters_data.delete(:zip_code_class)
+
+        result = {}
+
+        filters_data.each do |filter_data|
+          filter_type, filter_column = filter_data.last
+          result[filter_data.first] = lambda { |filter|
+            public_send("generate_#{filter_type}_clause", filter_column, filter)
+          }
+        end
+
+        result.with_indifferent_access
+      end
+
+      def zip_code_class
+        return RadCoreRails::ZipCode unless @zip_code_class
+        @zip_code_class.to_s.constantize
+      end
     end
   end
 end