object_dojo 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+gem 'rake'
+gem 'rspec'
+gem 'mocha'
+gem 'trollop'

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    object_dojo (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    metaclass (0.0.1)
+    mocha (0.10.0)
+      metaclass (~> 0.0.1)
+    rake (0.9.2.2)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  object_dojo!
+  rake
+  rspec
+  trollop

data/README.markdown

@@ -0,0 +1,32 @@
+ObjectDojo is a utility to improve your Object oriented programming skills using rules described in the article "Object Calisthenics" by JeffBay:
+
+[www.xpteam.com/jeff/writings/objectcalisthenics.rtf](www.xpteam.com/jeff/writings/objectcalisthenics.rtf)
+
+### The Rules
+
+1. One level of indentation per method
+2. Don’t use the ELSE keyword
+3. Wrap all primitives and Strings
+4. First class collections
+5. One dot per line
+6. Don’t abbreviate
+7. Keep all entities small
+8. No classes with more than two instance variables
+9. No getters/setters/properties
+
+### Usage
+
+Run the command line utility dojo in your current project folder.
+
+myapp$ dojo
+
+### Configure
+
+The rules can be configured by passing command line options. To get the full list of command line options
+
+$ dojo -h
+
+#### Supported languages
+
+The current version supports only Ruby.
+Support for other languages like Java, C# and Python will be added in the future.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/bin/dojo

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'dojo'
+require 'yaml'
+require 'trollop'
+
+default_options = YAML::load_file(File.expand_path(File.dirname(__FILE__) + '/../config/rules.yml'))['rules'].symbolize_keys!
+
+options = Trollop::options do
+  version "object_dojo"
+  banner <<-EOS
+ObjectDojo is a utility to practice Object oriented programming.
+It checks the rules described in the article "Object Calisthenics" by Jeff Bay.
+
+www.xpteam.com/jeff/writings/objectcalisthenics.rtf
+
+Usage:
+       dojo [options] <path>+
+where [options] are:
+EOS
+  opt :max_indent, "Level of indentation per method", default: default_options[:max_indent]
+  opt :avoid_keywords, "Keywords to avoid in code", :type => String, default: default_options[:avoid_keywords]
+  opt :max_collections, "Number of first class collections in class", default: default_options[:max_collections]
+  opt :max_chaining, "Number of dots or chained method calls per line", default: default_options[:max_chaining]
+  opt :max_lines, "Lines of code per class", default: default_options[:max_lines]
+  opt :max_instance_vars, "Number of instance variables per class", default: default_options[:max_instance_vars]
+end
+
+dojo = Dojo.new(ARGV.last)
+dojo.validate(default_options.merge(options))

data/config/rules.yml

@@ -0,0 +1,7 @@
+rules:
+  max_indent: 3
+  avoid_keywords: "else,elsif"
+  max_collections: 1
+  max_chaining: 1
+  max_lines: 50
+  max_instance_vars: 2

data/lib/class_structure.rb

@@ -0,0 +1,26 @@
+class ClassStructure
+  def initialize(code)
+    @code = code
+  end
+  
+  def instance_variables
+    @code.scan(/\s+\@\w+/).map {|name| name.strip.sub('@','')}.uniq
+  end
+  
+  def method_names
+    @code.scan(/def \w+/).map {|name| name.sub('def ','')}.uniq
+  end
+  
+  def has_accessor_method?
+    all_instance_variables = instance_variables
+    method_names.any? {|method_name| instance_variables.include?(method_name.gsub('=',''))}
+  end
+  
+  def line_count
+    @code.split("\n").reject{|line| line.strip.size==0}.size
+  end
+  
+  def collection_count
+    @code.scan(/\s+@\w+\s*\=\s*(\[.*?\]|\{.*?\}|Array\.new|Set\.new|Hash\.new)/).size
+  end
+end

data/lib/class_validator.rb

@@ -0,0 +1,29 @@
+class ClassValidator
+  def initialize(file, options={})
+    @file = file
+    @options = options
+  end
+  
+  def validate
+    code = File.open(@file).read
+    rules.each do |rule|
+      next if rule.valid?(code)
+      puts "#{@file}: #{rule.message}"
+    end
+  end
+  
+  private
+  
+  def rules
+    options = @options
+    [
+      MethodIndentation.new(options[:max_indent]),
+      *options[:avoid_keywords].split(',').map {|keyword| AvoidKeyword.new(keyword)},
+      FirstClassCollections.new(options[:max_collections]),
+      MethodChainingLimit.new(options[:max_chaining]),
+      ClassLineLimit.new(options[:max_lines]),
+      InstanceVariableLimit.new(options[:max_instance_vars]),
+      AvoidAccessor.new
+    ]
+  end
+end

data/lib/dojo.rb

@@ -0,0 +1,18 @@
+require 'class_structure'
+require 'class_validator'
+require 'rules'
+require 'extensions'
+
+class Dojo
+  def initialize(dir, file_filter = "**/*.rb")
+    @dir = dir
+    @file_filter = file_filter
+  end
+  
+  def validate(options)
+    Dir.glob("#{@dir}/#{@file_filter}").each do |file|
+      validator = ClassValidator.new(file, options)
+      validator.validate
+    end
+  end
+end

data/lib/extensions.rb

@@ -0,0 +1,8 @@
+class Hash
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+end

data/lib/object_dojo/version.rb

@@ -0,0 +1,3 @@
+module ObjectDojo
+  VERSION = "0.0.1"
+end

data/lib/rules.rb

@@ -0,0 +1,7 @@
+require 'rules/avoid_keyword'
+require 'rules/method_indentation'
+require 'rules/instance_variable_limit'
+require 'rules/avoid_accessor'
+require 'rules/class_line_limit'
+require 'rules/method_chaining_limit'
+require 'rules/first_class_collections'

data/lib/rules/avoid_accessor.rb

@@ -0,0 +1,10 @@
+class AvoidAccessor
+  def valid?(code)
+    class_structure = ClassStructure.new(code)
+    code !~ /attr_(reader|writer|accessor)/ && !class_structure.has_accessor_method?
+  end
+  
+  def message
+    "has accessor methods"
+  end
+end

data/lib/rules/avoid_keyword.rb

@@ -0,0 +1,13 @@
+class AvoidKeyword
+  def initialize(keyword)
+    @keyword = keyword
+  end
+  
+  def valid?(code)
+    !code.include?(@keyword)
+  end
+  
+  def message
+    "uses #{@keyword} keyword"
+  end
+end

data/lib/rules/class_line_limit.rb

@@ -0,0 +1,13 @@
+class ClassLineLimit
+  def initialize(max)
+    @max = max
+  end
+  
+  def valid?(code)
+    ClassStructure.new(code).line_count <= @max
+  end
+  
+  def message
+    "is longer than #{@max} lines"
+  end
+end

data/lib/rules/first_class_collections.rb

@@ -0,0 +1,13 @@
+class FirstClassCollections
+  def initialize(max)
+    @max = max
+  end
+  
+  def valid?(code)
+    ClassStructure.new(code).collection_count <= 1
+  end
+
+  def message
+    "more than 1 collection member variable"
+  end    
+end

data/lib/rules/instance_variable_limit.rb

@@ -0,0 +1,15 @@
+class InstanceVariableLimit
+  
+  def initialize(max)
+    @max = max
+  end
+  
+  def valid?(code)
+    class_structure = ClassStructure.new(code)
+    class_structure.instance_variables.size <= @max
+  end
+  
+  def message
+    "has more than #{@max} instance variables"
+  end
+end

data/lib/rules/method_chaining_limit.rb

@@ -0,0 +1,15 @@
+class MethodChainingLimit
+  def initialize(max)
+    @max = max
+  end
+  
+  def valid?(code)
+    code.gsub(/\d+\.\d+/,'').split("\n").all? do |line|
+      line.count('.') <= @max
+    end
+  end
+  
+  def message
+    "more than one dot per line"
+  end
+end

data/lib/rules/method_indentation.rb

@@ -0,0 +1,25 @@
+class MethodIndentation
+  TABS = 2
+  
+  def initialize(max)
+    @max = max + 2 # including class and def indent
+  end
+  
+  def valid?(method)
+    max_indent(method) <= @max
+  end
+  
+  def message
+    "indentation is more than #{@max} levels"
+  end
+  
+  private
+  
+  def max_indent(code)
+    indents = code.split("\n").collect do |line|
+      match = line.match(/^(\s*)/)
+      match ? match[1].length/TABS : 0
+    end
+    indents.max - indents.min
+  end
+end

data/object_dojo.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "object_dojo/version"
+
+Gem::Specification.new do |s|
+  s.name        = "object_dojo"
+  s.version     = ObjectDojo::VERSION
+  s.authors     = ["Sathish"]
+  s.email       = ["sathish316@gmail.com"]
+  s.homepage    = "http://www.github.com/sathish316/object_dojo"
+  s.summary     = %q{ObjectDojo is a utility to improve your Object oriented programming skills using rules described in the article "Object Calisthenics" by JeffBay}
+  s.description = %q{ObjectDojo is a utility to improve your Object oriented programming skills using rules described in the article "Object Calisthenics" by JeffBay}
+  s.rubyforge_project = "object_dojo"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/spec/class_structure_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe ClassStructure do
+  describe "instance variables" do
+    it "should return unique instance variable names" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          def initialize(first, last)
+            @first, @last = first, last
+          end
+          
+          def to_s
+            @first + @last
+          end
+        end
+      CODE
+      
+      class_structure.instance_variables.sort.should == ['first', 'last']
+    end
+    
+    it "should be empty if there are no instance variables" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+        end
+      CODE
+      class_structure.instance_variables.should be_empty
+    end
+
+    it "should not include class variables" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          @@count = 0
+        end
+      CODE
+      class_structure.instance_variables.should be_empty
+    end
+  end
+
+  describe "method names" do
+    it "should return unique method names" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          def foo
+          end
+          
+          def bar
+          end
+          
+          def first
+            @first
+          end
+          
+          def last
+            @last
+          end
+        end
+      CODE
+      
+      class_structure.method_names.should == ['foo', 'bar', 'first', 'last']
+    end
+    
+    it "should be empty if there are no methods" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          attr_accessor :first, :last
+        end
+      CODE
+      
+      class_structure.method_names.should be_empty
+    end
+  end
+  
+  describe "has accessor method" do
+    it "should be true if there are getter methods" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          def name
+            @name
+          end
+        end
+      CODE
+      
+      class_structure.should have_accessor_method
+    end
+    
+    it "should be true if there are setter methods" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          attr_accessor :first, :last
+          def name=(name)
+            @name = name
+          end
+        end
+      CODE
+      
+      class_structure.should have_accessor_method
+    end
+    
+    it "should be false if there are no accessor methods" do
+      class_structure = ClassStructure.new <<-CODE
+        class Person
+          def name
+            @first + @last
+          end
+        end
+      CODE
+      
+      class_structure.should_not have_accessor_method
+    end
+  end
+
+  describe "collection count" do
+    it "should count the number of Arrays" do
+      class_structure = ClassStructure.new <<-CODE
+        @foo = []
+        @bar=[1,2,3]
+      CODE
+      class_structure.collection_count.should == 2
+    end
+
+    it "should count the number of Hashes" do
+      class_structure = ClassStructure.new <<-CODE
+        @foo = {}
+        @bar={a: 1, b: 2}
+        @baz = {'a' => 1, 'b' => 2}
+      CODE
+      class_structure.collection_count.should == 3
+    end
+
+    it "should count the number of Arrays declared using new" do
+      class_structure = ClassStructure.new <<-CODE
+        @foo = []
+        @bar=Array.new(5)
+      CODE
+      class_structure.collection_count.should == 2
+    end
+    
+    it "should count the number of Hashes declared using new" do
+      class_structure = ClassStructure.new <<-CODE
+        @bar=Hash.new
+      CODE
+      class_structure.collection_count.should == 1
+    end
+    
+    it "should count the number of Sets declared using new" do
+      class_structure = ClassStructure.new <<-CODE
+        @foo = Set.new
+        @bar=Set.new
+      CODE
+      class_structure.collection_count.should == 2
+    end
+    
+    it "should count only instance collections" do
+      class_structure = ClassStructure.new <<-CODE
+        @foo = []
+        @@bar = []
+      CODE
+      class_structure.collection_count.should == 1
+    end
+  end
+end

data/spec/dojo_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Dojo do
+end

data/spec/rules/avoid_accessor_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AvoidAccessor do
+  let(:rule) {AvoidAccessor.new}
+  
+  it "should be valid if there are no accessors" do
+    rule.should be_valid <<-CODE
+      class Foo
+        def initialize(x,y)
+          @x = x
+          @y = y
+        end
+      end
+    CODE
+  end
+  
+  it "should be invalid if attr_reader is used" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        attr_reader :x
+        def initialize(x)
+          @x = x
+        end
+      end
+    CODE
+  end
+  
+  it "should be invalid if attr_writer is used" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        attr_writer :x
+        def initialize(x)
+          @x = x
+        end
+      end
+    CODE
+  end
+  
+  it "should be invalid if attr_accessor is used" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        attr_accessor :x
+        def initialize(x)
+          @x = x
+        end
+      end
+    CODE
+  end
+  
+  it "should be invalid if getter is used" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        def initialize(value)
+          @value = value
+        end
+        
+        def value
+          @value
+        end
+      end
+    CODE
+  end
+  
+  it "should be invalid if writer is used" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        def initialize(value)
+          @value = value
+        end
+        
+        def value=(value)
+          @value = value
+        end
+      end
+    CODE
+  end
+  
+end

data/spec/rules/avoid_keyword_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe AvoidKeyword do
+  let(:rule) {AvoidKeyword.new('else')}
+  
+  it "should be invalid if keyword used in code" do
+    rule.should_not be_valid <<-CODE
+      if dojo
+        :code
+      else
+        :play_games
+      end
+    CODE
+  end
+  
+  it "should be valid if keyword is not used in code" do
+    rule.should be_valid <<-CODE
+      return :code if dojo
+      :play_games
+    CODE
+  end
+end

data/spec/rules/class_line_limit_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe ClassLineLimit do
+  let(:rule) {ClassLineLimit.new(5)}
+
+  it "should be valid if max length is not exceeded" do
+    rule.should be_valid <<-CODE
+      class Foo
+
+        def initialize(bar)
+          @bar = bar
+        end
+
+      end
+    CODE
+  end
+  
+  it "should be invalid if max length is exceeded" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        def initialize(bar, baz)
+          @bar = bar
+          @baz = baz
+        end
+      end
+    CODE
+  end
+end

data/spec/rules/first_class_collections_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe FirstClassCollections do
+  let(:rule) {FirstClassCollections.new(1)}
+
+  it "should be invalid if there is more than 1 collection" do
+    ClassStructure.any_instance.stubs(:collection_count).returns(2)
+    rule.should_not be_valid <<-CODE
+      @foo = []
+      @bar = []
+    CODE
+  end
+
+  it "should be valid if there is <= 1 collection" do
+    ClassStructure.any_instance.stubs(:collection_count).returns(1)
+    rule.should be_valid <<-CODE
+      @foo = [1,2,3]
+    CODE
+  end
+end

data/spec/rules/instance_variable_limit_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe InstanceVariableLimit do
+  let(:rule) {InstanceVariableLimit.new(2)}
+  
+  it "should be invalid if limit is exceeded" do
+    rule.should_not be_valid <<-CODE
+      class Foo
+        def initialize(x,y,z)
+          @x = x
+          @y = y
+          @z = @x * @y
+        end
+      end
+    CODE
+  end
+  
+  it "should be valid if limit is not exceeded" do
+    rule.should be_valid <<-CODE
+      class Foo
+        def initialize(x,y,z)
+          @x = x
+          @y = y
+        end
+        
+        def perimeter
+          @x + @y
+        end
+      end
+    CODE
+  end
+end

data/spec/rules/method_chaining_limit_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe MethodChainingLimit do
+  
+  let(:rule) {MethodChainingLimit.new(1)}
+  
+  it "should be valid if there is 1 dot per line" do
+    rule.should be_valid <<-CODE
+      foo.bar
+      bar.baz
+      baz.foo
+    CODE
+  end
+  
+  it "should be invalid if there are more than 1 dots per line" do
+    rule.should_not be_valid <<-CODE
+      foo
+      foo.bar
+      bar.baz.foo
+    CODE
+  end
+
+  it "should ignore decimals and count only method chaining" do
+    rule.should be_valid <<-CODE
+      foo.bar = 5.67
+    CODE
+  end
+end

data/spec/rules/method_indentation_spec.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MethodIndentation do
+  let(:rule) {MethodIndentation.new(1)}
+  
+  it "should be invalid if level of indentation is more than 2" do
+    rule.should_not be_valid <<-CODE
+    class Foo
+      def foo
+        bars.each do |bar|
+          bazs.each do |baz|
+            bar * baz
+          end
+        end
+      end
+    end
+    CODE
+  end
+  
+  it "should be valid if level of indentation is 2" do
+    rule.should be_valid <<-CODE
+    class Foo
+      def foo
+        bars.each do |bar|
+          bar * bar
+        end
+      end
+    end
+    CODE
+  end
+
+  it "should be valid if level of indentation is 0" do
+    rule.should be_valid <<-CODE
+    class Foo
+      def foo
+        foos.first
+      end
+    end
+    CODE
+  end
+
+  it "should be valid if level of indentation is 0 with multiple methods" do
+    rule.should be_valid <<-CODE
+    class Foo
+      def foo
+        foos.first
+      end
+      
+      def bar
+        bars.first
+      end
+    CODE
+  end
+
+  it "should be invalid if level of indentation is more than 2 with multiple methods" do
+    rule.should_not be_valid <<-CODE
+    class Foo
+      def foo
+        bars.each do |bar|
+          bazs.each do |baz|
+            bar * baz
+          end
+        end
+      end
+      
+      def bar
+        bars.first
+      end
+    end
+    CODE
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler/setup'
+require 'rspec/mocks'
+require 'dojo'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: object_dojo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sathish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-11 00:00:00.000000000Z
+dependencies: []
+description: ObjectDojo is a utility to improve your Object oriented programming skills
+  using rules described in the article "Object Calisthenics" by JeffBay
+email:
+- sathish316@gmail.com
+executables:
+- dojo
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- bin/dojo
+- config/rules.yml
+- lib/class_structure.rb
+- lib/class_validator.rb
+- lib/dojo.rb
+- lib/extensions.rb
+- lib/object_dojo/version.rb
+- lib/rules.rb
+- lib/rules/avoid_accessor.rb
+- lib/rules/avoid_keyword.rb
+- lib/rules/class_line_limit.rb
+- lib/rules/first_class_collections.rb
+- lib/rules/instance_variable_limit.rb
+- lib/rules/method_chaining_limit.rb
+- lib/rules/method_indentation.rb
+- object_dojo.gemspec
+- spec/class_structure_spec.rb
+- spec/dojo_spec.rb
+- spec/rules/avoid_accessor_spec.rb
+- spec/rules/avoid_keyword_spec.rb
+- spec/rules/class_line_limit_spec.rb
+- spec/rules/first_class_collections_spec.rb
+- spec/rules/instance_variable_limit_spec.rb
+- spec/rules/method_chaining_limit_spec.rb
+- spec/rules/method_indentation_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/sathish316/object_dojo
+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'
+      segments:
+      - 0
+      hash: -1806527109624100395
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1806527109624100395
+requirements: []
+rubyforge_project: object_dojo
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ObjectDojo is a utility to improve your Object oriented programming skills
+  using rules described in the article "Object Calisthenics" by JeffBay
+test_files:
+- spec/class_structure_spec.rb
+- spec/dojo_spec.rb
+- spec/rules/avoid_accessor_spec.rb
+- spec/rules/avoid_keyword_spec.rb
+- spec/rules/class_line_limit_spec.rb
+- spec/rules/first_class_collections_spec.rb
+- spec/rules/instance_variable_limit_spec.rb
+- spec/rules/method_chaining_limit_spec.rb
+- spec/rules/method_indentation_spec.rb
+- spec/spec_helper.rb