classmeta 0.0.2 → 0.1.0

data/README.md

@@ -1,27 +1,30 @@
-Classmeta for Rails 3.2+
+Classmeta for Rails 3.x+
 =====
 
-Creates new classes on the fly to allow you to refactor common changes.
+Creates new classes on the fly in Rails, optionally transform them, and have kick-ass, short association descriptions that double as class definitions. Open a ticket to add to the README if you find an inventive use that you think others would benefit from.
 
 Lets say you wanted whitelisted attributes to be different depending which class was including it as an association.
 
 In car, you only want the names of passengers:
 
-    has_many :passengers, class_name: Person.meta(:std, attrs: [:name]).name
+    has_many :passengers, class_name: Person.meta(attrs: [:name]).name
 
 In train, you want their seat preference:
 
-    has_many :riders, class_name: Person.meta(:std, attrs: [:name, :seat_preference]).name
+    has_many :riders, class_name: Person.meta(attrs: [:name, :seat_preference]).name
 
 So, include the gem in Gemfile and bundle install:
 
     gem 'classmeta'
 
-Add a transformer somewhere in the load path like app/models/:
+Add a transformer somewhere in the load path, e.g. to transform models, maybe you could put this in `app/models/default_transformer.rb` which would ensure the `table_name`, `primary_key` are set to be the same as the original class, and it would also allow the `_accessible_attributes` whitelist to be overriden with `:attrs` value in the options hash:
 
-    class StandardTransformer
-      def transform(klazz, options)
-        klazz.class_eval "self._accessible_attributes[:default] = #{options[:attrs].inspect}" if options[:attrs]
+    class DefaultTransformer
+      def transform(klass, derived_from_class, options)
+        status_column = options[:status_column] || 'record_status'
+        klass.class_eval "self.table_name = #{derived_from_class.table_name.inspect}"
+        klass.class_eval "self.primary_key = #{derived_from_class.primary_key.inspect}"
+        klass.class_eval "self._accessible_attributes[:default] = #{options[:attrs].inspect}" if options[:attrs]
       end
     end
 
@@ -29,7 +32,7 @@ And add this to environment.rb:
 
     Classmeta::Options.configure({
       :transformers => {
-        :std => StandardTransformer
+        :default => DefaultTransformer
       }
     })
 
@@ -45,11 +48,53 @@ Works with class reloading or caching.
 
 It's useful if you have a number of classes, like models, that just differ by a little bit and module includes just aren't solving the problem of doubling, tripling, etc. the number of files you are having to create just to represent new classes.
 
-### Just Rails?
+### Unnamed metas
 
-Feel free to add off-Rails support and do a pull request.
+This generates a new class named "MyModel<some unique random string>" sending that class and nil options hash to the transform function of transformer associated with the :default key in Classmeta::Options if there is one, otherwise it will just generate a new model class with the same behavior as the old one and not transform it:
+
+    MyModel.meta
+
+This generates a new class named "MyModel<some unique random string>" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column'` to the transform function of transformer associated with the :default key in Classmeta::Options if there is one, otherwise it will just generate a new model class with the same behavior as the old one and not transform it:
+
+    MyModel.meta(attrs: [:name, :status], special_column: 'my_column')
+
+This generates a new class named "MyModel<some unique random string>" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column'` to the transform function of transformer associated with the :awesome key in Classmeta::Options:
+
+    MyModel.meta(:awesome, attrs: [:name, :status], special_column: 'my_column')
+
+This generates a new class named "MyModel<some unique random string>" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}}` to the transform function of transformers associated with the :awesome and :bitchin keys in Classmeta::Options:
+
+    MyModel.meta(:awesome, :bitchin, attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}})
+
+### Named metas
+
+This generates a new class named "Fabular" sending that class and nil options hash to the transform function of transformer associated with the :default key in Classmeta::Options if there is one, otherwise it will just generate a new model class with the same behavior as the old one and not transform it:
+
+    MyModel.named_meta('Fabular')
 
-### Quick Test!
+This generates a new class named "Fabular" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column'` to the transform function of transformer associated with the :default key in Classmeta::Options if there is one, otherwise it will just generate a new model class with the same behavior as the old one and not transform it:
+
+    MyModel.named_meta('Fabular', {attrs: [:name, :status], special_column: 'my_column'})
+
+This generates a new class named "Fabular" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column'` to the transform function of transformer associated with the :awesome key in Classmeta::Options:
+
+    MyModel.named_meta('Fabular', :awesome, {attrs: [:name, :status], special_column: 'my_column'})
+
+This generates a new class named "Fabular" sending that class and options hash `attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}}` to the transform function of transformers associated with the :awesome and :bitchin keys in Classmeta::Options:
+
+    MyModel.named_meta('Fabular', [:awesome, :bitchin], {attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}}})
+
+### 'm' and 'n' functions
+
+Instead of `meta`, use `m`:
+
+    MyModel.m(:awesome, :bitchin, attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}})
+
+Instead of `named_meta`, use `n`:
+
+    MyModel.n('Fabular', [:awesome, :bitchin], {attrs: [:name, :status], special_column: 'my_column', somethin_else: {a: 1, b: {c: 1, d: 2}}})
+
+### Try it out
 
 Add to your Gemfile:
 
@@ -79,15 +124,63 @@ Note: if you define `Classmeta::Options.configure({...})`, it automatically gets
       }
     })
 
+### Just Rails?
+
+Feel free to add off-Rails support and do a pull request.
+
+### Compatibility Notes
+
+Not tested with Rails 2.3. Let me know if you have any compatibility issues.
+
+Ruby 1.9 is expected because of the way `SecureRandom` is abused for classes that aren't given a defined name via `named_meta`.
+
+But, it should work in Ruby 1.8.x if you try adding one of the following on the load path, e.g. in `config/environment.rb`:
+
+    class SecureRandom
+      # not guaranteed to be unique
+      def self.uuid
+        # from http://stackoverflow.com/questions/88311/how-best-to-generate-a-random-string-in-ruby
+        o = [('a'..'z'),('A'..'Z')].map{|i|i.to_a}.flatten
+        (0..50).map{o[rand(o.length)]}.join
+      end
+    end
+
+or maybe:
+
+    class SecureRandom
+      def self.uuid
+        ActiveSupport::SecureRandom.uuid
+      end
+    end
+
 ### Troubleshooting
 
+#### Debugging
+
+Add `:debug => true` to the Classmeta configuration:
+
+    Classmeta::Options.configure({
+      :debug => true,
+      ...
+    })
+
+#### OriginalModelName.n('NewModelName') results in (Table doesn't exist) being displayed next to model instance, or get error: 'relation "new_model_names" does not exist', etc.
+
+If you are duplicating the model class instance and renaming the new instance with classmeta, then it still has to deal with ActiveRecord as if you defined a new model class with that name, so if the original class name didn't define table name, etc. explicitly and ActiveRecord is trying to intuit those from the classname, it still won't find them.
+
+#### uninitialized constant (something) (NameError), etc.
+
 Since Classmeta delegates to Rails's dependency loading, any errors you get like this:
 
     .../classmeta/lib/classmeta/dependencies.rb:7:in `load_missing_constant': uninitialized constant (something) (NameError)
 
 Just means Rails couldn't find your class.
 
-For other errors, too, for the most part, pretend you are getting that from .../activesupport/lib/activesupport/dependencies.rb, then Google it and scratch your head until you figure out you mistyped something.
+For these and other errors, pretend you are getting that from `.../activesupport/lib/activesupport/dependencies.rb`, then Google it and scratch your head until you figure out you mistyped something.
+
+### Updating from prior versions
+
+* v0.0.2 -> v0.1.0: breaking transform method signature change- now expects to be able to send in the derived from class: `def transform(klass, derived_from_class, options)`
 
 ### License
 

data/lib/classmeta/class.rb

@@ -2,33 +2,58 @@ require 'securerandom'
 
 module Classmeta
   module ClassMethods
+    # Generates a unique classname and calls named_meta with provided parameters.
     # e.g. has_many :employees, class_name: MyModel.meta(:ref, attrs: [:name, :status], special_column: 'my_column').name
     def meta(*args)
+      puts "#{self.name}.meta called with args=#{args.inspect}" if Classmeta::Options.debugging?
       options = args.extract_options! # separates options hash and leaves one or more transform names
       self.named_meta("#{self}#{SecureRandom.uuid.gsub('-','')}", args, options)
     end
+    alias_method :m, :meta
 
-    # e.g. has_many :employees, class_name: MyModel.named_meta(MyNewModel, :ref, {attrs: [:name, :status], special_column: 'my_column'}).name
-    # e.g. has_many :employees, class_name: MyModel.named_meta(MyNewModel, [:transform1, :transform2], {attrs: [:name, :status], special_column: 'my_column'}).name
-    def named_meta(new_classname, transform_name_or_names, options = {})
-      transforms = Array.wrap(transform_name_or_names).flatten
-      #puts "#{self.name}.dup will be named: #{name}"
+    # Define a new class with specified classname using the specified transformer(s) and options.
+    # e.g. has_many :employees, class_name: MyModel.named_meta(MyNewModel, :transformer_key, {attrs: [:name, :status], special_column: 'my_column'}).name
+    # e.g. has_many :employees, class_name: MyModel.named_meta(MyNewModel, [:transformer_key1, :transformer_key2], {attrs: [:name, :status], special_column: 'my_column'}).name
+    def named_meta(new_classname, transformer_key_or_keys = [], options = {})
+      # handle unspecified transformer_key_or_keys
+      if transformer_key_or_keys.is_a?(Hash) && options.is_a?(Hash) && options.size == 0
+        options = transformer_key_or_keys
+        transformer_key_or_keys = []
+      end
+
+      if Classmeta::Options.debugging?
+        puts "#{self.name}.named_meta called with new_classname=#{new_classname.inspect}, transformer_key_or_keys=#{transformer_key_or_keys.inspect}, options=#{options.inspect}"
+        puts "#{self.name} calling #{self.name}.dup" if Classmeta::Options.debugging?
+      end
       new_class = self.dup
+      puts "#{self.name} defining function called 'name' on new class #{new_class} to return #{new_classname.inspect}" if Classmeta::Options.debugging?
       new_class.instance_eval("def name; #{new_classname.inspect}; end")
-      transforms.each do |transform|
-        transformer = Classmeta::Options.get_transformer(transform)
+      transformer_keys = Array.wrap(transformer_key_or_keys).flatten
+      if transformer_keys && transformer_keys.size > 0
+        puts "#{self.name} using Transformers #{transformer_keys.inspect} to transform class #{new_classname.inspect}" if Classmeta::Options.debugging?
+        transformer_keys.each do |transformer_key|
+          transformer = Classmeta::Options.get_transformer(transformer)
+          if transformer
+            puts "#{self.name} calling #{transformer.name}.transform(#{new_class}, #{self}, #{options.inspect})" if Classmeta::Options.debugging?
+            transformer.transform(new_class, self, options)
+          else
+            Classmeta::Options.output if Classmeta::Options.debugging?
+            raise "Classmeta::Options needs a :transformers hash that contains a key called #{transformer_key.inspect}"
+          end
+        end
+      else
+        transformer = Classmeta::Options.get_transformer(:default)
+        puts "Classmeta::Options's :default transformer = #{transformer.inspect}" if Classmeta::Options.debugging?
         if transformer
-          #puts "#{transformer.name}.transform(#{new_class.name}, #{options.inspect})"
-          transformer.transform(new_class, options)
-        else
-          Classmeta::Options.output
-          raise "Classmeta::Options needs a transformer mapping for #{transform.inspect}"
+          puts "#{self.name} calling #{transformer.name}.transform(#{new_class}, #{self}, #{options.inspect})" if Classmeta::Options.debugging?
+          transformer.transform(new_class, self, options)
         end
       end
-      #puts "Registering #{name} so class lookup works, if riding Rails"
-      Classmeta::ClassRegistry.register(new_classname, [self, transforms])
-      # TODO: figure out how to cache class in Rails: ActiveSupport::Dependencies::Registry.store(new_class)
+      puts "#{self.name} registering #{name} so class lookup works in Rails" if Classmeta::Options.debugging?
+      Classmeta::ClassRegistry.register(new_classname, [self, transformer_key_or_keys, options])
+      # TODO: use ActiveSupport::Dependencies::Registry.store(new_class) ?
       new_class
     end
+    alias_method :n, :named_meta
   end
 end

data/lib/classmeta/class_registry.rb

@@ -3,16 +3,19 @@ module Classmeta
     @@registry = {}
 
     def self.register(name, arr)
+      puts "Classmeta::ClassRegistry registering #{name.inspect}, #{arr.inspect}" if Classmeta::Options.debugging?
       @@registry[name.to_sym] = arr
     end
 
-    def self.get(name)      
+    def self.get(name)
+      puts "Classmeta::ClassRegistry.get called" if Classmeta::Options.debugging?
       arr = @@registry[name.to_sym]
       if arr
         # re-meta, so the class that was derived from can be reloaded
-        arr[0].meta(arr[1])
+        puts "Classmeta::ClassRegistry calling #{arr[0].name}.named_meta with #{name.inspect}, #{arr[1].inspect}, #{arr[2].inspect}" if Classmeta::Options.debugging?
+        arr[0].named_meta(name, arr[1], arr[2])
       else
-        #puts "Didn't find anything for name #{name} in Classmeta's class registry: #{@@registry.inspect}"
+        puts "Classmeta::ClassRegistry didn't find anything for name #{name} in Classmeta's class registry: #{@@registry.inspect}" if Classmeta::Options.debugging?
         nil
       end
     end

data/lib/classmeta/echo.rb

@@ -1,7 +1,7 @@
 module Classmeta
   class Echo
-    def self.transform(klazz, options)
-      puts "Classmeta::Echo.transform(klazz, options) called with klazz: #{klazz.name} and options: #{options.inspect}"
+    def self.transform(klass, derived_from_class, options)
+      puts "Classmeta::Echo.transform(klazz, options) called with klass: #{klass.name}, derived_from_class: #{derived_from_class.name}, and options: #{options.inspect}"
     end
   end
 end

data/lib/classmeta/options.rb

@@ -1,6 +1,7 @@
 module Classmeta
   class Options
     @@options = {
+      :debug => false,
       :transformers => {
         :echo => Classmeta::Echo
       }
@@ -10,6 +11,10 @@ module Classmeta
       @@options = hash
     end
 
+    def self.debugging?
+      @@options[:debug]
+    end
+
     def self.get_transformer(name)
       (@@options[:transformers])[name]
     end

data/lib/classmeta/version.rb

@@ -1,3 +1,3 @@
 module Classmeta
-  VERSION = '0.0.2'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: classmeta
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-30 00:00:00.000000000 Z
+date: 2012-09-10 00:00:00.000000000 Z
 dependencies: []
 description: Magic class creator that lets you create and transform classes dynamically.
 email: