tailor 0.0.2

data/features/step_definitions/spacing_steps.rb

@@ -0,0 +1,93 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'tailor/indentation_checker'
+require 'tailor/file_line'
+
+include Tailor
+include Tailor::IndentationChecker
+
+#-----------------------------------------------------------------------------
+# "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
+    if source_line.hard_tabbed?
+      contains_hard_tabs = true
+      break
+    end
+  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')
+
+  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
+end
+
+Given /^that file contains lines with trailing whitespace$/ do
+  @ruby_source = File.open(@file_list[0], 'r')
+
+  @ruby_source.each_line do |line|
+    source_line = Tailor::FileLine.new line
+
+    @whitespace_count = source_line.trailing_whitespace_count
+
+    @whitespace_count.should > 0
+  end
+end
+
+Given /^that file contains lines longer than 80 characters$/ do
+  @ruby_source = File.open(@file_list[0], 'r')
+
+  @ruby_source.each_line do |line|
+    source_line = Tailor::FileLine.new line
+
+    if source_line.too_long?
+      too_long = true
+      break
+    else
+      too_long = false
+    end
+
+    too_long.should be_true
+  end
+end
+
+
+#-----------------------------------------------------------------------------
+# "When" statements
+#-----------------------------------------------------------------------------
+When "I run the checker on the project" do
+  @result = `#{@tailor} #{@project_dir}`
+end
+
+#-----------------------------------------------------------------------------
+# "Then" statements
+#-----------------------------------------------------------------------------
+Then /^the checker should tell me each line that has a hard tab$/ do
+  @result.should include("Line is hard-tabbed")
+end
+
+Then "the checker should tell me my indentation is OK" do
+  pending
+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
+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
+end

data/features/support/1_file_with_camel_case_class/camel_case_class.rb

@@ -0,0 +1,5 @@
+class CamelCase
+  def my_method
+    return
+  end
+end

data/features/support/1_file_with_camel_case_method/camel_case_method.rb

@@ -0,0 +1,3 @@
+def doSomething
+  return
+end

data/features/support/1_file_with_hard_tabs/hard_tab.rb

@@ -0,0 +1,3 @@
+def my_method
+	  return
+end

data/features/support/1_file_with_long_lines/long_lines.rb

@@ -0,0 +1,5 @@
+# This method has a line in it that is way too freaking long.  Seriously, why would you do
+# something like this?
+def do_something and_stuff
+  this_is_a_long_variable_name = Hash.new(:thing1 => 'something', :thing2 => 'something')
+end

data/features/support/1_file_with_snake_case_class/snake_case_class.rb

@@ -0,0 +1,5 @@
+class A_Class
+  def do_something
+    return
+  end
+end

data/features/support/1_file_with_snake_case_method/snake_case_method.rb

@@ -0,0 +1,3 @@
+def do_something
+  return
+end

data/features/support/1_file_with_trailing_whitespace/trailing_whitespace.rb

@@ -0,0 +1,5 @@
+class MyClass  
+  def do_something   
+    return    
+  end     
+end      

data/features/support/1_good_simple_file/my_project.rb

@@ -0,0 +1,7 @@
+# This file contains 1 method, no class, and is properly indented
+#   in order to test a related scenario.
+def a_method
+  an_array = Array.new
+  a_hash = Hash.new
+end
+  

data/features/support/common.rb

@@ -0,0 +1,29 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/../../lib/tailor"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/features/support/world.rb

@@ -0,0 +1,53 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'tailor'
+
+include Tailor
+
+
+# Counts keywords in the file provided.
+#
+# @param [String] file Path to the file to check
+# @param [String] keyword Keyword to count
+# @return [Number] Number of keywords counted
+def count_keywords file, keyword
+  ruby_source = File.open(file, 'r')
+
+  count = 0
+  ruby_source.each_line do |line|
+    if line =~ /^#{keyword}/
+      count =+ 1
+    end
+  end
+  ruby_source.close
+  count
+end
+
+
+# Prep for the testing
+Before do
+  @tailor = "#{File.dirname(__FILE__)}/../../bin/tailor"
+end
+
+
+#-----------------------------------------------------------------------------
+# "Given" statements
+#-----------------------------------------------------------------------------
+Given /^I have a project directory "([^\"]*)"$/ do |project_dir|
+  project_dir = "support/#{project_dir}"
+  File.exists?(project_dir).should be_true
+  File.directory?(project_dir).should be_true
+  @project_dir = project_dir
+end
+
+Given /^the file contains only "([^\"]*)" "([^\"]*)" statement$/ do
+  |count_in_spec, keyword|
+  #count_in_file = count_keywords(@ruby_source, keyword)
+  count_in_file = count_keywords(@file_list[0], keyword)
+  count_in_file.should == count_in_spec.to_i
+end
+
+Given /^I have "([^\"]*)" file in my project$/ do |file_count|
+  @file_list = Dir.glob("#{@project_dir}/*")
+  @file_list.length.should == file_count.to_i
+end

data/lib/tailor.rb

@@ -0,0 +1,143 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'fileutils'
+require 'pathname'
+require 'tailor/file_line'
+
+module Tailor
+  VERSION = '0.0.2'
+
+  RUBY_KEYWORDS_WITH_END = [
+    'begin',
+    'case',
+    'class',
+    'def',
+    'do',
+    'if',
+    'unless',
+    'until',
+    'while'
+    ]
+
+  # Check all files in a directory for style problems.
+  #
+  # @param [String] project_base_dir Path to a directory to recurse into and
+  #   look for problems in.
+  # @return [Hash] Returns a hash that contains file_name => problem_count.
+  def self.check project_base_dir
+    # Get the list of files to process
+    ruby_files_in_project = project_file_list(project_base_dir)
+
+    files_and_problems = Hash.new
+
+    # Process each file
+    ruby_files_in_project.each do |file_name|
+      problems = find_problems file_name
+      files_and_problems[file_name] = problems
+    end
+
+    files_and_problems
+  end
+
+  # Gets a list of .rb files in the project.  This gets each file's absolute
+  #   path in order to alleviate any possible confusion.
+  #
+  # @param [String] base_dir Directory to start recursing from to look for .rb
+  #   files
+  # @return [Array] Sorted list of absolute file paths in the project
+  def self.project_file_list base_dir
+    if File.directory? base_dir
+      FileUtils.cd base_dir
+    end
+
+    # 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 }
+
+    # Expand paths to all files in the list
+    list_with_absolute_paths = Array.new
+    ruby_files_in_project.each do |file|
+      list_with_absolute_paths << File.expand_path(file)
+    end
+
+    list_with_absolute_paths.sort
+  end
+
+  # Checks a sing file for all defined styling parameters.
+  #
+  # @param [String] file_name Path to a file to check styling on.
+  # @return [Number] Returns the number of errors on the file.
+  def self.find_problems file_name
+    source = File.open(file_name, 'r')
+    file_path = Pathname.new(file_name)
+
+    puts
+    puts "#-------------------------------------------------------------------"
+    puts "# Looking for bad style in:"
+    puts "# \t'#{file_path}'"
+    puts "#-------------------------------------------------------------------"
+
+    problem_count = 0
+    line_number = 1
+    source.each_line do |source_line|
+      line = FileLine.new source_line
+
+      # 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 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
+
+      # 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
+
+      # 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
+
+      # 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
+
+      line_number += 1
+    end
+
+    problem_count
+  end
+
+  # Prints a summary report that shows which files had how many problems.
+  #
+  # @param [Hash] files_and_problems Returns a hash that contains
+  #   file_name => problem_count.
+  def self.print_report files_and_problems
+    puts
+    puts "The following files are out of style:"
+
+    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"
+      end
+    end
+  end
+end

data/lib/tailor/file_line.rb

@@ -0,0 +1,228 @@
+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.
+  class FileLine < String
+
+    LINE_LENGTH_MAX = 80
+
+    # This passes the line of code to String (the parent) so that it can act
+    #   like a standard string.
+    #
+    # @param [String] line_of_code Line from a Ruby file that will be checked
+    #   for styling.
+    # @return [String] Returns a String that includes all of the methods
+    #   defined here.
+    def initialize line_of_code
+      super line_of_code
+    end
+
+    # Determines the number of spaces the line is indented.
+    #
+    # @return [Number] Returns the number of spaces the line is indented.
+    def indented_spaces
+      # Find out how many spaces exist at the beginning of the line
+      spaces = self.scan(/^\x20+/).first
+
+      unless spaces.nil?
+        return spaces.length
+      else
+        return 0
+      end
+    end
+
+    # Checks to see if the source code line is tabbed
+    #
+    # @return [Boolean] Returns true if the file contains a tab
+    #   character before any others in that line.
+    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
+      end
+    end
+
+    # Checks to see if the method is using camel case.
+    #
+    # @return [Boolean] Returns true if the method name is camel case.
+    def camel_case_method?
+      words = self.split(/ /)
+
+      # If we're dealing with a method, check for uppercase chars
+      if self.method?
+
+        # 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.
+      else
+        return nil
+      end
+    end
+
+    # Checks to see if the class is using camel case.
+    #
+    # @return [Boolean] Returns true if the class name is camel case.
+    def camel_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
+        return nil
+      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?
+      words = self.split(/ /)
+      if words[0].eql? "def" and starts_with_lowercase?(words[1])
+        return true
+      else
+        return false
+      end
+    end
+
+    # Checks to see if the line is the start of a class's definition.
+    #
+    # @return [Boolean] Returns true if the line contains 'class' and the
+    #   second word begins with a uppercase letter.
+    def class?
+      words = self.split(/ /)
+      if words[0].eql? "class" and starts_with_uppercase?(words[1])
+        return true
+      else
+        return false
+      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?
+        return false
+      else
+        return true
+      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!
+    #
+    # @return [Number] Returns the number of trailing spaces at the end of the
+    #   line.
+    def trailing_whitespace_count
+      spaces = self.scan(/(\x20+|\x09+)$/)
+      if spaces.first.eql? nil
+        return 0
+      else
+        return spaces.first.first.length
+      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?.
+    #
+    # @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 false
+      else
+        return true
+      end
+    end
+
+    ##
+    # Checks to see if there's no spaces after a comma.
+    #
+    # @return [Boolean] Returns true if there isn't a space after a comma.
+    def no_space_after_comma?
+      if self.scan(/\w\,\w/).empty?
+        return false
+      else
+        return true
+      end
+    end
+
+    ##
+    # Checks to see if there's no space 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 true
+      else
+        return false
+      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
+
+      spaces[:before] = self.scan(/(\x20+),/)
+      spaces[:after] = self.scan(/,(\x20+)/)
+
+      spaces
+    end
+
+    ##
+    # Checks to see if the line is greater than the defined max (80 chars is
+    #   default).
+    #
+    # @return [Boolean] Returns true if the line length exceeds the allowed
+    #   length.
+    def too_long?
+      self.length > LINE_LENGTH_MAX ? true : false
+    end
+
+    #-----------------------------------------------------------------
+    # Private methods
+    #-----------------------------------------------------------------
+    private
+
+    # Checks to see if a word begins with a lowercase letter.
+    #
+    # @param [String] word The word to check case on.
+    def starts_with_lowercase? word
+      if word =~ /^[a-z]/
+        return true
+      else
+        return false
+      end
+    end
+
+    # Checks to see if a word begins with an uppercase letter.
+    #
+    # @param [String] word The word to check case on.
+    def starts_with_uppercase? word
+      if word =~ /^[A-Z]/
+        return true
+      else
+        return false
+      end
+    end
+  end
+end