power_enum 0.4.5 → 0.5.0

data/README.md

@@ -88,7 +88,7 @@ If you're using Rails prior to 3.1, your migration file will look something like
       end
       
       def self.down
-        create_enum :booking_status
+        remove_enum :booking_status
       end
     
     end
@@ -124,7 +124,7 @@ Now, when you create your Booking model, your migration should create a referenc
     
 There are two methods added to Rails migrations:
 
-##### `create_enum(enum_name, options = {})`
+##### `create_enum(enum_name, options = {}, &block)`
 
 Creates a new enum table.  `enum_name` will be automatically pluralized.  The following options are supported:
 
@@ -135,6 +135,8 @@ Creates a new enum table.  `enum_name` will be automatically pluralized.  The fo
 - [:active]  Set this to `true` to have a boolean 'active' column generated.  The 'active' column will have the options of NOT NULL and DEFAULT TRUE.
 - [:timestamps]  Set this to `true` to have the timestamp columns (created\_at and updated\_at) generated
 
+You can also pass in a block that takes a table object as an argument, like `create_table`.
+
 Example:
 
     create_enum :booking_status
@@ -165,7 +167,21 @@ is the equivalent of
     end
     add_index :booking_statuses, [:booking_name], :unique => true
 
-Notice that a unique index is automatically created.
+You can also customize the creation process by using a block:
+
+    create_enum :booking_status do |t|
+      t.boolean :first_booking, :null => false
+    end
+
+is the equivalent of
+
+    create_table :booking_statuses do |t|
+      t.string :name, :null => false
+      t.boolean :first_booking, :null => false
+    end
+    add_index :booking_statuses, [:name], :unique => true
+
+Notice that a unique index is automatically created on the specified name column.
 
 ##### `remove_enum(enum_name)`
 
@@ -224,8 +240,20 @@ Each enumeration model gets the following instance methods.
 
 ##### `===(arg)`
 
-`BookingStatus[:foo] === arg` returns true if `BookingStatus[:foo] === BookingStatus[arg]` returns true if arg is Fixnum, String,
-or Symbol.  If arg is an Array, will compare every element of the array and return true if any element return true for `===`.
+Behavior depends on the type of `arg`.
+
+* If `arg` is `nil`, returns `false`.
+* If `arg` is an instance of `Symbol`, `Fixnum` or `String`, returns the result of `BookingStatus[:foo] == BookingStatus[arg]`.
+* If `arg` is an `Array`, returns `true` if any member of the array returns `true` for `===(arg)`, `false` otherwise.
+* In all other cases, delegates to `===(arg)` of the superclass.
+
+Examples:
+
+    BookingStatus[:foo] === :foo #Returns true
+    BookingStatus[:foo] === 'foo' #Returns true
+    BookingStatus[:foo] === :bar #Returns false
+    BookingStatus[:foo] === [:foo, :bar, :baz] #Returns true
+    BookingStatus[:foo] === nil #Returns false
 
 You should note that defining an `:on_lookup_failure` method that raises an exception will cause `===` to also raise an exception for any lookup failure of `BookingStatus[arg]`.
 
@@ -235,6 +263,10 @@ You should note that defining an `:on_lookup_failure` method that raises an exce
 
 Returns true if any element in the list returns true for `===(arg)`, false otherwise.
 
+Example:
+
+    BookingStatus[:foo].in? :foo, :bar, :baz #Returns true
+
 ##### `name`
 
 Returns the 'name' of the enum, i.e. the value in the `:name_column` attribute of the enumeration model.

data/lib/active_record/acts/enumerated.rb

@@ -129,55 +129,85 @@ module ActiveRecord
           @name_column ||= read_inheritable_attribute( :acts_enumerated_name_column )
         end
 
-        private 
-        
-        def all_by_id 
-          return @all_by_id if @all_by_id
-          @all_by_id = all.inject({}) { |memo, item| memo[item.id] = item; memo }.freeze
+        # ---Private methods---
+
+        def all_by_id
+          @all_by_id ||= all_by_attribute( :id )
         end
+        private :all_by_id
         
         def all_by_name
-          return @all_by_name if @all_by_name
           begin
-            @all_by_name = all.inject({}) { |memo, item| memo[item.name] = item; memo }.freeze
+            @all_by_name ||= all_by_attribute( :name )
           rescue NoMethodError => err
             if err.name == name_column
               raise TypeError, "#{self.name}: you need to define a '#{name_column}' column in the table '#{table_name}'"
             end
             raise
           end            
-        end   
+        end
+        private :all_by_name
+
+        def all_by_attribute(attr)
+          all.inject({}) { |memo, item|
+            memo[item.send(attr)] = item
+            memo
+          }.freeze
+        end
+        private :all_by_attribute
         
         def enforce_none(arg)
           nil
         end
+        private :enforce_none
 
         def enforce_strict(arg)
           raise_record_not_found(arg)
         end
+        private :enforce_strict
 
         def enforce_strict_literals(arg)
           raise_record_not_found(arg) if (Fixnum === arg) || (Symbol === arg)
           nil
         end
+        private :enforce_strict_literals
 
         def enforce_strict_ids(arg)
           raise_record_not_found(arg) if Fixnum === arg
           nil
         end
+        private :enforce_strict_ids
 
         def enforce_strict_symbols(arg)
           raise_record_not_found(arg) if Symbol === arg
           nil
         end
+        private :enforce_strict_symbols
 
         def raise_record_not_found(arg)
           raise ActiveRecord::RecordNotFound, "Couldn't find a #{self.name} identified by (#{arg.inspect})"
         end
+        private :raise_record_not_found
         
       end
 
       module InstanceMethods
+        # Behavior depends on the type of +arg+.
+        #
+        # * If +arg+ is +nil+, returns +false+.
+        # * If +arg+ is an instance of +Symbol+, +Fixnum+ or +String+, returns the result of +BookingStatus[:foo] == BookingStatus[arg]+.
+        # * If +arg+ is an +Array+, returns +true+ if any member of the array returns +true+ for +===(arg)+, +false+ otherwise.
+        # * In all other cases, delegates to +===(arg)+ of the superclass.
+        #
+        # Examples:
+        #
+        #     BookingStatus[:foo] === :foo #Returns true
+        #     BookingStatus[:foo] === 'foo' #Returns true
+        #     BookingStatus[:foo] === :bar #Returns false
+        #     BookingStatus[:foo] === [:foo, :bar, :baz] #Returns true
+        #     BookingStatus[:foo] === nil #Returns false
+        #
+        # You should note that defining an +:on_lookup_failure+ method that raises an exception will cause +===+ to also raise an exception for any lookup failure of +BookingStatus[arg]+.
         def ===(arg)
           case arg
           when nil

data/lib/power_enum/reflection.rb

@@ -8,13 +8,13 @@ module PowerEnum::Reflection
       reflections.values.grep(PowerEnum::Reflection::EnumerationReflection)
     end
 
-    def reflect_on_enumerated enumerated
+    def reflect_on_enumerated( enumerated )
       reflections[enumerated.to_sym].is_a?(PowerEnum::Reflection::EnumerationReflection) ? reflections[enumerated.to_sym] : nil
     end
   end
 
   class EnumerationReflection < ActiveRecord::Reflection::MacroReflection
-    def initialize name, options, active_record
+    def initialize( name, options, active_record )
       super :has_enumerated, name, options, active_record
     end
     

data/lib/power_enum/schema/schema_statements.rb

@@ -31,6 +31,8 @@ module PowerEnum::Schema
     # [:timestamps]
     #   Set this to <tt>true</tt> to have timestamp columns (created_at and updated_at) generated.
     #
+    # You can also pass in a block that takes a table object as an argument, like <tt>create_table</tt>.
+    #
     # ===== Examples
     # ====== Basic Enum
     #  create_enum :connector_type
@@ -56,8 +58,20 @@ module PowerEnum::Schema
     #  end
     #  add_index :connector_types, [:connector], :unique => true
     #
-    # Notice that a unique index is automatically created.
-    def create_enum(enum_name, options = {})
+    # ====== Customizing Enum with a block
+    #  create_enum :connector_type, :description => true do |t|
+    #    t.boolean :has_sound
+    #  end
+    # is the equivalent of
+    #  create_table :connector_types do |t|
+    #    t.string :name, :null => false
+    #    t.string :description
+    #    t.boolean :has_sound
+    #  end
+    #  add_index :connector_types, [:connector], :unique => true
+    #
+    # Notice that a unique index is automatically created in each case on the proper name column.
+    def create_enum(enum_name, options = {}, &block)
       enum_table_name = enum_name.pluralize
       name_column = options[:name_column] || :name
       generate_description = !!options[:description]
@@ -77,6 +91,9 @@ module PowerEnum::Schema
         if generate_timestamps
           t.timestamps
         end
+        if block_given?
+          yield t
+        end
       end
 
       add_index enum_table_name, [name_column], :unique => true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: power_enum
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -12,11 +12,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-10 00:00:00.000000000Z
+date: 2011-11-12 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &27154260 !ruby/object:Gem::Requirement
+  requirement: &10818300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -24,10 +24,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *27154260
+  version_requirements: *10818300
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &27152980 !ruby/object:Gem::Requirement
+  requirement: &10817360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -35,10 +35,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27152980
+  version_requirements: *10817360
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &27152060 !ruby/object:Gem::Requirement
+  requirement: &10816140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -46,10 +46,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27152060
+  version_requirements: *10816140
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &27151240 !ruby/object:Gem::Requirement
+  requirement: &10813220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -57,18 +57,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27151240
+  version_requirements: *10813220
 - !ruby/object:Gem::Dependency
   name: genspec
-  requirement: &27150660 !ruby/object:Gem::Requirement
+  requirement: &10812140 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - =
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.1
   type: :development
   prerelease: false
-  version_requirements: *27150660
+  version_requirements: *10812140
 description: ! 'Power Enum allows you to treat instances of your ActiveRecord models
   as though they were an enumeration of values.
 
@@ -115,6 +115,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2560307407996447465
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: