acts_as_select 0.1.4 → 0.1.5

data/README.md

@@ -35,7 +35,7 @@ This makes all columns database accessible. You can return selectable options by
 obtain a list of the contents of a column by calling <column_name>_list
 
 ### Options
-acts_as_select takes two options to allow for finer grained control over which methods are created:
+acts_as_select takes two options to allow for finer grained control over which methods are created and allows for scoping to restrict or change order.
 
     :include => [column_list]
 
@@ -55,32 +55,41 @@ names in both lists, these columns are excluded, regardless of the order of the
 
 With this database table
 
-    | id | name |      email      |
-    |----|------|-----------------|
-    | 1  | Bob  | bob@example.com |
-    | 2  | Jen  | jen@example.com |
+    | id | name |       email      |
+    |----|------|------------------|
+    | 1  | Bob  | bob@example.com  |
+    | 2  | Jen  | jen@example.com  |
+    | 3 | april | sheri@example.com|
 
 And this model
 
     class Person < ActiveRecord::Base
-      acts_as_select :include=>['name', 'email'], :exclude=>['id']
+      acts_as_select :include=>['name', 'email'], :exclude=>'id'
     end
 
 This would create two select methods, `name_select` and `email_select`,
 and three list methods `name_list` and `email_list`
 
     Person.name_select
-    #=> [["Bob", 1], ["Jen", 2]]
+    #=> [["Bob", 1], ["Jen", 2], ["april", 3]]
     Person.email_select
-    #=> [["bob@example.com", 1], ["jen@example.com", 2]]
+    #=> [["bob@example.com", 1], ["jen@example.com", 2], ["april@example.com",3]]
 
 This is the right format for use in a select tag and friends
 
     select :order, :customer, Person.name_select
 
-You can combine it with scopes
+If you want to change the sorting of the table, based on a non-chosen field (for example), you can use
+arel_scopes to do so. The same `email_select` and `email_list` can have their contents sorted by the 
+lowercase corrected name (for example)
 
-    Person.where(...).name_select
+    Person.order('lower(name) asc').email_select
+    #=> [["sheri@example.com", 3], ["bob@example.com", 1], ["jen@example.com", 2]]
+
+You can combine it with any other named_scopes, but as it maps to an array for use
+in a select dropdown, it will need to be the last method on the chain.
+
+    Person.where(...).group(...).order(...).name_select
 
 ## Contributing
 

data/acts_as_select.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'sqlite3'
   if RUBY_VERSION >= '1.9'
     spec.add_development_dependency 'minitest'
-    spec.add_development_dependency 'active_record'
+    spec.add_development_dependency 'activerecord'
   else
     spec.add_development_dependency 'test-unit'
     spec.add_development_dependency 'activerecord'

data/lib/active_record/acts/select.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Acts
     module Select
-      VERSION="0.1.4"
+      VERSION="0.1.5"
       class << self
         def included(base)
           base.instance_eval do

data/test/select_test.rb

@@ -1,14 +1,16 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
 require 'rubygems'
 if RUBY_VERSION >= '1.9'
+  gem 'minitest'
   require 'minitest/autorun'
   require 'active_record'
+  require_relative(File.dirname(__FILE__) + '/../lib/acts_as_select')
 else
   require 'test/unit'
   require 'activerecord'
   require 'sqlite3'
+  require File.dirname(__FILE__) + '/../acts_as_select'
 end
-$:.unshift File.dirname(__FILE__) + '/../lib'
-require File.dirname(__FILE__) + '/../acts_as_select'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
@@ -84,6 +86,18 @@ class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
     ]
   end
 
+  def selection_names_sorted
+    [
+        ['fifth', 5],
+        ['first', 1],
+        ['forth', 4],
+        ['second', 2],
+        ['sixth', 6],
+        ['third', 3]
+    ]
+  end
+
+
   def selection_descriptions
     [
       ['First field', 1],
@@ -108,14 +122,14 @@ class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
 
   def test_all_names_selection
     SelectAll.acts_as_select
-    assert_equal(SelectAll.id_select, selection_ids)
-    assert_equal(SelectAll.id_list, selection_ids.map(&:first))
-    assert_equal(SelectAll.name_select, selection_names)
-    assert_equal(SelectAll.name_list, selection_names.map(&:first))
-    assert_equal(SelectAll.description_select, selection_descriptions)
-    assert_equal(SelectAll.description_list, selection_descriptions.map(&:first))
-    assert_equal(SelectAll.excluded_string_select, selection_excluded_strings)
-    assert_equal(SelectAll.excluded_string_list, selection_excluded_strings.map(&:first))
+    assert_equal(selection_ids,SelectAll.id_select)
+    assert_equal(selection_ids.map(&:first),SelectAll.id_list)
+    assert_equal(selection_names,SelectAll.name_select)
+    assert_equal(selection_names.map(&:first),SelectAll.name_list)
+    assert_equal(selection_descriptions,SelectAll.description_select)
+    assert_equal(selection_descriptions.map(&:first),SelectAll.description_list)
+    assert_equal(selection_excluded_strings,SelectAll.excluded_string_select)
+    assert_equal(selection_excluded_strings.map(&:first),SelectAll.excluded_string_list)
   end
 
   def test_incorrect_inclusion
@@ -127,8 +141,8 @@ class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
     SelectIncludeSingle.acts_as_select :include => 'name'
     assert_raises(NoMethodError) { SelectIncludeSingle.id_select }
     assert_raises(NoMethodError) { SelectIncludeSingle.id_list }
-    assert_equal(SelectIncludeSingle.name_select, selection_names.map { |x| [x[0], x[1]+6] })
-    assert_equal(SelectIncludeSingle.name_list, selection_names.map(&:first))
+    assert_equal(selection_names.map { |x| [x[0], x[1]+6] },SelectIncludeSingle.name_select)
+    assert_equal(selection_names.map(&:first),SelectIncludeSingle.name_list)
     assert_raises(NoMethodError) { SelectIncludeSingle.description_select }
     assert_raises(NoMethodError) { SelectIncludeSingle.description_list }
     assert_raises(NoMethodError) { SelectIncludeSingle.excluded_string_select }
@@ -139,32 +153,32 @@ class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
     SelectIncludeMulti.acts_as_select :include => %w(name description)
     assert_raises(NoMethodError) { SelectIncludeMulti.id_select }
     assert_raises(NoMethodError) { SelectIncludeMulti.id_list }
-    assert_equal(SelectIncludeMulti.name_select, selection_names.map { |x| [x[0], x[1]+12] })
-    assert_equal(SelectIncludeMulti.name_list, selection_names.map(&:first))
-    assert_equal(SelectIncludeMulti.description_select, selection_descriptions.map { |x| [x[0], x[1]+12] })
-    assert_equal(SelectIncludeMulti.description_list, selection_descriptions.map(&:first))
+    assert_equal(selection_names.map { |x| [x[0], x[1]+12] },SelectIncludeMulti.name_select)
+    assert_equal(selection_names.map(&:first), SelectIncludeMulti.name_list)
+    assert_equal(selection_descriptions.map { |x| [x[0], x[1]+12] },SelectIncludeMulti.description_select)
+    assert_equal(selection_descriptions.map(&:first),SelectIncludeMulti.description_list)
     assert_raises(NoMethodError) { SelectIncludeMulti.excluded_string_select }
     assert_raises(NoMethodError) { SelectIncludeMulti.excluded_string_list }
   end
 
   def test_single_field_exclusion
     SelectExcludeSingle.acts_as_select :exclude => 'excluded_string'
-    assert_equal(SelectExcludeSingle.id_select, selection_ids.map { |x| [x[0]+18, x[1]+18] })
-    assert_equal(SelectExcludeSingle.id_list, selection_ids.map { |x| x[0]+18 })
-    assert_equal(SelectExcludeSingle.name_select, selection_names.map { |x| [x[0], x[1]+18] })
-    assert_equal(SelectExcludeSingle.name_list, selection_names.map(&:first))
-    assert_equal(SelectExcludeSingle.description_select, selection_descriptions.map { |x| [x[0], x[1]+18] })
-    assert_equal(SelectExcludeSingle.description_list, selection_descriptions.map(&:first))
+    assert_equal(selection_ids.map { |x| [x[0]+18, x[1]+18] },SelectExcludeSingle.id_select)
+    assert_equal(selection_ids.map { |x| x[0]+18 },SelectExcludeSingle.id_list)
+    assert_equal(selection_names.map { |x| [x[0], x[1]+18] },SelectExcludeSingle.name_select)
+    assert_equal(selection_names.map(&:first),SelectExcludeSingle.name_list)
+    assert_equal(selection_descriptions.map { |x| [x[0], x[1]+18] },SelectExcludeSingle.description_select)
+    assert_equal(selection_descriptions.map(&:first),SelectExcludeSingle.description_list)
     assert_raises(NoMethodError) { SelectExcludeSingle.excluded_string_select }
     assert_raises(NoMethodError) { SelectExcludeSingle.excluded_string_list }
   end
 
   def test_multi_field_exclusion
     SelectExcludeMulti.acts_as_select :exclude => %w(description excluded_string)
-    assert_equal(SelectExcludeMulti.id_select, selection_ids.map { |x| [x[0]+24, x[1]+24] })
-    assert_equal(SelectExcludeMulti.id_list, selection_ids.map { |x| x[0]+24 })
-    assert_equal(SelectExcludeMulti.name_select, selection_names.map { |x| [x[0], x[1]+24] })
-    assert_equal(SelectExcludeMulti.name_list, selection_names.map(&:first))
+    assert_equal(selection_ids.map { |x| [x[0]+24, x[1]+24] },SelectExcludeMulti.id_select)
+    assert_equal(selection_ids.map { |x| x[0]+24 },SelectExcludeMulti.id_list)
+    assert_equal(selection_names.map { |x| [x[0], x[1]+24] },SelectExcludeMulti.name_select)
+    assert_equal(selection_names.map(&:first),SelectExcludeMulti.name_list)
     assert_raises(NoMethodError) { SelectExcludeMulti.description_select }
     assert_raises(NoMethodError) { SelectExcludeMulti.description_list }
     assert_raises(NoMethodError) { SelectExcludeMulti.excluded_string_select }
@@ -175,12 +189,18 @@ class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
     SelectedIncludeExclude.acts_as_select :include => %w(name description), :exclude => %w(description excluded_string)
     assert_raises(NoMethodError) { SelectedIncludeExclude.id_select }
     assert_raises(NoMethodError) { SelectedIncludeExclude.id_list }
-    assert_equal(SelectedIncludeExclude.name_select, selection_names.map { |x| [x[0], x[1]+30] })
-    assert_equal(SelectedIncludeExclude.name_list, selection_names.map(&:first))
+    assert_equal(selection_names.map { |x| [x[0], x[1]+30] },SelectedIncludeExclude.name_select)
+    assert_equal(selection_names.map(&:first),SelectedIncludeExclude.name_list)
     assert_raises(NoMethodError) { SelectedIncludeExclude.description_select }
     assert_raises(NoMethodError) { SelectedIncludeExclude.description_list }
     assert_raises(NoMethodError) { SelectedIncludeExclude.excluded_string_select }
     assert_raises(NoMethodError) { SelectedIncludeExclude.excluded_string_list }
   end
+
+  def test_sorted_fields
+    SelectIncludeSingle.acts_as_select :include => 'name'
+    assert_equal(selection_names_sorted.map { |x| [x[0], x[1]+6] },SelectIncludeSingle.order('name asc').name_select)
+    assert_equal(selection_names_sorted.map(&:first), SelectIncludeSingle.order('name asc').name_list)
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_select
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -76,7 +76,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: active_record
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements: