tailor 0.1.5 → 1.0.0.alpha

data/lib/tailor/cli.rb

@@ -0,0 +1,49 @@
+require_relative 'configuration'
+require_relative 'critic'
+require_relative 'cli/options'
+require_relative 'logger'
+require_relative 'reporter'
+
+class Tailor
+
+  # The Command-Line Interface worker.  Execution from the command line should
+  # come through here.
+  class CLI
+    include LogSwitch::Mixin
+
+    # The main method of execution from the command line.
+    def self.run(args)
+      new(args).execute!
+    end
+
+    def initialize(args)
+      Tailor::Logger.log = false
+      options = Options.parse!(args)
+
+      @configuration = Configuration.new(args, options)
+      @configuration.load!
+
+      if options.show_config
+        @configuration.show
+      end
+
+      @critic = Critic.new(@configuration.file_sets)
+      @reporter = Reporter.new(@configuration.formatters)
+    end
+
+    # This checks all of the files detected during the configuration gathering
+    # process, then hands results over to the {Reporter} to be reported.
+    #
+    # @return [Boolean] +true+ if no problems were detected; false if there
+    #   were.
+    def execute!
+      @critic.critique do |problems_for_file, label|
+        @reporter.file_report(problems_for_file, label)
+      end
+
+      @reporter.summary_report(@critic.problems)
+
+      @critic.problem_count > 0
+    end
+  end
+end

data/lib/tailor/cli/options.rb

@@ -0,0 +1,251 @@
+require 'erb'
+require 'optparse'
+require 'ostruct'
+require 'text-table'
+require_relative '../version'
+require_relative '../configuration'
+
+class Tailor
+  class CLI
+    class Options
+      @output_color = true
+
+      def self.parse!(args)
+        options = OpenStruct.new
+        options.config_file = ''
+        options.formatters = []
+        options.show_config = false
+        options.style = {}
+
+        opts = OptionParser.new do |opt|
+          opt.banner = self.banner
+
+          opt.separator ""
+          opt.separator ""
+          opt.separator "Config file options:"
+          opt.on('-s', '--show-config', 'Show your current config.') do
+            options.show_config = true
+          end
+
+          opt.on('-c', '--config-file FILE',
+            "Use a specific config file.") do |config|
+            options.config_file = config
+          end
+
+          opt.on('--create-config', 'Create a new .tailor file') do
+            if create_config
+              msg = "Your new tailor config file was created at "
+              msg << "#{Dir.pwd}."
+              $stdout.puts msg
+              exit
+            else
+              $stderr.puts "Creation of .tailor failed!"
+              exit 1
+            end
+          end
+
+          #---------------------------------------------------------------------
+          # Style options
+          #---------------------------------------------------------------------
+          opt.separator ""
+          opt.separator "Style Options:"
+          opt.separator "  (Any option that doesn't have an explicit way of"
+          opt.separator "  turning it off can be done so simply by passing"
+          opt.separator "  passing it 'false'.)"
+
+          opt.separator ""
+          opt.separator "  * Horizontal Spacing:"
+          opt.on('--allow-hard-tabs BOOL',
+            'Check for hard tabs?  (default: true)') do |c|
+            options.style[:allow_hard_tabs] = c
+          end
+
+          opt.on('--allow-trailing-line-spaces BOOL',
+            'Check for trailing spaces at the end of lines?',
+            '(default: true)') do |c|
+            options.style[:allow_trailing_line_spaces] = c
+          end
+
+          opt.on('--indentation-spaces NUMBER',
+            'Spaces to expect indentation.  (default: 2)') do |c|
+            options.style[:indentation_spaces] = c
+          end
+
+          opt.on('--max-line-length NUMBER',
+            'Max characters in a line. (default: 80)') do |c|
+            options.style[:max_line_length] = c
+          end
+
+          opt.on('--spaces-after-comma NUMBER',
+            'Spaces to expect after a comma.  (default: 1)') do |c|
+            options.style[:spaces_after_comma] = c
+          end
+
+          opt.on('--spaces-before-comma NUMBER',
+            'Spaces to expect before a comma.  (default: 0)') do |c|
+            options.style[:spaces_before_comma] = c
+          end
+
+          opt.on('--spaces-after-lbrace NUMBER',
+            'Spaces to expect after a {.  (default: 1)') do |c|
+            options.style[:spaces_after_lbrace] = c
+          end
+
+          opt.on('--spaces-before-lbrace NUMBER',
+            'Spaces to expect before a {.  (default: 1)') do |c|
+            options.style[:spaces_before_lbrace] = c
+          end
+
+          opt.on('--spaces-before-rbrace NUMBER', Integer,
+            'Spaces to expect before a }.  (default: 1)') do |c|
+            options.style[:spaces_before_rbrace] = c
+          end
+
+          opt.on('--spaces-in-empty-braces NUMBER', Integer,
+            'Spaces to expect between a { and }.  (default: 0)') do |c|
+            options.style[:spaces_in_empty_braces] = c
+          end
+
+          opt.on('--spaces-after-lbracket NUMBER', Integer,
+            'Spaces to expect after a [.  (default: 0)') do |c|
+            options.style[:spaces_after_lbracket] = c
+          end
+
+          opt.on('--spaces-before-rbracket NUMBER', Integer,
+            'Spaces to expect before a ].  (default: 0)') do |c|
+            options.style[:spaces_before_rbracket] = c
+          end
+
+          opt.on('--spaces-after-lparen NUMBER', Integer,
+            'Spaces to expect after a (.  (default: 0)') do |c|
+            options.style[:spaces_after_lparen] = c
+          end
+
+          opt.on('--spaces-before-rparen NUMBER', Integer,
+            'Spaces to expect before a ).  (default: 0)') do |c|
+            options.style[:spaces_before_rparen] = c
+          end
+
+          opt.separator ""
+          opt.separator ""
+
+          opt.separator "  * Naming:"
+
+          opt.on('--allow-camel-case-methods BOOL',
+            'Check for camel-case method names?', '(default: true)') do |c|
+            options.style[:allow_camel_case_methods] = instance_eval(c)
+          end
+
+          opt.on('--allow-screaming-snake-case-classes BOOL',
+            'Check for classes like "My_Class"?', '(default: true)') do |c|
+            options.style[:allow_screaming_snake_case_classes] =
+              instance_eval(c)
+          end
+
+          opt.separator ""
+          opt.separator ""
+          opt.separator "  * Vertical Spacing"
+
+          opt.on('--max-code-lines-in-class NUMBER', Integer,
+            'Max number lines of code in a class.', '(default: 300)') do |c|
+            options.style[:max_code_lines_in_class] = c
+          end
+
+          opt.on('--max-code-lines-in-method NUMBER', Integer,
+            'Max number lines of code in a method.', '(default: 30)') do |c|
+            options.style[:max_code_lines_in_method] = c
+          end
+
+          opt.on('--trailing-newlines NUMBER', Integer,
+            'Newlines to expect at the end of the file.', '(default: 1)') do |c|
+            options.style[:trailing_newlines] = c
+          end
+
+          #---------------------------------------------------------------------
+          # Common options
+          #---------------------------------------------------------------------
+          opt.separator ""
+          opt.separator "Common options:"
+
+          opt.on('-f', '--format FORMATTER') do |format|
+            options.formatters << format
+          end
+
+          opt.on('--[no-]color', "Output in color") do |color|
+            @output_color = color
+          end
+
+          opt.on_tail('-v', '--version', "Show the version") do
+            puts version
+            exit
+          end
+
+          opt.on_tail('-d', '--debug', "Turn on debug logging") do
+            Tailor::Logger.log = true
+          end
+
+          opt.on_tail('-h', '--help', 'Show this message') do |help|
+            puts opt
+            exit
+          end
+        end
+
+        opts.parse!(args)
+        require_relative '../../ext/string_ext' if @output_color
+
+        options
+      end
+
+      # @return [String]
+      def self.banner
+        ruler + about + "\r\n" + usage + "\r\n"
+      end
+
+      # @return [String]
+      def self.version
+        ruler + about + "\r\n"
+      end
+
+      # @return [String]
+      def self.ruler
+        <<-RULER
+  _________________________________________________________________________
+  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
+  |     |     |     |     |     |     |     |     |     |     |     |     |
+  |           |           |           |           |           |           |
+  |           1           2           3           4           5           |
+  |                                                                       |
+  -------------------------------------------------------------------------
+        RULER
+      end
+
+      # @return [String]
+      def self.about
+        <<-ABOUT
+  tailor (v#{Tailor::VERSION}).  \t\tA Ruby style checker.
+\t\t\t\t\thttp://github.com/turboladen/tailor
+        ABOUT
+      end
+
+      # @return [String]
+      def self.usage
+        "  Usage:  tailor [FILE|DIR]"
+      end
+
+      def self.create_config
+        if File.exists? Dir.pwd + '/.tailor'
+          $stderr.puts "Can't create new config; it already exists."
+          false
+        else
+          erb_file = File.expand_path(
+            File.dirname(__FILE__) + '/../tailorrc.erb')
+          formatters = Tailor::Configuration.default.formatters
+          file_list = 'lib/**/*.rb'
+          style = Tailor::Configuration.default.file_sets[:default][:style]
+          default_config_file = ERB.new(File.read(erb_file)).result(binding)
+          File.open('.tailor', 'w') { |f| f.write default_config_file }
+        end
+      end
+    end
+  end
+end

data/lib/tailor/composite_observable.rb

@@ -0,0 +1,56 @@
+class Tailor
+  module CompositeObservable
+    def self.define_observer(name)
+      define_method("add_#{name}_observer") do |observer|
+        @notifiers = {} unless defined? @notifiers
+        @notifiers[name] = {} unless @notifiers[name]
+
+        call_back = "#{name}_update".to_sym
+
+        unless observer.respond_to? call_back
+          raise NoMethodError, "observer does not respond to '#{call_back}'"
+        end
+
+        @notifiers[name][observer] = call_back
+      end
+
+      define_method("notify_#{name}_observers") do |*args|
+        if defined? @notifier_state and @notifier_state
+          if @notifier_state[name]
+            if defined? @notifiers and @notifiers[name]
+              @notifiers[name].each do |k, v|
+                k.send(v, *args)
+              end
+            end
+          end
+        end
+      end
+
+      define_method("#{name}_changed") do
+        @notifier_state = {} unless defined? @notifier_state
+        @notifier_state[name] = true
+      end
+    end
+
+    define_observer :comma
+    define_observer :comment
+    define_observer :const
+    define_observer :embexpr_beg
+    define_observer :embexpr_end
+    define_observer :file
+    define_observer :ident
+    define_observer :ignored_nl
+    define_observer :kw
+    define_observer :lbrace
+    define_observer :lbracket
+    define_observer :lparen
+    define_observer :nl
+    define_observer :period
+    define_observer :rbrace
+    define_observer :rbracket
+    define_observer :rparen
+    define_observer :sp
+    define_observer :tstring_beg
+    define_observer :tstring_end
+  end
+end

data/lib/tailor/configuration.rb

@@ -0,0 +1,263 @@
+require_relative '../tailor'
+require_relative 'runtime_error'
+require_relative 'logger'
+
+class Tailor
+
+  # Pulls in any configuration from the places configuration can be set:
+  #   1. ~/.tailorrc
+  #   2. CLI options
+  #   3. Default options
+  #
+  # It then basically represents a list of "file sets" and the rulers that
+  # should be applied against each file set.
+  class Configuration
+    include Tailor::Logger::Mixin
+
+    DEFAULT_GLOB = 'lib/**/*.rb'
+    DEFAULT_RC_FILE = Dir.home + '/.tailorrc'
+    DEFAULT_PROJECT_CONFIG = Dir.pwd + '/.tailor'
+    DEFAULT_STYLE = {
+      allow_camel_case_methods: false,
+      allow_hard_tabs: false,
+      allow_screaming_snake_case_classes: false,
+      allow_trailing_line_spaces: false,
+      indentation_spaces: 2,
+      max_code_lines_in_class: 300,
+      max_code_lines_in_method: 30,
+      max_line_length: 80,
+      spaces_after_comma: 1,
+      spaces_before_comma: 0,
+      spaces_before_lbrace: 1,
+      spaces_after_lbrace: 1,
+      spaces_before_rbrace: 1,
+      spaces_in_empty_braces: 0,
+      spaces_after_lbracket: 0,
+      spaces_before_rbracket: 0,
+      spaces_after_lparen: 0,
+      spaces_before_rparen: 0,
+      trailing_newlines: 1
+    }
+
+    # @return [Hash]
+    def self.default
+      new
+    end
+
+    attr_reader :file_sets
+    attr_reader :formatters
+
+    # @param [Array] runtime_file_list
+    # @param [OpenStruct] options
+    # @option options [String] config_file
+    # @option options [Array] formatters
+    # @option options [Hash] style
+    def initialize(runtime_file_list=nil, options=nil)
+      @formatters = ['text']
+      @file_sets = {
+        default: {
+          file_list: file_list(DEFAULT_GLOB),
+          style: DEFAULT_STYLE
+        }
+      }
+
+      @runtime_file_list = runtime_file_list
+      log "Got runtime file list: #{@runtime_file_list}"
+      @options = options
+      log "Got options: #{@options}"
+    end
+
+    # Call this to load settings from the config file and from CLI options.
+    def load!
+      # Get config file settings
+      @config_file = @options.config_file unless @options.config_file.empty?
+      load_from_config_file(config_file)
+
+      if @config_file
+
+        if @rc_file_config
+          # Get formatters from config file
+          unless @rc_file_config.formatters.empty?
+            @formatters = @rc_file_config.formatters
+            log "@formatters is now #{@formatters}"
+          end
+
+          # Get file sets from config file
+          unless @rc_file_config.file_sets.empty?
+            @rc_file_config.file_sets.each do |label, file_set|
+              unless @file_sets[label]
+                @file_sets[label] = { style: DEFAULT_STYLE }
+              end
+
+              @file_sets[label][:file_list].concat file_set[:file_list]
+              @file_sets[label][:file_list].uniq!
+              @file_sets[label][:style].merge! file_set[:style]
+            end
+          end
+        end
+      end
+
+      # Get formatters from CLI options
+      unless @options.formatters.empty? || @options.formatters.nil?
+        @formatters = @options.formatters
+        log "@formatters is now #{@formatters}"
+      end
+
+      # Get file sets from CLI options
+      unless @runtime_file_list.nil? || @runtime_file_list.empty?
+        # Only use options set for the :default file set because the user gave
+        # a different set of files to measure.
+        @file_sets.delete_if { |k, v| k != :default }
+        @file_sets[:default][:file_list] = file_list(@runtime_file_list)
+      end
+
+      # Get style overrides from CLI options
+      @file_sets[:default][:style].merge!(@options.style)
+
+      if @file_sets[:default][:file_list].empty?
+        @file_sets[:default][:file_list] = file_list(DEFAULT_GLOB)
+      end
+
+    end
+
+    # @return [String] Name of the config file to use.
+    def config_file
+      return @config_file if @config_file
+
+      if File.exists?(DEFAULT_PROJECT_CONFIG)
+        return @config_file = DEFAULT_PROJECT_CONFIG
+      end
+
+      if File.exists?(DEFAULT_RC_FILE)
+        return @config_file = DEFAULT_RC_FILE
+      end
+    end
+
+    # @return [Array] The list of formatters.
+    def formatters(*new_formatters)
+      @formatters = new_formatters unless new_formatters.empty?
+
+      @formatters
+    end
+
+    # @param [String] file_glob The String that represents the file set.  This
+    #   can be a file, directory, or a glob.
+    # @param [Symbol] label The label that represents the file set.
+    def file_set(file_glob=DEFAULT_GLOB, label=:default, &block)
+      log "file set label #{label}"
+
+      @temp_style = {}
+      instance_eval(&block) if block_given?
+
+      if @file_sets[label]
+        @file_sets[label][:file_list].concat file_list(file_glob)
+        log "file set: #{@file_sets}"
+        @file_sets[label][:file_list].uniq!
+        @file_sets[label][:style].merge @temp_style
+      else
+        @file_sets[label] = {
+          file_list: file_list(file_glob),
+          style: DEFAULT_STYLE.merge(@temp_style)
+        }
+      end
+
+      @temp_style = {}
+    end
+
+    # Implemented for {file_set}, this converts the config file lines that look
+    # like methods into a Hash.
+    #
+    # @return [Hash] The new style as defined by the config file.
+    def method_missing(meth, *args, &blk)
+      ok_methods = DEFAULT_STYLE.keys
+
+      if ok_methods.include? meth
+        @temp_style[meth] = args.first
+      else
+        super(meth, args, blk)
+      end
+    end
+
+    # Tries to open the file at the path given at +config_file+ and read in
+    # the configuration given there.
+    #
+    # @param [String] config_file Path to the config file to use.
+    def load_from_config_file(config_file)
+      user_config_file = File.expand_path(config_file)
+
+      if File.exists? user_config_file
+        log "Loading config from file: #{user_config_file}"
+        begin
+          config = instance_eval File.read(user_config_file)
+        rescue LoadError => ex
+          raise Tailor::RuntimeError,
+            "Couldn't load config file: #{user_config_file}"
+        end
+      else
+        log "No config file found at #{user_config_file}."
+      end
+
+      if config
+        log "Got new config from file: #{config}"
+        @rc_file_config = config
+      end
+    end
+
+    # Gets a list of only files that are in +base_dir+.
+    #
+    # @param [String] base_dir The directory to get the file list for.
+    # @return [Array<String>] The List of files.
+    def all_files_in_dir(base_dir)
+      files = Dir.glob(File.join(base_dir, '**', '*')).find_all do |file|
+        file if File.file?(file)
+      end
+
+      files
+    end
+
+    # The list of the files in the project to check.
+    #
+    # @param [String] glob Path to the file, directory or glob to check.
+    # @return [Array] The list of files to check.
+    def file_list(glob)
+      files_in_project = if glob.is_a? Array
+        log "Configured glob is an Array: #{glob}"
+
+        glob.map do |e|
+          if File.directory?(e)
+            all_files_in_dir(e)
+          else
+            e
+          end
+        end.flatten.uniq
+      elsif File.directory? glob
+        log "Configured glob is an directory: #{glob}"
+        all_files_in_dir(glob)
+      else
+        log "Configured glob is a glob/single-file: #{glob}"
+        Dir.glob glob
+      end
+
+      list_with_absolute_paths = []
+
+      files_in_project.each do |file|
+        list_with_absolute_paths << File.expand_path(file)
+      end
+
+      log "All files: #{list_with_absolute_paths}"
+
+      list_with_absolute_paths.sort
+    end
+
+    def show
+      table = Text::Table.new(horizontal_padding: 4)
+      table.head = [{ value: 'Configuration', colspan: 2, align: :center }]
+      table.rows << :separator
+      table.rows << ['Style', @file_sets.inspect]
+      table.rows << :separator
+      table.rows << ['Formatters', @formatters]
+
+      puts table
+    end
+  end
+end