rulebook 0.3.0 → 0.3.1

data/README.md

@@ -29,11 +29,11 @@ The format is _back_ to what it was before 0.2.2!
 
 ## How It Works
 
-When you call the `rules` method in a class, it defines the constant `INSTANCE_RULEBOOK` and sets it to a new `RuleBook` instance; but only if the constant wasn't already defined. This way, it only defines the constant the first time you call the `rules` method.
+When you call the `rule` method in a class, it defines the constant `INSTANCE_RULEBOOK` and sets it to a new `RuleBook` instance; but only if the constant wasn't already defined. This way, it only defines the constant the first time you call the `rule` method.
 
-When the first time `rules` is called in a class, we also include the `RuleBook::InstanceMethods` module which overrides the classes `method_missing`. So when you call an undefined method on your class's instance, we will try to match the method against the rules you've defined in `INSTANCE_RULEBOOK`.
+When the first time `rule` is called in a class, we also include the `RuleBook::IncludeMethods` module which overrides the classes `method_missing`. So when you call an undefined method on your class's instance, we will try to match the method against the rules you've defined in `INSTANCE_RULEBOOK`.
 
-There is also a method called `class_rules` which does the same as rules does, only it defines the `CLASS_RULEBOOK` constance in the class; which is a different `RuleBook` instance. The first time `class_rules` is called, it extends the class with the `RuleBook::ClassMethods` module, which also contains a `method_missing` method.
+There is also a method called `class_rule` which does the same as rules does, only it defines the `CLASS_RULEBOOK` constance in the class; which is a different `RuleBook` instance. The first time `class_rules` is called, it extends the class with the `RuleBook::ExtendMethods` module, which also contains a `method_missing` method.
 
 ## Better Example
 
@@ -126,7 +126,16 @@ Since 0.2 you can call the class methods `rules` and `class_rules` to wrap your
         rule(...){}
     end
     
-The result is exactly the same.
+The result is exactly the same. These are also callable from inside the class.
+
+    class Car
+        rules do
+            rule(...){}
+        end
+        class_rules do
+            rule(...){}
+        end
+    end
 
 #### There are more examples in the examples and [test][1] directories and [Rubular][2] is a great place to test your Regexp.
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.3.1

data/lib/rulebook.rb

@@ -1,116 +1,116 @@
-class RuleBook  
-    class Rule
-        attr :what_to_capture, :block
-        
-        def initialize(what_to_capture, &block)
-            raise(TypeError, 'what_to_capture must be of type Regexp') \
-                unless what_to_capture.is_a?(Regexp)
-                
-            @what_to_capture, @block = what_to_capture, block
-        end
-        
-        def matches_against?(query)
-            !match_against(query).nil?
-        end
-        
-        def match_against(query)
-            query.to_s.match(@what_to_capture)
-        end
-    end
-end
-
-class RuleBook
-    attr :rules
-    
-    def initialize
-        @rules = []
-    end
-    
-    def rule(what_to_capture, &block)
-        rule = Rule.new(what_to_capture, &block)
-        @rules << rule
-        rule
-    end
-    
-    def find_rules_that_match_against(query)
-        @rules.find_all { |rule| !query.to_s.match(rule.what_to_capture).nil? }
-    end
-end
-
-class RuleBook
-    module IncludeMethods
-        def method_missing(meth, *args, &block)
-            rulebook = self.class.const_get('INSTANCE_RULEBOOK')
-            rules = rulebook.find_rules_that_match_against(meth)
-            
-            unless rules.nil? || rules.empty?
-                rule = rules.first
-                match = rule.match_against(meth)
-                instance_exec(*match.captures, *args, &rule.block)
-            else
-                super
-            end
-        end
-    end
-    
-    module ExtendMethods
-        def method_missing(meth, *args, &block)
-            rulebook = const_get('CLASS_NOTEBOOK')
-            rules = rulebook.find_rules_that_match_against(meth)
-            
-            unless rules.nil?
-                rule = rules.first
-                match = rule.match_against(meth)
-                class_exec(*match.captures, *args, &rule.block)
-            else
-                super
-            end
-        end
-    end
-end
-
-class Module
-    def rule(what_to_capture, &block)
-        raise(ArgumentError, 'rules must have a block') unless block_given?
-        
-        setup_rulebook('INSTANCE_RULEBOOK', :include)
-        const_get('INSTANCE_RULEBOOK').rule(what_to_capture, &block)
-    end
-    
-    def class_rule(what_to_capture, &block)
-        raise(ArgumentError, 'class_rules must have a block') unless block_given?
-        
-        setup_rulebook('CLASS_NOTEBOOK', :extend)
-        const_get('CLASS_NOTEBOOK').rule(what_to_capture, &block)
-    end
-    
-    def rules(&block)
-        raise(ArgumentError, 'rules must have a block') unless block_given?
-        
-        setup_rulebook('INSTANCE_RULEBOOK', :include)
-        const_get('INSTANCE_RULEBOOK').instance_eval(&block)
-        const_get('INSTANCE_RULEBOOK')
-    end
-    
-    def class_rules(&block)
-        raise(ArgumentError, 'class_rules must have a block') unless block_given?
-        
-        setup_rulebook('CLASS_NOTEBOOK', :extend)
-        const_get('CLASS_NOTEBOOK').instance_eval(&block)
-        const_get('CLASS_NOTEBOOK')
-    end
-    
-    private
-    
-    def setup_rulebook(rulebook_constant, extend_or_include)
-        raise(ArgumentError, 'extend_or_include must be :extend or :include') \
-            unless [:extend, :include].include?(extend_or_include)
-            
-        unless const_defined?(rulebook_constant)
-            const_set(rulebook_constant, RuleBook.new)
-            
-            module_name = extend_or_include.to_s.capitalize + 'Methods'
-            send(extend_or_include, RuleBook.const_get(module_name))
-        end
-    end
-end
+class RuleBook  
+    class Rule
+        attr_accessor :what_to_capture, :block
+        
+        def initialize(what_to_capture, &block)
+            raise(TypeError, 'what_to_capture must be of type Regexp') \
+                unless what_to_capture.is_a?(Regexp)
+                
+            @what_to_capture, @block = what_to_capture, block
+        end
+        
+        def matches_against?(query)
+            !match_against(query).nil?
+        end
+        
+        def match_against(query)
+            query.to_s.match(@what_to_capture)
+        end
+    end
+end
+
+class RuleBook
+    attr_accessor :rules
+    
+    def initialize
+        @rules = []
+    end
+    
+    def rule(what_to_capture, &block)
+        rule = Rule.new(what_to_capture, &block)
+        @rules << rule
+        rule
+    end
+    
+    def find_rules_that_match_against(query)
+        @rules.find_all { |rule| !query.to_s.match(rule.what_to_capture).nil? }
+    end
+end
+
+class RuleBook
+    module IncludeMethods
+        def method_missing(meth, *args, &block)
+            rulebook = self.class.const_get('INSTANCE_RULEBOOK')
+            rules = rulebook.find_rules_that_match_against(meth)
+            
+            unless rules.nil? || rules.empty?
+                rule = rules.first
+                match = rule.match_against(meth)
+                instance_exec(*(match.captures||[] + args)[0...rule.block.arity], &rule.block)
+            else
+                super
+            end
+        end
+    end
+    
+    module ExtendMethods
+        def method_missing(meth, *args, &block)
+            rulebook = const_get('CLASS_NOTEBOOK')
+            rules = rulebook.find_rules_that_match_against(meth)
+            
+            unless rules.nil?
+                rule = rules.first
+                match = rule.match_against(meth)
+                class_exec(*(match.captures||[] + args)[0...rule.block.arity], &rule.block)
+            else
+                super
+            end
+        end
+    end
+end
+
+class Module
+    def rule(what_to_capture, &block)
+        raise(ArgumentError, 'rules must have a block') unless block_given?
+        
+        setup_rulebook('INSTANCE_RULEBOOK', :include)
+        const_get('INSTANCE_RULEBOOK').rule(what_to_capture, &block)
+    end
+    
+    def class_rule(what_to_capture, &block)
+        raise(ArgumentError, 'class_rules must have a block') unless block_given?
+        
+        setup_rulebook('CLASS_NOTEBOOK', :extend)
+        const_get('CLASS_NOTEBOOK').rule(what_to_capture, &block)
+    end
+    
+    def rules(&block)
+        raise(ArgumentError, 'rules must have a block') unless block_given?
+        
+        setup_rulebook('INSTANCE_RULEBOOK', :include)
+        const_get('INSTANCE_RULEBOOK').instance_eval(&block)
+        const_get('INSTANCE_RULEBOOK')
+    end
+    
+    def class_rules(&block)
+        raise(ArgumentError, 'class_rules must have a block') unless block_given?
+        
+        setup_rulebook('CLASS_NOTEBOOK', :extend)
+        const_get('CLASS_NOTEBOOK').instance_eval(&block)
+        const_get('CLASS_NOTEBOOK')
+    end
+    
+    private
+    
+    def setup_rulebook(rulebook_constant, extend_or_include)
+        raise(ArgumentError, 'extend_or_include must be :extend or :include') \
+            unless [:extend, :include].include?(extend_or_include)
+            
+        unless const_defined?(rulebook_constant)
+            const_set(rulebook_constant, RuleBook.new)
+            
+            module_name = extend_or_include.to_s.capitalize + 'Methods'
+            send(extend_or_include, RuleBook.const_get(module_name))
+        end
+    end
+end

data/rulebook.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rulebook}
-  s.version = "0.3.0"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ryan Lewis"]
-  s.date = %q{2010-04-29}
+  s.date = %q{2010-05-01}
   s.description = %q{Lets you define methods with regex for dynamic methods}
   s.email = %q{c00lryguy@gmail.com}
   s.extra_rdoc_files = [
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
      "test/helper.rb",
      "test/test_chevy.rb",
      "test/test_class_methods.rb",
+     "test/test_rules.rb",
      "test/test_ryguy.rb",
      "test/test_user.rb"
   ]

data/test/test_chevy.rb

@@ -1,69 +1,69 @@
-require 'helper'
-
-class TestChevy < Test::Unit::TestCase
-    class Engine
-        attr :state
-        
-        def initialize
-            @state = "off"
-        end
-        
-        rules do
-            rule(/is_(.*)/) do |state|
-                @state = state.gsub(/_/, " ")
-            end
-        end
-    end
-
-    context 'A Chevy engine checked with #state_is?' do
-        setup do
-            @chevy = Engine.new
-            class << @chevy
-                def state_is?(state)
-                    @state == state
-                end
-            end
-        end
-        
-        should 'be off' do
-            assert @chevy.state_is?('off')
-        end
-        
-        should 'be idling' do
-            @chevy.is_idling
-            assert @chevy.state_is?('idling')
-        end
-        
-        should 'be broken as usual' do
-            @chevy.is_broken_as_usual
-            assert @chevy.state_is?('broken as usual')
-        end
-    end
-    
-    context 'A Chevy engine checked with custom rule' do
-        setup do
-            @chevy = Engine.new
-            class << @chevy
-                rules do
-                    rule(/is_(.*)?/) do |state|
-                        @state == state
-                    end
-                end
-            end
-        end
-        
-        should 'be off' do
-            assert @chevy.is_off?
-        end
-        
-        should 'be idling' do
-            @chevy.is_idling
-            assert @chevy.is_idling?
-        end
-        
-        should 'be broken as usual' do
-            @chevy.is_broken_as_usual
-            assert @chevy.is_broken_as_usual?
-        end
-    end
-end
+require 'helper'
+
+class TestChevy < Test::Unit::TestCase
+    class Engine
+        attr_accessor :state
+        
+        def initialize
+            @state = "off"
+        end
+        
+        rules do
+            rule(/is_(.*)/) do |state|
+                @state = state.gsub(/_/, " ")
+            end
+        end
+    end
+
+    context 'A Chevy engine checked with #state_is?' do
+        setup do
+            @chevy = Engine.new
+            class << @chevy
+                def state_is?(state)
+                    @state == state
+                end
+            end
+        end
+        
+        should 'be off' do
+            assert @chevy.state_is?('off')
+        end
+        
+        should 'be idling' do
+            @chevy.is_idling
+            assert @chevy.state_is?('idling')
+        end
+        
+        should 'be broken as usual' do
+            @chevy.is_broken_as_usual
+            assert @chevy.state_is?('broken as usual')
+        end
+    end
+    
+    context 'A Chevy engine checked with custom rule' do
+        setup do
+            @chevy = Engine.new
+            class << @chevy
+                rules do
+                    rule(/is_(.*)?/) do |state|
+                        @state == state
+                    end
+                end
+            end
+        end
+        
+        should 'be off' do
+            assert @chevy.is_off?
+        end
+        
+        should 'be idling' do
+            @chevy.is_idling
+            assert @chevy.is_idling?
+        end
+        
+        should 'be broken as usual' do
+            @chevy.is_broken_as_usual
+            assert @chevy.is_broken_as_usual?
+        end
+    end
+end

data/test/test_class_methods.rb

@@ -1,53 +1,53 @@
-require 'helper'
-
-class TestClassMethods < Test::Unit::TestCase
-    class Car
-        attr :make, :model
-        
-        def initialize(make, model)
-            @make, @model = make, model
-        end
-        
-        class_rules do
-            rule(/new_([a-z]+)_(.+)/) do |make, model|
-                
-                make.capitalize!
-                model = model.split('_').inject(''){ |result, word|
-                    result << word.capitalize + ' '
-                }.strip
-                new(make, model)
-            end
-        end
-    end
-    
-    should 'be a Ford F150' do
-        @car = Car.new_ford_f150
-        assert_equal @car.make, 'Ford'
-        assert_equal @car.model, 'F150'
-    end
-
-    should 'be a Ford Mustang' do
-        @car = Car.new_ford_mustang
-        assert_equal @car.make, 'Ford'
-        assert_equal @car.model, 'Mustang'
-    end
-    
-    should 'be a Pontiac GTO' do
-        @car = Car.new_pontiac_gto
-        @car.model.upcase!
-        assert_equal @car.make, 'Pontiac'
-        assert_equal @car.model, 'GTO'
-    end
-    
-    should 'be a Toyota Camry' do
-        @car = Car.new_toyota_camry
-        assert_equal @car.make, 'Toyota'
-        assert_equal @car.model, 'Camry'
-    end
-    
-    should 'be a Hyundai Santa Fe' do
-        @car = Car.new_hyundai_santa_fe
-        assert_equal @car.make, 'Hyundai'
-        assert_equal 'Santa Fe', @car.model
-    end
-end
+require 'helper'
+
+class TestClassMethods < Test::Unit::TestCase
+    class Car
+        attr_accessor :make, :model
+        
+        def initialize(make, model)
+            @make, @model = make, model
+        end
+        
+        class_rules do
+            rule(/new_([a-z]+)_(.+)/) do |make, model|
+                
+                make.capitalize!
+                model = model.split('_').inject(''){ |result, word|
+                    result << word.capitalize + ' '
+                }.strip
+                new(make, model)
+            end
+        end
+    end
+    
+    should 'be a Ford F150' do
+        @car = Car.new_ford_f150
+        assert_equal @car.make, 'Ford'
+        assert_equal @car.model, 'F150'
+    end
+
+    should 'be a Ford Mustang' do
+        @car = Car.new_ford_mustang
+        assert_equal @car.make, 'Ford'
+        assert_equal @car.model, 'Mustang'
+    end
+    
+    should 'be a Pontiac GTO' do
+        @car = Car.new_pontiac_gto
+        @car.model.upcase!
+        assert_equal @car.make, 'Pontiac'
+        assert_equal @car.model, 'GTO'
+    end
+    
+    should 'be a Toyota Camry' do
+        @car = Car.new_toyota_camry
+        assert_equal @car.make, 'Toyota'
+        assert_equal @car.model, 'Camry'
+    end
+    
+    should 'be a Hyundai Santa Fe' do
+        @car = Car.new_hyundai_santa_fe
+        assert_equal @car.make, 'Hyundai'
+        assert_equal 'Santa Fe', @car.model
+    end
+end

data/test/test_ryguy.rb

@@ -1,45 +1,45 @@
-require 'helper'
-
-class TestRyguy < Test::Unit::TestCase
-    class Ryguy
-        attr :nouns, :adjectives
-        
-        rules do
-            rule(/is_a_(.*)/) do |noun|
-                @nouns ||= []
-                @nouns << noun.gsub(/_/, ' ')
-            end
-            
-            rule(/is_(.*)/) do |adjective|
-                @adjectives ||= []
-                @adjectives << adjective.gsub(/_/, ' ')
-            end
-        end
-    end
-    
-    context 'Ryguy' do
-        setup do
-            @ryguy = Ryguy.new
-            @ryguy.is_awesome
-            @ryguy.is_a_bear
-            @ryguy.is_superfly
-            @ryguy.is_a_programmer
-            @ryguy.is_fantastic
-            @ryguy.is_a_master_of_the_ancient_chinese_art_of_karate
-        end
-        
-        should 'be awesome, superfly, and fantastic' do
-            assert_same_elements(
-                ['awesome', 'superfly', 'fantastic'],
-                @ryguy.adjectives
-            )
-        end
-        
-        should 'be a bear, a programmer, and a master of karate' do
-            assert_same_elements(
-                ['bear', 'programmer', 'master of the ancient chinese art of karate'],
-                @ryguy.nouns
-            )
-        end
-    end
-end
+require 'helper'
+
+class TestRyguy < Test::Unit::TestCase
+    class Ryguy
+        attr_accessor :nouns, :adjectives
+        
+        rules do
+            rule(/is_a_(.*)/) do |noun|
+                @nouns ||= []
+                @nouns << noun.gsub(/_/, ' ')
+            end
+            
+            rule(/is_(.*)/) do |adjective|
+                @adjectives ||= []
+                @adjectives << adjective.gsub(/_/, ' ')
+            end
+        end
+    end
+    
+    context 'Ryguy' do
+        setup do
+            @ryguy = Ryguy.new
+            @ryguy.is_awesome
+            @ryguy.is_a_bear
+            @ryguy.is_superfly
+            @ryguy.is_a_programmer
+            @ryguy.is_fantastic
+            @ryguy.is_a_master_of_the_ancient_chinese_art_of_karate
+        end
+        
+        should 'be awesome, superfly, and fantastic' do
+            assert_same_elements(
+                ['awesome', 'superfly', 'fantastic'],
+                @ryguy.adjectives
+            )
+        end
+        
+        should 'be a bear, a programmer, and a master of karate' do
+            assert_same_elements(
+                ['bear', 'programmer', 'master of the ancient chinese art of karate'],
+                @ryguy.nouns
+            )
+        end
+    end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Ryan Lewis
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-29 00:00:00 -04:00
+date: 2010-05-01 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -41,6 +41,7 @@ files:
 - test/helper.rb
 - test/test_chevy.rb
 - test/test_class_methods.rb
+- test/test_rules.rb
 - test/test_ryguy.rb
 - test/test_user.rb
 has_rdoc: true