rulebook 0.3.3 → 0.4.0

data/.document

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

data/Gemfile

@@ -0,0 +1,7 @@
+gem 'meta_tools'
+
+group :development do
+  gem 'rake'
+  gem 'riot'
+  gem 'jeweler'
+end

data/Gemfile.lock

@@ -0,0 +1,21 @@
+GEM
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    meta_tools (0.1.0)
+    rake (0.8.7)
+    riot (0.12.3)
+      rr
+    rr (1.0.2)
+
+PLATFORMS
+  x86-mingw32
+
+DEPENDENCIES
+  jeweler
+  meta_tools
+  rake
+  riot

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Ryan Lewis
+Copyright (c) 2009,2010,2011 Ryan Lewis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,4 @@
-# rulebook
+# rulebook ![](http://stillmaintained.com/c00lryguy/rulebook.png)
 
 Allows you to define a set of 'rules' or dynamic methods to apply to a class.
 
@@ -7,68 +7,56 @@ Allows you to define a set of 'rules' or dynamic methods to apply to a class.
     > gem update --system
     > gem install rulebook
 
-## _Notice_
-
-The format is _back_ to what it was before 0.2.2!
-
 ## Simple Example
 
     require 'rulebook'
     
     class User
-        def initialize(name)
-            @name = name
-        end
-        
-        rule /say_(.+)/ do |what_to_say|
-            puts "#{@name} says '#{what_to_say.gsub(/_/, ' ')}'"
-        end
+      follows_the_rules!
+
+      def initialize(name)
+        @name = name
+      end
+      
+      rulebook.add /say_(.+)/ do |what_to_say|
+        puts "#{@name} says '#{what_to_say.gsub(/_/, ' ')}'"
+      end
     end
     
     User.new('Ryan').say_hello_world # => Ryan says 'hello world'
 
 ## How It Works
 
-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 `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_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.
+TODO
 
 ## Better Example
 
     require 'rulebook'
     
     class User
-        attr :name, :title
-        
-        def initialize(name)
-            @name = name
-            @title = :user
-        end
-        
-        rule /is_(admin|moderator|super_user|user)/ do |title|
-            @title = title.to_sym
-        end
+      attr :name, :title
+      
+      def initialize(name)
+        @name = name
+        @title = :user
+      end
+      
+      rulebook.add /is_(admin|moderator|super_user|user)/ do |title|
+        @title = title.to_sym
+      end
     end
     
 You can now do things like
 
-    users = [
-        User.new('Ryan'),
-        User.new('Natale'),
-        User.new('Joe'),
-        User.new('Monica'),
-        User.new('Matt'),
-        User.new('Jess')
-    ].shuffle
+    users = ['Ryan', 'Natale', 'Kasey', 'Jenna', 'Joe', 'Monica','Allan', 'Amanda']
+    users.collect! { |n| User.new(n) }.shuffle!
     
     users[0].is_admin
     users[1].is_moderator
     users[2].is_super_user
     
     users.each do |user|
-        puts "#{user.name} is a #{user.title}"
+      puts "#{user.name} is a #{user.title}"
     end
 
 ## Class Methods Example
@@ -76,26 +64,32 @@ You can now do things like
     require 'rulebook'
     
     class Car
-        attr :make, :model
-        
-        def initialize(make, model)
-            @make, @model = make.capitalize, model.capitalize
-        end
-        
-        class_rule /new_([a-z]+)_(.+)/ do |make, model|
-            new(make, model)
+      attr :make, :model
+      
+      def initialize(make, model)
+        @make, @model = make.capitalize, model.capitalize
+      end
+      
+      class << self
+        follows_the_rules!
+
+        rulebook.add /new_([a-z]+)_(.+)/ do |make, model|
+          new(make, model)
         end
+      end
     end
     
     my_cars = [
-        Car.new_honda_accord,
-        Car.new_dodge_neon,
-        Car.new_volkswagen_beetle
+      Car.new_honda_accord,
+      Car.new_dodge_neon,
+      Car.new_volkswagen_beetle
     ]
     
     p my_cars.first.make # => "Honda"
     p my_cars.first.model # => "Accord"
 
+This works out if you already have ``
+
 ### Now lets add some instance rules
 
     class Car

data/Rakefile

@@ -1,64 +1,43 @@
 require 'rubygems'
-require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "rulebook"
-    gem.summary = %Q{Allows you to define a set of 'rules' or dynamic methods to apply to a class}
-    gem.description = %Q{Lets you define methods with regex for dynamic methods}
-    gem.email = "c00lryguy@gmail.com"
-    gem.homepage = "http://github.com/c00lryguy/rulebook"
-    gem.authors = ["Ryan Lewis"]
-    # gem.add_development_dependency "riot", ">= 0"
-    # 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
+# Gay as hell jeweler workaround
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-    test.libs << 'lib' << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = false
-end
+require 'psych'
+YAML::ENGINE.yamler = 'psych'
 
+require 'bundler'
 begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/*_test.rb'
-    test.verbose = false
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
 end
+require 'rake'
 
-task :test => :check_dependencies
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "rulebook #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rulebook"
+  gem.homepage = "http://github.com/c00lryguy/rulebook"
+  gem.license = "MIT"
+  gem.summary = %Q{Define methods with regex for dynamic methods.}
+  gem.description = %Q{Allows you to define a set of 'rules' or dynamic methods to apply to a class.}
+  gem.email = "c00lryguy@gmail.com"
+  gem.authors = ["Ryan Lewis"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  gem.add_runtime_dependency 'meta_tools', '> 0.1'
+  gem.add_development_dependency 'rake', '> 0.0.0'
+  gem.add_development_dependency 'riot', '> 0.0.0'
 end
+Jeweler::RubygemsDotOrgTasks.new
 
+require 'rake/testtask'
 
-begin
-    require 'reek/rake/task'
-
-    Reek::Rake::Task.new do |t|
-        t.fail_on_error = true
-        t.verbose = true
-    end
-rescue LoadError
-end
+Rake::TestTask.new(:test) do |t|
+  t.libs.concat ['lib', 'test']
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = false
+end
+task :default => :test

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.4.0

data/examples/simple.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'rulebook'
+
+class User
+  follows_the_rules!
+
+  attr :title
+
+  def initialize(title=:user)
+    @title = title
+  end
+
+  rulebook.add /^is_(admin|user)$/ do |title|
+    @title = title.to_sym
+    self
+  end
+
+  rulebook.add /^is_(admin|user)\?$/ do |title|
+    @title == title.to_sym
+  end
+
+  class << self
+    metaclass.follows_the_rules!
+    metaclass.rulebook.add /^new_(admin|user)$/ do |title|
+      instance = new
+      instance.instance_eval { @title = title.to_sym }
+      instance
+    end
+  end
+end
+
+u = User.new
+
+p u.is_user?  # => true
+p u.is_admin? # => false
+
+u.is_admin
+
+p u.is_user?  # => false
+p u.is_admin? # => true
+
+u = User.new_admin
+p u.is_admin? # => true

data/lib/rulebook.rb

@@ -1,158 +1,19 @@
-class RuleBook  
-  class Rule
-    attr :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 [](query)
-      query.to_s.match(@what_to_capture)
-    end
-    alias_method :match_against, :[]
-    
-    def matches_against?(query)
-      !self[query].nil?
-    end
-  end
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
 
-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 rules_that_match_against(regexp)
-    @rules.find_all { |rule| rule.matches_against?(regexp) }
-  end
+class Rulebook
+  VERSION = "0.4.0"
 end
 
-# TODO: DRY up the code here a bit...
-class RuleBook
-  module IncludeMethods
-    def respond_to?(meth)
-      rulebook = self.class.const_get('INSTANCE_RULEBOOK')
-      rulebook.rules_that_match_against(meth).any? || super
-    end 
-    
-    def method_missing(meth, *args, &block)
-      rulebook = self.class.const_get('INSTANCE_RULEBOOK')
-      rules = rulebook.rules_that_match_against(meth)
-      
-      # TODO: Why would this ever be nil?
-      unless rules.nil? || rules.empty?
-        # Run the first matched rule..
-        # TODO: if the method NEXT if called within the rule, 
-        #       then goto the next matched rule
-        rule = rules.first 
-        captures = rule[meth].captures || []
-        block = rule.block
-        
-        # Remove the possibility of optional arguments
-        arity = block.arity == -1 ? 0 : block.arity
-        
-        # Define the method
-        klass = self.class
-        klass.send(:define_method, meth) do |*args|
-          instance_exec(*(captures + args).take(arity), &block)
-        end 
-        
-        # Call the method
-        send(meth, *args, &block)
-      else
-        super
-      end
-    end
-  end
-  
-  module ExtendMethods
-    def respond_to?(meth)
-      rulebook = const_get('CLASS_NOTEBOOK')
-      rulebook.rules_that_match_against(meth).any? || super
-    end 
-    
-    def method_missing(meth, *args, &block)
-      rulebook = const_get('CLASS_NOTEBOOK')
-      rules = rulebook.rules_that_match_against(meth)
-      
-      # TODO: Why would this ever be nil?
-      unless rules.nil? || rules.empty?
-        # Run the first matched rule..
-        # TODO: if the method NEXT if called within the rule, 
-        #       then goto the next matched rule
-        rule = rules.first 
-        captures = rule[meth].captures || []
-        block = rule.block
-        
-        # Remove the possibility of optional arguments
-        arity = block.arity == -1 ? 0 : block.arity
-        
-        # Define the method
-        klass = class << self; self; end
-        klass.send(:define_method, meth) do |*args|
-          class_exec(*(captures + args).take(arity), &block)
-        end 
-        
-        # Call the method
-        send(meth, *args, &block)
-      else
-        super
-      end
-    end
-  end
-end
+require 'rulebook/rule'
 
-# TODO: DRY up the code here too...
-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
+class Rulebook
+  attr_accessor :rules
+  def initialize; @rules = []; end
+  def add(what_to_capture, &block); @rules << Rule.new(what_to_capture, &block); end
+  def [](query); @rules.find_all { |rule| rule.matches_against?(query) }; end
+  alias_method :rules_that_match_against, :[]
 end
+
+require 'rulebook/class_methods'
+require 'rulebook/instance_methods'
+require 'rulebook/core_ext/module'