irregular_method 0.2.0 → 0.3.0

data/README.rdoc

@@ -1,6 +1,6 @@
 = irregular_method
 
-Writing a bunch of case statements to handle regular expressions in method missing is just plain annoying. I suggest they get separated out and defined as their own methods. Well... ruby doesn't really let that happen, but there is an alternative.
+Rather than having a bunch of lame logic in your method_missing method, define separated regular expression methods that are called when no normally defined method matches.
 
 == Installation
 
@@ -17,53 +17,63 @@ The purpose of irregular_method is to allow methods with regular expression name
   ...
  end
 
-All reg_def methods are passed back the MatchData and the arguments passed to the call. For instance, let's say we have this class:
+All reg_def methods are passed back the MatchData[http://ruby-doc.org/core/classes/MatchData.html] and the arguments passed to the call. For instance, let's say we have this class:
 
- class Layer
+ class Account
   include ::Irregular::Method
+  
+  VALID_USER_TYPES = %w(janitor secretary manager)
+  has_many :users
 
-  cattr_accessor :layers
-  attr_accessible :index
+  reg_def(/^(#{VALID_USER_TYPES.join('|')})$/) do |match, args|
+   self.user(match[1])
+  end
 
-  reg_def(/^layer_(.+)$/) do |m, args|
-   above_or_below = m[1].downcase #first match in the expression
-   layers[self.index + (above_or_below == 'above' && 1 || above_or_below == 'below' && -1 || 0)]
+  def user(of_type)
+   self.users.select{|u| u.type == of_type.classify}.first
   end
- end
 
-What this is doing is matching a method looking like "layer_XXX". If the match (XXX) is 'above', than it's giving back the layer above the current one. If it's 'below' than it's giving back the layer below.
-What's nice about this is you no longer need to write a bunch of messy code in your method_missing. Instead, write it as reg_def's and have a cleaner definition of your class. Let's take a look at one more example:
+ end
+This is a simple example, but this allows you to access a specific kind of user directly, rather than passing the type or creating separate method declarations. So now you can do account.secretary and you'll get back a secretary object. Similarly, account.janitor will pass back the accounts janitor if it exists.
+What's nice about this is you no longer need to write a bunch of separate methods or messy logic in your method_missing. Instead, write it as reg_def's and have a cleaner definition of your class. Let's take a look at one more example with functionality separated out into a module:
 
- class Example < ActiveRecord::Base
+ module Modular
   include ::Irregular::Method
-  
- has_many :users
- has_many :cars
 
-  reg_def [/^capable_(.+)s$/, /^capable_(.+)$/] do |match, args|
-   self.send["#{m[1]}s"].select{|item| self.capable?(item)}
+  reg_def(/^say_(.+)$/) do |match, args|
+   self.speak(match[1].humanize)
+  end
+
+  def speak(words)
+   "#{self.name} says: #{words}"
+  end
+ end
+
+ class Talker
+  include Modular
+
+  def initialize(name)
+   @name = name
   end
 
-  def capable?(something)
-   ... # do something to determine if this object is "capable"
+  def name
+   @name
   end
  end
 
- e = Example.find 1
- e.users
-  => [#<User id: 1, created_at: "2010-01-27 01:09:42", updated_at: "2010-01-27 01:09:42">, #<User id: 4, created_at: "2010-01-27 03:09:42", updated_at: "2010-01-27 03:09:42">]
+The above code allows you to do this:
 
- e.capable_users
-  => [#<User id: 1, created_at: "2010-01-27 01:09:42", updated_at: "2010-01-27 01:09:42">]
+ t = Talker.new('John')
+ t.say_hello => 'John says: hello'
 
-You may have noticed that you can pass an array to to the reg_def. It will check each element of that array for a match. ORDER IS IMPORTANT! Take the example case... If we swapped the order of the regular expressions we would be sending self the method "userss" which would obviously be incorrect. Now, please don't yell at me... I understand I should be using m[1].pluralize.... It's an EXAMPLE... and I didn't want to think too hard. It hurts when I do that.
+You can pass in a single regular expression to the reg_def method, or you can pass an array of expressions. If you pass an array, make sure the order is from most specific to least specific.
 
 ---
 
 == Important Things (not from Demetri Martin)
-* irregular_method can be used on ANY ruby object.
+* irregular_method can be used in ANY ruby class or module.
 
-* The reference to 'self' IS a reference to the instance of the class. Normally, it would be a reference to the class since it's being evaluated as a class method, but there's a workaround. In any case, using self to reference the instance of the class you're working with is absolutely correct.
+* The reference to 'self' IS a reference to the instance of the class. Normally, it would be a reference to the class since it's being evaluated as a class method, but the actual call to the block is bound to 'self'. In any case, using self to reference the instance of the class you're working with is absolutely correct.
 
 == Copyright
 

data/Rakefile

@@ -5,8 +5,8 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "irregular_method"
-    gem.summary = "Method missing is messy. Fix it by defining regular expression methods."
-    gem.description = "Writing a bunch of case statements to handle regular expressions in method missing is just plain annoying. I suggest they get separated out and defined as their own methods. Well... ruby doesn't really let that happen, so this is the alternative."
+    gem.summary = "Method missing logic is messy. Fix it by defining regular expression methods."
+    gem.description = "Rather than having a bunch of lame logic in your method_missing method, define separated regular expression methods that are called when no normally defined method matches."
     gem.email = "mdnelson30@gmail.com"
     gem.homepage = "http://github.com/mnelson/irregular_method"
     gem.authors = ["Mike Nelson"]

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/irregular_method.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{irregular_method}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mike Nelson"]
-  s.date = %q{2010-03-15}
-  s.description = %q{Writing a bunch of case statements to handle regular expressions in method missing is just plain annoying. I suggest they get separated out and defined as their own methods. Well... ruby doesn't really let that happen, so this is the alternative.}
+  s.date = %q{2010-03-19}
+  s.description = %q{Rather than having a bunch of lame logic in your method_missing method, define separated regular expression methods that are called when no normally defined method matches.}
   s.email = %q{mdnelson30@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
      "lib/irregular_method.rb",
      "spec/irregular_method_spec.rb",
      "spec/models/method_missing.rb",
+     "spec/models/modular.rb",
      "spec/models/plain_object.rb",
      "spec/models/user.rb",
      "spec/schema.rb",
@@ -37,10 +38,11 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Method missing is messy. Fix it by defining regular expression methods.}
+  s.summary = %q{Method missing logic is messy. Fix it by defining regular expression methods.}
   s.test_files = [
     "spec/irregular_method_spec.rb",
      "spec/models/method_missing.rb",
+     "spec/models/modular.rb",
      "spec/models/plain_object.rb",
      "spec/models/user.rb",
      "spec/schema.rb",

data/lib/irregular_method.rb

@@ -1,30 +1,37 @@
+require 'rubygems'
+require 'active_support'
+
 module Irregular
+	
 	module Method
 		
 		def self.included(base)
-			base.extend Irregular::Method::ClassMethods
-			
+			base.send :extend, Irregular::Method::ClassMethods
 		end
-		
+				
 		module ClassMethods
 			
+			
 			def reg_def(regex, &block)
-				if(!self.included_modules.include?(Irregular::Method::InstanceMethods))
+				if(!self.include?(Irregular::Method::InstanceMethods))
 					send(:include, Irregular::Method::InstanceMethods)
 					send('irregular_methods=', [])
 				end
+				
 				irregular_methods << [[regex].flatten.compact, block]
 			end
 		end
 		
 		module InstanceMethods
+			
 			def self.included(base)
+				
 				base.class_eval do
-					cattr_accessor :irregular_methods
+					base.respond_to?(:cattr_accessor) && cattr_accessor(:irregular_methods) || mattr_accessor(:irregular_methods)
 				end
+				
 			end
 			
-			
 			def method_missing(name, *args)
 				method_id = name.to_s
 				irregular_methods && irregular_methods.each do |context|

data/spec/irregular_method_spec.rb

@@ -31,4 +31,13 @@ describe "IrregularMethod" do
 		
 	end
 	
+	
+	it "should integrate with modules" do 
+		t = Talker.new('Johnny')
+		t.say_hello.should eql("Johnny says: hello")
+		
+		t = NestedTalker.new('Charles')
+		t.say_hello.should eql("Charles says: hello")
+	end
+	
 end

data/spec/models/modular.rb

@@ -0,0 +1,40 @@
+module Modular
+	include ::Irregular::Method
+	
+	reg_def(/^say_(.+)$/) do |match, args|
+		self.speak(match[1])
+	end
+	
+	def speak(words)
+		"#{self.name} says: #{words}"
+	end
+end
+
+class Talker
+	include Modular
+	
+	def initialize(name)
+		@name = name
+	end
+	
+	def name
+		@name
+	end
+end
+
+module NestedModular
+	include Modular
+	
+end
+
+class NestedTalker
+	include NestedModular
+	
+	def initialize(name)
+		@name = name
+	end
+	
+	def name
+		@name
+	end
+end

data/spec/spec_helper.rb

@@ -8,6 +8,7 @@ require 'spec/autorun'
 require 'models/method_missing'
 require 'models/user'
 require 'models/plain_object'
+require 'models/modular'
 
 ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
 ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Mike Nelson
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 -04:00
+date: 2010-03-19 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,7 +31,7 @@ dependencies:
         version: 1.2.9
   type: :development
   version_requirements: *id001
-description: Writing a bunch of case statements to handle regular expressions in method missing is just plain annoying. I suggest they get separated out and defined as their own methods. Well... ruby doesn't really let that happen, so this is the alternative.
+description: Rather than having a bunch of lame logic in your method_missing method, define separated regular expression methods that are called when no normally defined method matches.
 email: mdnelson30@gmail.com
 executables: []
 
@@ -51,6 +51,7 @@ files:
 - lib/irregular_method.rb
 - spec/irregular_method_spec.rb
 - spec/models/method_missing.rb
+- spec/models/modular.rb
 - spec/models/plain_object.rb
 - spec/models/user.rb
 - spec/schema.rb
@@ -85,10 +86,11 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Method missing is messy. Fix it by defining regular expression methods.
+summary: Method missing logic is messy. Fix it by defining regular expression methods.
 test_files: 
 - spec/irregular_method_spec.rb
 - spec/models/method_missing.rb
+- spec/models/modular.rb
 - spec/models/plain_object.rb
 - spec/models/user.rb
 - spec/schema.rb