rap_enumerable 0.0.1

data/README

@@ -0,0 +1,45 @@
+# The RapEnumerable module adds functionality to facilitate the creation of 
+# enumeration classes.
+# 
+# Usage:
+#    class Klass
+#       include RapEnumerable
+#       
+#       create(:id => 1, :aliases => ['hello', 'there'])
+#       create(:id => 2, :aliases => ['foo', 'bar'])
+#       # ...
+#    end
+#
+# *  This ensures that instances of Klass can only be created from within Klass
+#    by calling new_instance(attributes), where attributes is a hash used to set initial
+#    values of instance variables, using the key as a method name and sending in the value.
+#    
+# *  Instances of Klass will get methods id() and aliases() to retrieve these values.
+# 
+# *  Instances of Klass can be retrieved by calling Klass.find(key) where key is
+#    an instance id or any of its aliases.
+#    
+# *  Instances of Klass can be checked to see whether they are a particular instance by calling
+#    <name>? for any of its indexed values. In the example above, you can take k, an instance
+#    of Klass, and call k.hello?
+#    
+# *  By default, the find method uses an index keyed by the id and aliases of the 
+#    Klass instances. You can add attributes to be used as finders by calling find_by as shown below. This
+#    will also generate accessor methods for the given attribute names. Note that you must call
+#    find_by before creating your enumeration instances.
+#  
+#  For example, this will let you call Klass.find(1) or Klass.find('hello') and get back the
+#  instance:
+#     class Klass
+#       include RapEnumerable
+#       
+#       find_by :name
+#       
+#       create(:id => 1, :name => 'hello')
+#       create(:id => 2, :name => 'world')
+#
+#     end
+#    
+# *  An array of all Klass instances can be retrieved with Klass.all
+# 
+# Jeremy Lizt (jeremy@rapleaf.com) - 4/2007

data/lib/rap_enumerable.rb

@@ -0,0 +1,84 @@
+module RapEnumerable
+  
+  attr_reader :id, :aliases
+
+  def initialize(attributes = {})
+    @id = attributes.delete(:id)
+    @aliases = attributes.delete(:aliases).to_a
+    attributes.each {|k,v| send(k.to_s + "=", v)}
+  end
+  
+  # Return an array of aliases plus
+  def _keys
+    self.class.finder_attrs.map {|attr| send(attr) if respond_to?(attr)}.flatten.compact
+  end
+  
+  # Check if any indexed keys match the query. Only handle if the query matches an indexed key.
+  def method_missing(method_id, *arguments)
+    if match = /^(\w*)\?$/.match(method_id.to_s)
+      inst = self.class.find(match[1])
+      if(inst.nil?) then super
+      else self == inst
+      end
+    else
+      super
+    end
+  end
+
+end
+
+
+class << RapEnumerable
+
+  def included(klass)
+    super
+    klass.extend(RapEnumerableClassMethods)
+    klass.private_class_method  :new, :allocate, :create
+    klass.instance_eval do
+      @finder_attrs = [:id, :aliases] # Attribute names to use to find keys for the find index.
+      @instances = []
+      @instances_by_key = {}
+    end
+  end
+
+  module RapEnumerableClassMethods
+  
+    attr_reader :finder_attrs
+  
+    # Add one or more attribute names to use for indexing the finder. Also, generate accessor methods for these attributes.
+    def find_by(*attribute_names)
+      attr_accessor(*attribute_names)
+      @finder_attrs.concat(attribute_names).uniq!
+    end
+  
+    def create(attributes = nil)
+      inst = new(attributes)
+    
+      # Check for key & alias uniqueness
+      if(dup_key = inst._keys.find {|key| @instances_by_key[key]})
+        raise "Duplicate key error: #{dup_key}" 
+      end
+      
+      # Add instance and index
+      @instances << inst
+      inst._keys.each {|key| @instances_by_key[key.to_s.strip.downcase] = inst}
+      inst
+    end
+    
+    def find(key)
+      @instances_by_key[key.to_s.strip.downcase] unless key.nil?
+    end
+    
+    def all
+      @instances
+    end
+    
+    def each
+      @instances.each {|instance| yield instance}
+    end
+    
+  end
+
+end
+
+

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rap_enumerable
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-10-05 00:00:00 -07:00
+summary: Module to facilitate the creation of enumeration classes.
+require_paths: 
+- lib
+email: jeremy@rapleaf.com
+homepage: http://blog.rapleaf.com/dev
+rubyforge_project: 
+description: 
+autorequire: rap_enumerable
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jeremy Lizt
+files: 
+- lib/rap_enumerable.rb
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+