irregular_method 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+
+spec/*.log
+spec/database.yml

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Mike Nelson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,71 @@
+= 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.
+
+== Installation
+
+Install the gem
+ gem install irregular_method
+
+Add it to your environment.rb
+
+ config.gem 'irregular_method'
+
+== Usage
+
+The purpose of irregular_method is to allow methods with regular expression names to be defined. To do so, simply define a method using the reg_def command.
+
+ reg_def( /^total_(.+)$/) do |m, args|
+  ...
+  # do something with the match data and arguments
+  ...
+ 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:
+
+ class Layer < ActiveRecord::Base
+  
+  cattr_accessor :layers
+  attr_accessible :index
+
+  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)]
+  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:
+
+ class Example < ActiveRecord::Base
+ 
+ has_many :users
+ has_many :cars
+
+  reg_def [/^capable_(.+)s$/, /^capable_(.+)$/] do |match, args|
+   self.send["#{m[1]}s"].select{|item| self.capable?(item)}
+  end
+
+  def capable?(something)
+   ... # do something to determine if this object is "capable"
+  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">]
+
+ e.capable_users
+  => [#<User id: 1, created_at: "2010-01-27 01:09:42", updated_at: "2010-01-27 01:09:42">]
+
+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.
+
+---
+
+== Important Things (not from Demetri Martin)
+
+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.
+
+== Copyright
+
+Copyright (c) 2010 Mike Nelson. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+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, but there is an alternative."
+    gem.email = "mdnelson30@gmail.com"
+    gem.homepage = "http://github.com/mnelson/irregular_method"
+    gem.authors = ["Mike Nelson"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "irregular_method #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/irregular_method.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{irregular_method}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mike Nelson"]
+  s.date = %q{2010-02-01}
+  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, but there is an alternative.}
+  s.email = %q{mdnelson30@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "irregular_method.gemspec",
+     "lib/irregular_method.rb",
+     "spec/irregular_method_spec.rb",
+     "spec/models/method_missing.rb",
+     "spec/schema.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/mnelson/irregular_method}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Method missing is messy. Fix it by defining regular expression methods.}
+  s.test_files = [
+    "spec/irregular_method_spec.rb",
+     "spec/models/method_missing.rb",
+     "spec/schema.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/irregular_method.rb

@@ -0,0 +1,47 @@
+module Irregular
+	module Method
+		
+		def self.included(base)
+			base.extend Irregular::Method::ClassMethods
+			
+		end
+		
+		module ClassMethods
+			
+			def reg_def(regex, &block)
+				if(!self.included_modules.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
+				end
+			end
+			
+			
+			def method_missing(name, *args)
+				method_id = name.id2name
+				irregular_methods && irregular_methods.each do |context|
+					regex = context[0]
+					block = context[1]
+					regex.each do |reg|
+						if method_id =~ reg
+							return block.bind(self).call($~, args)
+						end
+					end
+				end
+				super
+			end
+			
+		end
+		
+	end
+end
+
+::ActiveRecord::Base.send :include, ::Irregular::Method

data/spec/irregular_method_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "IrregularMethod" do
+  it "should implement and bind reg_def properly" do
+    mm = MethodMissing.create(:name => 'mm1')
+		MethodMissing.irregular_methods.size.should eql(4)
+		
+		mm.nothing_test.should eql('mm1 found: nothing')
+		mm.dogs_method_cats.should eql('mm1 found 2 things: dogs and cats')
+		mm.argument_tester('hello').should eql('mm1 sees an argument: hello')
+		mm.test_multiple.should eql('mm1 handles multiple options: test')
+		mm.success_options.should eql('mm1 handles multiple options: success')
+  end
+end

data/spec/models/method_missing.rb

@@ -0,0 +1,19 @@
+class MethodMissing < ActiveRecord::Base
+	
+	reg_def(/^(.+)_test$/) do |m, args|
+		"#{self.name} found: #{m[1]}"
+	end
+	
+	reg_def(/^(.+)_method_(.+)$/) do |m, args|
+		"#{self.name} found 2 things: #{m[1]} and #{m[2]}"
+	end
+	
+	reg_def(/^(.+)_tester$/) do |m, args|
+		"#{self.name} sees an argument: #{args[0]}"
+	end
+	
+	reg_def [/^(.+)_multiple$/, /^(.+)_options$/] do |m, args|
+		"#{self.name} handles multiple options: #{m[1]}"
+	end
+	
+end

data/spec/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define :version => 0 do
+  
+	create_table :method_missings, :force => true do |t|
+		t.string :name
+		t.timestamps
+	end
+
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format specdoc
+--loadby mtime

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_record'
+require 'irregular_method'
+require 'spec'
+require 'spec/autorun'
+require 'models/method_missing'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'mysql')
+ 
+load(File.dirname(__FILE__) + '/schema.rb')
+
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: irregular_method
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mike Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-01 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+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, but there is an alternative.
+email: mdnelson30@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- irregular_method.gemspec
+- lib/irregular_method.rb
+- spec/irregular_method_spec.rb
+- spec/models/method_missing.rb
+- spec/schema.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mnelson/irregular_method
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: Method missing is messy. Fix it by defining regular expression methods.
+test_files: 
+- spec/irregular_method_spec.rb
+- spec/models/method_missing.rb
+- spec/schema.rb
+- spec/spec_helper.rb