dm-aux_codes 1.0.6

data/lib/aux_codes/aux_code_class.rb

@@ -0,0 +1,163 @@
+#
+# extend AuxCode to return a full-blown ActiveRecord class
+#
+class AuxCode
+
+  def aux_code_class &block
+    klass = Class.new
+    klass.send :include, Stuff
+    klass.class_eval do
+
+      storage_names[:default] = 'aux_codes'
+
+      class << self
+        def name
+          'AuxCode'
+        end
+      end
+
+      def self.codes
+        all
+      end
+
+      def self.code_names
+        codes.map &:name
+      end
+
+      class << self
+
+        attr_accessor :aux_code_id, :aux_code
+
+        def aux_code
+          # @aux_code ||= AuxCode.find aux_code_id
+          AuxCode.get 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
+          method_missing_without_aux_code_scope name, *args, &block
+        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 :aux_code_id => self.aux_code_id do
+            count_without_aux_code_scope options
+          end
+        end
+        alias_method_chain :count, :aux_code_scope
+
+        def first_with_aux_code_scope options = {}
+          with_scope :aux_code_id => self.aux_code_id do
+            first_without_aux_code_scope options
+          end
+        end
+        alias_method_chain :first, :aux_code_scope
+
+        def all_with_aux_code_scope options = {}
+          with_scope :aux_code_id => self.aux_code_id do
+            all_without_aux_code_scope options
+          end
+        end
+        alias_method_chain :all, :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 Exception => ex
+
+            # we were likely passed some unknown meta attributes ... define them ...
+            meta_attribute_name = /The attribute '(.*)' is not accessible in/.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.rb

@@ -0,0 +1,272 @@
+%w( rubygems dm-core dm-validations dm-aggregates dm-timestamps ).each {|lib| require lib }
+
+require 'activesupport' # just for alias_method_chain
+
+#
+# the basic AuxCode class (DataMapper::Resource)
+#
+class AuxCode
+end
+
+module Stuff
+  def self.included base
+    base.class_eval do
+
+      include DataMapper::Resource
+
+      property :id,          DataMapper::Types::Serial
+      property :aux_code_id, Integer, :default  => 0
+      property :name,        String,  :required => true, :unique => :aux_code_id
+      property :meta,        DataMapper::Types::Text
+
+      # timestamps :at
+
+      belongs_to :aux_code
+      has n,     :aux_codes
+
+      def self.name
+        'AuxCode'
+      end
+      
+      alias code     aux_code
+      alias category aux_code
+      alias codes    aux_codes
+
+      # Helper methods to make DataMapper happy.
+      #
+      # In theory, we shouldn't use these in DataMapper but ... it's easy to port them
+
+      def self.find_all_by_aux_code_id aux_code_id
+        all :aux_code_id => aux_code_id
+      end
+
+      def self.find_by_name_and_aux_code_id name, aux_code_id
+        first :name => name, :aux_code_id => aux_code_id
+      end
+
+      def self.find_or_create_by_name name
+        first(:name => name) || create(:name => name)
+      end
+
+      def self.find_by_name name
+        first :name => name
+      end
+
+      def self.find_all_by_name name
+        all :name => name
+      end
+
+      def code_names
+        codes.map &:name
+      end
+
+      def is_a_category?
+        aux_code_id == 0
+      end
+
+      def class_name
+        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
+          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
+          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
+
+      # class methods
+      class << self
+
+        def categories
+          AuxCode.find_all_by_aux_code_id(0)
+        end
+
+        def category_names
+          AuxCode.categories.map &:name
+        end
+
+        def category category_object_or_id_or_name
+          obj = category_object_or_id_or_name
+          return obj if obj.is_a?(AuxCode)
+          return AuxCode.get(obj) if obj.is_a?(Fixnum)
+          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.first :name.like => obj.gsub('_', ' '), :aux_code_id => 0
+            end
+            return found
+          end
+          raise "I don't know how to find an AuxCode of type #{ obj.class }"
+        end
+        alias [] category
+
+        def category_codes category_object_or_id_or_name
+          category( category_object_or_id_or_name ).codes
+        end
+        alias category_values category_codes
+
+        def category_code_names category_object_or_id_or_name
+          category( category_object_or_id_or_name ).code_names
+        end
+
+        def create_classes!
+          AuxCode.categories.each do |category|
+            Object.const_set category.class_name, category.aux_code_class
+          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
+          begin
+            method_missing_without_indifferent_hash_style_values name, *args, &block
+          rescue NoMethodError => ex
+            begin
+              self[name]
+            rescue
+              raise ex
+            end
+          end
+        end
+        
+        alias_method_chain :method_missing, :indifferent_hash_style_values
+
+        def load_yaml yaml_string
+          require 'yaml'
+          self.load_from 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_from 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
+
+    end
+
+  end
+end
+
+AuxCode.send :include, Stuff
+
+require File.dirname(__FILE__) + '/aux_codes/aux_code_class' # define the class returned by #aux_code_class

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+name: dm-aux_codes
+version: !ruby/object:Gem::Version 
+  version: 1.0.6
+platform: ruby
+authors: 
+- remi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: DataMapper plugin for easily managing lots of enumeration-type data
+email: remi@remitaylor.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/aux_codes.rb
+- lib/aux_codes/aux_code_class.rb
+has_rdoc: true
+homepage: http://github.com/remi/aux_codes
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: DataMapper plugin for easily managing lots of enumeration-type data
+test_files: []
+