sorted-activerecord 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c21400fbc224e7d0575432c714970ed799cc0d4d
-  data.tar.gz: 1f6e0062fdddf976f0b257becf262f5149cc45dc
+  metadata.gz: 73c6a1710bf109f92c675c82bfb51adbae2e83fe
+  data.tar.gz: f839fef7e88e8ca7632f3e9055467a217d7e2a96
 SHA512:
-  metadata.gz: c74ee20c9c63598e6adf5af36d290a8397a0f7d0be20c4c0ed9c558dc92a0fbecabae17d3fbb3f857c79e86fbf6dd0cadd2071764def00ed1b5c2b97b870c1f2
-  data.tar.gz: 6722154d0bfd8fc0ea142602c64caa2e8d786db9fec30c0d7407d3136c012ce6fedfbcf4ea93f3d5e03f6af79f45551349f6a91121ed8f0adec15e256b8ebc55
+  metadata.gz: be76ff4089fe1a2062ad37b001f1084f76b92401ca8011b356a480a8499036b4de359fc3ae6cf1e6b62da7a9655e914b805a0c028eba102758ec0145dbb0c853
+  data.tar.gz: d65155d4a62a460667c0e38e8fd1a3832bba1e0f6f9b0e43a837848f21d2e92f6610bed1bcaa286d769b9ee7c01682d59faf71580f0806f578042fefe48f88a1

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.5
+  - ruby-head
+
+script: bundle exec rake spec

data/Guardfile

@@ -0,0 +1,14 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/README.md

@@ -24,17 +24,34 @@ Or install it yourself as:
 
 ## Usage
 
-Using the `sorted` method with the optional default order argument:
+The sorted scope takes two optional arguments, `sort` and `order`, they both
+conform to the [AR query
+interface](http://guides.rubyonrails.org/active_record_querying.html#ordering)
+except that if you provide a string to the sort argument it expects a
+`Sorted::URIQuery` encoded string:
 
 ```ruby
-@users = User.sorted(params[:sort], "email ASC").page(params[:page])
+@users = User.sorted(sort: 'created_asc!orders_count_asc'
+                     order: 'orders_count ASC, created_at DESC')
 ```
 
-A `resorted` method is also available and works the same way as the `reorder` method in Rails.
-It forces the order to be the one passed in:
+See https://github.com/mynameisrufus/sorted-actionview for a view helper to
+generate the sort string or roll your own.
+
+A `resorted` method is also available and works the same way as the `reorder`
+method in Rails. It forces the order to be the one passed in:
+
+```ruby
+@users = User.order(:id).sorted(order: 'name DESC')
+             .resorted(sort: params[:sort], order: 'email ASC')
+```
+
+If you want to prevent people creating 500s by messing with the sort url string
+you can use a white list:
 
 ```ruby
-@users = User.order(:id).sorted(nil, 'name DESC').resorted(params[:sort], 'email ASC')
+@users = User.sorted(sort: 'created_asc!explode_me_asc'
+                     whitelist: %w(created_at))
 ```
 
 ## Contributing

data/lib/sorted/activerecord/builder.rb

@@ -2,21 +2,58 @@ require 'sorted'
 
 module Sorted
   module ActiveRecord
-    Builder = Struct.new(:sort, :order, :quoter) do
-      def uri
-        ::Sorted::URIQuery.parse(sort)
+    class Builder
+      class ParseError < StandardError; end
+
+      attr_reader :set
+
+      def initialize(sort: [], order: [], whitelist: [])
+        uri = parse_sort(sort)
+        if whitelist.length > 0
+          uri = ::Sorted::Set.new(uri.select { |o| whitelist.include?(o[0]) })
+        end
+        sql = parse_order(order)
+        @set = uri + (sql - uri)
       end
 
-      def sql
-        ::Sorted::SQLQuery.parse(order)
+      def parse_sort(sort)
+        case sort.class.name
+        when 'String'
+          ::Sorted::URIQuery.parse(sort)
+        when 'Array'
+          parse(sort)
+        else
+          raise ParseError, "could not parse sort - #{sort}"
+        end
       end
 
-      def set
-        uri + (sql - uri)
+      def parse_order(order)
+        case order.class.name
+        when 'String'
+          ::Sorted::SQLQuery.parse(order)
+        when 'Array'
+          parse(order)
+        else
+          raise ParseError, "could not parse sort - #{order}"
+        end
       end
 
-      def to_s
-        ::Sorted::SQLQuery.encode(set, quoter)
+      def parse(values)
+        values.inject(Sorted::Set.new) do |memo, value|
+          case value.class.name
+          when 'Hash'
+            memo = memo + parse(value.to_a)
+          when 'String'
+            memo = memo + ::Sorted::SQLQuery.parse(value)
+          when 'Symbol'
+            memo = memo << [value.to_s, 'asc']
+          when 'Array'
+            memo = memo << [value[0].to_s, value[1].to_s]
+          else
+            raise ParseError, "could not parse - #{value}"
+          end
+          memo
+        end
       end
     end
   end

data/lib/sorted/activerecord/helper.rb

@@ -7,16 +7,19 @@ module Sorted
     module Helper
       extend ActiveSupport::Concern
       included do
-        def self.sorted(sort, order = nil)
-          quote = ->(frag) { connection.quote_column_name(frag) }
-          builder = ::Sorted::ActiveRecord::Builder.new(sort, order, quote)
-          order(builder.to_s)
+
+        def self.sorted(sort: [], order: [], whitelist: [])
+          builder = ::Sorted::ActiveRecord::Builder.new(sort: sort,
+                                                        order: order,
+                                                        whitelist: whitelist)
+          order(builder.set.to_hash)
         end
 
-        def self.resorted(sort, order = nil)
-          quote = ->(frag) { connection.quote_column_name(frag) }
-          builder = ::Sorted::ActiveRecord::Builder.new(sort, order, quote)
-          reorder(builder.to_s)
+        def self.resorted(sort: [], order: [], whitelist: [])
+          builder = ::Sorted::ActiveRecord::Builder.new(sort: sort,
+                                                        order: order,
+                                                        whitelist: whitelist)
+          reorder(builder.set.to_hash)
         end
       end
     end

data/lib/sorted/activerecord/version.rb

@@ -1,5 +1,5 @@
 module Sorted
   module Activerecord
-    VERSION = '0.0.1'
+    VERSION = '0.1.0'
   end
 end

data/sorted-activerecord.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'railties', '>= 4.0.0'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'guard-rspec'
   # spec.add_development_dependency 'activerecord-jdbcsqlite3-adapter'
   spec.add_development_dependency 'sqlite3', '>= 1.3.5'
 end

data/spec/sorted/activerecord_spec.rb

@@ -15,19 +15,69 @@ describe Sorted::ActiveRecord do
     scope :page, -> { limit(50) }
   end
 
+  let(:subject) { SortedActiveRecordTest }
+
   it 'should integrate with ActiveRecord::Base' do
-    expect(SortedActiveRecordTest.respond_to?(:sorted)).to eq(true)
-    expect(SortedActiveRecordTest.respond_to?(:resorted)).to eq(true)
+    expect(subject.respond_to?(:sorted)).to eq(true)
+    expect(subject.respond_to?(:resorted)).to eq(true)
+  end
+
+  it 'should allow symbols and strings order' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."created_at" ASC'
+    expect(subject.sorted(order: [:created_at]).to_sql).to match(order_by)
+    expect(subject.sorted(order: ['created_at']).to_sql).to match(order_by)
+  end
+
+  it 'should allow symbols and strings as sort' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."created_at" ASC'
+    expect(subject.sorted(sort: [:created_at]).to_sql).to match(order_by)
+    expect(subject.sorted(sort: ['created_at']).to_sql).to match(order_by)
+  end
+
+  it 'should allow hash as order' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(order: [{ created_at: :desc }]).to_sql).to match(order_by)
+  end
+
+  it 'should allow hash as sort' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(sort: [{ created_at: :desc }]).to_sql).to match(order_by)
+  end
+
+  it 'should allow symbols and hash as order' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."orders_count" ASC, "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(order: [:orders_count, { created_at: :desc }]).to_sql).to match(order_by)
+  end
+
+  it 'should allow sql' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."orders_count" ASC, "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(order: 'orders_count ASC, created_at DESC').to_sql).to match(order_by)
+  end
+
+  it 'should allow uri' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."orders_count" ASC, "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(sort: 'orders_count_asc!created_at_desc').to_sql).to match(order_by)
+  end
+
+  it 'should allow an array of sql' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."orders_count" ASC, "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(order: ['orders_count ASC', 'created_at DESC']).to_sql).to match(order_by)
   end
 
   it 'should play nice with other scopes' do
-    sql = "SELECT  \"sorted_active_record_tests\".* FROM \"sorted_active_record_tests\" WHERE \"sorted_active_record_tests\".\"name\" = 'bob'  ORDER BY \"name\" ASC LIMIT 50"
-    expect(SortedActiveRecordTest.where(name: 'bob').page.sorted(nil, 'name ASC').to_sql).to eq(sql)
-    expect(SortedActiveRecordTest.page.sorted(nil, 'name ASC').where(name: 'bob').to_sql).to eq(sql)
+    sql = "SELECT  \"sorted_active_record_tests\".* FROM \"sorted_active_record_tests\" WHERE \"sorted_active_record_tests\".\"name\" = 'bob'  ORDER BY \"sorted_active_record_tests\".\"name\" ASC LIMIT 50"
+    expect(subject.where(name: 'bob').page.sorted(order: 'name ASC').to_sql).to eq(sql)
+    expect(subject.page.sorted(order: 'name ASC').where(name: 'bob').to_sql).to eq(sql)
   end
 
   it 'should override the provided order' do
-    sql = "SELECT  \"sorted_active_record_tests\".* FROM \"sorted_active_record_tests\" WHERE \"sorted_active_record_tests\".\"name\" = 'bob'  ORDER BY \"name\" ASC LIMIT 50"
-    expect(SortedActiveRecordTest.page.where(name: 'bob').order(:id).sorted(nil, 'name DESC').resorted(nil, 'name ASC').to_sql).to eq(sql)
+    sql = "SELECT  \"sorted_active_record_tests\".* FROM \"sorted_active_record_tests\" WHERE \"sorted_active_record_tests\".\"name\" = 'bob'  ORDER BY \"sorted_active_record_tests\".\"name\" ASC LIMIT 50"
+    expect(subject.page.where(name: 'bob').order(:id).sorted(order: 'name DESC').resorted(order: 'name ASC').to_sql).to eq(sql)
+  end
+
+  it 'should work with whitelist' do
+    order_by = 'ORDER BY "sorted_active_record_tests"."created_at" DESC'
+    expect(subject.sorted(sort: 'orders_count_asc!created_at_desc',
+                          whitelist: %(created_at)).to_sql).to match(order_by)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorted-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Rufus Post
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-31 00:00:00.000000000 Z
+date: 2015-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-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
@@ -144,8 +158,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile