ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/cli.rb

@@ -1,167 +1,23 @@
-require 'optparse'
-
-module RubyLint
-  ##
-  # {RubyLint::CLI} is the commandline interface to RubyLint.
-  #
-  class CLI
-    ##
-    # Creates a new instance of the class and configures OptionParser.
-    #
-    def initialize
-      @formatters = constant_short_names(RubyLint::Formatter)
-      @analyzers  = constant_short_names(RubyLint::Analyze)
-
-      @option_parser = OptionParser.new do |opts|
-        opts.banner         = 'A static code analysis tool and linter for Ruby'
-        opts.program_name   = 'ruby-lint'
-        opts.version        = RubyLint::VERSION
-        opts.summary_indent = '  '
-
-        opts.separator ''
-        opts.separator 'Usage:'
-        opts.separator '  $ ruby-ling [FILES] [OPTIONS]'
-
-        opts.separator ''
-        opts.separator 'Analyzers:'
-        opts.separator hash_to_list(@analyzers)
-
-        opts.separator ''
-        opts.separator 'Formatters:'
-        opts.separator hash_to_list(@formatters)
-
-        opts.separator ''
-        opts.separator 'Reporting Levels:'
-        opts.separator "  error\n  warning\n  info"
-
-        opts.separator ''
-        opts.separator 'Options:'
-
-        opts.on(
-          '-f',
-          '--formatter=VALUE',
-          'The formatter to use',
-          String
-        ) do |formatter|
-          if @formatters.key?(formatter)
-            RubyLint.options.formatter = @formatters[formatter]
-          end
-        end
-
-        opts.on(
-          '-l',
-          '--levels=VALUE',
-          'The reporting levels to enable',
-          Array
-        ) do |levels|
-          RubyLint.options.levels = levels.map { |level| level.to_sym }
-        end
-
-        opts.on(
-          '-a',
-          '--analyzers=VALUE',
-          'The analyzers to enable',
-          Array
-        ) do |names|
-          analyzers = Options::REQUIRED_ANALYZERS.dup
-
-          names.each do |name|
-            const = @analyzers[name]
-
-            if const and !analyzers.include?(const)
-              analyzers << const
-            end
-          end
-
-          RubyLint.options.analyzers = analyzers
-        end
-
-        opts.on('-h', '--help', 'Shows this help message') do
-          puts @option_parser
-          exit
-        end
-
-        opts.on('-v', '--version', 'Shows the current version') do
-          version
-        end
-      end
-    end
-
-    ##
-    # Runs RubyLint.
-    #
-    # @param [Array] argv Array of commandline parameters.
-    #
-    def run(argv = ARGV)
-      @option_parser.parse!(argv)
-
-      abort 'You have to specify a file to analyze' if argv.empty?
-
-      argv.each do |file|
-        abort "The file #{file} is not valid" unless File.file?(file)
-
-        code      = File.read(file, File.size(file))
-        tokens    = Parser.new(code, file).parse
-        report    = Report.new(file, RubyLint.options.levels)
-        iterator  = Iterator.new(report)
-        formatter = RubyLint.options.formatter.new
-
-        RubyLint.options.analyzers.each { |const| iterator.bind(const) }
-
-        iterator.run(tokens)
-
-        output = formatter.format(report)
-
-        puts output unless output.empty?
-      end
-    end
-
-    ##
-    # Shows the current version of RubyLint.
-    #
-    def version
-      puts "RubyLint version #{RubyLint::VERSION} running on #{RUBY_DESCRIPTION}"
-      exit
-    end
-
-    private
-
-    ##
-    # Returns a hash containing various short names and the constants to use.
-    #
-    # @param  [Class] constant The constant to use.
-    # @return [Hash]
-    #
-    def constant_short_names(constant)
-      hash = {}
-
-      constant.constants.sort.each do |const|
-        name       = const.to_s.gsub(/([a-z]+)([A-Z]+)/, '\\1_\\2').downcase
-        hash[name] = constant.const_get(const)
-      end
-
-      return hash
-    end
-
-    ##
-    # Returns a string containing the names and descriptions of various
-    # constants formatted as a list.
-    #
-    # @param  [Hash] hash
-    # @return [String]
-    #
-    def hash_to_list(hash)
-      longest = hash.keys.sort { |l, r| l.length <=> r.length }[-1].length
-      longest = longest > 32 ? longest : 32
-      list    = []
-
-      hash.each do |name, const|
-        description = const.const_get(:DESCRIPTION)
-
-        list << "  %-#{longest}s %s" % [name, description]
-      end
-
-      return list.join("\n")
-    end
-  end # CLI
-end # RubyLint
+RubyLint::Configuration.register_names 'analysis' do |names|
+  names['argument_amount']     = RubyLint::Analyze::ArgumentAmount
+  names['shadowing_variables'] = RubyLint::Analyze::ShadowingVariables
+  names['undefined_methods']   = RubyLint::Analyze::UndefinedMethods
+  names['undefined_variables'] = RubyLint::Analyze::UndefinedVariables
+  names['unused_variables']    = RubyLint::Analyze::UnusedVariables
+end
+
+RubyLint::Configuration.register_names 'presenters' do |names|
+  names['text'] = RubyLint::Presenter::Text
+  names['json'] = RubyLint::Presenter::JSON
+end
+
+RubyLint::Configuration.register_names 'levels' do |names|
+  RubyLint::Report.levels.each do |level|
+    names[level.to_s] = level
+  end
+end
+
+require 'slop'
+require_relative 'cli/base'
+require_relative 'cli/analyze'
+require_relative 'cli/ast'

data/lib/ruby-lint/cli/analyze.rb

@@ -0,0 +1,99 @@
+RubyLint::CLI.options.command :analyze do
+  banner      'Usage: ruby-lint analyze [FILES] [OPTIONS]'
+  description 'Analyzes the source code of Ruby files'
+
+  separator <<-EOF.chomp
+
+About:
+
+  This command analyses the source code of a Ruby file and presents a report
+  containing information such as errors about invalid code, warnings and
+  informational messages.
+
+Configuration:
+
+  When this command is executed it will try to load a configuration file in
+  one of the following two locations (in this order):
+
+  * $PWD/ruby-lint.rb
+  * ~/.ruby-lint.rb
+
+  Only the first existing configuration file is loaded.
+
+  These configuration files can be used for specifying the presenter, reporting
+  levels and various other options.
+
+  You can also configure various parts using the supplied commandline options.
+  For example, to use the JSON presenter you'd run the following:
+
+    $ ruby-lint analyze ./test_file.rb --presenter=json
+
+Analysis Classes:
+
+  #{RubyLint::CLI.format_names('analysis')}
+
+Presenters:
+
+  #{RubyLint::CLI.format_names('presenters')}
+
+Reporting Levels:
+
+  #{RubyLint::CLI.format_names('levels')}
+
+Examples:
+
+  To analyze a single file you can run the following command:
+
+      $ ruby-lint analyze ./test_file.rb
+
+  You can also specify multiple files:
+
+      $ ruby-lint analyze first_file.rb second_file.rb
+  EOF
+
+  separator RubyLint::CLI::OPTIONS_HEADER
+
+  RubyLint::CLI.help_option(self)
+
+  on :l=, :levels=, 'The reporting levels to enable', :as => Array
+  on :p=, :presenter=, 'The presenter to use', :as => String
+  on :a=, :analysis=, 'The analysis classes to use', :as => Array
+
+  run do |opts, args|
+    abort 'You must specify at least one file to analyze' if args.empty?
+
+    files = RubyLint::CLI.existing_files(args)
+
+    RubyLint.load_configuration
+
+    RubyLint.configuration.set_reporting_levels(opts[:l]) if opts[:l]
+    RubyLint.configuration.set_presenter(opts[:p]) if opts[:p]
+    RubyLint.configuration.set_analysis(opts[:a]) if opts[:a]
+
+    files.each do |file|
+      ast = RubyLint::Parser.new(File.read(file), file).parse
+
+      RubyLint::ConstantLoader.new.iterate(ast)
+
+      report       = RubyLint.configuration.report
+      presenter    = RubyLint.configuration.presenter.new
+      defs_builder = RubyLint::DefinitionsBuilder.new
+
+      defs_builder.iterate(ast)
+
+      RubyLint.configuration.analysis.each do |constant|
+        instance = constant.new(
+          :report           => report,
+          :definitions      => defs_builder.options[:definitions],
+          :node_definitions => defs_builder.options[:node_definitions]
+        )
+
+        instance.iterate(ast)
+      end
+
+      output = presenter.present(report)
+
+      puts output unless output.empty?
+    end
+  end # run do |opts, args|
+end # RubyLint::CLI.options.command

data/lib/ruby-lint/cli/ast.rb

@@ -0,0 +1,35 @@
+RubyLint::CLI.options.command :ast do
+  banner      'Usage: ruby-lint ast [FILE] [OPTIONS]'
+  description 'Shows the AST of a Ruby file'
+
+  separator <<-EOF.chomp
+
+About:
+
+  This command displays the raw AST of a Ruby file. Unlike the `analyze`
+  command this particular one only takes a single file.
+
+  The output is a set of S expressions generated by the ruby-lint parser
+  (RubyLint::Parser).
+
+Examples:
+
+  Displaying the AST:
+
+    $ ruby-lint ast ./test_file.rb
+  EOF
+
+  separator   RubyLint::CLI::OPTIONS_HEADER
+
+  RubyLint::CLI.help_option(self)
+
+  run do |opts, args|
+    file = args[0]
+
+    if !file or !File.file?(file)
+      abort 'You must specify an existing file'
+    end
+
+    puts RubyLint::Parser.new(File.read(file), file).parse.inspect
+  end
+end

data/lib/ruby-lint/cli/base.rb

@@ -0,0 +1,120 @@
+module RubyLint
+  module CLI
+    ##
+    # Hash containing configuration options for Slop.
+    #
+    # @return [Hash]
+    #
+    SLOP_OPTIONS = {
+      :strict => true,
+      :banner => 'Usage: ruby-lint [COMMAND] [OPTIONS]'
+    }
+
+    ##
+    # The header to use for separating options with other bits of information
+    # in help messages.
+    #
+    # @return [String]
+    #
+    OPTIONS_HEADER = "\nOptions:\n"
+
+    ##
+    # Returns an Array containing the file paths that exist. If a non existing
+    # file is encountered `abort` is called.
+    #
+    # @param [Array] files
+    # @return [Array]
+    #
+    def self.existing_files(files)
+      existing = []
+
+      files.each do |file|
+        file = File.expand_path(file)
+
+        if File.file?(file)
+          existing << file
+        else
+          abort "The file #{file} does not exist"
+        end
+      end
+
+      return existing
+    end
+
+    ##
+    # Returns a String containing a list of names as registered in
+    # {RubyLint::Configuration.names}.
+    #
+    # @param [String] scope
+    # @see RubyLint::Configuration.names
+    # @return [String]
+    #
+    def self.format_names(scope)
+      return "* #{Configuration.names[scope].keys.sort.join("\n  * ")}"
+    end
+
+    ##
+    # Starts the CLI.
+    #
+    def self.run
+      options.parse
+    end
+
+    ##
+    # @return [Slop]
+    #
+    def self.options
+      return @options ||= default_options
+    end
+
+    ##
+    # @return [Slop]
+    #
+    def self.default_options
+      return Slop.new(SLOP_OPTIONS) do
+        separator OPTIONS_HEADER
+
+        CLI.help_option(self)
+
+        on :v, :version, 'Shows the current version' do
+          puts CLI.version_information
+          exit
+        end
+
+        run do |opts, args|
+          if args.empty?
+            puts self
+            exit
+          else
+            CLI.options.commands['analyze'].parse(args)
+          end
+        end
+      end
+    end
+
+    ##
+    # Adds a `-h/--help` option for a command. This method should be executed
+    # in the context of a Slop command.
+    #
+    # @param [Mixed] command
+    #
+    def self.help_option(command)
+      command.instance_eval do
+        on :h, :help, 'Shows this help message' do
+          puts self
+          exit
+        end
+      end
+    end
+
+    ##
+    # Returns a String containing information about the current ruby-lint
+    # version and platform.
+    #
+    # @return [String]
+    #
+    def self.version_information
+      return "ruby-lint v#{VERSION} on #{RUBY_DESCRIPTION}"
+    end
+  end # CLI
+end # RubyLint

data/lib/ruby-lint/configuration.rb

@@ -0,0 +1,112 @@
+module RubyLint
+  ##
+  # The Configuration class is used for storing configuration information used
+  # when running the CLI of ruby-lint. It contains information such as the
+  # reporting levels, the formatter to use and so on.
+  #
+  # @!attribute [rw] presenter
+  #  @return [RubyLint::Presenter] The presenter to use for displaying reports.
+  # @!attribute [rw] report_levels
+  #  @return [Array] The reporting levels to use.
+  # @!attribute [rw] analysis
+  #  @return [Array] The analysis classes to enable.
+  #
+  class Configuration
+    attr_accessor :presenter, :report_levels, :analysis
+
+    ##
+    # Provides a small block based DSL for registering multiple names.
+    #
+    # @param [String] scope The scope to store the names under.
+    # @see RubyLint::Configuration.names
+    #
+    def self.register_names(scope)
+      hash = {}
+
+      yield hash
+
+      names[scope] = hash
+    end
+
+    ##
+    # Returns a Hash used for storing values and their human readable names.
+    # This Hash is primarily used for the CLI.
+    #
+    # @return [Hash]
+    #
+    def self.names
+      return @names ||= {}
+    end
+
+    ##
+    # @param [Hash] options
+    #
+    def initialize(options = {})
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+
+      @presenter     ||= RubyLint::Presenter::Text
+      @report_levels ||= Report::DEFAULT_LEVELS
+      @analysis      ||= default_analysis_classes
+    end
+
+    ##
+    # @return [Array]
+    #
+    def default_analysis_classes
+      return Analyze.constants.map do |const|
+        Analyze.const_get(const)
+      end
+    end
+
+    ##
+    # Returns a report with the report levels set based on this configuration
+    # instance.
+    #
+    # @return [RubyLint::Report]
+    #
+    def report
+      return Report.new(report_levels)
+    end
+
+    ##
+    # Set the reporting levels based on a set of CLI options.
+    #
+    # @param [Array] levels
+    #
+    def set_reporting_levels(levels)
+      self.report_levels = []
+      available          = self.class.names['levels']
+
+      levels.each do |level|
+        report_levels << available[level] if available[level]
+      end
+    end
+
+    ##
+    # Sets the presenter based on a set of CLI options.
+    #
+    # @param [String] name
+    #
+    def set_presenter(name)
+      if self.class.names['presenters'][name]
+        self.presenter = self.class.names['presenters'][name]
+      end
+    end
+
+    ##
+    # Sets the analysis classes based on a set of CLI options.
+    #
+    # @param [Array] names
+    #
+    def set_analysis(names)
+      self.analysis = []
+      available     = self.class.names['analysis']
+
+      names.each do |name|
+        self.analysis << available[name] if available[name]
+      end
+    end
+  end # Configuration
+end # RubyLint