acts_as_select 0.0.3 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e114efe5884981553cae5f2216196f593c83ebfb
+  data.tar.gz: 4614fd67e72e492b3e3bec4427a82cdfebd02fe7
+SHA512:
+  metadata.gz: 6c5688553ed5ce7bdee580b0246ebc0e304f022029663497519cf728208bc2c06e3963084beec32bc2af7f33868cfb2de49c4a43cd55bad6b735eb0c78c37fcc
+  data.tar.gz: c5c5a99e8a1a59a2241eee8d3f810473a8dbee979f6c9e3ff899a69bbc546422b6a5c85a6087b3b7cf3f12a6ee09e8be8c86eaec747f937eae2f7a82cea6d565

data/README.md

@@ -1,7 +1,14 @@
 # ActsAsSelect
 
-acts_as_select creates a select style for each column in the database (except the primary key) and returns a 2d array
-in a form suitable for use in a selection drop down (hence the name)
+Acts_as_select allows you to automatically use the columns from an activerecord reference table with a
+descriptive name and primary key ids
+
+It generates <column_name>_select methods for each permitted column, which maps that column and its primary
+key to a 2d array suitable for use in an option_select or as a container for options_for_select.
+
+Additionally, it can generate a list of items using <column_name>_list methods.
+
+All of these options can be used to terminate scopes or other database methods.
 
 ## Installation
 
@@ -18,18 +25,62 @@ Or install it yourself as:
     $ gem install acts_as_select
 
 ## Usage
+Include acts_as_select in your model file.
+
+    class Person < ActiveRecord::Base
+      acts_as_select
+    end
+
+This makes all columns database accessible. You can return selectable options by calling <column_name>_select, or
+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:
+
+    :include => [column_list]
+
+This specifies which columns have _select and _list methods created for them. All other columns are excluded
+Note: if you include a column name that doesn't exist, it will raise a NoMethodError exception when you try to use it.
+
+    :exclude => [column_list]
+
+This specifies which columns are excluded from having the _select and _list methods created.
+
+    :include => [column_list_1], :exclude => [column_list_2]
+
+When both options are supplied, the exclusion happens after the inclusion. That is, if there are overlapping column
+names in both lists, these columns are excluded, regardless of the order of the options.
+
+### Example
+
+With this database table
+
+    | id | name |      email      |
+    |----|------|-----------------|
+    | 1  | Bob  | bob@example.com |
+    | 2  | Jen  | jen@example.com |
+
+And this model
+
+    class Person < ActiveRecord::Base
+      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]]
+    Person.email_select
+    #=> [["bob@example.com", 1], ["jen@example.com", 2]]
 
-Include acts_as_select in your model file. This makes all columns accessible by calling select_<column_name>
+This is the right format for use in a select tag and friends
 
-Example:
-  class Dummy < ActiveRecord::Base
-  acts_as_select
-  end
+    select :order, :customer, Person.name_select
 
-If dummy had a name and description defined in the database, this would create
-the methods: select_description, select_name
+You can combine it with scopes
 
-These can then be used anywhere you need a select.
+    Person.where(...).name_select
 
 ## Contributing
 

data/Rakefile

@@ -1 +1,12 @@
-require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run all tests.'
+task :default=>:test
+
+desc 'Test acts_as_select plugin'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end

data/acts_as_select.gemspec

@@ -1,14 +1,15 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
+require File.dirname(__FILE__) + '/lib/active_record/acts/select'
+
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'acts_as_select/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'acts_as_select'
-  spec.version       = ActsAsSelect::VERSION
+  spec.version       = ActiveRecord::Acts::Select::VERSION
   spec.authors       = ['Paul McKibbin']
   spec.email         = ['pmckibbin@gmail.com']
-  spec.description   = %q{Creation of automatic selection suitable for drop downs from all column fields in an ActiveRecord table}
+  spec.description   = %q{Creation of automatic selection suitable for drop downs from column fields in an ActiveRecord table}
   spec.summary       = %q{Automated selection for Activerecord Tables}
   spec.homepage      = 'http://blackrat.org'
   spec.license       = 'MIT'
@@ -20,4 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'test-unit'
+  spec.add_development_dependency 'activerecord'
 end

data/init.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/lib/active_record/acts/select.rb'
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Select

data/lib/active_record/acts/select.rb

@@ -0,0 +1,57 @@
+module ActiveRecord
+  module Acts
+    module Select
+      VERSION="0.1.0"
+      class << self
+        def included(base)
+          base.instance_eval do
+            extend ClassMethods
+          end
+        end
+      end
+
+      #Acts_as_select allows you to automatically use the columns from an activerecord reference table with a
+      #descriptive name and primary key ids
+      #It generates XXXX_select method for each permitted column, which maps that column and its primary key
+      #to an array suitable for use in an option_select or as a container for options_for_select.
+
+      module ClassMethods
+        private
+        def default_opts
+          {
+            :include=>column_names,
+            :exclude=>[]
+          }
+        end
+
+        def allowed_columns(*opts)
+          opts=!opts.empty? && opts.first.is_a?(Hash) ? default_opts.merge(opts.first) : default_opts
+          opts[:include]=[opts[:include]] if opts[:include].is_a?(String)
+          opts[:exclude]=[opts[:exclude]] if opts[:exclude].is_a?(String)
+          column_names & (opts[:include]-opts[:exclude])
+        end
+
+        public
+        def acts_as_select(*opts)
+          allowed_columns(*opts).each do |field|
+            (class << self;self;end).class_eval do
+              define_method "#{field}_select" do
+                if respond_to?(:scoped)
+                  scoped(:select=>["#{field}, #{primary_key}"])
+                else
+                  select(field,primary_key)
+                end.map{|x| [x.send(field),x.send(primary_key)]}
+              end
+              define_method "#{field}_list" do
+                (respond_to?(:scoped) ? scoped(:select=>[field]) : select(field)).map{|x| x.send(field)}
+              end
+              define_method "#{field}_objects" do
+                respond_to?(:scoped) ? scoped(:select=>[field]) : select(field)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/select_test.rb

@@ -0,0 +1,186 @@
+require 'rubygems'
+if RUBY_VERSION >= '1.9'
+  require 'minitest/autorun'
+  require 'active_record'
+else
+  require 'test/unit'
+  require 'activerecord'
+  require 'sqlite3'
+end
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+def setup_db
+  ActiveRecord::Base.logger
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :selections do |t|
+      t.column :type, :string
+      t.column :name, :string
+      t.column :description, :string
+      t.column :excluded_string, :string
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Selection < ActiveRecord::Base;
+end
+class SelectAll < Selection;
+end
+class SelectIncludeSingle < Selection;
+end
+class SelectIncludeMulti < Selection;
+end
+class SelectExcludeSingle < Selection;
+end
+class SelectExcludeMulti < Selection;
+end
+class SelectedIncludeExclude < Selection;
+end
+
+class SelectTest < (begin MiniTest::Test rescue Test::Unit::TestCase end)
+  def setup
+    setup_db
+    [SelectAll, SelectIncludeSingle, SelectIncludeMulti, SelectExcludeSingle, SelectExcludeMulti, SelectedIncludeExclude].each do |klass|
+      klass.create! :name => 'first',  :description => 'First field',  :excluded_string => 'not allowed'
+      klass.create! :name => 'second', :description => 'Second field', :excluded_string => 'not allowed'
+      klass.create! :name => 'third',  :description => 'Third field',  :excluded_string => 'not allowed'
+      klass.create! :name => 'forth',  :description => 'Forth field',  :excluded_string => 'not allowed'
+      klass.create! :name => 'fifth',  :description => 'Fifth field',  :excluded_string => 'not allowed'
+      klass.create! :name => 'sixth',  :description => 'Sixth field',  :excluded_string => 'not allowed'
+    end
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  def selection_ids
+    [
+      [1, 1],
+      [2, 2],
+      [3, 3],
+      [4, 4],
+      [5, 5],
+      [6, 6]
+    ]
+  end
+
+  def selection_names
+    [
+      ['first', 1],
+      ['second', 2],
+      ['third', 3],
+      ['forth', 4],
+      ['fifth', 5],
+      ['sixth', 6]
+    ]
+  end
+
+  def selection_descriptions
+    [
+      ['First field', 1],
+      ['Second field', 2],
+      ['Third field', 3],
+      ['Forth field', 4],
+      ['Fifth field', 5],
+      ['Sixth field', 6]
+    ]
+  end
+
+  def selection_excluded_strings
+    [
+      ['not allowed', 1],
+      ['not allowed', 2],
+      ['not allowed', 3],
+      ['not allowed', 4],
+      ['not allowed', 5],
+      ['not allowed', 6]
+    ]
+  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))
+  end
+
+  def test_incorrect_inclusion
+    Selection.acts_as_select :include => ['wibble']
+    assert_raises(NoMethodError) { Selection.wibble_select }
+  end
+
+  def test_single_field_selection
+    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_raises(NoMethodError) { SelectIncludeSingle.description_select }
+    assert_raises(NoMethodError) { SelectIncludeSingle.description_list }
+    assert_raises(NoMethodError) { SelectIncludeSingle.excluded_string_select }
+    assert_raises(NoMethodError) { SelectIncludeSingle.excluded_string_list }
+  end
+
+  def test_multi_field_selection
+    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_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_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_raises(NoMethodError) { SelectExcludeMulti.description_select }
+    assert_raises(NoMethodError) { SelectExcludeMulti.description_list }
+    assert_raises(NoMethodError) { SelectExcludeMulti.excluded_string_select }
+    assert_raises(NoMethodError) { SelectExcludeMulti.excluded_string_list }
+  end
+
+  def test_include_exclude
+    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_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
+end
+

metadata

@@ -1,102 +1,125 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: acts_as_select
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.1.0
 platform: ruby
-authors: 
+authors:
 - Paul McKibbin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2014-12-16 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2015-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bundler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 1
-        - 3
-        version: "1.3"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: Creation of automatic selection suitable for drop downs from all column fields in an ActiveRecord table
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Creation of automatic selection suitable for drop downs from column fields
+  in an ActiveRecord table
+email:
 - pmckibbin@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - acts_as_select.gemspec
-- lib/acts_as_select.rb
-- lib/acts_as_select/selection.rb
-- lib/acts_as_select/version.rb
+- init.rb
+- lib/active_record/acts/select.rb
+- test/select_test.rb
 homepage: http://blackrat.org
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Automated selection for Activerecord Tables
-test_files: []
-
+test_files:
+- test/select_test.rb

data/lib/acts_as_select.rb

@@ -1,6 +0,0 @@
-require 'acts_as_select/version'
-require 'acts_as_select/selection'
-
-class ActiveRecord::Base
-  extend ActsAsSelect
-end

data/lib/acts_as_select/selection.rb

@@ -1,28 +0,0 @@
-module ActsAsSelect
-  def acts_as_select
-    column_names.each do |field|
-      class_eval %Q(
-                    if case Rails::VERSION_MAJOR < 3
-                      named_scope :select_#{field}_objects, lambda {{:select => "#{field}, \#{primary_key}"}}
-                    else
-                      scope :select_#{field}_objects, lambda { select("#{field}, \#{primary_key}") }
-                    end
-
-                    class << self
-                      def #{field}_select
-                        select_#{field}_objects.map{|x| [x.#{field}, x.send(x.class.primary_key)]}
-                      end
-
-                      def #{field}_list
-                        select_#{field}_objects.map(&:#{field})
-                      end
-
-                      def #{field}_objects
-                        select_#{field}_objects.map(&:#{field})
-                      end
-
-                    end
-                  )
-    end
-  end
-end

data/lib/acts_as_select/version.rb

@@ -1,3 +0,0 @@
-module ActsAsSelect
-  VERSION = "0.0.3"
-end