ordy 1.1.0

data/lib/ordy/orm/active_record/orderable.rb

@@ -0,0 +1,188 @@
+module Ordy
+  module Orm
+    module ActiveRecord
+      module Orderable
+
+        def self.included(base)
+          base.extend(Order::ClassMethods)
+        end
+
+        class Order
+          DELIMITER = '-'.freeze
+          include Enumerable
+
+          attr_reader :model, :default
+
+          # @param [ActiveRecord::Model] model
+          def initialize(model)
+            @model = model
+            @orderables = {}
+          end
+
+          def each(&block)
+            @orderables.each(&block)
+          end
+
+          def [](key)
+            @orderables.fetch(key)
+          end
+
+          # columns :name, :email
+          #
+          # @param [Array][Symbol] column_names
+          def columns(*column_names)
+            column_names.each do |column|
+              @orderables[column] = { args: { table: model.table_name, column: column },
+                                      orderable: Orderable::ByColumn }
+            end
+          end
+
+          # associations comment: :scripts
+          #
+          # @param [Array][Hash] associations
+          def associations(associations)
+            associations.each do |assoc, opts|
+              column, association = if opts.is_a?(Hash)
+                                      [opts.fetch(:column), opts.fetch(:as, assoc)]
+                                    else
+                                      [opts, assoc]
+                                    end
+              table_name = model.reflections.symbolize_keys.fetch(assoc).class_name.constantize.table_name
+
+              @orderables[association] = { args: { association: association,
+                                                   table: table_name,
+                                                   column: column },
+                                           orderable: Orderable::ByAssociation }
+            end
+          end
+
+          # specified(state: %w(new pending_migration migrating failed))
+          #
+          # @param [Array][Hash] args
+          def specified(args)
+            args.each do |column, values|
+              specified_column = "specified_#{column}".to_sym
+
+              @orderables[specified_column] = { args: { table: model.table_name,
+                                                        column: column,
+                                                        values: values },
+                                                orderable: Orderable::BySpecified }
+            end
+          end
+
+          # query :users do |scope, args|
+          #   scope.where(...).order(field: args[:direction])
+          # end
+          #
+          # @param [Symbol] query
+          # @param [Proc] block
+          def query(query, &block)
+            @orderables[query] = { args: {}, orderable: block }
+          end
+
+          # default do
+          #   order_by_specified(:state).order_by(started: :desc, created_at: :desc)
+          # end
+          #
+          # @param [Symbol] name
+          # @param [Proc] block
+          def default(name = nil, &block)
+            return -> { order_by(name => :asc) } if name.present?
+            @default = block if block_given?
+            @default ||= -> { order(nil) }
+          end
+
+          module ClassMethods
+
+            # orderable_by do
+            #   column :name
+            #   association :comments
+            #   specified(state: %w(new pending_migration migrating failed))
+            #
+            #   query(:topics) do |scope, args|
+            #     ...
+            #   end
+            # end
+            #
+            # @param [Proc] block
+            def orderable_by(&block)
+              @_orderables ||= Order.new(self)
+              @_orderables.instance_eval(&block)
+              @_orderables
+            end
+
+            # Model.order_by(name: :desc)
+            #
+            # Model.order_by('name-desc')
+            #
+            # Default direction :asc
+            # Model.order_by(name)
+            #
+            # Call default do method or order(nil)
+            # Model.order_by(nil)
+            # Model.order_by('')
+            #
+            # @param [Hash] order_query
+            def order_by(order_query = nil)
+              return default_order              if order_query.nil? || order_query.blank?
+              return default_order(order_query) if order_query.is_a?(Symbol)
+
+
+              specs = case order_query
+                      when String then parse_order_query(order_query)
+                      when Hash   then parse_order_hash(order_query)
+                      else
+                        []
+                      end
+
+              return default_order if specs.blank?
+
+              scope = default_scope
+
+              specs.each do |spec|
+                orderable = @_orderables[spec[:orderable]]
+                orderable[:args][:direction] = spec[:direction]
+
+                scope = orderable[:orderable].call(scope, orderable[:args])
+              end
+
+              scope
+            end
+
+            # Model.order_by_specified(:name)
+            #
+            # @param [Symbol] name
+            def order_by_specified(name)
+              orderable = @_orderables["specified_#{name}".to_sym]
+              orderable[:orderable].call(default_scope, orderable[:args])
+            end
+
+            def default_order(name = nil)
+              default_scope.instance_exec(&@_orderables.default(name))
+            end
+
+            private
+
+            # @param [Hash] order_query
+            # # @return [Array][Hash]
+            def parse_order_hash(order_query)
+              order_query.symbolize_keys.map { |(orderable, direction)| { orderable: orderable, direction: direction } }
+            end
+
+            # @param [String] order_query
+            # @return [Array][Hash]
+            def parse_order_query(order_query)
+              orderable, direction = order_query.to_s.split(DELIMITER).map(&:to_s).map(&:strip)
+              direction = 'asc' unless %w(desc asc).include?(direction)
+              [{ orderable: orderable.to_sym, direction: direction.to_sym }]
+            end
+
+            def default_scope
+              current_scope || where(nil)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ordy.rb

@@ -0,0 +1,9 @@
+module Ordy
+end
+
+require_relative 'config/settings'
+require_relative 'ordy/orm/active_record/orderable'
+require_relative 'ordy/orm/active_record/orderable/by_association'
+require_relative 'ordy/orm/active_record/orderable/by_column'
+require_relative 'ordy/orm/active_record/orderable/by_specified'
+require_relative 'ordy/helpers/action_view/orderable_link_helper'

data/ordy.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+
+Gem::Specification.new do |spec|
+  spec.name        = 'ordy'
+  spec.version     = File.read('VERSION')
+  spec.date        = '2018-11-23'
+  spec.summary     = 'Simple sorting gem'
+  spec.description = 'Simple sorting gem for RubyObject\'s and ORM\'s '
+  spec.authors     = ['nine.ch Development-Team']
+  spec.email       = 'development@nine.ch'
+  spec.files       = ['lib/ordy.rb']
+  spec.homepage    = 'http://github.com/ninech/'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'appraisal'
+
+  spec.add_runtime_dependency 'activerecord', '>= 4.0.0'
+  spec.add_runtime_dependency 'actionview', '>= 4.0.0'
+end

data/readme.md

@@ -0,0 +1,138 @@
+[![Build Status](https://travis-ci.org/ninech/ordy.svg)](https://travis-ci.org/ninech/ordy)
+
+## Usage
+
+#### Ordering
+
+__Model usage__
+
+```rb
+class User < ApplicationRecord
+  include Ordy::Orm::ActiveRecord::Orderable
+  
+  has_many :comments
+
+  orderable_by do
+    # order by field
+    columns :name, :email
+    
+    # order by relations field
+    associations comments: :scripts
+    
+    # sort by specified order
+    specified(state: %w(new, pending, active, removed))
+    
+    # custom query
+    query :custom_query do |scope, args|
+      scope.where(name: 'example').order(email: args[:direction])
+    end
+  end
+end
+```
+
+__Code usage__
+
+```rb
+# order by columns
+User.order_by(name: :asc)
+# or
+User.order_by('name-asc')
+
+# order by multiple columns
+User.order_by(name: :asc, email: :desc) 
+# or
+User.order_by(name: :asc).order_by(email: :desc)
+
+# order by association column
+User.order_by(comments: :asc)
+
+# order by specified column values
+User.order_by_specified(:state)
+
+# order by custom query
+User.order_by(custom_query: :asc)
+
+# default ordering
+User.order_by('') 
+# or
+User.order_by(nil)
+
+# ordering by more than one criteria
+User.order_by(email: :asc, state: :desc)
+```
+
+#### View helper
+
+__Helper inclusion__
+
+```rb
+# users_helper.rb 
+
+include Ordy::Helpers::ActionView::OrderableLinkHelper
+```
+
+__Html usage__
+
+```html
+# index.html
+
+<%= order_link('link_title', 'ordering_filed') %>
+```
+
+__Controller usage__
+
+```rb
+class UsersController
+    def index
+        if params[:order_by].present? && params[:direction].present?
+          @users = User.order_by(params[:order_by] => params[:direction])
+        else
+          @users = User.all
+        end
+    end
+end
+```
+
+## Run development environment
+
+```bash
+# position in gem dir
+cd ordy
+
+# build app
+docker-compose build app
+
+# run app and attach with bash 
+docker-compose run app /bin/bash
+```
+
+## Test
+
+```bash
+# install dependencies
+bundle exec appraisal install
+
+# run tests for rails 4 env 
+bundle exec appraisal rails-4 rspec
+
+# run tests for rails 5 env
+bundle exec appraisal rails-5 rspec
+```
+
+# Contributing
+Bug reports and pull requests are very welcome [on GitHub](https://github.com/ninech/ordy).
+
+Before opening a PR, please
+
+extend the existing specs
+- run rspec
+- run rubocop and fix your warnings
+- check if this README.md file needs adjustments
+
+#License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+# About
+This gem is currently maintained and funded by [nine](https://www.nine.ch/de/home).
+
+[![logo of the company 'nine'](https://logo.apps.at-nine.ch/Dmqied_eSaoBMQwk3vVgn4UIgDo=/trim/500x0/logo_claim.png)](https://www.nine.ch)

data/spec/ordy/orm/active_record/orderable_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+require './spec/support/orm/active_record/active_record_test_db'
+
+describe Ordy::Orm::ActiveRecord::Orderable do
+
+  describe '#order_by' do
+
+    context 'columns' do
+      let(:base_query) { User }
+      let(:order) { base_query.order_by(order_by) }
+      let(:result) { order.pluck(:name) }
+
+      context 'order by name: :asc' do
+        let(:order_by) { { name: :asc } }
+        specify { expect(result).to eq(%w(axample demo example)) }
+      end
+
+      context 'order by name-asc' do
+        let(:order_by) { 'name-asc' }
+        specify { expect(result).to eq(%w(axample demo example)) }
+      end
+
+      context 'order by name: :desc' do
+        let(:order_by) { { name: :desc } }
+        specify { expect(result).to eq(%w(example demo axample)) }
+      end
+
+      context 'order by name-desc' do
+        let(:order_by) { 'name-desc' }
+        specify { expect(result).to eq(%w(example demo axample)) }
+      end
+
+      context 'base query immutability' do
+        it 'should not change base query' do
+          query = base_query.where(name: 'example')
+          query.order_by(name: :desc).pluck(:name)
+          expect(query.to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'')
+        end
+      end
+    end
+
+    context 'associations' do
+      let(:base_query) { User }
+      let(:order) { base_query.order_by(order_by) }
+      let(:result) { order.pluck(:id) }
+
+      context 'order by name: :asc' do
+        let(:order_by) { { comments: :asc } }
+        specify { expect(result).to eq([3, 2, 1]) }
+      end
+
+      context 'order by name-asc' do
+        let(:order_by) { 'comments-asc' }
+        specify { expect(result).to eq([3, 2, 1]) }
+      end
+
+      context 'order by name: :desc' do
+        let(:order_by) { { comments: :desc } }
+        specify { expect(result).to eq([1, 2, 3]) }
+      end
+
+      context 'order by name-desc' do
+        let(:order_by) { 'comments-desc' }
+        specify { expect(result).to eq([1, 2, 3]) }
+      end
+
+      context 'base query immutability' do
+        it 'should not change base query' do
+          query = base_query.where(name: 'example')
+          query.order_by(comments: :desc).pluck(:id)
+          expect(query.to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'')
+        end
+      end
+    end
+
+    context 'query' do
+      let(:base_query) { User }
+      let(:order) { base_query.order_by(order_by) }
+      let(:result) { order.pluck(:email) }
+
+      context 'order by name: :asc' do
+        let(:order_by) { { custom_query: :asc } }
+        specify { expect(result).to eq(%w(example@example.com custom_example@example.com)) }
+      end
+
+      context 'order by name-asc' do
+        let(:order_by) { 'custom_query-asc' }
+        specify { expect(result).to eq(%w(example@example.com custom_example@example.com)) }
+      end
+
+      context 'order by name: :desc' do
+        let(:order_by) { { custom_query: :desc } }
+        specify { expect(result).to eq(%w(custom_example@example.com example@example.com)) }
+      end
+
+      context 'order by name-desc' do
+        let(:order_by) { 'custom_query-desc' }
+        specify { expect(result).to eq(%w(custom_example@example.com example@example.com)) }
+      end
+
+      context 'base query immutability' do
+        it 'should not change base query' do
+          query = base_query.where(name: 'example')
+          query.order_by('custom_query-desc').pluck(:email)
+          expect(query.to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'')
+        end
+      end
+    end
+
+    context 'default ordering' do
+      let(:spacing) { ENV['BUNDLE_GEMFILE'].include?('gemfiles/rails_4.gemfile') ? '  ' : ' ' }
+
+      context 'default proc' do
+        let(:query) { User.where(name: 'example') }
+
+        it 'should return asc ordering for nil' do
+          expect(query.order_by(nil).to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'' + spacing + 'ORDER BY "users"."state"=\'active\' DESC,"users"."state"=\'pending\' DESC, users.name asc')
+        end
+
+        it 'should not mutate base query' do
+          expect(query.to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'')
+        end
+      end
+
+      context 'default field direction' do
+        let(:query) { User.where(name: 'example') }
+
+        it 'should return asc ordering for :field' do
+          expect(query.order_by(:name).to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'' + spacing + 'ORDER BY users.name asc')
+        end
+
+        it 'should not mutate base query' do
+          expect(query.to_sql).to eq('SELECT "users".* FROM "users" WHERE "users"."name" = \'example\'')
+        end
+      end
+
+      context 'default ordering' do
+        let(:base_query_sql) { 'SELECT "comments".* FROM "comments" WHERE "comments"."user_id" = 1' }
+        let(:query) { Comment.where(user_id: 1) }
+
+        it 'should return asc ordering for \'\'' do
+          expect(query.order_by('').to_sql).to eq(base_query_sql)
+        end
+
+        it 'should not mutate base query' do
+          expect(query.to_sql).to eq(base_query_sql)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'ordy'
+require 'pry'

data/spec/support/orm/active_record/active_record_test_db.rb

@@ -0,0 +1,95 @@
+require 'active_record'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    create_db
+    migrate
+    seed
+  end
+
+  config.after(:all) do
+    drop_db
+  end
+end
+
+def create_db
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+end
+
+def migrate
+  ActiveRecord::Base.connection.create_table :users do |t|
+    t.text :name
+    t.text :email
+    t.text :state
+  end
+
+  ActiveRecord::Base.connection.create_table :comments do |t|
+    t.integer :user_id
+    t.text :content
+  end
+end
+
+def seeds
+  [
+      { table: "'users'",
+        fields: %w(id name email state),
+        values: [
+            [1, "'demo'", "'demo@demo.com'", "'active'"],
+            [2, "'axample'", "'example@example.com'", "'pending'"],
+            [3, "'example'", "'custom_example@example.com'", "'active'"]
+        ]
+      },
+      { table: "'comments'",
+        fields: %w(content user_id),
+        values: [
+            ["'example'", 1],
+            ["'demo'", 2]
+        ]
+      }
+  ]
+end
+
+def seed
+  seeds.each do |model|
+    model[:values].each do |args|
+      ActiveRecord::Base.connection.execute("INSERT INTO #{model[:table]} (#{model[:fields].join(',')}) VALUES (#{args.join(',')})")
+    end
+  end
+end
+
+def drop_db
+  [:users, :comments].each do |table|
+    ActiveRecord::Base.connection.drop_table table
+  end
+end
+
+class Comment < ActiveRecord::Base
+  include Ordy::Orm::ActiveRecord::Orderable
+
+  orderable_by do
+
+  end
+
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  include Ordy::Orm::ActiveRecord::Orderable
+
+  has_many :comments
+
+  orderable_by do
+    columns :name, :email
+    associations comments: :content
+    specified(state: %w(active pending))
+
+    query :custom_query do |scope, args|
+      scope.where('email LIKE \'%example%\'',).order(id: args.fetch(:direction))
+    end
+
+    default do
+      order_by_specified(:state).order_by(:name)
+    end
+  end
+end
+