tailor 0.1.5 → 1.0.0.alpha

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

@@ -1,4 +0,0 @@
-# Spaces after open and before closed parentheses in a comment: ( me, you )
-def do_something( hello, and_hi=[ "me", "you" ] )
-  File.expand_path( File.dirname (__FILE__) )
-end

data/features/support/1_file_with_bad_square_brackets/bad_square_brackets.rb

@@ -1,62 +0,0 @@
-# Arrays...
-# Perfect
-thing = []
-
-# 1 space after [
-thing = [ ]
-
-# Perfect with element
-one = 'won'
-thing = [one]
-
-# 1 space after [ with element
-thing = [ one]
-
-# 1 space before ] with element
-thing = [one ]
-
-# 1 space before and after [ and ]
-thing = [ one ]
-
-# Perfect element reference
-thing[0]
-
-# 1 space after [ with element reference
-thing[ 0]
-
-# 1 space before [ with element reference
-thing [0]
-
-# 1 space before ] with element reference
-thing[0 ]
-
-# Perfect multi-line
-two = 'too'
-thing = [
-  one,
-  two
-]
-
-# Perfect multi-line, indented
-def thing
-  a_thing = [
-    one,
-    two
-  ]
-end
-
-
-# Hash references...
-thing = { :one => 1 }
-
-# Perfect element reference
-thing[:one]
-
-# 1 space after [ with element reference
-thing[ :one]
-
-# 1 space before [ with element reference
-thing [:one]
-
-# 1 space before ] with element reference
-thing[:one ]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +0,0 @@
-class Something
-  def a_method
-    puts "hi"
-  end
-end

data/features/support/common.rb

@@ -1,102 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../../lib')
-
-require 'tailor'
-
-include Tailor
-
-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)
-
-# 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
-
-def check_file
-  ruby_source = File.open(@file_list[0], 'r')
-
-  ruby_source.each_line do |line|
-    yield(line)
-  end
-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 = "#{@features_path}/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 1 file in my project$/ do
-  @file_list = Dir.glob("#{@project_dir}/*")
-  @file_list.length.should == 1
-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
-
-#-----------------------------------------------------------------------------
-# "When" statements
-#-----------------------------------------------------------------------------
-When "I run the checker on the project" do
-  @result = `#{@tailor} #{@project_dir}`
-end

data/features/support/matchers.rb

@@ -1,11 +0,0 @@
-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/lib/tailor/file_line.rb

@@ -1,220 +0,0 @@
-require 'logger'
-require 'rubygems'
-require 'tailor/spacing'
-require 'tailor/indentation'
-require 'term/ansicolor'
-
-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
-    include Tailor::Spacing
-    include Tailor::Indentation
-    include Term::ANSIColor
-
-    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.
-    # @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, file_path, line_number)
-      super line_of_code
-      @file_path = file_path
-      @line_number = line_number
-      @line_problem_count = 0
-      @logger = ::Logger.new(STDOUT)
-      #@logger.datetime_format = "%H:%M:%S"
-      @logger.datetime_format = ""
-    end
-
-    # 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 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]/
-        @line_problem_count += 1
-        print_problem "Method name uses camel case"
-        return true
-      end
-
-      false
-    end
-
-    # Checks to see if the class name is using snake case.
-    #
-    # @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.
-      unless self.class_line?
-        return nil
-      end
-
-      # The 2nd word is the class name, so check that.
-      if words[1] =~ /_/
-        @line_problem_count += 1
-        print_problem "Class name does NOT use camel case"
-        return true
-      end
-
-      false
-    end
-
-    # Checks to see if the line is the start of a method's definition.
-    #
-    # @return [Boolean] Returns true if the line starts with 'def'.
-    def method_line?
-      words = self.strip.split(/ /)
-      if words[0].eql? "def"
-        return true
-      end
-
-      false
-    end
-
-    # Returns the name of the method if the line is one that contains a method
-    # definition.
-    #
-    # @return [String] The method name.
-    def method_name
-      unless self.method_line?
-        return nil
-      end
-
-      words = self.strip.split(/ /)
-      words[1]
-    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_line?
-      words = self.split(/ /)
-      if words[0].eql? "class" and starts_with_uppercase?(words[1])
-        return true
-      end
-
-      false
-    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
-      end
-
-      true
-    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 comment_line?
-      unless self.scan(/^\s*#/).empty?
-        return true
-      end
-
-      false
-    end
-
-    # Checks to see if the whole line is only space characters.
-    #
-    # @return [Boolean] Returns true if the line is only space characters.
-    def empty_line?
-      if self.scan(/^\s*$/).empty?
-        return false
-      end
-
-      true
-    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?
-      length = self.length
-      if length > LINE_LENGTH_MAX
-        @line_problem_count += 1
-        print_problem "Line is >#{LINE_LENGTH_MAX} characters (#{length})"
-        return true
-      end
-
-      false
-    end
-
-    #-----------------------------------------------------------------
-    # Private methods
-    #-----------------------------------------------------------------
-    private
-
-    # Prints the file name and line number that the problem occurred on.
-    #
-    # @param [String] Error message to print.
-    def print_problem message
-      if @line_problem_count == 1
-        line_info = "Problems in"
-        line_info += " #{@file_path.relative_path_from(Pathname.pwd)}"
-        line_info += " [#{@line_number}]:"
-
-        puts ""
-        puts line_info
-      end
-
-      puts red("\t"+ message)
-    end
-
-    # 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
-      end
-
-      false
-    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
-      end
-
-      false
-    end
-  end
-end