tailor 0.0.2 → 0.0.3

data/.autotest

@@ -0,0 +1,24 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+require 'autotest/growl'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -1,3 +1,8 @@
+=== 0.0.3 2010-04-26
+
+* Added checks for spacing around commas
+* Added checks for spacing around open/closed parenthesis/brackets
+
 === 0.0.2 2010-04-23
 
 * Renamed project from ruby_style_checker to Tailor

data/Manifest.txt

@@ -1,3 +1,4 @@
+.autotest
 History.txt
 Manifest.txt
 PostInstall.txt
@@ -10,6 +11,8 @@ features/spacing.feature
 features/step_definitions/case_checking_steps.rb
 features/step_definitions/common_steps.rb
 features/step_definitions/spacing_steps.rb
+features/support/1_file_with_bad_comma_spacing/bad_comma_spacing.rb
+features/support/1_file_with_bad_parenthesis/bad_parenthesis.rb
 features/support/1_file_with_camel_case_class/camel_case_class.rb
 features/support/1_file_with_camel_case_method/camel_case_method.rb
 features/support/1_file_with_hard_tabs/hard_tab.rb

data/README.rdoc

@@ -21,6 +21,9 @@ here http://wiki.github.com/turboladen/tailor.
   * Extra whitespace
     * At the end of lines
     * On empty lines
+    * Before & after commas
+    * Before & after open/closed parentheses
+    * Before & after open/closed square brackets
   * Line length
     * Should be <= 80 characters
 

data/Rakefile

@@ -14,7 +14,7 @@ def get_descr_from_readme
   paragraph_count = 0
   File.readlines('README.rdoc', '').each do |paragraph|
     paragraph_count += 1
-    if paragraph_count == 2
+    if paragraph_count == 4
       return paragraph
     end
   end

data/features/spacing.feature

@@ -1,10 +1,10 @@
-Feature: Indentation
-  In order to determine if my Ruby file is indented according to 
-    2-space standards
+Feature: Spacing
+  In order to determine if my Ruby file is spaced according to 
+    standards
   As a Ruby developer
-  I want to find out which files have indentation problems,
+  I want to find out which files have spacing problems,
     which lines those problems occur on,
-    and how much indentation they're missing
+    and what type of spacing they're missing
 
   Scenario: A single class-less file in a project; 1 method, indented properly
     Given I have a project directory "1_good_simple_file"
@@ -38,3 +38,65 @@ Feature: Indentation
     When I run the checker on the project
     Then the checker should tell me each line is too long
   
+  Scenario: A single file that has a comment, method name, and statement without spaces after the commas
+    Given I have a project directory "1_file_with_bad_comma_spacing"
+      And I have "1" file in my project
+      And that file contains a "comment" line without spaces after commas
+      And that file contains a "method" line without spaces after commas
+      And that file contains a "statement" line without spaces after commas
+    When I run the checker on the project
+    Then the checker should tell me each line has commas without spaces after them
+  
+  Scenario: A single file that has a comment, method name, and statement with > 1 spaces after the commas
+    Given I have a project directory "1_file_with_bad_comma_spacing"
+      And I have "1" file in my project
+      And that file contains a "comment" line with > 1 spaces after commas
+      And that file contains a "method" line with > 1 spaces after commas
+      And that file contains a "statement" line with > 1 spaces after commas
+    When I run the checker on the project
+    Then the checker should tell me each line has commas with > 1 spaces after them
+  
+  Scenario: A single file that has a comment, method name, and statement with spaces before the commas
+    Given I have a project directory "1_file_with_bad_comma_spacing"
+      And I have "1" file in my project
+      And that file contains a "comment" line with spaces before commas
+      And that file contains a "method" line with spaces before commas
+      And that file contains a "statement" line with spaces before commas
+    When I run the checker on the project
+    Then the checker should tell me each line has commas with spaces before them
+
+  Scenario: A single file that has a comment, method, and statement with spaces after open parentheses
+    Given I have a project directory "1_file_with_bad_parenthesis"
+      And I have "1" file in my project
+      And that file contains a "comment" line with spaces after an open parenthesis
+      And that file contains a "method" line with spaces after an open parenthesis
+      And that file contains a "statement" line with spaces after an open parenthesis
+    When I run the checker on the project
+    Then the checker should tell me each line has open parentheses with spaces before them
+
+  Scenario: A single file that has a comment, method, and statement with spaces after open brackets
+    Given I have a project directory "1_file_with_bad_parenthesis"
+      And I have "1" file in my project
+      And that file contains a "comment" line with spaces after an open bracket
+      And that file contains a "method" line with spaces after an open bracket
+      And that file contains a "statement" line with spaces after an open bracket
+    When I run the checker on the project
+    Then the checker should tell me each line has open brackets with spaces before them
+
+  Scenario: A single file that has a comment, method, and statement with spaces before closed parentheses
+    Given I have a project directory "1_file_with_bad_parenthesis"
+      And I have "1" file in my project
+      And that file contains a "comment" line with spaces after an open parenthesis
+      And that file contains a "method" line with spaces after an open parenthesis
+      And that file contains a "statement" line with spaces after an open parenthesis
+    When I run the checker on the project
+    Then the checker should tell me each line has closed parentheses with spaces before them
+
+  Scenario: A single file that has a comment, method, and statement with spaces before closed brackets
+    Given I have a project directory "1_file_with_bad_parenthesis"
+      And I have "1" file in my project
+      And that file contains a "comment" line with spaces after an open bracket
+      And that file contains a "method" line with spaces after an open bracket
+      And that file contains a "statement" line with spaces after an open bracket
+    When I run the checker on the project
+    Then the checker should tell me each line has closed brackets with spaces before them

data/features/step_definitions/case_checking_steps.rb

@@ -8,7 +8,7 @@ def contains_camel_case? keyword
     line = FileLine.new source_line
 
     if keyword.eql? "method"
-      line.camel_case_method? ? (return true) : (return false)
+      line.snake_case_method? ? (return false) : (return false)
     elsif keyword.eql? "class"
       line.camel_case_class? ? (return true) : (return false)
     end

data/features/step_definitions/spacing_steps.rb

@@ -5,52 +5,91 @@ require 'tailor/file_line'
 include Tailor
 include Tailor::IndentationChecker
 
+def check_file
+  ruby_source = File.open(@file_list[0], 'r')
+
+  ruby_source.each_line do |line|
+    yield(line)
+  end
+end
+
+def check_spacing method_name, line_type
+  is_line_type = false
+  bad_spacing = false
+  line_number = 1
+
+  file_path = Pathname.new(File.expand_path(@file_list[0]))
+
+  check_file do |line|
+    source_line = Tailor::FileLine.new(line, file_path, line_number)
+
+    is_line_type = source_line.send("#{line_type}_line?")
+    bad_spacing = source_line.send(method_name)
+
+    break line if is_line_type == true and bad_spacing == true
+
+    line_number += 1
+  end
+
+  is_line_type.should be_true
+  bad_spacing.should be_true
+end
+
 #-----------------------------------------------------------------------------
 # "Given" statements
 #-----------------------------------------------------------------------------
 Given /^that file contains lines with hard tabs$/ do
-  @ruby_source = File.open(@file_list[0], 'r')
   contains_hard_tabs = false
-  @ruby_source.each_line do |line|
-    source_line = Tailor::FileLine.new line
+  line_number = 1
+
+  file_path = Pathname.new(File.expand_path(@file_list[0]))
+
+  check_file do |line|
+    source_line = Tailor::FileLine.new(line, file_path, line_number)
     if source_line.hard_tabbed?
       contains_hard_tabs = true
       break
     end
+    line_number += 1
   end
+
   contains_hard_tabs.should be_true
 end
 
 Given /^that file does not contain any "([^\"]*)" statements$/ do |keyword|
-  @ruby_source = File.open(@file_list[0], 'r')
+  ruby_source = File.open(@file_list[0], 'r')
 
-  count = count_keywords(@ruby_source, keyword)
+  count = count_keywords(ruby_source, keyword)
   count.should == 0
 end
 
 Given /^that file is indented properly$/ do
-  @file_list.each do |file|
-    Tailor::IndentationChecker.validate_indentation file
-  end
+  pending
 end
 
 Given /^that file contains lines with trailing whitespace$/ do
-  @ruby_source = File.open(@file_list[0], 'r')
+  line_number = 1
 
-  @ruby_source.each_line do |line|
-    source_line = Tailor::FileLine.new line
+  file_path = Pathname.new(File.expand_path(@file_list[0]))
+
+  check_file do |line|
+    source_line = Tailor::FileLine.new(line, file_path, line_number)
 
     @whitespace_count = source_line.trailing_whitespace_count
 
     @whitespace_count.should > 0
+
+    line_number += 1
   end
 end
 
 Given /^that file contains lines longer than 80 characters$/ do
-  @ruby_source = File.open(@file_list[0], 'r')
+  line_number = 1
+
+  file_path = Pathname.new(File.expand_path(@file_list[0]))
 
-  @ruby_source.each_line do |line|
-    source_line = Tailor::FileLine.new line
+  check_file do |line|
+    source_line = Tailor::FileLine.new(line, file_path, line_number)
 
     if source_line.too_long?
       too_long = true
@@ -60,9 +99,34 @@ Given /^that file contains lines longer than 80 characters$/ do
     end
 
     too_long.should be_true
+
+    line_number += 1
   end
 end
 
+Given /^that file contains a "([^\"]*)" line without spaces after commas$/ do |line_type|
+  check_spacing("no_space_after_comma?", line_type)
+end
+
+Given /^that file contains a "([^\"]*)" line with > 1 spaces after commas$/ do |line_type|
+  check_spacing("more_than_one_space_after_comma?", line_type)
+end
+
+Given /^that file contains a "([^\"]*)" line with spaces before commas$/ do |line_type|
+  check_spacing("space_before_comma?", line_type)
+end
+
+Given /^that file contains a "([^\"]*)" line with spaces after open parentheses$/ do |line_type|
+  check_spacing("space_after_open_parenthesis?", line_type)
+end
+
+Given /^that file contains a "([^\"]*)" line with spaces after an open bracket$/ do |line_type|
+  check_spacing("space_after_open_bracket?", line_type)
+end
+
+Given /^that file contains a "([^\"]*)" line with spaces after an open parenthesis$/ do |line_type|
+  check_spacing("space_before_closed_parenthesis?", line_type)
+end
 
 #-----------------------------------------------------------------------------
 # "When" statements
@@ -75,7 +139,7 @@ end
 # "Then" statements
 #-----------------------------------------------------------------------------
 Then /^the checker should tell me each line that has a hard tab$/ do
-  @result.should include("Line is hard-tabbed")
+  @result.should include("Line contains hard tabs")
 end
 
 Then "the checker should tell me my indentation is OK" do
@@ -83,11 +147,45 @@ Then "the checker should tell me my indentation is OK" do
 end
 
 Then /^the checker should tell me each line has trailing whitespace$/ do
-  message= "Line contains #{@whitespace_count} trailing whitespace(s)"
-  @result.should include message
+  @result.should include("Line contains #{@whitespace_count} trailing whitespace(s)")
 end
 
 Then /^the checker should tell me each line is too long$/ do
-  msg = "Line is greater than #{Tailor::FileLine::LINE_LENGTH_MAX} characters"
-  @result.should include msg
+  message = "Line is greater than #{Tailor::FileLine::LINE_LENGTH_MAX} characters"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has commas without spaces after them$/ do
+  message = "Line has a comma with 0 spaces after it"
+  @result.should include(message)
 end
+
+Then /^the checker should tell me each line has commas with spaces before them$/ do
+  message = "Line has at least one space before a comma"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has commas with > 1 spaces after them$/ do
+  message = "Line has a comma with > 1 space after it"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has open parentheses with spaces before them$/ do
+  message = "Line has an open parenthesis with spaces after it"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has open brackets with spaces before them$/ do
+  message = "Line has an open bracket with spaces after it"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has closed parentheses with spaces before them$/ do
+  message = "Line has a closed parenthesis with spaces before it"
+  @result.should include(message)
+end
+
+Then /^the checker should tell me each line has closed brackets with spaces before them$/ do
+  message = "Line has a closed bracket with spaces before it"
+  @result.should include(message)
+end

data/features/support/1_file_with_bad_comma_spacing/bad_comma_spacing.rb

@@ -0,0 +1,5 @@
+# This is a sample which ,when checked,should show bad-comma errors. Comma errors,  
+# and stuff,   make source difficult to read!
+def do_something this ,that,  other
+  puts "We ,I mean I,am doing,  er, something!"
+end

data/features/support/1_file_with_bad_parenthesis/bad_parenthesis.rb

@@ -0,0 +1,6 @@
+# This is a comment; this should get caught: ( me, you )
+# This is a comment; this should also get caught: [ us, them ]
+def do_something( hello, and_hi=[ "me", "you" ] )
+  test = [ "one", "two" ]
+  File.expand_path( File.dirname (__FILE__) )
+end

data/lib/tailor.rb

@@ -6,7 +6,7 @@ require 'pathname'
 require 'tailor/file_line'
 
 module Tailor
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 
   RUBY_KEYWORDS_WITH_END = [
     'begin',
@@ -53,7 +53,7 @@ module Tailor
 
     # Get the .rb files
     ruby_files_in_project = Dir.glob(File.join('*', '**', '*.rb'))
-    Dir.glob(File.join('*.rb')).each { |f| ruby_files_in_project << f }
+    Dir.glob(File.join('*.rb')).each { |file| ruby_files_in_project << file }
 
     # Expand paths to all files in the list
     list_with_absolute_paths = Array.new
@@ -78,51 +78,51 @@ module Tailor
     puts "# \t'#{file_path}'"
     puts "#-------------------------------------------------------------------"
 
-    problem_count = 0
+    @problem_count = 0
     line_number = 1
     source.each_line do |source_line|
-      line = FileLine.new source_line
+      line = FileLine.new(source_line, file_path, line_number)
 
-      # Check for hard tabs
-      if line.hard_tabbed?
-        puts "Line is hard-tabbed:"
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{line_number}"
-        problem_count += 1
-      end
+      # Check for indenting by spaces only
+      @problem_count += 1 if line.hard_tabbed?
 
       # Check for camel-cased methods
-      if line.method? and line.camel_case_method?
-        puts "Method name uses camel case:"
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{line_number}"
-        problem_count += 1
-      end
+      @problem_count += 1 if line.method_line? and line.camel_case_method?
 
       # Check for non-camel-cased classes
-      if line.class? and !line.camel_case_class?
-        puts "Class name does NOT use camel case:"
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{line_number}"
-        problem_count += 1
-      end
+      @problem_count += 1 if line.class_line? and line.snake_case_class?
 
       # Check for trailing whitespace
-      count = line.trailing_whitespace_count
-      if count > 0
-        puts "Line contains #{count} trailing whitespace(s):"
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{line_number}"
-        problem_count += 1
-      end
+      @problem_count += 1 if line.trailing_whitespace?
 
       # Check for long lines
-      if line.too_long?
-        puts "Line is greater than #{FileLine::LINE_LENGTH_MAX} characters:"
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{line_number}"
-        problem_count += 1
-      end
+      @problem_count += 1 if line.too_long?
+
+      # Check for spacing after commas
+      @problem_count += 1 if line.more_than_one_space_after_comma?
+
+      # Check for spacing after commas
+      @problem_count += 1 if line.no_space_after_comma?
+
+      # Check for spacing after commas
+      @problem_count += 1 if line.space_before_comma?
+
+      # Check for spacing after open parentheses
+      @problem_count += 1 if line.space_after_open_parenthesis?
+
+      # Check for spacing after open brackets
+      @problem_count += 1 if line.space_after_open_bracket?
+
+      # Check for spacing after closed parentheses
+      @problem_count += 1 if line.space_before_closed_parenthesis?
+
+      # Check for spacing after closed brackets
+      @problem_count += 1 if line.space_before_closed_bracket?
 
       line_number += 1
     end
 
-    problem_count
+    @problem_count
   end
 
   # Prints a summary report that shows which files had how many problems.
@@ -136,7 +136,8 @@ module Tailor
     files_and_problems.each_pair do |file, problem_count|
       file_path = Pathname.new(file)
       unless problem_count == 0
-        puts "\t#{file_path.relative_path_from(Pathname.pwd)}: #{problem_count} problems"
+        print "\t#{problem_count} problems in: "
+        puts "#{file_path.relative_path_from(Pathname.pwd)}"
       end
     end
   end

data/lib/tailor/file_line.rb

@@ -1,8 +1,14 @@
+require 'pathname'
+
 module Tailor
 
   # Calling modules will get the Ruby file to check, then read by line.  This
   #   class allows for checking of line-specific style by Represents a single
   #   line of a file of Ruby code.  Inherits from String so "self" can be used.
+  #
+  # Methods are named such that they check for bad style conditions, and return
+  #   true and print the associated error message when the bad style condition
+  #   is discovered in the file line.
   class FileLine < String
 
     LINE_LENGTH_MAX = 80
@@ -12,10 +18,15 @@ module Tailor
     #
     # @param [String] line_of_code Line from a Ruby file that will be checked
     #   for styling.
+    # @param [Pathname] file_path Path to the file the line is in.
+    # @param [Number] line_number Line number in the file that contains the
+    #   line.
     # @return [String] Returns a String that includes all of the methods
     #   defined here.
-    def initialize line_of_code
+    def initialize line_of_code, file_path, line_number
       super line_of_code
+      @file_path = file_path
+      @line_number = line_number
     end
 
     # Determines the number of spaces the line is indented.
@@ -32,66 +43,67 @@ module Tailor
       end
     end
 
-    # Checks to see if the source code line is tabbed
+    # Checks to see if the source code line contains any hard tabs.
     #
-    # @return [Boolean] Returns true if the file contains a tab
-    #   character before any others in that line.
+    # @return [Boolean] Returns true if the file line contains hard tabs.
+    #   false if the line contains only spaces.
     def hard_tabbed?
-      result = case self
-        # The line starts with a tab
-        when /^\t/ then true
-        # The line starts with spaces, then has a tab
-        when /^\s+\t/ then true
-        else false
+      if self.scan(/\t/).empty?
+        return false
+      else
+        print_problem "Line contains hard tabs:"
+        return true
       end
     end
 
-    # Checks to see if the method is using camel case.
+    # Checks to see if the method name is using camel case.
     #
     # @return [Boolean] Returns true if the method name is camel case.
+    #   Returns nil if this line doesn't contain a method definition.
     def camel_case_method?
       words = self.split(/ /)
 
-      # If we're dealing with a method, check for uppercase chars
-      if self.method?
+      # If we're not dealing with a method, get outta here.
+      unless self.method_line?
+        return nil
+      end
 
-        # The 2nd word is the method name, so evaluate that for caps chars.
-        if words[1] =~ /[A-Z]/
-          return true
-        else
-          return false
-        end
-      # If we're dealing with a class, check for an underscore.
+      # The 2nd word is the method name, so evaluate that for caps chars.
+      if words[1] =~ /[A-Z]/
+        print_problem "Method name uses camel case:"
+        return true
       else
-        return nil
+        return false
       end
     end
 
-    # Checks to see if the class is using camel case.
+    # Checks to see if the class name is using snake case.
     #
-    # @return [Boolean] Returns true if the class name is camel case.
-    def camel_case_class?
+    # @return [Boolean] Returns true if the class name is snake case.
+    #   Returns nil if this line doesn't contain a class definition.
+    def snake_case_class?
       words = self.split(/ /)
 
       # If we're dealing with a class, check for an underscore.
-      if self.class?
-        if words[1] =~ /_/
-          return false
-        else
-          return true
-        end
-      else
+      unless self.class_line?
         return nil
       end
+
+      # The 2nd word is the class name, so check that.
+      if words[1] =~ /_/
+        print_problem "Class name does NOT use camel case:"
+        return true
+      else
+        return false
+      end
     end
 
     # Checks to see if the line is the start of a method's definition.
     #
-    # @return [Boolean] Returns true if the line contains 'def' and the second
-    #   word begins with a lowercase letter.
-    def method?
+    # @return [Boolean] Returns true if the line starts with 'def'.
+    def method_line?
       words = self.split(/ /)
-      if words[0].eql? "def" and starts_with_lowercase?(words[1])
+      if words[0].eql? "def"
         return true
       else
         return false
@@ -102,7 +114,7 @@ module Tailor
     #
     # @return [Boolean] Returns true if the line contains 'class' and the
     #   second word begins with a uppercase letter.
-    def class?
+    def class_line?
       words = self.split(/ /)
       if words[0].eql? "class" and starts_with_uppercase?(words[1])
         return true
@@ -111,18 +123,49 @@ module Tailor
       end
     end
 
+    ##
+    # Checks to see if the line is a regular statement (not a class, method, or
+    #   comment).
+    #
+    # @return [Boolean] Returns true if the line is not a class, method or
+    #   comment.
+    def statement_line?
+      if self.method_line? or self.class_line? or self.comment_line?
+        return false
+      else
+        return true
+      end
+    end
+
     # Checks to see if the whole line is a basic comment line.  This doesn't
     #   check for trailing-line comments (@see #trailing_comment?).
     #
     # @return [Boolean] Returns true if the line begins with a pound symbol.
-    def line_comment?
-      if self.scan(/\s+#/).empty?
+    def comment_line?
+      if self.scan(/\s*#/).empty?
         return false
       else
         return true
       end
     end
 
+    ##
+    # Checks to see if there's whitespace at the end of the line.  Prints the
+    #   number of whitespaces at the end of the line.
+    #
+    # @return [Boolean] Returns true if theres whitespace at the end of the
+    #   line.
+    def trailing_whitespace?
+      count = self.trailing_whitespace_count
+
+      if count > 0
+        print_problem "Line contains #{count} trailing whitespace(s):"
+        return true
+      else
+        return false
+      end
+    end
+
     # Checks to see if the line has trailing whitespace at the end of it. Note
     #   that this excludes empty lines that have spaces on them!
     #
@@ -137,55 +180,104 @@ module Tailor
       end
     end
 
-    # Checks to see if a single space exists after a comma in uncomented code.
-    #   This method doesn't check if the line is a comment, so this should be
-    #   done before calling this method.  @see #line_comment?.
+    ##
+    # Checks to see if there's more than one one space after a comma.
     #
-    # @return [Boolean] Returns true if only 1 space exists after a comma.
-    def two_or_more_spaces_after_comma?
-      if self.scan(/\w\,\s{2,}/).empty?
+    # @return [Boolean] Returns true if there is more than one space after
+    #   a comma.
+    def more_than_one_space_after_comma?
+      if self.scan(/\,\x20{2,}/).first.nil?
         return false
-      else
+      elsif self.scan(/\,\x20{2,}/)
+        print_problem "Line has a comma with > 1 space after it:"
         return true
       end
     end
 
     ##
-    # Checks to see if there's no spaces after a comma.
+    # Checks to see if there's no spaces after a comma and the next word.
     #
-    # @return [Boolean] Returns true if there isn't a space after a comma.
+    # @return [Boolean] Returns true if there's no spaces between a comma and
+    #   the next word.
     def no_space_after_comma?
-      if self.scan(/\w\,\w/).empty?
+      if self.scan(/\w\x20?\,\w/).first.nil?
         return false
-      else
+      elsif self.scan(/\w\x20?\,\w/)
+        print_problem "Line has a comma with 0 spaces after it:"
         return true
       end
     end
 
     ##
-    # Checks to see if there's no space before a comma.
+    # Checks to see if there's spaces before a comma.
     #
-    # @return [Boolean] Returns true if there's no space before a comma.
-    def no_space_before_comma?
-      if self.scan(/\w\s\,/)
+    # @return [Boolean] Returns true if there's any spaces before a comma.
+    #   Returns nil if the line doesn't contain a comma.
+    def space_before_comma?
+      if self.scan(/\w\x20+\,/).first.nil?
+        return false
+      elsif self.scan(/\w\x20+\,/)
+        print_problem "Line has at least one space before a comma:"
         return true
       else
+        return nil
+      end
+    end
+
+    ##
+    # Checks to see if there's spaces after an open parenthesis.
+    # 
+    # @return [Boolean] Returns true if there's spaces after an open
+    #   parenthesis.
+    def space_after_open_parenthesis?
+      if self.scan(/\(\x20+/).first.nil?
         return false
+      elsif self.scan(/\(\x20+/)
+        print_problem "Line has an open parenthesis with spaces after it:"
+        return true
       end
     end
 
-    # Counts the number of spaces around a comma and returns before and after
-    #   values as a hash.
-    #
-    # @return [Hash<:before,:after>] Returns a Hash with values for :before and
-    #   :after.
-    def spaces_around_comma
-      spaces = Hash.new
+    ##
+    # Checks to see if there's spaces after an open bracket.
+    # 
+    # @return [Boolean] Returns true if there's spaces after an open
+    #   bracket.
+    def space_after_open_bracket?
+      if self.scan(/\[\x20+/).first.nil?
+        return false
+      elsif self.scan(/\[\x20+/)
+        print_problem "Line has an open bracket with spaces after it:"
+        return true
+      end
+    end
 
-      spaces[:before] = self.scan(/(\x20+),/)
-      spaces[:after] = self.scan(/,(\x20+)/)
+    ##
+    # Checks to see if there's spaces before a closed parenthesis.
+    # 
+    # @return [Boolean] Returns true if there's spaces before a closed
+    #   parenthesis.
+    def space_before_closed_parenthesis?
+      if self.scan(/\x20+\)/).first.nil?
+        return false
+      elsif self.scan(/\x20+\)/)
+        print_problem "Line has a closed parenthesis with spaces before it:"
+        return true
+      end
+    end
 
-      spaces
+    ##
+    # Checks to see if there's spaces before a closed brackets.
+    # 
+    # @return [Boolean] Returns true if there's spaces before a closed
+    #   bracket.
+    def space_before_closed_bracket?
+      if self.scan(/\x20+\]/).first.nil?
+        return false
+      elsif self.scan(/\x20+\]/)
+        print_problem "Line has a closed bracket with spaces before it:"
+        return true
+      end
     end
 
     ##
@@ -195,7 +287,12 @@ module Tailor
     # @return [Boolean] Returns true if the line length exceeds the allowed
     #   length.
     def too_long?
-      self.length > LINE_LENGTH_MAX ? true : false
+      if self.length > LINE_LENGTH_MAX
+        print_problem "Line is greater than #{LINE_LENGTH_MAX} characters:"
+        return true
+      else
+        return false
+      end
     end
 
     #-----------------------------------------------------------------
@@ -203,6 +300,15 @@ module Tailor
     #-----------------------------------------------------------------
     private
 
+    ##
+    # Prints the file name and line number that the problem occured on.
+    #
+    # @param [String] Error message to print.
+    def print_problem message
+      puts message
+      puts "\t#{@file_path.relative_path_from(Pathname.pwd)}: #{@line_number}"
+    end
+
     # Checks to see if a word begins with a lowercase letter.
     #
     # @param [String] word The word to check case on.

data/lib/tailor/indentation_checker.rb

@@ -12,9 +12,9 @@ module Tailor
         line = FileLine.new(line_of_code)
 
         # Make sure the line isn't hard-tabbed
-        if line.hard_tabbed?
-          results << "Line #{line_number} is hard-tabbed."
-        end
+        #if line.soft_tabbed?
+        #  results << "Line #{line_number} is hard-tabbed."
+        #end
 
         # Check for indentation
         #spaces = line.indented_spaces

data/spec/file_line_spec.rb

@@ -1,135 +1,244 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 require 'tailor/file_line'
+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"
+      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"
+      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"
+      line = FileLine.new(" \tdef do_something", Pathname.new(__FILE__),
+        __LINE__)
       line.indented_spaces.should == 1
     end
   end
 
-  context "should check hard tabs" do
+  context "should check indenting by spaces" do
     it "when the line is indented 1 hard tab" do
-      line = FileLine.new "\tdef do_something"
+      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"
+      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"
+      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"
+      line = FileLine.new("def do_something", Pathname.new(__FILE__), __LINE__)
       line.hard_tabbed?.should be_false
     end
   end
 
-  context "should check for camel case when" do
-    it "is a method and the method name is camel case" do
-      line = FileLine.new "def doSomething"
+  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__)
       line.camel_case_method?.should be_true
     end
 
-    it "is a method and the method name is snake case" do
-      line = FileLine.new "def do_something"
+    it "the method name is snake case" do
+      line = FileLine.new("def do_something", Pathname.new(__FILE__), __LINE__)
       line.camel_case_method?.should be_false
     end
+  end
 
-    it "is a class and the class name is camel case" do
-      line = FileLine.new "class AClass"
-      line.camel_case_class?.should be_true
+  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__)
+      line.snake_case_class?.should be_false
     end
 
-    it "is a class and the class name is snake case" do
-      line = FileLine.new "class A_Class"
-      line.camel_case_class?.should be_false
+    it "the class name is snake case" do
+      line = FileLine.new("class A_Class", Pathname.new(__FILE__), __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"
+    line = FileLine.new("  puts 'This is a line.'  \n",
+      Pathname.new(__FILE__), __LINE__)
     line.trailing_whitespace_count.should == 2
   end
 
-  # TODO: These methods should probably all be called by
-  #   line.check_comma_spacingor something.  As it stands, these tests are
-  #   going to start to get confusing, plus having one entry point for
-  #   checking commas probably makes the most sense.
-  context "spacing after a comma" do
-    it "should detect no space after a comma" do
-      line = FileLine.new "  def do_something this,that"
-      line.no_space_after_comma?.should be_true
-    end
-
-    it "should skip code that has 1 space after a comma" do
-      line = FileLine.new "  def do_something this, that"
-      line.no_space_after_comma?.should be_false
-    end
-
-    it "should detect 2 spaces after a comma" do
-      line = FileLine.new "  def do_something this,  that"
-      line.two_or_more_spaces_after_comma?.should be_true
+  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
 
-    it "should skip code that has 1 space after a comma" do
-      line = FileLine.new "  def do_something this, that"
-      line.two_or_more_spaces_after_comma?.should be_false
+  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
     it "should detect a regular full line comment" do
-      line = FileLine.new "  # This is a comment."
-      line.line_comment?.should be_true
+      line = FileLine.new("  # This is a comment.", Pathname.new(__FILE__),
+        __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.'"
-      line.line_comment?.should be_false
+      line = FileLine.new("  puts 'this is some code.'",
+        Pathname.new(__FILE__), __LINE__)
+      line.comment_line?.should be_false
     end
   end
 
   context "line length" do
     it "should detect greater than 80 characters" do
       string_81_chars = '#' * 81
-      line = FileLine.new string_81_chars
+      line = FileLine.new(string_81_chars, Pathname.new(__FILE__), __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
+      line = FileLine.new(string_81_spaces, Pathname.new(__FILE__), __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
+      line = FileLine.new(string_80_chars, Pathname.new(__FILE__), __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
+      line = FileLine.new(string_80_spaces, Pathname.new(__FILE__), __LINE__)
       line.too_long?.should be_false
     end
   end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Steve Loveless
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-23 00:00:00 -07:00
+date: 2010-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -114,7 +114,10 @@ dependencies:
   type: :development
   version_requirements: *id007
 description: |+
-  * http://github.com/turboladen/tailor
+  tailor is an executable that recursively parses Ruby files in a 
+  directory and checks them for bad style.  Rules for judging style are based on 
+  a number of style guides that are popular in the Ruby community.  More on this
+  here http://wiki.github.com/turboladen/tailor.
   
 email: 
 - steve.loveless@gmail.com
@@ -127,6 +130,7 @@ extra_rdoc_files:
 - Manifest.txt
 - PostInstall.txt
 files: 
+- .autotest
 - History.txt
 - Manifest.txt
 - PostInstall.txt
@@ -139,6 +143,8 @@ files:
 - features/step_definitions/case_checking_steps.rb
 - features/step_definitions/common_steps.rb
 - features/step_definitions/spacing_steps.rb
+- features/support/1_file_with_bad_comma_spacing/bad_comma_spacing.rb
+- features/support/1_file_with_bad_parenthesis/bad_parenthesis.rb
 - features/support/1_file_with_camel_case_class/camel_case_class.rb
 - features/support/1_file_with_camel_case_method/camel_case_method.rb
 - features/support/1_file_with_hard_tabs/hard_tab.rb
@@ -186,7 +192,7 @@ rdoc_options:
 - - Manifest.txt
   - History.txt
 - --title
-- tailor Documentation (0.0.2)
+- tailor Documentation (0.0.3)
 - --markup
 - :rdoc
 require_paths: