active_record_arrangeable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eef7092e6af2f283d12896673fb48def675ca978f6ec0d94742efe25c9d51cd9
+  data.tar.gz: 42c1bb3be2c742724e757e1af0c80ca7d8713c96af085b488a02fa2d66961b83
+SHA512:
+  metadata.gz: fcaef282224e196f7ed7d9fd1d333593dbfd4ef7e0050a1ea4356cd0a24a6a92fa5dc6b4dd42c24c61285dc1243537a6135d5bf4d6478a8ed98eb812527ac969
+  data.tar.gz: b973bbf1506f88ecea5111d933b1db283b6178c1270459c6181f046d35591f0c6b2ab02e18c55cf09365e913f78ee19647800ce1ae718456a3984ab88a667038

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+test.sqlite3
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+db

data/.travis.yml

@@ -0,0 +1,16 @@
+sudo: false
+language: ruby
+
+cache:
+  directories:
+    - vendor/bundle
+
+rvm:
+  - 2.5.1
+
+bundler_args: --jobs 3 --retry 3
+
+script: bundle exec rspec
+
+gemfile:
+  - Gemfile

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'pg', '>= 0.18', '< 2.0'
+  gem 'mysql2', '>= 0.5.0', '< 0.6.0'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Rafael Jurado
+
+MIT License
+
+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,57 @@
+# ActiveRecord::Filterable
+![Build Status](https://travis-ci.org/pacop/active_record_arrangeable.svg?branch=master)
+
+Let you add scopes to active_record document for filters.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_record_arrangeable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record_arrangeable
+
+## Usage
+
+#### Model
+
+```ruby
+class City < ActiveRecord::Base
+  include ActiveRecord::Arrangeable
+
+  has_many :provinces
+
+  arrange_by :province_name, (lambda do |direction=:asc|
+    includes(:provinces).order("provinces.name #{direction}")
+  end)
+end
+class Province < ActiveRecord::Base
+  belongs_to :city
+end
+
+City.create(name: 'city2', provinces: [Province.create(name: 'c3'),
+                                       Province.create(name: 'd4')])
+City.create(name: 'city1', provinces: [Province.create(name: 'a1'),
+                                       Province.create(name: 'b2')])
+City.create(name: 'city3', provinces: [Province.create(name: 'a1'),
+                                       Province.create(name: 'b2')])
+
+City.arrange(:province_name) => [city1, city3, city2]
+City.arrange(province_name: :desc) => [city2, city1, city3]
+City.arrange(:province_name, :name) => [city1, city3, city2]
+City.arrange(:province_name, name: :desc) => [city3, city1, city2]
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/active_record_arrange/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/active_record_arrangeable.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record_arrangeable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'active_record_arrangeable'
+  spec.version       = ActiveRecord::Arrangeable::VERSION
+  spec.authors       = ['Francisco Padillo']
+  spec.email         = ['pacopa.93@gmail.com']
+  spec.summary       = 'Friendly and easy sort'
+  spec.description   = 'Friendly and easy sort'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_dependency 'activerecord', ['>= 3.0', '<= 5.2']
+end

data/lib/active_record_arrangeable.rb

@@ -0,0 +1,3 @@
+require 'active_record_arrangeable/version'
+require 'active_record_arrangeable/arrangeable'
+require 'active_record_arrangeable/arrange_service'

data/lib/active_record_arrangeable/arrange_service.rb

@@ -0,0 +1,68 @@
+module ActiveRecord
+  module Arrangeable
+    class ArrangeService
+      VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC,
+                          "asc", "desc", "ASC", "DESC"].freeze
+
+      DEFAULT_DIRECTION = :asc
+
+      def self.arrange(relation, *args)
+        self.new(relation).arrange!(args)
+      end
+
+      def initialize(relation)
+        @relation = is_a?(ActiveRecord::Relation) ? relation : relation.all
+      end
+
+      def arrange!(*args)
+        preproces_args(args)
+
+        args.each do |arg|
+          if arg.is_a?(Hash)
+            arg.each do |field, value|
+              apply_arrange(field, value)
+            end
+          else
+            apply_arrange(arg, DEFAULT_DIRECTION)
+          end
+        end
+
+        @relation
+      end
+
+      private
+
+      def apply_arrange(field, direction)
+        method_name  = "arrange_with_#{field}"
+
+        @relation = if @relation.respond_to?(method_name)
+                      @relation.public_send(method_name, direction)
+                    else
+                      @relation.order(field => direction)
+                    end
+      end
+
+      def preproces_args(order_args)
+        order_args.map! do |arg|
+          @relation.sanitize_sql_for_order(arg)
+        end
+        order_args.flatten!
+
+        validate_direction_args(order_args)
+      end
+
+      def validate_direction_args(args)
+        args.each do |arg|
+          next unless arg.is_a?(Hash)
+          arg.each do |_key, value|
+            unless VALID_DIRECTIONS.include?(value)
+              raise ArgumentError,
+                "Direction \"#{value}\" is invalid. Valid directions are: "\
+                "#{VALID_DIRECTIONS.to_a.inspect}"
+            end
+          end
+        end
+      end
+    end
+    end
+end

data/lib/active_record_arrangeable/arrangeable.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module Arrangeable
+    def self.included(base)
+      base.extend ArrangeClassMethods
+
+      base.class_eval do
+        ##
+        # Adds custom arrange as scope
+        #
+        private_class_method def self.arrange_by(attr, arrange)
+          scope "arrange_with_#{attr}", arrange
+        end
+      end
+
+      return unless defined?(ActiveRecord::Relation)
+
+      ActiveRecord::Relation.send :include, ArrangeClassMethods
+    end
+
+    module ArrangeClassMethods
+      ##
+      # Applies params sorts to current scope
+      #
+      def arrange(*args)
+        ArrangeService.arrange(self, *args)
+      end
+    end
+  end
+end
+

data/lib/active_record_arrangeable/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Arrangeable
+    VERSION = '0.1.0'.freeze
+  end
+end

data/spec/arrangeable_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+RSpec.describe ActiveRecord::Arrangeable do
+  class City < ActiveRecord::Base
+    include ActiveRecord::Arrangeable
+
+    scope :actives, ->() { where(active: true) }
+
+    has_many :provinces
+
+    arrange_by :province_name, (lambda do |direction=:asc|
+      includes(:provinces).order("provinces.name #{direction}")
+    end)
+  end
+  class Province < ActiveRecord::Base
+    belongs_to :city
+  end
+
+  before do
+    City.unscoped.destroy_all
+  end
+
+  {model: City, all: City.all, scope: City.actives}.each do |explanation, subject|
+    describe explanation do
+      let(:subject_sort_by) { subject.respond_to?(:subject) ? subject : subject.all }
+
+      context 'when custom arrange_by is used in isolation' do
+        let(:sorted_cities) { subject_sort_by.sort_by { |city| city.provinces.map(&:name) } }
+
+        before do
+          City.create(active: false)
+          City.create(name: 'city2', provinces: [Province.create(name: 'c3'),
+                                                 Province.create(name: 'd4')])
+          City.create(name: 'city1', provinces: [Province.create(name: 'a1'),
+                                                 Province.create(name: 'b2')])
+        end
+
+        context 'with symbol' do
+          it 'sorts ascending by default' do
+            expect(subject.arrange(:province_name).map(&:id)).to eq(sorted_cities.map(&:id))
+          end
+        end
+
+        context 'with string' do
+          it 'sorts ascending by default' do
+            expect(subject.arrange('province_name').map(&:id)).to eq(sorted_cities.map(&:id))
+          end
+        end
+
+        context 'with hash' do
+          it 'sorts descending' do
+            expect(subject.arrange(province_name: :desc).map(&:id)).to eq(
+              sorted_cities.map(&:id).reverse
+            )
+          end
+
+          it 'sorts ascending' do
+            expect(subject.arrange(province_name: :asc).map(&:id)).to eq(sorted_cities.map(&:id))
+          end
+        end
+
+        context 'with an array' do
+          it 'sorts descending' do
+            expect(subject.arrange([province_name: :desc]).map(&:id)).to eq(
+              sorted_cities.map(&:id).reverse
+            )
+          end
+
+          it 'sorts ascending' do
+            expect(subject.arrange([province_name: :asc]).map(&:id)).to eq(sorted_cities.map(&:id))
+          end
+        end
+      end
+
+      context 'when custom arrange_by is combined with attrs' do
+        let(:sorted_cities_asc) do
+          subject_sort_by.sort_by { |city| [city.provinces.map(&:name), city.name] }.map(&:id)
+        end
+        let(:sorted_cities_desc) do
+          subject_sort_by.sort_by { |city| [city.provinces.map(&:name), city.name] }.map(&:id).reverse
+        end
+        let(:sorted_cities_desc_asc) do
+          subject_sort_by.sort do |c1, c2|
+            [c2.provinces.map(&:name), c1.name] <=> [c1.provinces.map(&:name), c2.name]
+          end.map(&:id)
+        end
+        let(:sorted_cities_asc_desc) do
+          subject_sort_by.sort do |c1, c2|
+            [c1.provinces.map(&:name), c2.name] <=> [c2.provinces.map(&:name), c1.name]
+          end.map(&:id)
+        end
+
+        before do
+          City.create(name: 'city2', provinces: [Province.create(name: 'c3'),
+                                                 Province.create(name: 'd4')])
+          City.create(name: 'city3', provinces: [Province.create(name: 'a1'),
+                                                 Province.create(name: 'b2')])
+          City.create(name: 'city1', provinces: [Province.create(name: 'a1'),
+                                                 Province.create(name: 'b2')])
+        end
+
+        it 'sorts ascending' do
+          expect(subject.arrange([province_name: :asc], name: :asc).map(&:id)).to eq(sorted_cities_asc)
+        end
+
+        it 'sorts descending' do
+          expect(subject.arrange([province_name: :desc], name: :desc).map(&:id)).to eq(
+            sorted_cities_desc
+          )
+        end
+
+        it 'provinces desc, name asc' do
+          expect(subject.arrange([province_name: :desc], name: :asc).map(&:id)).to eq(
+            sorted_cities_desc_asc
+          )
+        end
+
+        it 'provinces asc, name desc' do
+          expect(subject.arrange([province_name: :asc], name: :desc).map(&:id)).to eq(
+            sorted_cities_asc_desc
+          )
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'bundler/setup'
+require 'active_record'
+
+require 'active_record_arrangeable'
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3', database: 'db/active_record_arrangeablablee.sqlite3'
+)
+
+ActiveRecord::Base.connection.create_table(:cities, force: true, collate: :nocase) do |t|
+  t.string :name
+  t.boolean :active, default: true
+  t.timestamps null: false
+end
+
+ActiveRecord::Base.connection.create_table(:provinces, force: true, collate: :nocase) do |t|
+  t.string :name
+  t.belongs_to :city
+
+  t.timestamps null: false
+end
+
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  # config.example_status_persistence_file_path = 'spec/examples.txt'
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: active_record_arrangeable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Francisco Padillo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+description: Friendly and easy sort
+email:
+- pacopa.93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record_arrangeable.gemspec
+- lib/active_record_arrangeable.rb
+- lib/active_record_arrangeable/arrange_service.rb
+- lib/active_record_arrangeable/arrangeable.rb
+- lib/active_record_arrangeable/version.rb
+- spec/arrangeable_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Friendly and easy sort
+test_files:
+- spec/arrangeable_spec.rb
+- spec/spec_helper.rb