outlaw 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+.outlawed

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Brian Glusman
+
+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.md

@@ -0,0 +1,35 @@
+#Outlaw
+
+##Keep bad code out of your projects.  Your idea of bad code, no one elses.
+
+### 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
+
+### Proposed syntax for DSL:
+
+  A defined collection exists for core classes, such that
+
+    outlaw "class :symbol < :core_class",
+                              "core classes implemented in c, can cause bad mojo"
+
+  will outlaw subclassing from any core class
+
+
+ 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
+
+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. 

data/Rakefile

@@ -0,0 +1,4 @@
+task :default => 'test'
+task :test do
+  sh "ruby test/outlaw_test.rb"
+end

data/bin/outlaw

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "outlaw"
+load ".outlawed"
+
+puts Outlaw.enforce(ARGV[0] ? ARGV[0] : ".")

data/data/core_classes.txt

@@ -0,0 +1,103 @@
+ARGF
+ArgumentError
+Array
+BasicObject
+Bignum
+Binding
+Class
+Comparable
+Complex
+Continuation
+Data
+Dir
+ENV
+EOFError
+Encoding
+Encoding::CompatibilityError
+Encoding::Converter
+Encoding::ConverterNotFoundError
+Encoding::InvalidByteSequenceError
+Encoding::UndefinedConversionError
+EncodingError
+Enumerable
+Enumerator
+Enumerator::Generator
+Enumerator::Yielder
+Errno
+Exception
+FalseClass
+Fiber
+FiberError
+File
+File::Constants
+File::Stat
+FileTest
+Fixnum
+Float
+FloatDomainError
+GC
+GC::Profiler
+Hash
+IO
+IO::WaitReadable
+IO::WaitWritable
+IOError
+IndexError
+Integer
+Interrupt
+Kernel
+KeyError
+LoadError
+LocalJumpError
+Marshal
+MatchData
+Math
+Math::DomainError
+Method
+Module
+Mutex
+NameError
+NilClass
+NoMemoryError
+NoMethodError
+NotImplementedError
+Numeric
+Object
+ObjectSpace
+Proc
+Process
+Process::GID
+Process::Status
+Process::Sys
+Process::UID
+Random
+Range
+RangeError
+Rational
+Regexp
+RegexpError
+RubyVM
+RubyVM::Env
+RubyVM::InstructionSequence
+RuntimeError
+ScriptError
+SecurityError
+Signal
+SignalException
+StandardError
+StopIteration
+String
+Struct
+Symbol
+SyntaxError
+SystemCallError
+SystemExit
+SystemStackError
+Thread
+ThreadError
+ThreadGroup
+Time
+TrueClass
+TypeError
+UnboundMethod
+ZeroDivisionError

data/examples/.outlawed.example

@@ -0,0 +1,5 @@
+	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"

data/lib/outlaw.rb

@@ -0,0 +1,20 @@
+require 'ripper'
+require_relative 'outlaw/law_dsl'
+require_relative 'outlaw/enforcement'
+require_relative 'outlaw/rule'
+
+def outlaw(restriction, message)
+  law = Outlaw::LawDSL.parse(restriction, message)
+  Outlaw::Enforcement.add(law)
+end
+
+module Outlaw
+  def self.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
+end

data/lib/outlaw/enforcement.rb

@@ -0,0 +1,34 @@
+module Outlaw
+  class Enforcement
+    class << self
+      attr_reader :laws
+      def add(law)
+        @laws ||= []
+        @laws << law
+      end
+
+      def process_directory(path)
+        Dir.foreach(path) do |entry|
+          next if entry == '.' or entry == '..'
+          if File.directory?("#{path}/#{entry}")
+            process_directory("#{path}/#{entry}")
+          else
+            handle("#{path}/#{entry}")
+          end
+        end
+      end
+
+      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}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/outlaw/law_dsl.rb

@@ -0,0 +1,69 @@
+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

data/lib/outlaw/rule.rb

@@ -0,0 +1,85 @@
+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
+      @detection_block  = detection_block
+    end
+
+    def call(code)
+      @detection_block.call(code)
+    end
+
+    class << self
+      def test(program, start_index, pattern)
+        pattern_index = 0
+        params = params_count_hash(pattern)
+        start_index.upto(program.length) do |index|
+          code = program[index]
+          part = pattern[pattern_index]
+
+          next if 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
+        end
+
+        return false
+        # got to end of program without completing pattern
+      end
+
+      private
+
+      def match_token?(code, part, parameter)
+        case part
+        when Array
+          match = true if part.include?(code)
+        when Regexp
+          match = true if code.match(part)
+        when Symbol
+          return false unless param_type_equal(token_type(code), part)
+          #check count on first and count down subseq matches
+          if parameter.first.nil? #history of parameter match if any
+            parameter[0] = code
+            parameter[1] -= 1     #first occurrence of parameter
+            match = true
+          else
+            if parameter.first == code
+              parameter[1] -= 1
+              match = true
+            else
+              match = false
+            end
+          end
+        else
+          match = false
+        end
+
+        match
+      end
+
+
+      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
+      end
+
+      def token_type(code)
+        Ripper.lex(code).flatten(1)[1] #Ripper's name for token type is returned in array
+      end
+
+      def params_count_hash(pattern)
+        params = Hash.new(0)
+        pattern.each do |element|
+          params[element] += 1 if element.respond_to?(:to_sym)
+        end
+        output = {}                   #nil is placeholder for matched lex code
+        params.keys.each {|key| output[key] = [nil, params[key]]}
+        output
+      end
+    end
+  end
+end

data/lib/outlaw/version.rb

@@ -0,0 +1,3 @@
+module Outlaw
+  VERSION = "0.1.0"
+end

data/outlaw.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require "outlaw/version"
+
+Gem::Specification.new do |s|
+  s.name        = "outlaw"
+  s.version     = Outlaw::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Brian Glusman"]
+  s.email       = ["brian@neomindlabs.com"]
+  s.homepage    = "https://github.com/bglusman/Outlaw"
+  s.summary     = "Outlaw helps you enforce your opinions to keep bad code out your projects."
+  s.rubyforge_project = "outlaw"
+
+  s.description = <<-DESC
+      Keep bad code out of your projects. Your idea of bad code, no one elses.
+
+      Outlaw defines an example based DSL for demonstrating anti-patterns and
+      builds a rule for each anti-pattern that it alerts the user to violations
+      when encountered in a project's codebase during scanning.
+
+      Outlaw is a work in progress and contributions, suggestions and forks are welcome.
+      Outlaw was a personal project for Mendicant University, Session 10 in Jan '12
+  DESC
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "ripper-plus", "~> 1.3.0"
+
+  s.add_development_dependency "rake", "~> 0.9.0"
+  s.add_development_dependency "minitest"
+end

data/test/outlaw_test.rb

@@ -0,0 +1,181 @@
+require_relative 'test_helper'
+
+module Outlaw
+  describe LawDSL 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
+
+  end
+
+
+
+    it "correctly builds rule for class var" do
+      code1 = "@@"
+      rule1 = LawDSL.parse(code1)
+
+      class_var_file = <<CODE
+  def badthing(here)
+    @@here = here
+  end
+CODE
+
+      class_result    = rule1.call(class_var_file)
+      result1a        = rule1.call(@okay_file)
+      class_result    .must_equal true
+    end
+
+    it "correctly builds rule for protected" do
+      code2 = "protected"
+      rule2 = LawDSL.parse(code2)
+
+    protected_file = <<CODE
+class Whatever
+  protected
+  def not_really
+    :false
+  end
+end
+CODE
+
+      protected_result= rule2.call(protected_file)
+      result2a = rule2.call(@okay_file)
+
+      protected_result.must_equal true
+      result2a        .must_equal false
+    end
+
+
+    it "correctly builds rule for eval" do
+      code3 = "eval"
+      rule3 = LawDSL.parse(code3)
+
+    eval_file = <<CODE
+  def not_really
+    eval('1 + 1')
+  end
+CODE
+
+      eval_result = rule3.call(eval_file)
+      result3a    = rule3.call(@okay_file)
+
+      eval_result.must_equal true
+      result3a.must_equal false
+    end
+
+
+    it "correctly builds rule for module" do
+      code4 = "module :name end"
+      rule4 = LawDSL.parse(code4)
+
+      module_file = <<CODE
+module Thing
+end
+CODE
+
+      module_result   = rule4.call(module_file)
+      result4a        = rule4.call(@okay_file)
+
+      module_result.must_equal true
+      result4a.must_equal false
+    end
+
+    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)
+      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)
+      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)
+
+      struct_file = <<CODE
+class MyClass < Struct.new("Customer", :name, :address)
+CODE
+
+      struct_result   = rule8.call(struct_file)
+      result8a        = rule8.call(@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
+    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
+    end
+
+    it "returns a block from build_block method" do
+      block = LawDSL.send(:build_block,"@@")
+      assert_kind_of Proc, block
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require_relative '../lib/outlaw'
+require 'minitest/spec'
+require 'minitest/autorun'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: outlaw
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Brian Glusman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ripper-plus
+  requirement: &70327141430060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70327141430060
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70327141429400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *70327141429400
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70327141427520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70327141427520
+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
+  \     when encountered in a project's codebase during scanning.\n\n      Outlaw
+  is a work in progress and contributions, suggestions and forks are welcome.\n      Outlaw
+  was a personal project for Mendicant University, Session 10 in Jan '12\n"
+email:
+- brian@neomindlabs.com
+executables:
+- outlaw
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/outlaw
+- data/core_classes.txt
+- examples/.outlawed.example
+- lib/outlaw.rb
+- lib/outlaw/enforcement.rb
+- lib/outlaw/law_dsl.rb
+- lib/outlaw/rule.rb
+- lib/outlaw/version.rb
+- outlaw.gemspec
+- test/outlaw_test.rb
+- test/test_helper.rb
+homepage: https://github.com/bglusman/Outlaw
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: outlaw
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Outlaw helps you enforce your opinions to keep bad code out your projects.
+test_files: []