acts_as_enumeration 0.1.5 → 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f270cfec29a0cc1ce4a81e0e9924325b89e161c0
+  data.tar.gz: 9c1f15ed0a3f1d516a9f3a899acd551ff2168e05
+SHA512:
+  metadata.gz: 2a40b0eeaa87e6112dacb74e21676f664868edfa575a97bbb54e3dd17b046e07acec5080125869a02df7b9885ee4b6b7db4cd1e5b8596e493a5f72d2715c8fc0
+  data.tar.gz: 1a5b9951d26819bde4f60b61619c86c8fa41c46d6cbe190310b330195eb552ab5471c3cb0ace644acac9f443abc3eeb5769cfb5a6ae23e08010a052ff18c49c8

data/lib/active_record/acts/enumeration.rb

@@ -1,96 +1,78 @@
 module ActiveRecord
   module Acts
     module Enumeration
-      VERSION='0.1.5'
+
+      VERSION="0.1.6"
       class << self
+
         def included(base)
-          base.class_eval do
+          base.instance_eval do
             extend ClassMethods
           end
         end
       end
 
-      def method_missing(method_id, *args, &block)
-        method_name=method_id.to_s
-        if match_data=method_name.match(/^(is(?:_not)*)(\?|_(\w*)\?)/)
-          method=match_data[1] << "?"
-          new_args= ((match_data[2]=='?') ? args : match_data[3].split(/_or_/).map { |x| x.intern })
-          respond_to?(method) ? send(method, *new_args, &block) : false
-        else
-          super
+      module ClassMethods
+        private
+        def portable_select(*args)
+          respond_to?(:scoped) ? scoped(:select => ["#{args.join(',')}"]) : select(*args)
         end
-      end
 
+        def normalize(string)
+          string.to_s.gsub(/[\\W]+/, ' ').strip.gsub(/\s+/, '_').underscore
+        end
 
-      module ClassMethods
-        def normalize(field)
-          field.to_s.gsub(/[\\W]+/, ' ').strip.gsub(/\s+/, '_').underscore
+        public
+        def normalize_intern(string)
+          normalize(string).intern
         end
 
-        def acts_as_enumeration(*opts)
-          opts.each do |field|
-            klass=self
+        def acts_as_enumeration(*args)
+          class << self;
+            attr_accessor :enumeration;
+          end
+          self.enumeration||=HashWithIndifferentAccess.new
+          args.each do |field|
+            self.enumeration[field]=HashWithIndifferentAccess[
+              *portable_select(field, primary_key).map do |x|
+                [normalize_intern(x.send(field)), x.send(x.class.primary_key)]
+              end.flatten
+            ]
             (
-            class<<self;
+            class << self;
               self;
             end).class_eval do
-              define_method "enum_#{field}" do
-                instance_variable_get("@enum_#{field}") || instance_variable_set("@enum_#{field}", HashWithIndifferentAccess[*klass.all.map { |x| [x.send(field).gsub(/[\\W]+/, ' ').strip.gsub(/\s+/, '_').underscore, x.send(x.class.primary_key)] }.flatten])
-              end
-
-              define_method :as_key do |value|
-                return '' unless exists?(value)
-                klass.find(value).as_key
-              end
-
-              alias_method :as_symbol, :as_key
-
-              define_method "valid_#{field}?" do |value|
-                send("enum_#{field}").has_key?(value)
-              end
-
-              define_method "id_for_#{field}" do |value|
-                send("enum_#{field}")[value]
-              end
-
-              define_method "for_#{field}" do |value|
-                klass.find(send("id_for_#{field}", value))
-              end
-            end
-
-            define_method 'is?' do |*types|
-              types.any? { |x| send(self.class.primary_key)==self.class.send("enum_#{field}")[x] }
-            end
-
-            define_method 'is_not?' do |*types|
-              !is?(*types)
-            end
-
-            define_method :as_key do
-              self.class.normalize(send(field)).intern
+              define_method(:enumerations) { |name| self.enumeration[name] }
+              define_method("#{field}_valid?") { |value| !!send("id_for_#{field}", value) }
+              alias_method "valid_#{field}?", "#{field}_valid?"
+              define_method("id_for_#{field}") { |value| enumerations(field)[value] }
+              define_method("for_#{field}") { |value| find(send("id_for_#{field}", value)) }
+              define_method("enum_#{field}") { enumerations(field) }
+              define_method("as_key") { |value| find(value).as_key rescue nil }
             end
 
-            alias_method :as_symbol, :as_key
-
-            all.map { |x| normalize(x.send(field)) }.each do |y|
-
-              define_method "is_#{y}?" do
-                is?("#{y}")
-              end
-
-              identifier = y.to_s=~/^[a-z_]/ ? y.to_s : "_#{y.to_s}"
-
-              define_method "#{identifier}?" do
-                is?("#{y}")
+            define_method(:is?) { |*types| types.any? { |x| self==(self.class.send(x) rescue nil) } }
+            define_method(:is_not?) { |*types| !is?(*types) }
+            define_method(:method_missing) do |method_id, *args, &block|
+              method_name=method_id.to_s
+              if match_data=method_name.match(/^(is[_not]*)(\?|_(\w*)\?)/)
+                method  =match_data[1] << "?"
+                new_args= (match_data[2]=='?') ? args : match_data[3].split(/_or_/)
+                respond_to?(method) ? send(method, *new_args, &block) : false
+              else
+                super method_id, *args, &block
               end
+            end
 
-              (
+            portable_select(field).map { |x| normalize_intern(x.send(field)) }.each do |y|
+              key = y.to_s=~/^[a-z_]/ ? y.to_s : "_#{y.to_s}"
+              define_method(:as_key) { self.class.normalize_intern(send(field)) }
+              define_method("is_#{y}?") { is?(y) }
+              alias_method "#{key}?", "is_#{y}?"
               class << self;
                 self;
-              end).class_eval do
-                define_method identifier do
-                  self.send("for_#{field}", y)
-                end
+              end.instance_eval do
+                define_method(key) { self.send("for_#{field}", y) }
               end
             end
           end

data/lib/acts_as_enumeration.rb

@@ -1,2 +1,2 @@
-require_relative File.join('active_record', 'acts', 'enumeration.rb')
+require (File.join(File.dirname(__FILE__), 'active_record', 'acts', 'enumeration.rb'))
 ActiveRecord::Base.send :include, ActiveRecord::Acts::Enumeration

data/test/enumeration_test.rb

@@ -8,7 +8,7 @@ else
   require 'sqlite3'
 end
 $:.unshift File.dirname(__FILE__) + '/../lib'
-require File.dirname(__FILE__) + '/../acts_as_enumeration'
+require 'acts_as_enumeration'
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
 
@@ -33,6 +33,8 @@ class Enumerate < ActiveRecord::Base;
 end
 class EnumerateAll < Enumerate;
 end
+class EnumerateSome < Enumerate;
+end
 
 class EnumerateTest < (
 begin
@@ -44,11 +46,14 @@ end)
       klass.create! :name => 'first', :description => 'First field'
       klass.create! :name => 'second', :description => 'Second field'
       klass.create! :name => 'third', :description => 'Third field'
+    end
+    [EnumerateSome].each do |klass|
       klass.create! :name => 'forth', :description => 'Forth field'
       klass.create! :name => 'fifth', :description => 'Fifth field'
       klass.create! :name => 'sixth', :description => 'Sixth field'
     end
-    Enumerate.acts_as_enumeration :description
+    EnumerateAll.acts_as_enumeration :description
+    EnumerateSome.acts_as_enumeration :description
   end
 
   def teardown
@@ -56,25 +61,47 @@ end)
   end
 
   def test_basics
-    assert Enumerate.first.is?(:first_field)
     assert Enumerate.first.is?('first_field')
+    assert Enumerate.first.is?(:first_field)
     assert Enumerate.first.is_not?(:second_field)
     assert Enumerate.first.is?(:first_field, :second_field)
     assert Enumerate.first.is_not?(:second_field, :third_field)
     assert Enumerate.first.is_first_field?
     assert Enumerate.first.is_not_second_field?
     assert Enumerate.first.is_first_field_or_second_field?
-    assert Enumerate.second_field.is_first_field_or_second_field?
-    assert Enumerate.second_field.is_not_first_field?
-    assert Enumerate.first.first_field?
-    assert_equal Enumerate.first, Enumerate.first_field
+    assert EnumerateAll.second_field.is_first_field_or_second_field?
+    assert EnumerateAll.second_field.is_not_first_field?
+    assert EnumerateAll.first.first_field?
+    assert_equal EnumerateAll.first, EnumerateAll.first_field
     assert_equal(:first_field, Enumerate.first.as_key)
-    assert_equal(:first_field, Enumerate.as_key(Enumerate.first.id))
-    assert Enumerate.valid_description?(:first_field)
-    assert Enumerate.valid_description?('first_field')
-    assert !Enumerate.valid_description?(:blah_blah_field)
-    assert !Enumerate.valid_description?('blah_blah_field')
-    assert Enumerate.first.id, Enumerate.id_for_description(:first_field)
+    assert_equal(:first_field, EnumerateAll.as_key(Enumerate.first.id))
+    assert EnumerateAll.valid_description?(:first_field)
+    assert EnumerateAll.valid_description?('first_field')
+    assert !EnumerateAll.valid_description?(:blah_blah_field)
+    assert !EnumerateAll.valid_description?('blah_blah_field')
+    assert Enumerate.first.id, EnumerateAll.id_for_description(:first_field)
+  end
+
+  def test_sti
+    assert EnumerateSome.first.is?('forth_field')
+    assert EnumerateSome.first.is?(:forth_field)
+    assert EnumerateSome.first.is_not?(:second_field)
+    assert EnumerateSome.first.is?(:forth_field, :second_field)
+    assert EnumerateSome.first.is_not?(:second_field, :third_field)
+    assert EnumerateSome.first.is_forth_field?
+    assert EnumerateSome.first.is_not_second_field?
+    assert EnumerateSome.first.is_forth_field_or_second_field?
+    assert EnumerateSome.forth_field.is_forth_field_or_second_field?
+    assert EnumerateSome.forth_field.is_not_fifth_field?
+    assert EnumerateSome.first.forth_field?
+    assert_equal EnumerateSome.first, EnumerateSome.forth_field
+    assert_equal(:forth_field, EnumerateSome.first.as_key)
+    assert_equal(:forth_field, EnumerateSome.as_key(EnumerateSome.first.id))
+    assert EnumerateSome.valid_description?(:forth_field)
+    assert EnumerateSome.valid_description?('forth_field')
+    assert !EnumerateSome.valid_description?(:first_field)
+    assert !EnumerateSome.valid_description?('first_field')
+    assert EnumerateSome.first.id, EnumerateSome.id_for_description(:forth_field)
   end
 end
 

metadata

@@ -1,62 +1,52 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: acts_as_enumeration
-version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 5
-  version: 0.1.5
+version: !ruby/object:Gem::Version
+  version: 0.1.6
 platform: ruby
-authors: 
+authors:
 - Paul McKibbin
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2016-03-18 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2016-04-04 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 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  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 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: Active Record extender to enable the selection of a database column and have all of it's values enumerable
-email: 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Active Record extender to enable the selection of a database column and
+  have all of it's values enumerable
+email:
 - pmckibbin@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README
@@ -68,37 +58,28 @@ files:
 - lib/acts_as_enumeration.rb
 - test/enumeration_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.15
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: enumerable values from database columns
-test_files: 
+test_files:
 - test/enumeration_test.rb