tailor 0.0.3 → 0.1.0

data/lib/tasks/metrics.rake

@@ -0,0 +1,23 @@
+require 'metric_fu'
+
+MetricFu::Configuration.run do |config|
+  #define which metrics you want to use
+  config.metrics  = [:churn, :flog, :flay, :reek, :roodi, :rcov, :stats]
+  config.graphs   = [:flog, :flay, :reek, :roodi]
+  config.flay     = { :dirs_to_flay => ['lib'],
+                      :minimum_score => 10  } 
+  config.flog     = { :dirs_to_flog => ['lib']  }
+  config.reek     = { :dirs_to_reek => ['lib']  }
+  config.roodi    = { :dirs_to_roodi => ['lib'] }
+  config.churn    = { :start_date => "1 year ago", :minimum_churn_count => 10}
+  config.rcov     = { :environment => 'test',
+                      :test_files => ['spec/*_spec.rb',
+                                      'spec/**/*_spec.rb'],
+                      :rcov_opts => ["--sort coverage", 
+                                     "--no-html", 
+                                     "--text-coverage",
+                                     "--no-color",
+                                     "--profile",
+                                     "--exclude /gems/,/Library/"]}
+  config.graph_engine = :bluff
+end

data/lib/tasks/stats.rake

@@ -0,0 +1,11 @@
+STATS_DIRECTORIES = [
+  %w(Library            lib/),
+  %w(Feature\ tests     features/),
+  %w(Unit\ tests        spec/)
+].collect { |name, dir| [ name, "#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end

data/logic.txt

@@ -0,0 +1,30 @@
+If we're at level x
+  the current level should be x.
+If we find an indent word there
+  the level of the current line should be x + 1.
+    unless that's the first indent word we found.
+If we find and outdent word there
+  the level of current line should be x - 1.
+If we don't find an indent word there
+  the level of the next line should be x.
+
+The first current level is NOT set by the first line encountered.
+  The first current level is always 0.
+
+
+Before executing:
+line 1
+next level should be 0
+
+Check line 1:
+is should be at level 0
+if it contains in keyword, change next level to 1
+(else, next level stays at 0)
+
+Check line 2:
+it should be at level 1
+if it contains in keyword, change next level to 2
+
+Check line 3:
+it should be at level 2
+if it contains an out keyword, chnage next level to 1

data/ruby-style-checker.rb

@@ -1,9 +1,9 @@
-$tabSize = 2
-$tabStr = " "
+$tab_size = 2
+$tab_string = " "
 
 # indent regexp tests
 
-$indentExp = [
+$indent_expression = [
   /^module\b/,
   /(=\s*|^)if\b/,
   /(=\s*|^)until\b/,
@@ -27,7 +27,7 @@ $indentExp = [
 
 # outdent regexp tests
 
-$outdentExp = [
+$outdent_expression = [
   /^rescue\b/,
   /^ensure\b/,
   /^elsif\b/,
@@ -38,95 +38,126 @@ $outdentExp = [
   /^[^\[]*\]/
 ]
 
-def makeTab(tab)
-  return (tab < 0)?"":$tabStr * $tabSize * tab
+def make_tab(tab)
+  # If the tab is negative, don't do anything
+  return (tab < 0) ? "" : $tab_string * $tab_size * tab
 end
 
-def addLine(line,tab)
+def add_line line, tab
   line.strip!
-  line = makeTab(tab)+line if line.length > 0
+  line = make_tab(tab) + line if line.length > 0
   return line + "\n"
 end
 
 def format_ruby
-  commentBlock = false
-  multiLineArray = Array.new
-  multiLineStr = ""
+  comment_block = false
+  multi_line_array = Array.new
+  multi_line_string = ""
   tab = 0
   ############
   #filename entered on command line as argument gets passed in Ruby's
   #special argument array ARGV. The ARGV[0] zeroth element has the filename
   ############
   filename = ARGV[0]
+
+  # Open the file for reading
   source = File.new(filename,'r').read
-  dest = ""
+  new_file = ""
+
+  # Read each line
   source.split("\n").each do |line|
+    # SKIPPING THIS FOR NOW.  NOT SURE WHY I'D NEED TO DO THIS YET.
+    #   Says: if it's not a comment line and has a \ (plus spaces)
     # combine continuing lines
     if(!(line =~ /^\s*#/) && line =~ /[^\\]\\\s*$/)
-      puts "hereeeeer"
-      #multiLineArray.push line
-      #multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+      multi_line_array.push line
+      multi_line_string += line.sub(/^(.*)\\\s*$/,"\\1")
       next
     end
 
+    # THIS GOES WITH THE PREVIOUS IF STATEMENT; SKIP FOR NOW.
     # add final line
-    if(multiLineStr.length > 0)
-      puts "HERLKJHLJKEHR"
-      #multiLineArray.push line
-      #multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+    if(multi_line_string.length > 0)
+      multi_line_array.push line
+      multi_line_string += line.sub(/^(.*)\\\s*$/,"\\1")
     end
 
-    tline = ((multiLineStr.length > 0)?multiLineStr:line).strip
-    if(tline =~ /^=begin/)
-      commentBlock = true
+    # tab_line is really just the line to check
+    tab_line = ((multi_line_string.length > 0) ? multi_line_string : line).strip
+
+    # HE SKIPS CHECKING OF COMMENT BLOCKS; LET'S GO AHEAD AND CHECK THEM
+    if(tab_line =~ /^=begin/)
+      comment_block = true
     end
-    if(commentBlock)
+
+    if(comment_block)
       # add the line unchanged
-      dest += line + "\n"
+      new_file += line + "\n"
+    # THIS IS WHERE THE MAGIC STARTS
     else
-      commentLine = (tline =~ /^#/)
-      if(!commentLine)
+      commentab_line = (tab_line =~ /^#/)
+
+      # 
+      if(!commentab_line)
         # throw out sequences that will
         # only sow confusion
-        tline.gsub!(/\/.*?\//,"")
-        tline.gsub!(/%r\{.*?\}/,"")
-        tline.gsub!(/%r(.).*?\1/,"")
-        tline.gsub!(/\\\"/,"'")
-        tline.gsub!(/".*?"/,"\"\"")
-        tline.gsub!(/'.*?'/,"''")
-        tline.gsub!(/#\{.*?\}/,"")
-        $outdentExp.each do |re|
-          if(tline =~ re)
+        tab_line.gsub!(/\/.*?\//,"")  # Subs anything / stuff / with ""
+        tab_line.gsub!(/%r\{.*?\}/,"")
+        tab_line.gsub!(/%r(.).*?\1/,"")
+        tab_line.gsub!(/\\\"/,"'")
+        tab_line.gsub!(/".*?"/,"\"\"")
+        tab_line.gsub!(/'.*?'/,"''")
+        tab_line.gsub!(/#\{.*?\}/,"")
+
+        $outdent_expression.each do |re|
+          # Search each line for an outdent keyword
+          # If the line contains one of the keywords, it's indented too far
+          #   so set it to be out 1 level
+          if(tab_line =~ re)
             tab -= 1
             break
           end
         end
       end
-      if (multiLineArray.length > 0)
-        multiLineArray.each do |ml|
-          dest += addLine(ml,tab)
+
+      if (multi_line_array.length > 0)
+        # This will:
+        #   Set lines with indent keywords to not change their indenting.
+        #   Set lines without indent keywords to not change their indenting
+        #     since tab is still 0.
+        multi_line_array.each do |ml|
+          # He adds the line; I'd compare actual vs. proper.
+          dest += add_line(ml,tab)
         end
-        multiLineArray.clear
-        multiLineStr = ""
+        multi_line_array.clear
+        multi_line_string = ""
       else
-        dest += addLine(line,tab)
+        dest += add_line(line,tab)
       end
-      if(!commentLine)
-        $indentExp.each do |re|
-          if(tline =~ re && !(tline =~ /\s+end\s*$/))
+
+      if(!commentab_line)
+        # Check the line to see if it contains one of the indent keywords
+        $indent_expression.each do |re|
+          # If it does contain one of the keywords and doesn't contain the 
+          #   'end' keywords
+          if(tab_line =~ re && !(tab_line =~ /\s+end\s*$/))
+            # Bump the level up 1
             tab += 1
             break
           end
         end
       end
     end
-    if(tline =~ /^=end/)
-      commentBlock = false
+
+    if(tab_line =~ /^=end/)
+      comment_block = false
     end
   end
+
   #STDOUT.write(dest)
   #File.open(filename, 'w') {|fw| fw.write(dest)}
   puts "File #{ARGV[0]} has been formatted."
+
   # uncomment this to complain about mismatched blocks
   if(tab != 0)
     STDERR.puts "Indentation error: #{tab}"

data/spec/file_line_spec.rb

@@ -5,214 +5,39 @@ require 'pathname'
 include Tailor
 
 describe Tailor::FileLine do
-  context "should return the number of leading spaces in a line" do
-    it "when the line is not indented" do
-      line = FileLine.new("def do_something", Pathname.new(__FILE__), __LINE__)
-      line.indented_spaces.should == 0
-    end
-
-    it "when the line is indented 1 space" do
-      line = FileLine.new(" def do_something", Pathname.new(__FILE__),
-        __LINE__)
-      line.indented_spaces.should == 1
-    end
-
-    it "when the line is indented 1 space and a hard tab" do
-      line = FileLine.new(" \tdef do_something", Pathname.new(__FILE__),
-        __LINE__)
-      line.indented_spaces.should == 1
-    end
-  end
-
-  context "should check indenting by spaces" do
-    it "when the line is indented 1 hard tab" do
-      line = FileLine.new("\tdef do_something", Pathname.new(__FILE__),
-        __LINE__)
-      line.hard_tabbed?.should be_true
-    end
-
-    it "when the line is indented with a space and 1 hard tab" do
-      line = FileLine.new(" \tdef do_something", Pathname.new(__FILE__),
-        __LINE__)
-      line.hard_tabbed?.should be_true
-    end
-
-    it "when the line is indented with a space" do
-      line = FileLine.new(" def do_something", Pathname.new(__FILE__),
-        __LINE__)
-      line.hard_tabbed?.should be_false
-    end
-
-    it "when the line is not indented" do
-      line = FileLine.new("def do_something", Pathname.new(__FILE__), __LINE__)
-      line.hard_tabbed?.should be_false
-    end
-  end
-
-  context "should check for camel case methods when" do
-    it "the method name is camel case" do
-      line = FileLine.new("def doSomething", Pathname.new(__FILE__), __LINE__)
+  
+  describe "with method definitions" do
+    it "should detect when the method name is camel case" do
+      line = create_file_line "def doSomething", __LINE__
       line.camel_case_method?.should be_true
     end
 
-    it "the method name is snake case" do
-      line = FileLine.new("def do_something", Pathname.new(__FILE__), __LINE__)
+    it "should be OK when the method name is snake case" do
+      line = create_file_line "def do_something", __LINE__
       line.camel_case_method?.should be_false
     end
   end
 
-  context "should check for snake case classes when" do
-    it "the class name is camel case" do
-      line = FileLine.new("class AClass", Pathname.new(__FILE__), __LINE__)
+  describe "with class names" do
+    it " should be OK when the class name is camel case" do
+      line = create_file_line "class AClass", __LINE__
       line.snake_case_class?.should be_false
     end
 
-    it "the class name is snake case" do
-      line = FileLine.new("class A_Class", Pathname.new(__FILE__), __LINE__)
+    it "should dectect the class name is snake case" do
+      line = create_file_line "class A_Class", __LINE__
       line.snake_case_class?.should be_true
     end
   end
 
-  it "should detect the number of trailing whitespace(s)" do
-    line = FileLine.new("  puts 'This is a line.'  \n",
-      Pathname.new(__FILE__), __LINE__)
-    line.trailing_whitespace_count.should == 2
-  end
-
-  context "comma spacing" do
-    context "after the comma" do
-      it "should detect 2 spaces after a comma" do
-        line = FileLine.new("  def do_something this,  that",
-          Pathname.new(__FILE__), __LINE__)
-        line.more_than_one_space_after_comma?.should be_true
-      end
-
-      it "should detect 2 spaces after a comma when at the end of a line" do
-        line = FileLine.new("  # This is a comment that,  \n",
-          Pathname.new(__FILE__), __LINE__)
-        line.more_than_one_space_after_comma?.should be_true
-      end
-
-      it "should be OK when 1 space after a comma" do
-        line = FileLine.new("  def do_something this, that",
-          Pathname.new(__FILE__), __LINE__)
-        line.more_than_one_space_after_comma?.should be_false
-      end
-
-      it "should be OK when no commas" do
-        line = FileLine.new("  def do_something this", Pathname.new(__FILE__),
-          __LINE__)
-        line.more_than_one_space_after_comma?.should be_false
-      end
-
-      it "should detect 0 spaces after a comma" do
-        line = FileLine.new("  def do_something this,that",
-          Pathname.new(__FILE__), __LINE__)
-        line.no_space_after_comma?.should be_true
-      end
-
-      it "should be OK when 1 space after a comma" do
-        line = FileLine.new("  def do_something this, that",
-          Pathname.new(__FILE__), __LINE__)
-        line.no_space_after_comma?.should be_false
-      end
-
-      it "should be OK when 0 spaces after a comma, but end of the line" do
-        line = FileLine.new("  # This is a comment that,\n",
-          Pathname.new(__FILE__), __LINE__)
-        line.no_space_after_comma?.should be_false
-      end
-    end
-
-    context "before the comma" do
-      it "should detect 1 space before a comma" do
-        line = FileLine.new("  def do_something this , that",
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_comma?.should be_true
-      end
-
-      it "should be OK when 0 spaces before a comma" do
-        line = FileLine.new("  def do_something this, that",
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_comma?.should be_false
-      end
-
-      it "should be OK when no commas" do
-        line = FileLine.new("  def do_something that", Pathname.new(__FILE__),
-          __LINE__)
-        line.space_before_comma?.should be_false
-      end
-    end
-  end
-
-  context "parenthesis/bracket spacing" do
-    context "open parenthesis" do
-      it "should detect a space after" do
-        line = FileLine.new("  def do_something( that, this)", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_after_open_parenthesis?.should be_true
-      end
-
-      it "should be OK with no space after" do
-        line = FileLine.new("  def do_something(that, this)", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_after_open_parenthesis?.should be_false
-      end
-    end
-
-    context "closed parenthesis" do
-      it "should detect a space before" do
-        line = FileLine.new("  def do_something(that, this )", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_closed_parenthesis?.should be_true
-      end
-
-      it "should be OK with no space after" do
-        line = FileLine.new("  def do_something(that, this)", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_closed_parenthesis?.should be_false
-      end
-    end
-
-    context "open bracket" do
-      it "should detect a space after" do
-        line = FileLine.new("[ that, this]", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_after_open_bracket?.should be_true
-      end
-
-      it "should be OK with no space after" do
-        line = FileLine.new("[that, this]", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_after_open_bracket?.should be_false
-      end
-    end
-
-    context "closed parenthesis" do
-      it "should detect a space before" do
-        line = FileLine.new("  def do_something(that, this )", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_closed_parenthesis?.should be_true
-      end
-
-      it "should be OK with no space after" do
-        line = FileLine.new("  def do_something(that, this)", 
-          Pathname.new(__FILE__), __LINE__)
-        line.space_before_closed_parenthesis?.should be_false
-      end
-    end
-  end
-
-  context "comments" do
+  describe "with comments" do
     it "should detect a regular full line comment" do
-      line = FileLine.new("  # This is a comment.", Pathname.new(__FILE__),
-        __LINE__)
+      line = create_file_line "  # This is a comment.", __LINE__
       line.comment_line?.should be_true
     end
 
     it "should skip code that's not a full line comment" do
-      line = FileLine.new("  puts 'this is some code.'",
-        Pathname.new(__FILE__), __LINE__)
+      line = create_file_line "  puts 'this is some code.'", __LINE__
       line.comment_line?.should be_false
     end
   end
@@ -220,25 +45,25 @@ describe Tailor::FileLine do
   context "line length" do
     it "should detect greater than 80 characters" do
       string_81_chars = '#' * 81
-      line = FileLine.new(string_81_chars, Pathname.new(__FILE__), __LINE__)
+      line = create_file_line string_81_chars, __LINE__
       line.too_long?.should be_true
     end
 
     it "should detect greater than 80 spaces" do
       string_81_spaces = ' ' * 81
-      line = FileLine.new(string_81_spaces, Pathname.new(__FILE__), __LINE__)
+      line = create_file_line string_81_spaces, __LINE__
       line.too_long?.should be_true
     end
 
     it "should be OK with 80 chars" do
       string_80_chars = '#' * 80
-      line = FileLine.new(string_80_chars, Pathname.new(__FILE__), __LINE__)
+      line = create_file_line string_80_chars, __LINE__
       line.too_long?.should be_false
     end
 
     it "should be OK with 80 spaces" do
       string_80_spaces  = ' ' * 80
-      line = FileLine.new(string_80_spaces, Pathname.new(__FILE__), __LINE__)
+      line = create_file_line string_80_spaces, __LINE__
       line.too_long?.should be_false
     end
   end