remi-aux_codes 1.0.1 → 1.0.5

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 ryan "remi" Taylor
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -83,14 +83,20 @@ Or with an Indifferent Hash-like syntax
 TODO
 ----
 
- * custom fields, eg:
-   * `Breed#acronym`
-   * `Breed#description`
-   * `Breed#kennel_association_id` ...
-   * these need an easy way to be defined!  `alias_attribute`?
-   * this needs to work in development mode, when the models are constantly being reloaded!
-   * you shouldn't have to know the name of the special field to use it ... something like `attr_string :name` could just grab the (first) string column!
- * create (or update) method(s) for helping with the original AuxCode migration and for creating the special additional fields
+ - make a spec specifically for showing off the different API features quickly and easily
+ - convert this README to RDoc
+ - custom fields, eg:
+   - `Breed#acronym`
+   - `Breed#description`
+   - `Breed#kennel_association_id` ...
+   - these need an easy way to be defined!  `alias_attribute`?
+   - this needs to work in development mode, when the models are constantly being reloaded!
+   - you shouldn't have to know the name of the special field to use it ... something like `attr_string :name` could just grab the (first) string column!
+   - should we have a field for misc serialized meta-data?  could be abused ... but could also be helpful ...
+ - create (or update) method(s) for helping with the original AuxCode migration and for creating the special additional fields
+ - make table name and column names configurable (but with strong defaults)
+ - should have a rails generator ... should be 1 command to setup `aux_codes` in Rails
+ - after i add a rails generator, i'll bump to 1.1.0 and release
 
 NOTES
 -----

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "aux_codes"
+    s.summary     = "ActiveRecord plugin for easily managing lots of enumeration-type data"
+    s.email       = "remi@remitaylor.com"
+    s.homepage    = "http://github.com/remi/aux_codes"
+    s.description = "ActiveRecord plugin for easily managing lots of enumeration-type data"
+    s.authors     = %w( remi )
+    s.files       = FileList["[A-Z]*", "{lib,spec,examples,rails_generators}/**/*"] 
+    # s.executables = "neato" 
+    # s.add_dependency 'person-project' 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'aux_codes'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('aux_codes.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 1
+:patch: 5
 :major: 1
 :minor: 0

data/lib/aux_codes/aux_code_class.rb

@@ -0,0 +1,150 @@
+#
+# extend AuxCode to return a full-blown ActiveRecord class
+#
+class AuxCode
+
+  def aux_code_class &block
+    klass = Class.new(AuxCode) do
+
+      class << self
+
+        attr_accessor :aux_code_id, :aux_code
+
+        def aux_code
+          # @aux_code ||= AuxCode.find aux_code_id
+          AuxCode.find aux_code_id
+        end
+
+        def [] code
+          aux_code[code]
+        end
+
+        #
+        # this handles typical ActiveRecord::Base method_missing features, eg: aux_code.find_by_name 'foo'
+        #
+        # we wrap these methods in the scope of this aux code (category)
+        #
+        def method_missing_with_aux_code_scope name, *args, &block
+          if name.to_s[/^find/]
+            if name.to_s[/or_create_by_/]
+              name = "#{name}_and_aux_code_id".to_sym
+              args << self.aux_code_id
+              # method_missing_without_aux_code_scope name, *args
+              AuxCode.send name, *args, &block
+            else
+              with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
+                method_missing_without_aux_code_scope name, *args, &block
+              end
+            end
+          else
+            method_missing_without_aux_code_scope name, *args, &block
+          end
+        rescue NoMethodError => ex
+          begin
+            aux_code.send name, *args, &block # try on the AuxCode instance for this class ...
+          rescue
+            raise ex
+          end
+        end
+        alias_method_chain :method_missing, :aux_code_scope
+
+        def count_with_aux_code_scope options = {}
+          with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
+            count_without_aux_code_scope options
+          end
+        end
+        alias_method_chain :count, :aux_code_scope
+
+        def find_with_aux_code_scope first_or_all, options = {}
+          with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
+            find_without_aux_code_scope first_or_all, options
+          end
+        end
+        alias_method_chain :find, :aux_code_scope
+        
+        def create_with_aux_code_scope options = {}
+          create_without_aux_code_scope options.merge({ :aux_code_id => self.aux_code_id })
+        end
+        alias_method_chain :create, :aux_code_scope
+        
+        def create_with_aux_code_scope! options = {}
+          create_without_aux_code_scope! options.merge({ :aux_code_id => self.aux_code_id })
+        end
+        alias_method_chain :create!, :aux_code_scope
+        
+        def new_with_aux_code_scope options = {}
+          begin
+            new_without_aux_code_scope options.merge({ :aux_code_id => self.aux_code_id })
+          rescue ActiveRecord::UnknownAttributeError => ex
+
+            # we were likely passed some unknown meta attributes ... define them ...
+            meta_attribute_name = /unknown attribute: (.*)/.match(ex.message).captures.first
+            meta_attributes << meta_attribute_name
+            self.reload_meta_attributes!
+            new_with_aux_code_scope options # re-call ... WARNING ... might end up in infinite loop!
+
+          end
+        end
+        alias_method_chain :new, :aux_code_scope
+
+      end
+    end
+
+    klass.aux_code_id = self.id # the class needs to know its own aux_code_id
+
+    # 
+    # add custom attributes
+    #
+    klass.class.class_eval do
+
+      # an array of valid meta attribute names
+      attr_accessor :meta_attributes
+
+      def attr_meta *attribute_names
+        @meta_attributes ||= []
+        @meta_attributes += attribute_names.map {|attribute_name| attribute_name.to_s }
+        @meta_attributes
+      end
+    end
+
+    # class customizations (if block passed in)
+    klass.class_eval(&block) if block
+    
+    # for each of the meta_attributes defined, create getter and setter methods
+    #
+    # CAUTION: the way we're currently doing this, this'll only work if attr_meta 
+    #          is set when you initially get the aux_code_class ... adding 
+    #          meta attributes later won't currently work!
+    #
+    klass.class_eval {
+
+      def self.reload_meta_attributes!
+        self.meta_attributes ||= []
+
+        self.meta_attributes.each do |meta_attribute|
+          
+          unless self.respond_to? meta_attribute
+            define_method(meta_attribute) do
+              get_meta_attribute(meta_attribute)
+            end
+          end
+
+          unless self.respond_to? "#{meta_attribute}="
+            define_method("#{meta_attribute}=") do |value|
+              set_meta_attribute(meta_attribute, value)
+            end
+          end
+
+        end
+      end
+
+      reload_meta_attributes!
+
+    }
+
+    # wow, need to clean this up ...
+
+    klass
+  end
+
+end

data/lib/aux_codes/migration.rb

@@ -1,24 +1,31 @@
 #
 # ActiveRecord migration for creating the aux_codes table
 #
-class CreateAuxCodes < ActiveRecord::Migration
+class AuxCodes
+  class CreateAuxCodes < ActiveRecord::Migration
   
-  def self.up
-    create_table :aux_codes,   :comment => 'Auxilary Codes' do |t|
+    def self.up
+      create_table :aux_codes,   :comment => 'Auxilary Codes' do |t|
 
-      t.integer  :aux_code_id, :comment => 'ID of parent aux code (Category)',      :null => false
-      t.string   :name,        :comment => 'Name of Category code (or child code)', :null => false
+        t.integer  :aux_code_id, :comment => 'ID of parent aux code (Category)',      :null => false
+        t.string   :name,        :comment => 'Name of Category code (or child code)', :null => false
 
-      %w( integer decimal string text boolean datetime ).each do |field_type|
-        t.column field_type.to_sym, "#{field_type}_field"
+        # disabled for now, as they're not needed - no specs using this functionality
+        #
+        # %w( integer decimal string text boolean datetime ).each do |field_type|
+        #   t.column field_type.to_sym, "#{field_type}_field"
+        # end
+        
+        # this should be added conditionally, based on whether or not meta attributes are desired
+        t.text :meta, :comment => 'Serialized meta_attributes'
+
+        t.timestamps
       end
+    end
 
-      t.timestamps
+    def self.down
+      drop_table :aux_codes
     end
-  end
 
-  def self.down
-    drop_table :aux_codes
   end
-
 end

data/lib/aux_codes.rb

@@ -2,6 +2,16 @@ $:.unshift File.dirname(__FILE__)
 
 %w( rubygems activerecord aux_codes/migration ).each {|lib| require lib }
 
+# top-level class for AuxCodes
+#
+# used for namespacing and global configuration (once added)
+#
+class AuxCodes
+end
+
+#
+# the basic AuxCode ActiveRecord class
+#
 class AuxCode < ActiveRecord::Base
 
   validates_presence_of :name
@@ -28,96 +38,73 @@ class AuxCode < ActiveRecord::Base
     name.gsub(/[^[:alpha:]]/,'_').titleize.gsub(' ','').singularize
   end
 
+  def to_s
+    name
+  end
+
   def [] attribute_or_code_name
     if attributes.include?attribute_or_code_name
       attributes[attribute_or_code_name]
     else
       found = codes.select {|c| c.name.to_s =~ /#{attribute_or_code_name}/ }
-      if found.empty? # try case insensitive (sans underscores)
-        found = codes.select {|c| c.name.downcase.gsub('_',' ').to_s =~ 
-          /#{attribute_or_code_name.to_s.downcase.gsub('_',' ')}/ }
-      end
+        if found.empty? # try case insensitive (sans underscores)
+          found = codes.select {|c| c.name.downcase.gsub('_',' ').to_s =~ 
+            /#{attribute_or_code_name.to_s.downcase.gsub('_',' ')}/ }
+        end
       found.first if found
     end
   end
 
+  def deserialized_meta_hash
+    require 'yaml'
+    self.meta ||= ""
+    YAML::load(self.meta) || { }
+  end
+
+  def get_meta_attribute meta_attribute
+    deserialized_meta_hash[meta_attribute.to_s]
+  end
+
+  def set_meta_attribute meta_attribute, value
+    require 'yaml'
+    meta_hash = deserialized_meta_hash
+    meta_hash[meta_attribute.to_s] = value
+    self.meta = meta_hash.to_yaml
+  end
+
+  # this allows us to say things like:
+  #
+  #   foo = AuxCode.create :name => 'foo'
+  #   foo.codes.create :name => 'bar'
+  #
+  #   foo.bar # should return the bar aux code under the foo category
+  #
+  #   if bar doesn't exist, we throw a normal NoMethodError
+  #
+  #   this should check meta_attributes on the object too
+  #
   def method_missing_with_indifferent_hash_style_values name, *args, &block
     method_missing_without_indifferent_hash_style_values name, *args, &block
   rescue NoMethodError => ex
     begin
-      self[name]
+      if name.to_s[/=$/]
+        self.set_meta_attribute(name.to_s.sub(/=$/,''), args.first) # we said `code.foo= X` so we should set the foo meta attribute to X
+        save
+      else
+        code = self[name]
+        code = self.get_meta_attribute(name) unless code
+        raise ex unless code
+        return code
+      end
     rescue
       raise ex
     end
   end
   alias_method_chain :method_missing, :indifferent_hash_style_values
 
-  def aux_code_class
-    klass = Class.new(AuxCode) do
-      class << self
-        attr_accessor :aux_code_id, :aux_code
-
-        def aux_code
-          # @aux_code ||= AuxCode.find aux_code_id
-          AuxCode.find aux_code_id
-        end
-
-        def count_with_aux_code_scope options = {}
-          with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
-            count_without_aux_code_scope options
-          end
-        end
-        def method_missing_with_aux_code_scope name, *args, &block
-          if name.to_s[/^find/]
-            if name.to_s[/or_create_by_/]
-              name = "#{name}_and_aux_code_id".to_sym
-              args << self.aux_code_id
-              # method_missing_without_aux_code_scope name, *args
-              AuxCode.send name, *args, &block
-            else
-              with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
-                method_missing_without_aux_code_scope name, *args, &block
-              end
-            end
-          else
-            method_missing_without_aux_code_scope name, *args, &block
-          end
-        rescue NoMethodError => ex
-          begin
-            aux_code.send name, *args, &block # try on the AuxCode instance for this class ...
-          rescue
-            raise ex
-          end
-        end
-        def find_with_aux_code_scope first_or_all, options = {}
-          with_scope(:find => { :conditions => ['aux_code_id = ?', self.aux_code_id] }) do
-            find_without_aux_code_scope first_or_all, options
-          end
-        end
-        def create_with_aux_code_scope options = {}
-          create_without_aux_code_scope options.merge({ :aux_code_id => self.aux_code_id })
-        end
-        def create_with_aux_code_scope! options = {}
-          create_without_aux_code_scope! options.merge({ :aux_code_id => self.aux_code_id })
-        end
-        def new_with_aux_code_scope options = {}
-          new_without_aux_code_scope options.merge({ :aux_code_id => self.aux_code_id })
-        end
-
-        alias_method_chain :count, :aux_code_scope
-        alias_method_chain :method_missing, :aux_code_scope
-        alias_method_chain :find, :aux_code_scope
-        alias_method_chain :create, :aux_code_scope
-        alias_method_chain :create!, :aux_code_scope
-        alias_method_chain :new, :aux_code_scope
-      end
-    end
-
-    klass.aux_code_id = self.id # the class needs to know its own aux_code_id
-    klass
-  end
-
+  # class methods
   class << self
+
     def categories
       AuxCode.find_all_by_aux_code_id(0)
     end
@@ -130,8 +117,15 @@ class AuxCode < ActiveRecord::Base
       obj = category_object_or_id_or_name
       return obj if obj.is_a?AuxCode
       return AuxCode.find(obj) if obj.is_a?Fixnum
-      return AuxCode.find_by_name_and_aux_code_id(obj, 0) if obj.is_a?String
-      return AuxCode.find_by_name_and_aux_code_id(obj.to_s, 0) if obj.is_a?Symbol
+      if obj.is_a?(String) || obj.is_a?(Symbol)
+        obj = obj.to_s
+        found = AuxCode.find_by_name_and_aux_code_id(obj, 0)
+        if found.nil?
+          # try replacing underscores with spaces and doing a 'LIKE' search
+          found = AuxCode.find :first, :conditions => ["name LIKE ? AND aux_code_id = ?", obj.gsub('_', ' '), 0]
+        end
+        return found
+      end
       raise "I don't know how to find an AuxCode of type #{ obj.class }"
     end
     alias [] category
@@ -151,6 +145,12 @@ class AuxCode < ActiveRecord::Base
       end
     end
 
+    # this allows us to say things like:
+    #
+    #   AuxCode.create :name => 'foo'
+    #
+    #   AuxCode.foo # should return the foo category aux code
+    #
     def method_missing_with_indifferent_hash_style_values name, *args, &block
       unless self.respond_to?:aux_code_id # in which case, this is a *derived* class, not AuxCode
         begin
@@ -167,12 +167,79 @@ class AuxCode < ActiveRecord::Base
       end
     end
     alias_method_chain :method_missing, :indifferent_hash_style_values
+
+    def load_yaml yaml_string
+      require 'yaml'
+      self.load YAML::load(yaml_string)
+    end
+
+    def load_file serialized_yaml_file_path
+      load_yaml File.read(serialized_yaml_file_path)
+    end
+
+    # initialize AuxCodes ... looks for config/aux_codes.yml
+    # and creates classes
+    def init # should eventually take configuration options (hash || block)
+      aux_codes_yml = File.join 'config', 'aux_codes.yml'
+      if File.file? aux_codes_yml
+        load_file aux_codes_yml
+        create_classes!
+      end
+    end
+
+    # 
+    # loads AuxCodes (creates them) from a Hash, keyed on the name of the aux code categories to create
+    #
+    # hash: a Hash or an Array [ [key,value], [key,value] ] or anything with an enumerator 
+    #       that'll work with `hash.each {|key,value| ... }`
+    #
+    def load hash
+      return unless hash.is_a?Hash
+      hash.each do |category_name, codes|
+        category = AuxCode.find_or_create_by_name( category_name.to_s ).aux_code_class
+        codes.each do |name, values|
+
+          # only a name given
+          if values.nil? or values.empty?
+            if name.is_a? String or name.is_a? Symbol # we have a String || Symbol, it's likely the code's name, eg. :foo or 'bar'
+              category.create :name => name.to_s unless category.code_names.include?(name.to_s)
+
+            elsif name.is_a? Hash # we have a Hash, likely with the create options, eg. { :name => 'hi', :foo =>'bar' }
+              category.create name
+
+            else
+              raise "not sure how to create code in category #{ category.name } with: #{ name.inspect }"
+            end
+
+            # we have a name and values
+          else
+            if values.is_a? Hash and (name.is_a? String or name.is_a? Symbol) # we have a Hash, likely with the create options ... we'll merge the name in as :name and create
+              code = category[ name.to_s ]
+              if code
+                values.each do |attribute, new_value|
+                  code.send "#{attribute}=", new_value # update values
+                end
+              else
+                code = category.create values.merge({ :name => name.to_s })
+              end
+
+            else
+              raise "not sure how to create code in category #{ category.name } with: #{ name.inspect }, #{ values.inspect }"
+
+            end
+          end
+        end
+      end
+    end
+
   end
 
-protected
+  protected
 
   def set_default_values
     self.aux_code_id = 0 unless aux_code_id
   end
 
 end
+
+%w( aux_codes/aux_code_class ).each {|lib| require lib } # define the class returned by #aux_code_class

data/rails_generators/aux_codes/USAGE

@@ -0,0 +1,5 @@
+Description:
+    Bootstraps aux_codes into Rails application
+    
+Examples:
+    `./script/generate aux_codes`

data/rails_generators/aux_codes/aux_codes_generator.rb

@@ -0,0 +1,56 @@
+# This generator bootstraps aux_codes into a Rails application
+class AuxCodesGenerator < Rails::Generator::Base
+
+  def initialize(runtime_args, runtime_options = {})
+    bootstrap
+    super
+  end
+
+  # bootstrap aux_codes into this project (add a require and a call to #init to environment.rb)
+  def bootstrap
+    environment_rb = File.join RAILS_ROOT, 'config', 'environment.rb'
+    if File.file? environment_rb
+      source = File.read environment_rb
+      unless source =~ /require .aux_codes./
+        File.open(environment_rb, 'a'){|f| f << "\nrequire 'aux_codes'\nAuxCode.init" }
+        puts "     updated  config/environment.rb"
+      end
+    end
+  end
+
+  # checks to see whether or not there's already a create_aux_codes migration
+  def migration_exists?
+    db_dir         = File.join RAILS_ROOT, 'db'
+    migrations_dir = File.join db_dir, 'migrate'
+    return false unless File.directory? db_dir
+    return false unless File.directory? migrations_dir
+    return false if Dir[ File.join(migrations_dir, '*_create_aux_codes.rb') ].empty?
+    return true
+  end
+
+  # copy files into the project, our templates:
+  #
+  # templates/
+  # |-- aux_codes.yml
+  # `-- migration.rb
+  #
+  def manifest
+    record do |m|
+      m.directory 'config'
+      m.file 'aux_codes.yml', 'config/aux_codes.yml'
+
+      unless migration_exists?
+        timestamp = Time.now.strftime '%Y%m%d%H%M%S'
+        m.directory 'db/migrate'
+        m.file 'migration.rb', "db/migrate/#{ timestamp }_create_aux_codes.rb"
+      end
+    end
+  end
+ 
+protected
+ 
+  def banner
+    "Usage: #{$0} aux_codes"
+  end
+ 
+end

data/rails_generators/aux_codes/templates/aux_codes.yml

@@ -0,0 +1,26 @@
+#
+# define your aux_codes!
+#
+# commented out below are some examples of a few of
+# the different ways you can define your aux_codes!
+#
+### foods:
+###   Pizza:
+###     taste: good
+###   Dirt:
+###     taste: bad
+### 
+### Snack Foods:
+### - Popcorn
+### - chips
+### 
+### days:
+###   Monday:
+###   Tuesday:
+###   Wednesday:
+### 
+### colors: 
+###   red: 
+###     first_letter: r
+###   blue: 
+###     first_letter: b

data/rails_generators/aux_codes/templates/migration.rb

@@ -0,0 +1,13 @@
+# autogenerated migration (generated by ./script/generate aux_codes)
+#
+# db/migrate/YYYYMMDDHHMMSS_create_aux_codes.rb
+#
+class CreateAuxCodes < ActiveRecord::Migration
+  def self.up
+    AuxCodes::CreateAuxCodes.migrate :up
+  end
+
+  def self.down
+    AuxCodes::CreateAuxCodes.migrate :down
+  end
+end

data/spec/aux_code_spec.rb

@@ -202,4 +202,204 @@ describe AuxCode do
     foo_category[:yay_for_bacon].should == bacon
   end
 
+  it 'an aux_code_class should raise a NoMethodError, as per usual, if an undefined method is called' do
+    chunky = AuxCode.create!( :name => 'chunky' ).aux_code_class
+    lambda { chunky.new.bacon }.should raise_error(NoMethodError)
+  end
+
+  it 'should be able to pass a block to aux_code_class for quick and easy class customization' do
+    chunky = AuxCode.create!( :name => 'chunky' ).aux_code_class do
+      def bacon
+        "chunky bacon!"
+      end
+    end
+    lambda { chunky.new.bacon }.should_not raise_error(NoMethodError)
+    chunky.new.bacon.should == 'chunky bacon!'
+  end
+
+  it 'should be able to pass a block to aux_code_class for quick and easy eigenclass customization' do
+    chunky = AuxCode.create!( :name => 'chunky' ).aux_code_class do
+      def self.bacon
+        "chunky bacon!"
+      end
+    end
+    chunky.bacon.should == 'chunky bacon!'
+    lambda { chunky.new.bacon }.should raise_error(NoMethodError) # bacon is a class method
+  end
+
+  it 'should be able to define a meta attribute' do
+    breed = AuxCode.create!( :name => 'breed' ).aux_code_class do
+      attr_meta :acronym
+    end
+
+    apbt = breed.create :name => 'American Pit Bull Terrier', :acronym => 'APBT'
+    breed.find_by_name('American Pit Bull Terrier').should == apbt
+    breed.find_by_name('American Pit Bull Terrier').acronym.should == 'APBT'
+  end
+
+  it 'should be able to define multiple meta attributes' do
+    breed = AuxCode.create!( :name => 'breed' ).aux_code_class do
+      attr_meta :acronym, :foo
+    end
+
+    apbt = breed.create :name => 'American Pit Bull Terrier', :acronym => 'APBT', :foo => 'bar'
+    breed.find_by_name('American Pit Bull Terrier').should == apbt
+    breed.find_by_name('American Pit Bull Terrier').acronym.should == 'APBT'
+    breed.find_by_name('American Pit Bull Terrier').foo.should == 'bar'
+  end
+
+  it 'to_s should return the name of an aux_code' do
+    AuxCode.new( :name => 'i Am the Name' ).to_s.should == 'i Am the Name'
+
+    x = AuxCode.create :name => 'foo'
+    y = x.codes.create :name => 'bar'
+    x.to_s.should == 'foo'
+    y.to_s.should == 'bar'
+  end
+    
+  it 'should be able to load AuxCodes from a Hash' do
+    AuxCode.count.should == 0
+    AuxCode.load({
+      
+      # symbol => String Array
+      :days => %w( Monday Tuesday Wednesday ),
+
+      # symbol => Hash
+      :colors => {
+        
+        # symbol => Hash options
+        :red  => { :first_letter => 'r' },
+        :blue => { :first_letter => 'b' }
+
+      },
+
+      # symbol => Array of hashes
+      :foods => [
+        { :name => 'Pizza', :taste => 'good' },
+        { :name => 'Dirt', :taste => 'bad' }
+      ],
+
+      'Snack Foods' => %w( Popcorn chips )
+
+    })
+
+    AuxCode.category_names.should include('days')
+    AuxCode.category_names.should include('colors')
+    AuxCode.category_names.should include('foods')
+
+    AuxCode[:days].codes.length.should == 3
+    AuxCode[:days].code_names.should include('Monday')
+    AuxCode[:days].monday.name.should == 'Monday'
+    AuxCode[:days][:monday].name.should == 'Monday'
+
+    AuxCode[:colors][:red].name.should == 'red'
+    AuxCode[:colors][:red].first_letter.should == 'r'
+
+    AuxCode[:colors].aux_code_class.red.name.should == 'red'
+    AuxCode[:colors].aux_code_class.red.first_letter.should == 'r'
+    AuxCode[:colors].aux_code_class[:red].first_letter.should == 'r'
+
+    AuxCode.foods.pizza.taste.should == 'good'
+    AuxCode.foods.dirt.taste.should == 'bad'
+
+    AuxCode['Snack Foods'].codes.length.should == 2
+    AuxCode.category('Snack Foods').codes.length.should == 2
+    AuxCode.snack_foods.codes.length.should == 2
+    AuxCode.snack_foods.code_names.should include('Popcorn')
+    AuxCode.snack_foods[:popcorn].name.should == 'Popcorn'
+    AuxCode[:snack_foods].popcorn.name.should == 'Popcorn'
+    AuxCode['Snack Foods'].popcorn.name.should == 'Popcorn'
+
+  end
+
+  it 'should be able to load AuxCodes from a Yaml string' do
+    require 'yaml'
+    AuxCode.count.should == 0
+    yaml = {
+      
+      # symbol => String Array
+      :days => %w( Monday Tuesday Wednesday ),
+
+      # symbol => Hash
+      :colors => {
+        
+        # symbol => Hash options
+        :red  => { :first_letter => 'r' },
+        :blue => { :first_letter => 'b' }
+
+      },
+
+      # symbol => Array of hashes
+      :foods => [
+        { :name => 'Pizza', :taste => 'good' },
+        { :name => 'Dirt', :taste => 'bad' }
+      ],
+
+      'Snack Foods' => %w( Popcorn chips )
+
+    }.to_yaml
+    AuxCode.load_yaml yaml
+
+    AuxCode.category_names.should include('days')
+    AuxCode[:days].code_names.should include('Monday')
+    AuxCode[:days][:monday].name.should == 'Monday'
+    AuxCode[:colors][:red].name.should == 'red'
+    AuxCode[:colors][:red].first_letter.should == 'r'
+    AuxCode[:colors].aux_code_class.red.first_letter.should == 'r'
+    AuxCode.foods.pizza.taste.should == 'good'
+    AuxCode.category('Snack Foods').codes.length.should == 2
+    AuxCode.snack_foods.code_names.should include('Popcorn')
+    AuxCode.snack_foods[:popcorn].name.should == 'Popcorn'
+  end
+  
+  it 'should be able to load AuxCodes from a Yaml file' do
+    AuxCode.count.should == 0
+
+    AuxCode.load_file File.dirname(__FILE__) + '/example_aux_codes.yml'
+
+    AuxCode.category_names.should include('days')
+    AuxCode[:days].code_names.should include('Monday')
+    AuxCode[:days][:monday].name.should == 'Monday'
+    AuxCode[:colors][:red].name.should == 'red'
+    AuxCode[:colors][:red].first_letter.should == 'r'
+    AuxCode[:colors].aux_code_class.red.first_letter.should == 'r'
+    AuxCode.foods.pizza.taste.should == 'good'
+    AuxCode.category('Snack Foods').codes.length.should == 2
+    AuxCode.snack_foods.code_names.should include('Popcorn')
+    AuxCode.snack_foods[:popcorn].name.should == 'Popcorn'
+  end
+
+  it 'should be able to update meta attribute easily' do
+    AuxCode.load_file File.dirname(__FILE__) + '/more_example_aux_codes.yml'
+    AuxCode.foods.pizza.taste.should == 'good'
+    AuxCode.foods.pizza.taste = 'yummy'
+    AuxCode.foods.pizza.taste.should == 'yummy'
+  end
+
+  it 'should be able to load AuxCodes from a [slightly different] Yaml file' do
+    AuxCode.count.should == 0
+
+    AuxCode.load_file File.dirname(__FILE__) + '/more_example_aux_codes.yml'
+
+    AuxCode.category_names.should include('days')
+    AuxCode[:days].code_names.should include('Monday')
+    AuxCode[:days][:monday].name.should == 'Monday'
+    AuxCode[:colors][:red].name.should == 'red'
+    AuxCode[:colors][:red].first_letter.should == 'r'
+    AuxCode[:colors].aux_code_class.red.first_letter.should == 'r'
+    AuxCode.foods.pizza.taste.should == 'good'
+    AuxCode.category('Snack Foods').codes.length.should == 2
+    AuxCode.snack_foods.code_names.should include('Popcorn')
+    AuxCode.snack_foods[:popcorn].name.should == 'Popcorn'
+
+    # quick test - overridable ...
+
+    AuxCode.load({
+      :colors => { 
+        :red => { :first_letter => 'CHANGED' } 
+      }
+    })
+    AuxCode[:colors][:red].first_letter.should == 'CHANGED'
+  end
+
 end

data/spec/example_aux_codes.yml

@@ -0,0 +1,18 @@
+--- 
+:foods: 
+- :taste: good
+  :name: Pizza
+- :taste: bad
+  :name: Dirt
+:colors: 
+  :red: 
+    :first_letter: r
+  :blue: 
+    :first_letter: b
+Snack Foods: 
+- Popcorn
+- chips
+:days: 
+- Monday
+- Tuesday
+- Wednesday

data/spec/more_example_aux_codes.yml

@@ -0,0 +1,22 @@
+# cleaned up a bit ... shows different ways you can create the yaml for your aux codes
+
+foods:
+  Pizza:
+    taste: good
+  Dirt:
+    taste: bad
+
+Snack Foods:
+- Popcorn
+- chips
+
+days:
+  Monday:
+  Tuesday:
+  Wednesday:
+
+colors: 
+  red: 
+    first_letter: r
+  blue: 
+    first_letter: b

data/spec/spec_helper.rb

@@ -2,8 +2,8 @@ require File.dirname(__FILE__) + '/../lib/aux_codes'
 require 'spec'
 
 ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => ':memory:'
-CreateAuxCodes.verbose = false
-CreateAuxCodes.migrate :up
+AuxCodes::CreateAuxCodes.verbose = false
+AuxCodes::CreateAuxCodes.migrate :up
 
 # use transactions
 AuxCode; # hit one of the AR classes

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: remi-aux_codes
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.5
 platform: ruby
 authors: 
 - remi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-27 00:00:00 -08:00
+date: 2009-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -22,13 +22,24 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- Rakefile
 - VERSION.yml
 - README.markdown
+- LICENSE
 - lib/aux_codes
+- lib/aux_codes/aux_code_class.rb
 - lib/aux_codes/migration.rb
 - lib/aux_codes.rb
+- spec/more_example_aux_codes.yml
 - spec/aux_code_spec.rb
 - spec/spec_helper.rb
+- spec/example_aux_codes.yml
+- rails_generators/aux_codes
+- rails_generators/aux_codes/aux_codes_generator.rb
+- rails_generators/aux_codes/USAGE
+- rails_generators/aux_codes/templates
+- rails_generators/aux_codes/templates/aux_codes.yml
+- rails_generators/aux_codes/templates/migration.rb
 has_rdoc: true
 homepage: http://github.com/remi/aux_codes
 post_install_message: