collate 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6e9c829cf7d2ee33ab2a3dcc18976a0dd398ffe
-  data.tar.gz: 4edbcc221115207821abe533c93a123a96bc9619
+  metadata.gz: c576c73f42f7ce0da453c0e0e0778a69fd9a27f7
+  data.tar.gz: 9db7728b9973c4bd4575b6a00f733d0312d69ed6
 SHA512:
-  metadata.gz: 28caee2d1066e2e00c9b34d8dfe7fc2aa512a44d7c4db7fe862af92db92c5685c8a8e46b27c3b3308c46b5cdb49e4b51c2291c94e5dac432ce9399931fd9e41c
-  data.tar.gz: ee77a8b8330258f9c034c944a729b005f9396741e7994bc8f7ae4f823e12a19e4f50ac8daba9f34d877071fc9b376402a3106efaff8d8641792d21bd708d6fef
+  metadata.gz: 64eb3c1bd01e5ffc31403424f1e3646bdb9e95a0fbb508bed7a1a3bca5a34e9e3f249cf39cb224565ebcb9e796c000d5a63a608210baf12631d4b40870b1f52b
+  data.tar.gz: 63b34d8658c421d24a87b125d818c9dd50c2bfb2285cfed011442cc4c486e01fcd712325215c874659644fd0ad2b071d16a81666cdb7444afacf00a11916b4b8

data/README.md

@@ -2,8 +2,8 @@
 
 [![CircleCI](https://img.shields.io/circleci/project/github/trackingboard/collate.svg)](https://circleci.com/gh/trackingboard/collate)
 [![Coveralls](https://img.shields.io/coveralls/trackingboard/collate.svg)](https://coveralls.io/github/trackingboard/collate?branch=master)
-[![Gem](https://img.shields.io/gem/v/collate.svg)]()
-[![Gem](https://img.shields.io/gem/dt/collate.svg)]()
+[![Gem](https://img.shields.io/gem/v/collate.svg)](https://rubygems.org/gems/collate)
+[![Gem](https://img.shields.io/gem/dt/collate.svg)](https://rubygems.org/gems/collate)
 
 ## Installation
 
@@ -13,11 +13,11 @@ or with bundler in your Gemfile:
 
 ```gem 'collate'```
 
-## Usage
+## Filter Usage
 
 This gem currently only supports PostgreSQL.
 
-To use collate in a model, include several collation definitions. The first argument is the name of the database column to use in the query. The simplest example looks like this:
+To use collate filtering in a model, include several collation definitions. The first argument is the name of the database column to use in the query. The simplest example looks like this:
 
 ```
 class Person < ActiveRecord::Base
@@ -284,6 +284,129 @@ In order to use this in a view, you could have some HAML like this:
 
 This will ensure that the keys that the inputs are submitted with match the parameter key that the gem is expecting for that specific filter.
 
+## Sorting Usage
+
+To use collate sorting for a model, include several ```collate_sort``` defintions. For example:
+
+```
+class Person < ActiveRecord::Base
+	collate_sort :name
+	collate_sort :popularity	
+end
+```
+
+Then, in the controller, use the ```collate``` method:
+
+```
+@people = Person.collate(params)
+```
+
+This will cause the people to be sorted on either ```name``` or ```popularity``` if the ```params[:order]``` value is set appropriately.
+
+```params[:order]``` must have a value of the format ```"#{table_name}.#{field_name} ASC``` or ```"#{table_name}.#{field_name} DESC```
+
+For example:
+
+```
+params[:order] = "people.name ASC"
+@people = Person.collate(params)
+```
+
+Will result in the following PostgreSQL query:
+
+```
+SELECT * FROM people ORDER BY people.name ASC
+```
+
+You can also pass parameter options to ```collate_sort``` for more complex sorting.
+
+#### Default
+--------------
+```
+collate_sort :name, default: 'asc'
+```
+
+This tells collate that this particular sorting should be performed if there is no other sorting specified by the user.
+
+It is also the second sorting to be applied on top of another sort.
+
+For instance:
+
+```
+class Person < ActiveRecord::Base
+	collate_sort :name, default: 'desc'
+	collate_sort :popularity	
+end
+```
+
+```
+params[:order] = 'people.popularity ASC'
+@people = Person.collate(params)
+```
+
+This would result in the following PostgreSQL query:
+
+```
+ORDER BY people.popularity ASC, people.name DESC
+```
+
+#### Joins
+--------------
+```
+collate_sort 'posts.created_at', joins: [:posts]
+```
+
+This will perform the ActiveRecord joins before the sorting is applied. Doing this will allow you to sort on fields that are on related models.
+
+#### Field_select
+--------------
+```
+collate_sort 'post_count', joins: [:posts], field_select: 'COUNT(posts.*) as post_count'
+```
+
+This will perform the ActiveRecord select before the sorting is applied. Doing this will allow you to sort on fields created using a subquery.
+
+#### Nulls_first
+--------------
+```
+collate_sort :popularity, nulls_first: true
+```
+
+This will append ```NULLS FIRST``` to the order portion of the database query
+
+#### Nulls_last
+--------------
+```
+collate_sort :popularity, nulls_last: true
+```
+
+This will append ```NULLS LAST``` to the order portion of the database query
+
+#### Label
+--------------
+```
+collate_sort :popularity, label: 'Popularity Score'
+```
+
+This will modify the default sorting label, which is ```field.to_s.titleize```.
+
+#### Asc_label
+--------------
+```
+collate_sort :popularity, asc_label: 'Popularity Score Lowest to Highest'
+```
+
+This will modify the default ascending sorting label, which is ```#{label} ⬇```.
+
+#### Desc_label
+--------------
+```
+collate_sort :popularity, desc_label: 'Popularity Score Highest to Lowest'
+```
+
+This will modify the default descending sorting label, which is ```#{label} ⬆```.
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/trackingboard/collate.

data/lib/app/views/collate/_sort_select.html.haml

@@ -0,0 +1,9 @@
+%select.collate_sort{opts}
+  - if opts[:allow_none]
+    %option{value: "", selected: (params[:order].to_s == "")}
+      None
+  - sorters.each do |sorter|
+    %option{value: "#{sorter.field} ASC", selected: (params[:order] == "#{sorter.field} ASC")}
+      = sorter.asc_label
+    %option{value: "#{sorter.field} DESC", selected: (params[:order] == "#{sorter.field} DESC")}
+      = sorter.desc_label

data/lib/collate/action_view_extension.rb

@@ -10,6 +10,14 @@ module Collate
       filters
     end
 
+    def sorting_for record, opts={}
+      sorters = record.model.collate_sorters ||= []
+
+      opts[:name] ||= "order"
+
+      render :partial => "collate/sort_select", locals: {sorters: sorters, opts: opts}
+    end
+
     def filter_for filter
       render :partial => "collate/#{filter.component[:type]}_field", locals: {filter: filter}
     end

data/lib/collate/active_record_extension.rb

@@ -1,8 +1,15 @@
 require_relative 'filter'
+require_relative 'sorter'
 
 module Collate
   module ActiveRecordExtension
 
+    def collate_sort field, opts={}
+      initialize_collate
+
+      self.collate_sorters << Collate::Sorter.new(field, opts.merge({base_model_table_name: self.table_name}))
+    end
+
     def collate_on field, opts={}
       initialize_collate
 
@@ -33,6 +40,20 @@ module Collate
         end
       end
 
+      self.collate_sorters.each do |sorter|
+        sort_field, _, sort_direction = params[:order].to_s.partition(' ')
+
+        if(sort_field == sorter.field && ['ASC','DESC'].include?(sort_direction))
+          ar_rel = apply_sorter ar_rel, sorter, params[:order]
+        end
+      end
+
+      default_sort = self.collate_sorters.select { |s| s.default }.first
+      if default_sort.present?
+        ar_rel = apply_sorter ar_rel, default_sort, "#{default_sort.field} #{default_sort.default.upcase}", 'order'
+        params[:order] = "#{default_sort.field} #{default_sort.default.upcase}"
+      end
+
       ar_rel
     end
 
@@ -41,14 +62,37 @@ module Collate
     def initialize_collate
       if !self.method_defined? :collate_filters
         class << self
-          attr_accessor :collate_filters, :default_group, :group_options
+          attr_accessor :collate_filters, :collate_sorters, :default_group, :group_options
         end
       end
       self.collate_filters ||= {}
+      self.collate_sorters ||= []
       self.default_group ||= :main
       self.group_options ||= {}
     end
 
+    def apply_sorter ar_rel, sorter, param_value, sorting_method = 'reorder'
+      if sorter.joins
+        sorter.joins.each do |join|
+          ar_rel = ar_rel.joins(join)
+        end
+      end
+
+      ar_rel = ar_rel.select("#{ar_rel.table_name}.*")
+
+      sorter.field_select = sorter.field unless sorter.field_select
+
+      ar_rel = ar_rel.select(sorter.field_select)
+
+      ar_rel = if sorter.nulls_first
+        ar_rel.send(sorting_method, "#{param_value} NULLS FIRST")
+      elsif sorter.nulls_last
+        ar_rel.send(sorting_method, "#{param_value} NULLS LAST")
+      else
+        ar_rel.send(sorting_method, param_value)
+      end
+    end
+
     def apply_filter ar_rel, filter, param_value
       filter_value = if param_value.duplicable?
         param_value.dup

data/lib/collate/sorter.rb

@@ -0,0 +1,23 @@
+module Collate
+  class Sorter
+    attr_accessor :field, :base_model_table_name, :label, :asc_label, :desc_label,
+                  :field_select, :joins, :default, :nulls_last, :nulls_first
+
+    def initialize(field, opt={})
+      opt.each do |field, value|
+        self.send("#{field}=", value)
+      end
+
+      self.field = field
+
+      self.label ||= self.field.to_s.titleize
+      self.asc_label ||= "#{label} ⬇"
+      self.desc_label ||= "#{label} ⬆"
+
+      self.field = "#{base_model_table_name}.#{field}" if field.is_a? Symbol
+
+      self.joins ||= []
+    end
+
+  end
+end

data/lib/collate/version.rb

@@ -1,3 +1,3 @@
 module Collate
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: collate
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Nicholas Page
@@ -176,12 +176,14 @@ files:
 - lib/app/views/collate/_checkboxgroup_field.html.haml
 - lib/app/views/collate/_date_field.html.haml
 - lib/app/views/collate/_select_field.html.haml
+- lib/app/views/collate/_sort_select.html.haml
 - lib/app/views/collate/_string_field.html.haml
 - lib/collate.rb
 - lib/collate/action_view_extension.rb
 - lib/collate/active_record_extension.rb
 - lib/collate/engine.rb
 - lib/collate/filter.rb
+- lib/collate/sorter.rb
 - lib/collate/version.rb
 homepage: https://github.com/trackingboard/collate
 licenses: