outlaw 0.1.2 → 0.1.3

data/README.md

@@ -1,35 +1,108 @@
 #Outlaw
 
 ##Keep bad code out of your projects.  Your idea of bad code, no one elses.
+##Because good documentation should be executable.
+
+###NOTE: Outlaw can evaluate any version ruby code, *BUT* it runs on only 1.9 -- set your system ruby to 1.9 to use
 
 ### Part of MendicantUniversity.org S10 class, personal project.
-From the included outlawed.rb example file for custom rule definition:
 
-    module Outlaw
-      outlaw "@@",                "Class variables are evil"
-      outlaw "protected",         "use private or public, protected is silly in ruby"
-      outlaw "module :token end", "nest modules to avoid empty module declarations"
-      outlaw "eval",              "never eval, rarely class_eval or instance_eval, but never eval"
-    end
+The current version of outlaw takes a user provided configuration file
+(currently named simply '.outlawed' in the project directory or user's home
+directory) and parses a series of method calls to the outlaw method (defined
+within the Outlaw module namespace, but module_eval'd so you don't need to
+namespace the file).  You can also define constants in your .outlawed file as
+collections of strings for use in your rules, but that will be addressed below.
+
+Each call to the outlaw method consists of two string arguments, the first an
+anti-pattern you wish to prohibit usage of in one or more projects, and the
+second an explanation to be provided when the anti-pattern is detected.
+
+### Syntax for rule creation:
+
+Some examples are included in the .outlawed.example file for reference:
+
+      outlaw "@@",                          "Class variables are evil"
+
+      outlaw "protected",                   "use private or public, protected
+                                            is silly in ruby"
+
+      outlaw "eval",                        "never eval, rarely class_eval or
+                                            instance_eval, but never eval"
+
+      outlaw "module :token end",           "nest modules to avoid empty module
+                                            declarations"
+
+      outlaw "class :symbol < :core_class", "core classes implemented in c,
+                                            can cause bad mojo"
+
+      outlaw :trailing_whitespace
+
+
+The first three examples are actual ruby keywords and features being outlawed
+and may not require much explanation except to indicate that they are detected
+via regular expression matches constructed from the strings, and attempt to use
+word boundaries intelligently so that eval is detected but not module_eval.
+
+The bottom two examples above use ruby symbols as standin variable or
+parameter names for identifiers that are matched at runtime with local
+variables, instance variables, class names and constants that may appear
+within the ruby program being analyzed.  Here, :symbol can be any ruby symbol
+if it appears only once, though if used multiple times it will only match the
+the same identifier on subsequent usage.  :core_class as used above is a
+special case where Outlaw has internally defined a constant called CORE_CLASS
+as a collection of string objects each containing the name of one of ruby's
+core classes.  You can define your own similar collections in the .outlawed
+file (to be loaded from an external data file preferably, if more than a few
+values) and then reference CONST_NAME as :const_name in your outlaw anti-
+patterns as above.  Presently mutliple references to the same collection
+are independent, but if there is interest special handling could be added to
+also match specific instances of a collection much like the symbol handling.
+
+The last one is a custom rule that calls a method defined on the Outlaw
+module called 'trailing_whitespace' which returns a Rule object.  Any
+such new methods may be defined in the .outlawed file (since it is
+module_eval'd into the outlaw namespace) and then outawed the same way.
+
+
+Outlaw currently ignores whitespace, parentheses and new lines, though I have
+ideas to change this behavior dynamically in certain rules if desired.
+
+Execute outlaw on your project from the root directory by simply entering
+"outlaw" into your shell, or specify another directory to run
+on with "outlaw /path/to/dir"
+
+Before using outlaw in a project you should create a .outlawed file which
+Outlaw will read rules from.
 
-### Proposed syntax for DSL:
+It comes with an example file (.outlawed.example) which is included in the
+gem and will be loaded if no .outlawed file is found in current directory or
+home directory, and will warn you to provide a real file (and provide
+location of the sample file in your system from the gem installation).
 
-  A defined collection exists for core classes, such that
+###Planned features (unimplemented):
+*Customize sensitivty , for instance whitespace is currently ignored, but
+could enforce style conventions with some whitespace sensitive rules.
+Also ignores parens, which might be required or prohibited in some
+context.
+*Specify AST-nodes of interest, and within them allow arbitrary amounts of
+code with a :disjoint_code_seperator token.
 
-    outlaw "class :symbol < :core_class",
-                              "core classes implemented in c, can cause bad mojo"
+This should allow, for instance, something like the following, which is not
+currently possible to outlaw in a useful way:
 
-  will outlaw subclassing from any core class
+    outlaw ":conditional_branch
+        unless
+        :disjoint_code_seperator
+        else",
+        "If you write unless else and think it makes sense then you are a
+        cylon"
 
+*Integrate Rails Best Practices gem, Reek gem, and perhaps others, so that individual issue
+detections they provide can be added as rules in the outlawed file while
+ignoring/not running other detection routines.
 
- Users can extend new defined collections and by creating new constants
-defined as arrays of variable names to match in example code the same
-way :core_class is used above
+*Automate optional integration with rake task and/or githooks for
+enforcement/notification of rules in a project.
 
-Disjoin code segments can be provided as a single example (assuming they
-occur in the same file) by inserting a :disjoint_code_seperator token in
-the outlawed sample definition.  I don't have a good use case for this
-at present though, and since it will be difficult to handle disjoint
-code across different files this may not be worthwhile...  but similar
-special case symbol meanings may be useful, and suggestions or examples
-are welcome. 
+*Specify classes of rules, such as log, warn and prevent for differing behavior regarding violations at runtime.

data/bin/outlaw

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
 
-require "outlaw"
+require_relative "../lib/outlaw"
 if File.exists?(Dir.pwd + '/.outlawed')
-  load Dir.pwd + "/.outlawed"
+   File.open(Dir.pwd + "/.outlawed") {|f| Outlaw.module_eval(f.read)}
 elsif File.exists?(Dir.home + '/.outlawed')
-  load Dir.home + '/.outlawed'
+   File.open(Dir.home + '/.outlawed') {|f| Outlaw.module_eval(f.read)}
 else
   puts "
   ***NOTICE:***
@@ -14,7 +14,8 @@ else
   at pwd first for ./outlawed and then at ~/.outlawed and defaults to example
   if neither is found\n\n"
 
-  load File.dirname(File.dirname(`gem which outlaw`.chop)) + '/examples/.outlawed.example'
+   File.open(File.dirname(File.dirname(`gem which outlaw`.chop)) +
+      '/examples/.outlawed.example') {|f| Outlaw.module_eval(f.read)}
 end
 
 puts Outlaw.enforce(ARGV[0] ? ARGV[0] : ".")

data/examples/.outlawed.example

@@ -1,5 +1,6 @@
 	outlaw "@@",                          "class variables are evil"
 	outlaw "protected",                   "use private or public, protected is silly in ruby"
 	outlaw "module :token end",           "nest modules to avoid empty module declarations"
-  outlaw "eval",                        "never eval, rarely class_eval or instance_eval, but never eval"
-  outlaw "class :symbol < :core_class", "core classes implemented in c, can cause bad mojo"
+  	outlaw "eval",                        "never eval, rarely class_eval or instance_eval, but never eval"
+  	outlaw "class :symbol < :core_class", "core classes implemented in c, can cause bad mojo"
+	outlaw :trailing_whitespace

data/lib/outlaw.rb

@@ -1,20 +1,34 @@
 require 'ripper'
-require_relative 'outlaw/law_dsl'
+require_relative 'outlaw/law_parser'
 require_relative 'outlaw/enforcement'
 require_relative 'outlaw/rule'
+require_relative 'outlaw/rule_methods'
+
 
-def outlaw(restriction, message)
-  law = Outlaw::LawDSL.parse(restriction, message)
-  Outlaw::Enforcement.add(law)
-end
 
 module Outlaw
-  def self.enforce(dir=".")
+  extend self
+  attr_accessor :ignore_types, :param_types
+
+  def outlaw(pattern, message=nil)
+    if pattern.kind_of?(String)
+      rule = Rule.new(pattern, message)
+      Outlaw::Enforcement.add(rule)
+    else
+      Outlaw::Enforcement.add(self.send(pattern))
+    end
+  end
+
+  def enforce(dir=".")
     Outlaw::Enforcement.process_directory(dir)
   end
-  PARAM_TYPES       = [:on_const, :on_ident, :on_ivar, :on_cvar]
-  IGNORE_TYPES      = [:on_sp, :on_nl, :on_ignored_nl, :on_rparen, :on_lparen]
-  SPECIAL_CASES     = [:disjoint_code_seperator] #need to work on naming here
-  CORE_CLASSES_FILE = File.expand_path("../../data/core_classes.txt", __FILE__)
-  CORE_CLASS        = File.readlines(CORE_CLASSES_FILE).map &:chomp
+  #these come from ripper's Lexer
+  self.param_types    = [:on_const, :on_ident, :on_ivar, :on_cvar]
+  self.ignore_types   = [:on_sp, :on_nl, :on_ignored_nl, :on_rparen, :on_lparen]
+  WHITESPACE          = [:on_sp, :on_nl, :on_ignored_nl]
+  VERTICAL_WHITESPACE = [:on_nl, :on_ignored_nl]
+  SPECIAL_CASES       = [:whitespace_sensitive, :vertical_whitespace_sensitive]
+
+  CORE_CLASSES_FILE   = File.expand_path("../../data/core_classes.txt", __FILE__)
+  CORE_CLASS          = File.readlines(CORE_CLASSES_FILE).map &:chomp
 end

data/lib/outlaw/enforcement.rb

@@ -1,10 +1,10 @@
 module Outlaw
   class Enforcement
     class << self
-      attr_reader :laws
-      def add(law)
-        @laws ||= []
-        @laws << law
+      attr_reader :rules
+      def add(rule)
+        @rules ||= []
+        @rules << rule
       end
 
       def process_directory(path)
@@ -21,10 +21,10 @@ module Outlaw
       def handle(file)
         if file.match(/.rb$/)
           text = File.open(file) {|f| f.read}
-          laws.each do |law|
-            if law.call(text)
-              puts "Outlaw Violation in file: #{file}\nRestriction:"   +
-                   "#{law.restriction}\n\n#{law.message}"
+          rules.each do |rule|
+            if rule.violation?(text)
+              puts "Outlaw Violation in file: #{file}\nRestriction:\n"   +
+                   "#{rule.pattern}\n#{rule.message}\n\n"
             end
           end
         end

data/lib/outlaw/law_parser.rb

@@ -0,0 +1,73 @@
+module Outlaw
+  module LawParser
+    extend self
+    def parse(restriction, rule)
+      tokens = restriction.split
+      parsed_restriction = []
+      tokens.each do |token|
+        case
+        when special_case?(string_to_sym(token))
+          handle_special(token, rule)
+        when multipart?(token)  #this handles multi-token literals, Const.new etc
+          parsed_restriction += Ripper.lex(token)
+                                      .reduce([]){|array, tkn|
+                                      array << token_type_regex(tkn) }
+        when defined_collection?(token)
+          parsed_restriction << Outlaw.const_get(string_to_sym(token.upcase))
+        when parameter?(token)
+          parsed_restriction << string_to_sym(token)
+        else
+          parsed_restriction += build_regex(token)
+        end
+      end
+       build_block(parsed_restriction)
+    end
+
+    private
+
+    def handle_special(token, rule)
+      rule.modifications ||= []
+      rule.modifications << string_to_sym(token)
+    end
+
+    def special_case?(token)
+      SPECIAL_CASES.include?(token)
+    end
+
+    def token_type_regex(token)
+      /#{token[2]}/
+    end
+
+    def parameter?(token)
+      token[0].chr == ':'
+    end
+
+    def defined_collection?(token)
+      parameter?(token) && Outlaw.const_defined?(string_to_sym(token.upcase))
+    end
+
+    def string_to_sym(str)
+      str[1..-1].to_sym
+    end
+
+    def build_regex(token)
+      #fully expect this hack to come back & haunt me, but passes curr. examples
+      [/\A#{token}/]
+    end
+
+    def multipart?(token)
+      !parameter?(token) && Ripper.lex(token).count > 1
+    end
+
+    def build_block(pattern)
+      ->(file) do
+        program = Ripper.tokenize(file)
+        program.each_with_index do |token, index|
+          next unless token.match(pattern.first)
+          return true if Rule.test(program, index, pattern)
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/outlaw/rule.rb

@@ -1,18 +1,50 @@
 module Outlaw
   class Rule
-    NoDetectionBlockProvided = Class.new(StandardError)
-    attr_reader :message, :restriction
-    def initialize(message, restriction, &detection_block)
-      raise NoDetectionBlockProvided unless detection_block
-      @message          = message
-      @restriction      = restriction
+    attr_reader :message, :pattern, :detection_block
+    attr_accessor :modifications
+    def initialize(pattern, message=nil, &detection_block)
+      @pattern          = pattern
+      @message          = message ? message : "Don't do this: #{pattern}"
       @detection_block  = detection_block
     end
 
-    def call(code)
-      @detection_block.call(code)
+    def violation?(code)
+      @detection_block = LawParser.parse(pattern, self) if detection_block.nil?
+      detect_violation(code)
     end
 
+    private
+
+    def detect_violation(code)
+      defaults = apply_modifications
+      result = detection_block.call(code)
+      apply_modifications(defaults)
+      result
+    end
+
+    def apply_modifications(restore=nil)
+      return nil if modifications.nil? && restore.nil?
+      default_ignores = Outlaw.ignore_types.clone
+      default_params  = Outlaw.param_types.clone
+      if modifications.include?(:whitespace_sensitive)
+        WHITESPACE.each do |ws|
+          Outlaw.ignore_types.delete(ws)
+          Outlaw.param_types << ws
+        end
+      end
+      if modifications.include?(:vertical_whitespace_sensitive)
+        VERTICAL_WHITESPACE.each do |ws|
+          Outlaw.ignore_types.delete(ws)
+          Outlaw.param_types << ws
+        end
+      end
+      Outlaw.ignore_types = restore.first if restore
+      Outlaw.param_types  = restore.last  if restore
+      [default_ignores, default_params]
+    end
+
+    public
+
     class << self
       def test(program, start_index, pattern)
         pattern_index = 0
@@ -20,8 +52,8 @@ module Outlaw
         start_index.upto(program.length) do |index|
           code = program[index]
           part = pattern[pattern_index]
-
-          next if IGNORE_TYPES.include? token_type(code)
+          return false if code.nil?
+          next if Outlaw.ignore_types.include?(token_type(code))
           return false unless match_token?(code, part, params[part])
           pattern_index +=1
           return true if pattern_index >= pattern.length
@@ -64,7 +96,7 @@ module Outlaw
 
       def param_type_equal(lex, param)
         #for now just check if it's a variable type, not kw, ws or other token
-        PARAM_TYPES.include? lex
+        Outlaw.param_types.include? lex
       end
 
       def token_type(code)

data/lib/outlaw/rule_methods.rb

@@ -0,0 +1,8 @@
+module Outlaw
+  def trailing_whitespace
+    Rule.new("Trailing whitespace",
+             "Trailing whitespace is ugly and can mess up version history") do |file|
+             file.match(/ \n/)
+           end
+  end
+end

data/lib/outlaw/version.rb

@@ -1,3 +1,3 @@
 module Outlaw
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/test/outlaw_test.rb

@@ -1,59 +1,61 @@
 require_relative 'test_helper'
 
 module Outlaw
-  describe LawDSL do
+  describe LawParser do
     it "returns a Rule which is called on code and returns true or false" do
   end
 
   before do
-        @okay_file = <<CODE
-class Whatever < Set
-  def okaything(here)
-    @here = here
-  end
-end
-
-module WithContent
-  def sumthin
-    class_eval('1 + 1')
-  end
-end
-CODE
-
+        @okay_file = %{
+          class Whatever < Set
+            def okaything(here)
+              @here = here
+            end
+          end
+
+          module WithContent
+            def sumthin
+              class_eval('1 + 1')
+            end
+
+            def okishthing
+            end
+          end
+        }
   end
 
 
 
     it "correctly builds rule for class var" do
       code1 = "@@"
-      rule1 = LawDSL.parse(code1)
+      rule1 = Rule.new(code1)
 
-      class_var_file = <<CODE
-  def badthing(here)
-    @@here = here
-  end
-CODE
+      class_var_file = %{
+        def badthing(here)
+          @@here = here
+        end
+      }
 
-      class_result    = rule1.call(class_var_file)
-      result1a        = rule1.call(@okay_file)
+      class_result    = rule1.violation?(class_var_file)
+      result1a        = rule1.violation?(@okay_file)
       class_result    .must_equal true
     end
 
     it "correctly builds rule for protected" do
       code2 = "protected"
-      rule2 = LawDSL.parse(code2)
+      rule2 = Rule.new(code2)
 
-    protected_file = <<CODE
-class Whatever
-  protected
-  def not_really
-    :false
-  end
-end
-CODE
+    protected_file = %{
+      class Whatever
+        protected
+        def not_really
+          :false
+        end
+      end
+    }
 
-      protected_result= rule2.call(protected_file)
-      result2a = rule2.call(@okay_file)
+      protected_result= rule2.violation?(protected_file)
+      result2a = rule2.violation?(@okay_file)
 
       protected_result.must_equal true
       result2a        .must_equal false
@@ -62,16 +64,16 @@ CODE
 
     it "correctly builds rule for eval" do
       code3 = "eval"
-      rule3 = LawDSL.parse(code3)
+      rule3 = Rule.new(code3)
 
-    eval_file = <<CODE
-  def not_really
-    eval('1 + 1')
-  end
-CODE
+    eval_file = %{
+      def not_really
+        eval('1 + 1')
+      end
+    }
 
-      eval_result = rule3.call(eval_file)
-      result3a    = rule3.call(@okay_file)
+      eval_result = rule3.violation?(eval_file)
+      result3a    = rule3.violation?(@okay_file)
 
       eval_result.must_equal true
       result3a.must_equal false
@@ -80,15 +82,15 @@ CODE
 
     it "correctly builds rule for module" do
       code4 = "module :name end"
-      rule4 = LawDSL.parse(code4)
+      rule4 = Rule.new(code4)
 
-      module_file = <<CODE
-module Thing
-end
-CODE
+      module_file = %{
+        module Thing
+        end
+      }
 
-      module_result   = rule4.call(module_file)
-      result4a        = rule4.call(@okay_file)
+      module_result   = rule4.violation?(module_file)
+      result4a        = rule4.violation?(@okay_file)
 
       module_result.must_equal true
       result4a.must_equal false
@@ -96,75 +98,73 @@ CODE
 
     it "correctly builds rule for core" do
       code5 = "class :symbol < :core_class"
-      rule5 = LawDSL.parse(code5)
-
-core_file = <<CODE
-class Whatever < String
-  def badthing(here)
-    @here = here
-  end
-end
-CODE
-      core_result     = rule5.call(core_file)
-      result5a        = rule5.call(@okay_file)
+      rule5 = Rule.new(code5)
+
+      core_file = %{
+        class Whatever < String
+          def badthing(here)
+            @here = here
+          end
+        end
+      }
+      core_result     = rule5.violation?(core_file)
+      result5a        = rule5.violation?(@okay_file)
       core_result     .must_equal true
       result5a.must_equal false
     end
 
-
-#     it "correctly builds rule for unless else" do
-#       code6 = "unless :symbols
-#               :disjoint_code_seperator
-#               else :more_symbols"
-#       rule6 = LawDSL.parse(code6)
-
-# core_file = <<CODE
-# class Whatever < String
-#   def badthing(here)
-#     @here = here
-#   end
-# end
-# CODE
-
     it "correctly builds rule for rescue nil" do
       code7 = "rescue nil"
-      rule7 = LawDSL.parse(code7)
-
-nil_file = <<CODE
-begin
-  "hi"
-rescue nil
-  "bye"
-end
-CODE
-      nil_result     = rule7.call(nil_file)
-      result7a       = rule7.call(@okay_file)
+      rule7 = Rule.new(code7)
+
+      nil_file = %{
+        begin
+          "hi"
+        rescue nil
+          "bye"
+        end
+      }
+      nil_result     = rule7.violation?(nil_file)
+      result7a       = rule7.violation?(@okay_file)
       nil_result     .must_equal true
       result7a.must_equal false
     end
 
     it "correctly builds rule for inherit struct.new" do
       code8 = "class :symbol < Struct.new"
-      rule8 = LawDSL.parse(code8)
+      rule8 = Rule.new(code8)
 
-      struct_file = <<CODE
-class MyClass < Struct.new("Customer", :name, :address)
-CODE
+      struct_file = %{
+        class MyClass < Struct.new("Customer", :name, :address)
+      }
 
-      struct_result   = rule8.call(struct_file)
-      result8a        = rule8.call(@okay_file)
+      struct_result   = rule8.violation?(struct_file)
+      result8a        = rule8.violation?(@okay_file)
 
       struct_result.must_equal true
       result8a.must_equal false
     end
 
-
-#     end
-
-    it "returns a hash with key counts and nil placeholders" do
-      params = Rule.send(:params_count_hash, [/module/, :token1, :token2, :token1, /class/, :token3, /end/])
-      params.keys.size.must_equal 3
-      params[:token1].last.must_equal 2
+    it "correctly builds whitespace sensitive rule" do
+      code9 = ":vertical_whitespace_sensitive end\ndef"
+      rule9 = Rule.new(code9)
+
+      def_file = %{
+      class Mine
+        def method
+          true
+        end
+        def method2
+          false
+        end
+      end
+      }
+
+      def_result    = rule9.violation?(def_file)
+      result9a      = rule9.violation?(@okay_file)
+
+      def_result.must_equal true
+      result9a.must_equal false
     end
 
     it "returns a hash with key counts and nil placeholders" do
@@ -174,7 +174,7 @@ CODE
     end
 
     it "returns a block from build_block method" do
-      block = LawDSL.send(:build_block,"@@")
+      block = LawParser.send(:build_block,"@@")
       assert_kind_of Proc, block
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: outlaw
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-25 00:00:00.000000000 Z
+date: 2012-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70266835445120 !ruby/object:Gem::Requirement
+  requirement: &20326092 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.9.0
   type: :development
   prerelease: false
-  version_requirements: *70266835445120
+  version_requirements: *20326092
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70266835444560 !ruby/object:Gem::Requirement
+  requirement: &20325792 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70266835444560
+  version_requirements: *20325792
 description: ! "      Keep bad code out of your projects. Your idea of bad code, no
   one elses.\n\n      Outlaw defines an example based DSL for demonstrating anti-patterns
   and\n      builds a rule for each anti-pattern that it alerts the user to violations\n
@@ -56,8 +56,9 @@ files:
 - examples/.outlawed.example
 - lib/outlaw.rb
 - lib/outlaw/enforcement.rb
-- lib/outlaw/law_dsl.rb
+- lib/outlaw/law_parser.rb
 - lib/outlaw/rule.rb
+- lib/outlaw/rule_methods.rb
 - lib/outlaw/version.rb
 - outlaw.gemspec
 - test/outlaw_test.rb

data/lib/outlaw/law_dsl.rb

@@ -1,69 +0,0 @@
-module Outlaw
-  module LawDSL
-    class << self
-      def parse(restriction, message="")
-        tokens = restriction.split
-        parsed_restriction = []
-        tokens.each do |token|
-          case
-          when special_case?(token)
-            next #TODO - handle AST branches/disjoint code/meta-symbols to be defined
-          when multipart?(token)  #this handles multi-token literals, Const.new etc
-            parsed_restriction += Ripper.lex(token)
-                                        .reduce([]){|array, tkn|
-                                        array << token_type_regex(tkn) }
-          when defined_collection?(token)
-            parsed_restriction << Outlaw.const_get(string_to_sym(token.upcase))
-          when parameter?(token)
-            parsed_restriction << string_to_sym(token)
-          else
-            parsed_restriction += build_regex(token)
-          end
-        end
-        Rule.new(message, restriction, &build_block(parsed_restriction))
-      end
-
-      private
-
-      def token_type_regex(token)
-        /#{token[2]}/
-      end
-
-      def parameter?(token)
-        token[0].chr == ':'
-      end
-
-      def special_case?(token)
-        SPECIAL_CASES.include? token
-      end
-
-      def defined_collection?(token)
-        parameter?(token) && Outlaw.const_defined?(string_to_sym(token.upcase))
-      end
-
-      def string_to_sym(str)
-        str[1..-1].to_sym
-      end
-
-      def build_regex(token)
-        #fully expect this hack to come back & haunt me, but passes curr. examples
-        [/\A#{token}/]
-      end
-
-      def multipart?(token)
-        !parameter?(token) && Ripper.lex(token).count > 1
-      end
-
-      def build_block(pattern)
-        lambda do |file|
-          program = Ripper.tokenize(file)
-          program.each_with_index do |token, index|
-            next unless token.match(pattern.first)
-            return true if Rule.test(program, index, pattern)
-          end
-          return false
-        end
-      end
-    end
-  end
-end