eav_hashes 1.0.1 → 1.0.2

data/lib/eav_hashes/util.rb

@@ -1,122 +1,122 @@
-module ActiveRecord
-  module EavHashes
-    module Util
-      # Sanity checks!
-      # @param [Hash] options the options hash to check for emptyness and Hashiness
-      def self.sanity_check(options)
-        raise "options cannot be empty (and you shouldn't be calling this since you left options blank)" if
-            (!options.is_a? Hash) or options.empty?
-      end
-
-      # Fills in any options not explicitly passed to eav_hash_for and creates an EavEntry type for the table
-      # @param [Hash] options the options hash to be filled with defaults on unset keys.
-      def self.fill_options_hash(options)
-        sanity_check options
-
-        # Generate a unique class name based on the eav_hash's name and owner
-        options[:entry_class_name] ||= "#{options[:parent_class_name]}_#{options[:hash_name]}_entry".camelize.to_sym
-
-        # Strip "_entries" from the table name
-        if /Entry$/.match options[:entry_class_name]
-          options[:table_name] ||= options[:entry_class_name].to_s.tableize.slice(0..-9).to_sym
-        else
-          options[:table_name] ||= options[:entry_class_name].to_s.tableize.to_sym
-        end
-
-        # Create the symbol name for the "belongs_to" association in the entry model
-        options[:parent_assoc_name] ||= "#{options[:parent_class_name].to_s.underscore}".to_sym
-
-        # Create the symbol name for the "has_many" association in the parent model
-        options[:entry_assoc_name] = options[:entry_class_name].to_s.tableize.to_sym
-
-        # Change slashes to underscores in options to match what's output by the generator
-        # TODO: Refactor table naming into one location
-        options[:table_name] = options[:table_name].to_s.gsub(/\//,'_').to_sym
-        options[:parent_assoc_name] = options[:parent_assoc_name].to_s.gsub(/\//,'_').to_sym
-        options[:entry_assoc_name] = options[:entry_assoc_name].to_s.gsub(/\//,'_').to_sym
-
-        # Create our custom type if it doesn't exist already
-        options[:entry_class] = create_eav_table_class options
-
-        return options
-      end
-
-      # Creates a new type subclassed from ActiveRecord::EavHashes::EavEntry which represents an eav_hash key-value pair
-      def self.create_eav_table_class (options)
-        sanity_check options
-
-        # Don't overwrite an existing type
-        return class_from_string(options[:entry_class_name].to_s) if class_from_string_exists?(options[:entry_class_name])
-
-        # Create our type
-        klass = set_constant_from_string options[:entry_class_name].to_s, Class.new(ActiveRecord::EavHashes::EavEntry)
-
-        # Fill in the associations and specify the table it belongs to
-        klass.class_eval <<-END_EVAL
-          self.table_name = "#{options[:table_name]}"
-          belongs_to :#{options[:parent_assoc_name]}
-        END_EVAL
-
-        return klass
-      end
-
-      # Searches an EavEntry's table for the specified key/value pair and returns an
-      # array containing the IDs of the models whose eav_hash key/value pair.
-      # You should not run this directly.
-      # @param [String, Symbol] key the key to search by
-      # @param [Object] value the value to search by. if this is nil, it will return all models which contain `key`
-      # @param [Hash] options the options hash which eav_hash_for hash generated.
-      def self.run_find_expression (key, value, options)
-        sanity_check options
-        raise "Can't search for a nil key!" if key.nil?
-        if value.nil?
-          options[:entry_class].where(
-              "entry_key = ? and symbol_key = ?",
-              key.to_s,
-              key.is_a?(Symbol)
-          ).pluck("#{options[:parent_assoc_name]}_id".to_sym)
-        else
-          val_type = EavEntry.get_value_type value
-          if val_type == EavEntry::SUPPORTED_TYPES[:Object]
-            raise "Can't search by Objects/Hashes/Arrays!"
-          else
-            options[:entry_class].where(
-                "entry_key = ? and symbol_key = ? and value = ? and value_type = ?",
-                key.to_s,
-                key.is_a?(Symbol),
-                value.to_s,
-                val_type
-            ).pluck("#{options[:parent_assoc_name]}_id".to_sym)
-          end
-        end
-      end
-
-      # Find a class even if it's contained in one or more modules.
-      # See http://stackoverflow.com/questions/3163641/get-a-class-by-name-in-ruby
-      def self.class_from_string(str)
-        str.split('::').inject(Object) do |mod, class_name|
-          mod.const_get(class_name)
-        end
-      end
-
-      # Check whether a class exists, even if it's contained in one or more modules.
-      def self.class_from_string_exists?(str)
-        begin
-          class_from_string(str)
-        rescue
-          return false
-        end
-        true
-      end
-
-      # Set a constant from a string, even if the string contains modules. Modules
-      # are created if necessary.
-      def self.set_constant_from_string(str, val)
-        parent = str.deconstantize.split('::').inject(Object) do |mod, class_name|
-          mod.const_defined?(class_name) ? mod.const_get(class_name) : mod.const_set(class_name, Module.new())
-        end
-        parent.const_set(str.demodulize.to_sym, val)
-      end
-    end
-  end
-end
+module ActiveRecord
+  module EavHashes
+    module Util
+      # Sanity checks!
+      # @param [Hash] options the options hash to check for emptyness and Hashiness
+      def self.sanity_check(options)
+        raise "options cannot be empty (and you shouldn't be calling this since you left options blank)" if
+            (!options.is_a? Hash) or options.empty?
+      end
+
+      # Fills in any options not explicitly passed to eav_hash_for and creates an EavEntry type for the table
+      # @param [Hash] options the options hash to be filled with defaults on unset keys.
+      def self.fill_options_hash(options)
+        sanity_check options
+
+        # Generate a unique class name based on the eav_hash's name and owner
+        options[:entry_class_name] ||= "#{options[:parent_class_name]}_#{options[:hash_name]}_entry".camelize.to_sym
+
+        # Strip "_entries" from the table name
+        if /Entry$/.match options[:entry_class_name]
+          options[:table_name] ||= options[:entry_class_name].to_s.tableize.slice(0..-9).to_sym
+        else
+          options[:table_name] ||= options[:entry_class_name].to_s.tableize.to_sym
+        end
+
+        # Create the symbol name for the "belongs_to" association in the entry model
+        options[:parent_assoc_name] ||= "#{options[:parent_class_name].to_s.underscore}".to_sym
+
+        # Create the symbol name for the "has_many" association in the parent model
+        options[:entry_assoc_name] = options[:entry_class_name].to_s.tableize.to_sym
+
+        # Change slashes to underscores in options to match what's output by the generator
+        # TODO: Refactor table naming into one location
+        options[:table_name] = options[:table_name].to_s.gsub(/\//,'_').to_sym
+        options[:parent_assoc_name] = options[:parent_assoc_name].to_s.gsub(/\//,'_').to_sym
+        options[:entry_assoc_name] = options[:entry_assoc_name].to_s.gsub(/\//,'_').to_sym
+
+        # Create our custom type if it doesn't exist already
+        options[:entry_class] = create_eav_table_class options
+
+        return options
+      end
+
+      # Creates a new type subclassed from ActiveRecord::EavHashes::EavEntry which represents an eav_hash key-value pair
+      def self.create_eav_table_class (options)
+        sanity_check options
+
+        # Don't overwrite an existing type
+        return class_from_string(options[:entry_class_name].to_s) if class_from_string_exists?(options[:entry_class_name])
+
+        # Create our type
+        klass = set_constant_from_string options[:entry_class_name].to_s, Class.new(ActiveRecord::EavHashes::EavEntry)
+
+        # Fill in the associations and specify the table it belongs to
+        klass.class_eval <<-END_EVAL
+          self.table_name = "#{options[:table_name]}"
+          belongs_to :#{options[:parent_assoc_name]}
+        END_EVAL
+
+        return klass
+      end
+
+      # Searches an EavEntry's table for the specified key/value pair and returns an
+      # array containing the IDs of the models whose eav_hash key/value pair.
+      # You should not run this directly.
+      # @param [String, Symbol] key the key to search by
+      # @param [Object] value the value to search by. if this is nil, it will return all models which contain `key`
+      # @param [Hash] options the options hash which eav_hash_for hash generated.
+      def self.run_find_expression (key, value, options)
+        sanity_check options
+        raise "Can't search for a nil key!" if key.nil?
+        if value.nil?
+          options[:entry_class].where(
+              "entry_key = ? and symbol_key = ?",
+              key.to_s,
+              key.is_a?(Symbol)
+          ).pluck("#{options[:parent_assoc_name]}_id".to_sym)
+        else
+          val_type = EavEntry.get_value_type value
+          if val_type == EavEntry::SUPPORTED_TYPES[:Object]
+            raise "Can't search by Objects/Hashes/Arrays!"
+          else
+            options[:entry_class].where(
+                "entry_key = ? and symbol_key = ? and value = ? and value_type = ?",
+                key.to_s,
+                key.is_a?(Symbol),
+                value.to_s,
+                val_type
+            ).pluck("#{options[:parent_assoc_name]}_id".to_sym)
+          end
+        end
+      end
+
+      # Find a class even if it's contained in one or more modules.
+      # See http://stackoverflow.com/questions/3163641/get-a-class-by-name-in-ruby
+      def self.class_from_string(str)
+        str.split('::').inject(Object) do |mod, class_name|
+          mod.const_get(class_name)
+        end
+      end
+
+      # Check whether a class exists, even if it's contained in one or more modules.
+      def self.class_from_string_exists?(str)
+        begin
+          class_from_string(str)
+        rescue
+          return false
+        end
+        true
+      end
+
+      # Set a constant from a string, even if the string contains modules. Modules
+      # are created if necessary.
+      def self.set_constant_from_string(str, val)
+        parent = str.deconstantize.split('::').inject(Object) do |mod, class_name|
+          mod.const_defined?(class_name) ? mod.const_get(class_name) : mod.const_set(class_name, Module.new())
+        end
+        parent.const_set(str.demodulize.to_sym, val)
+      end
+    end
+  end
+end

data/lib/eav_hashes/version.rb

@@ -1,5 +1,5 @@
-module ActiveRecord
-  module EavHashes
-    VERSION = "1.0.1"
-  end
-end
+module ActiveRecord
+  module EavHashes
+    VERSION = "1.0.2"
+  end
+end

data/lib/eav_hashes.rb

@@ -1,8 +1,8 @@
-require "eav_hashes/util"
-require "eav_hashes/eav_entry"
-require "eav_hashes/eav_hash"
-require "eav_hashes/activerecord_extension"
-require "generators/eav_migration/eav_migration"
-
-# tally-ho!
-ActiveRecord::Base.send :include, ActiveRecord::EavHashes
+require "eav_hashes/util"
+require "eav_hashes/eav_entry"
+require "eav_hashes/eav_hash"
+require "eav_hashes/activerecord_extension"
+require "generators/eav_migration/eav_migration"
+
+# tally-ho!
+ActiveRecord::Base.send :include, ActiveRecord::EavHashes

data/lib/generators/eav_migration/USAGE

@@ -1,26 +1,26 @@
-Description:
-    Creates a DB migration to generate the schema for a table which is used to
-    store the entries of an eav_hash.
-
-Example:
-    If you're not setting a custom table name, i.e., your model looks like this:
-
-        class ModelName < ActiveRecord::Base
-            eav_hash_for :hash_name
-        end
-
-    Then simply run this migration like so:
-
-        rails generate eav_migration ModelName hash_name
-
-    However, if you're a wizard and have specified a custom table name like this:
-
-        class ModelName < ActiveRecord::Base
-            eav_hash_for :hash_name, :table_name => :custom_table
-        end
-
-    Then run this generator like this:
-
-        rails generate eav_migration ModelName hash_name custom_table
-
-    Easy as pie!
+Description:
+    Creates a DB migration to generate the schema for a table which is used to
+    store the entries of an eav_hash.
+
+Example:
+    If you're not setting a custom table name, i.e., your model looks like this:
+
+        class ModelName < ActiveRecord::Base
+            eav_hash_for :hash_name
+        end
+
+    Then simply run this migration like so:
+
+        rails generate eav_migration ModelName hash_name
+
+    However, if you're a wizard and have specified a custom table name like this:
+
+        class ModelName < ActiveRecord::Base
+            eav_hash_for :hash_name, :table_name => :custom_table
+        end
+
+    Then run this generator like this:
+
+        rails generate eav_migration ModelName hash_name custom_table
+
+    Easy as pie!

data/lib/generators/eav_migration/eav_migration.rb

@@ -1,36 +1,36 @@
-require 'rails/generators'
-require 'rails/generators/active_record'
-
-class EavMigrationGenerator < ActiveRecord::Generators::Base
-
-  source_root File.expand_path "../templates", __FILE__
-  # small hack to override NamedBase displaying NAME
-  argument :name, :required => true, :type => :string, :banner => "<ModelName>"
-  argument :hash_name, :required => true, :type => :string, :banner => "<hash_name>"
-  argument :custom_table_name, :required => false, :type => :string, :banner => "table_name"
-
-  def create_eav_migration
-    p name
-    migration_template "eav_migration.erb", "db/migrate/#{migration_file_name}.rb"
-  end
-
-  def migration_file_name
-    "create_" + table_name
-  end
-
-  def migration_name
-    migration_file_name.camelize
-  end
-
-  def table_name
-    custom_table_name || "#{name}_#{hash_name}".underscore.gsub(/\//, '_')
-  end
-
-  def model_name
-    name
-  end
-
-  def model_association_name
-    model_name.underscore.gsub(/\//,'_')
-  end
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+class EavMigrationGenerator < ActiveRecord::Generators::Base
+
+  source_root File.expand_path "../templates", __FILE__
+  # small hack to override NamedBase displaying NAME
+  argument :name, :required => true, :type => :string, :banner => "<ModelName>"
+  argument :hash_name, :required => true, :type => :string, :banner => "<hash_name>"
+  argument :custom_table_name, :required => false, :type => :string, :banner => "table_name"
+
+  def create_eav_migration
+    p name
+    migration_template "eav_migration.erb", "db/migrate/#{migration_file_name}.rb"
+  end
+
+  def migration_file_name
+    "create_" + table_name
+  end
+
+  def migration_name
+    migration_file_name.camelize
+  end
+
+  def table_name
+    custom_table_name || "#{name}_#{hash_name}".underscore.gsub(/\//, '_')
+  end
+
+  def model_name
+    name
+  end
+
+  def model_association_name
+    model_name.underscore.gsub(/\//,'_')
+  end
 end

data/lib/generators/eav_migration/templates/eav_migration.erb

@@ -1,16 +1,16 @@
-class <%= migration_name %> < ActiveRecord::Migration
-  def change
-    create_table :<%= table_name %> do |t|
-      t.references :<%= model_association_name %>, :null => false
-      t.string :entry_key, :null => false
-      t.text :value, :null => false
-      t.integer :value_type, :null => false
-      t.boolean :symbol_key, :null => false, :default => true
-
-      t.timestamps
-    end
-
-    add_index :<%= table_name %>, :<%= model_association_name %>_id
-    add_index :<%= table_name %>, :entry_key
-  end
+class <%= migration_name %> < ActiveRecord::Migration
+  def change
+    create_table :<%= table_name %> do |t|
+      t.references :<%= model_association_name %>, :null => false
+      t.string :entry_key, :null => false
+      t.text :value, :null => false
+      t.integer :value_type, :null => false
+      t.boolean :symbol_key, :null => false, :default => true
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, :<%= model_association_name %>_id
+    add_index :<%= table_name %>, :entry_key
+  end
 end