mood_swing 0.0.1

data/README.rdoc

@@ -0,0 +1,36 @@
+= Mood Swing
+
+As we've been taught, conditional statements can be a code smell and a good way to clean them up is polymorphism. I've
+found that with rails coupling the persistence layer and the business logic sometimes the standard form of inheritance-
+based polymorphism is awkward or not feasible. However, Ruby with it's dynamic object model can provide a form of
+inheritance via extending instances by mixing in modules dynamically. Mood Swing embraces this and provides a convenient
+means of doing it.
+
+== Usage
+
+You simply define the class macro mood_trigger and pass it the attribute in which will be used to load the module. The
+value of the attribute will be inflected with .classify and then a module matching "#{value}Extension" will be loaded if
+it is available with in the class namespace. Given the mood_trigger attribute is breed, with a value of hound, in the
+class named Dog, then the module would be named Dog::HoundExtension.
+
+  class Dog < ActiveRecord::Base
+    mood_trigger 'breed'
+
+    def bark
+      'woof'
+    end
+
+    module HoundExtension
+      def bark
+        'Hoooooowl'
+      end
+    end
+  end
+
+Now whenever you load a dog with the breed set to hound, or if you assign the breed to hound, it will bark out "Hoooooowl"
+
+Optionally, you can supply a writer attribute if the writer is not the same as the reader. This is the case with with
+polymorphic associations.
+
+  belongs_to 'body', :polymorphic => true
+  mood_trigger 'body_type', :writer => 'body'

data/lib/mood_swing.rb

@@ -0,0 +1,68 @@
+# Allows polymorphic behavior based on the value of an attribute by including a module dynamically.
+module MoodSwing
+
+  # reader is the value to use as the basis of the included module. The convention for naming the include is:
+  # YourClass::YourNameExtension
+  #
+  # An example would be:
+  #
+  # class Dog < ActiveRecord::Base
+  #   mood_trigger 'breed'
+  #
+  #   def bark
+  #     puts 'woof'
+  #   end
+  # end
+  #
+  # module Dog::HoundExtension
+  #   def bark
+  #     puts 'Hoooooowl'
+  #   end
+  # end
+  #
+  # When a instance of dog is initialized the breed attribute is read and it's value is used to extend the current
+  # instance's behavior with the module matching following the previously mentioned convention. If the Dog instance's
+  # breed was "Hound" then it would be extended with the Dog::HoundExtension. Now when you call @dog.bark, your dog will
+  # howl instead of woof.
+  #
+  # The module is updated when the attribute changes. An example of the behavior to expect with a new object is:
+  #
+  # spot = Dog.new
+  # spot.bark
+  # => "woof"
+  # spot.breed = "hound"
+  # spot.bark
+  # => 'Hoooooowl'
+  #
+  # If your attribute writer is different from the reader, then you can pass in :writer => "your_writer_method" and it
+  # will use that. This is the case when using a polymorphic belongs_to accessor as the attribute.
+  #
+  # belongs_to 'body', :polymorphic => true
+  # mood_trigger 'body_type', :writer => 'body'
+  def mood_trigger(reader, options ={})
+    options[:writer] ||= reader
+
+    define_method("#{options[:writer]}_with_extension=") do |value|
+      self.send "#{options[:writer]}_without_extension=", value
+      self.send "#{reader}_extension!"
+      self.send reader
+    end
+
+    define_method("#{reader}_extension!") do
+      begin
+        self.extend "#{self.class}::#{self[reader].classify}Extension".constantize
+      rescue NameError
+      end
+    end
+
+    class_eval do
+      alias_method_chain "#{options[:writer]}=", 'extension'
+      after_initialize "#{reader}_extension!"
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  extend MoodSwing
+end
+

data/lib/mood_swing/version.rb

@@ -0,0 +1,3 @@
+module MoodSwing
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: mood_swing
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- TJ Singleton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-23 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Allows polymorphic behavior based on the value of an attribute by including a module dynamically.
+email: tjsingleton@vantagestreet.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/mood_swing/version.rb
+- lib/mood_swing.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/tjsingleton/mood_swing
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Polymorphic behavior based on the value of an attribute
+test_files: []
+