ruby-lint 0.0.2 → 0.0.3

data/lib/ruby-lint/parser_error.rb

@@ -3,38 +3,26 @@ module RubyLint
   # Exception class that's raised when the parser {RubyLint::Parser} detects
   # syntax errors.
   #
+  # @!attribute [r] line
+  #  @return [Numeric]
+  # @!attribute [r] column
+  #  @return [Numeric]
+  # @!attribute [r] file
+  #  @return [String]
+  #
   class ParserError < SyntaxError
-    ##
-    # The line number on which the error occured.
-    #
-    # @return [Fixnum|Bignum]
-    #
-    attr_reader :line
+    attr_reader :line, :column, :file
 
     ##
-    # The column on which the error occured.
-    #
-    # @return [Fixnum|Bignum]
-    #
-    attr_reader :column
-
-    ##
-    # The name of the file in which the error occured.
-    #
-    # @return [String]
-    #
-    attr_reader :file
-
-    ##
-    # Creates a new instance of the error class.
-    #
-    # @param [String] message The error message.
-    # @param [Fixnum|Bignum] line The line of the error.
-    # @param [Fixnum|Bignum] column The column of the error.
-    # @param [String] file The file in which the error occured.
+    # @param [String] message
+    # @param [Numeric] line
+    # @param [Numeric] column
+    # @param [String] file
     #
     def initialize(message, line, column, file)
-      @line, @column, @file = line, column, file
+      @line   = line
+      @column = column
+      @file   = file
 
       super(message)
     end

data/lib/ruby-lint/presenter/json.rb

@@ -0,0 +1,19 @@
+module RubyLint
+  module Presenter
+    ##
+    # {RubyLint::Presenter::JSON} formats a instance of {RubyLint::Report} into
+    # a JSON formatted string.
+    #
+    class JSON
+      ##
+      # @param [RubyLint::Report] report The report to present.
+      # @return [String]
+      #
+      def present(report)
+        require 'json'
+
+        return report.entries.sort.map(&:attributes).to_json
+      end
+    end # Text
+  end # Presenter
+end # RubyLint

data/lib/ruby-lint/presenter/text.rb

@@ -0,0 +1,37 @@
+module RubyLint
+  module Presenter
+    ##
+    # {RubyLint::Presenter::Text} formats a instance of {RubyLint::Report} into
+    # a text based, human readable format.
+    #
+    class Text
+      ##
+      # The default format to use when presenting report entries.
+      #
+      # @return [String]
+      #
+      FORMAT = '%{file}: %{level}: line %{line}, column %{column}: %{message}'
+
+      ##
+      # @param [String] format The format to use for each entry.
+      #
+      def initialize(format = FORMAT.dup)
+        @format = format
+      end
+
+      ##
+      # @param [RubyLint::Report] report The report to present.
+      # @return [String]
+      #
+      def present(report)
+        entries = []
+
+        report.entries.sort.each do |entry|
+          entries << @format % entry.attributes
+        end
+
+        return entries.join("\n")
+      end
+    end # Text
+  end # Presenter
+end # RubyLint

data/lib/ruby-lint/report.rb

@@ -1,98 +1,140 @@
 module RubyLint
   ##
-  # {RubyLint::Report} is a class used for storing error messages, warnings and
-  # informational messages about code processed by {RubyLint::Iterator} and
-  # individual callback classes.
+  # {RubyLint::Report} is a data container for error messages, warnings,
+  # informational messages and other custom defined types of messages. It
+  # should be used by the various analysis classes to store information such as
+  # errors for undefined variables and warnings for potentially confusing code.
   #
-  # The process of adding data to a report involves two steps:
+  # ## Levels
   #
-  # 1. setting which levels to enable
-  # 2. adding the data
+  # Each instance can add entries for a set of predefined reporting levels. By
+  # default the following levels are defined:
   #
-  # The first step is done by creating a new instance of this class and
-  # defining a list of level names in the constructor's second parameter. The
-  # following levels are used by RubyLint itself:
+  # * error
+  # * warning
+  # * info
   #
-  # * `:error`
-  # * `:warning`
-  # * `:info`
+  # Unless other levels are specified when creating an instance these levels
+  # are used for each new instance.
   #
-  # The second step is done by calling {RubyLint::Report#add}. This method is used
-  # to add data for a specific level. If this level is disabled the data is not
-  # added to the report.
+  # Adding available levels can be done as following:
   #
-  # A basic example of this is the following:
+  #     RubyLint::Report.add_level(:pedantic)
   #
-  #     report = RubyLint::Report.new('test_file.rb', [:error])
+  # Retrieving a list of available levels in turn is done as following:
   #
-  #     report.add(:error, 'This is an error message', 1, 0)
+  #     RubyLint::Report.levels # => [:error, :warning, :info, :pedantic]
   #
-  #     # This message will not be added since it's not an error.
-  #     report.add(:info, 'This is an info message', 2, 0)
+  # Each level is a Symbol and will be cased to one automatically.
+  #
+  # ## Adding Entries
+  #
+  # Adding entries can be done by either calling {RubyLint::Report#add} or a
+  # method for the corresponding reporting level:
+  #
+  #     report = RubyLint::Report.new
+  #
+  #     # Both these calls do the same.
+  #     report.add(:info, 'informational message', 1, 2, 'file.rb')
+  #     report.info('informational message', 1, 2, 'file.rb')
+  #
+  # When using {RubyLint::Report#add} any invalid/disabled reporting levels
+  # will be silently ignored. This makes it easier for code to add entries of a
+  # particular level without having to manually check if said level is enabled.
+  #
+  # @!attribute [r] entries
+  #  @return [Array] The entries of the report.
+  # @!attribute [r] levels
+  #  @return [Array] The enabled levels of the report.
   #
   class Report
+    attr_reader :entries, :levels
+
     ##
-    # Array containing the levels that are enabled by default.
+    # Reporting levels that are always available.
     #
     # @return [Array]
     #
     DEFAULT_LEVELS = [:error, :warning, :info]
 
     ##
-    # A hash containing the various messages stored per level.
+    # Adds a new reporting level to the list of available levels.
     #
-    # @return [Hash]
+    # @param [#to_sym] level The reporting level to add.
     #
-    attr_reader :messages
+    def self.add_level(level)
+      levels << level.to_sym
+    end
 
     ##
-    # An array of levels to use. For example, if `:info` is not included any
-    # message using this level is ignored.
+    # Deletes a reporting level from the list of available levels. This does
+    # not affect existing instances of this class.
     #
-    # @return [Array]
+    # @param [#to_sym] level The level to delete.
     #
-    attr_reader :levels
+    def self.delete_level(level)
+      levels.delete(level.to_sym)
+    end
 
     ##
-    # String containing the name/path of the file this report belongs to.
+    # Returns a list of the available reporting levels.
     #
-    # @return [String]
+    # @return [Array]
     #
-    attr_reader :file
+    def self.levels
+      return @levels ||= DEFAULT_LEVELS.dup
+    end
 
     ##
-    # Creates a new instance of the class.
-    #
-    # @param [String] file The name/path of the file that this report belongs
-    #  to.
-    # @param [Array] levels The message levels to use for this report.
+    # @param [Array] levels The reporting levels to enable for this instance.
     #
-    def initialize(file = '(ruby-lint)', levels = DEFAULT_LEVELS)
-      @file     = file
-      @levels   = levels
-      @messages = {}
+    def initialize(levels = self.class.levels)
+      @levels  = levels.map(&:to_sym)
+      @entries = []
     end
 
     ##
-    # Adds a message to the report.
+    # Adds a new entry to the report.
     #
-    # @param [#to_sym] level The level of the message.
-    # @param [String] message The message to add.
-    # @param [Fixnum] line The line number of the message.
-    # @param [Fixnum] column The column number of the message.
+    # @param [#to_sym] level
+    # @param [String] message
+    # @param [Numeric] line
+    # @param [Numeric] column
+    # @param [String] file
     #
-    def add(level, message, line, column)
+    def add(level, message, line, column, file)
       level = level.to_sym
 
-      return unless @levels.include?(level)
+      if valid_level?(level)
+        @entries << Entry.new(level, message, line, column, file)
+      end
+    end
+
+    ##
+    # Makes it easier to add entries to a report by calling methods such as
+    # `#info` instead of `add(:info, ...)`.
+    #
+    # @param [Symbol] name
+    # @param [Array] args
+    # @param [Proc] block
+    # @raise [NoMethodError] Raised when an invalid method was called.
+    #
+    def method_missing(name, *args, &block)
+      if valid_level?(name)
+        return add(name, *args, &block)
+      else
+        raise NoMethodError, 'undefined method "%s" for %s' % [name, inspect]
+      end
+    end
 
-      @messages[level] ||= []
+    private
 
-      @messages[level] << {
-        :message => message,
-        :line    => line,
-        :column  => column
-      }
+    ##
+    # @param [Symbol] level
+    # @return [TrueClass|FalseClass]
+    #
+    def valid_level?(level)
+      return @levels.include?(level)
     end
   end # Report
 end # RubyLint

data/lib/ruby-lint/report/entry.rb

@@ -0,0 +1,71 @@
+module RubyLint
+  class Report
+    ##
+    # {RubyLint::Report::Entry} contains data about a single report entry such
+    # as the message and line number.
+    #
+    # @!attribute [r] level
+    #  @return [Symbol]
+    # @!attribute [r] message
+    #  @return [String]
+    # @!attribute [r] line
+    #  @return [Numeric]
+    # @!attribute [r] column
+    #  @return [Numeric]
+    # @!attribute [r] file
+    #  @return [String]
+    #
+    class Entry
+      attr_reader :level, :message, :line, :column, :file
+
+      ##
+      # @param [Symbol] level
+      # @param [String] message
+      # @param [Numeric] line
+      # @param [Numeric] column
+      # @param [String] file
+      #
+      def initialize(level, message, line, column, file)
+        @level   = level
+        @message = message
+        @line    = line
+        @column  = column
+        @file    = file
+      end
+
+      ##
+      # @return [String]
+      #
+      def filename
+        return File.basename(file)
+      end
+
+      ##
+      # Returns a Hash containing the attributes of the entry.
+      #
+      # @return [Hash]
+      #
+      def attributes
+        return {
+          :level   => level,
+          :message => message,
+          :line    => line,
+          :column  => column,
+          :file    => file
+        }
+      end
+
+      ##
+      # Determines the sort order of the current entry. The entry is sorted
+      # based on the filename and the reporting level.
+      #
+      # @param [RubyLint::Report::Entry] other The entry to compare with the
+      #  current one.
+      # @return [Numeric]
+      #
+      def <=>(other)
+        return (filename <=> other.filename) <=> (other.level <=> level)
+      end
+    end # Entry
+  end # Report
+end # RubyLint

data/lib/ruby-lint/template/definition.erb

@@ -0,0 +1,24 @@
+##
+# Constant: <%= @constant_name %>
+# Created:  <%= Time.new %>
+# Platform: <%= RUBY_ENGINE %> <%= Rubinius::VERSION rescue RUBY_VERSION %>
+#
+RubyLint.global_scope.define_constant('<%= @constant_name %>') do |klass|
+  <%- if @superclass -%>
+  klass.inherits(RubyLint.global_constant('<%= @superclass %>'))
+  <%- end -%>
+  <%- @methods.each do |type, collection| -%>
+  <%- collection.each do |name, args| -%>
+
+  <%- if args.empty? -%>
+  klass.define_<%= type %>('<%= name %>')
+  <%- else -%>
+  klass.define_<%= type %>('<%= name %>') do |method|
+    <%- args.each do |arg| -%>
+    method.define_<%= arg[:method] %>('<%= arg[:name] %>')
+    <%- end -%>
+  end
+  <%- end -%>
+  <%- end -%>
+  <%- end -%>
+end

data/lib/ruby-lint/template/scope.rb

@@ -0,0 +1,25 @@
+module RubyLint
+  module Template
+    ##
+    # Class used for storing variables for an ERB template without polluting
+    # the namespace of the code that uses the template.
+    #
+    class Scope
+      ##
+      # @param [Hash] variables
+      #
+      def initialize(variables = {})
+        variables.each do |name, value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      ##
+      # @return [Binding]
+      #
+      def get_binding
+        return binding # #binding() is a private method.
+      end
+    end # Scope
+  end # Template
+end # RubyLint

data/lib/ruby-lint/variable_predicates.rb

@@ -0,0 +1,109 @@
+module RubyLint
+  ##
+  # Module that provides various predicate methods for checking node/definition
+  # types.
+  #
+  module VariablePredicates
+    ##
+    # Array containing the various variable types that are available in Ruby.
+    #
+    # @return [Array]
+    #
+    VARIABLE_TYPES = [
+      :local_variable,
+      :instance_variable,
+      :class_variable,
+      :global_variable
+    ]
+
+    ##
+    # Array containing various Ruby types that are considered to be scalar
+    # values.
+    #
+    # @return [Array]
+    #
+    SCALAR_TYPES = [:integer, :float, :string, :symbol]
+
+    ##
+    # Array containing various predicate methods to create.
+    #
+    # @return [Array]
+    #
+    PREDICATE_METHODS = [
+      :aref,
+      :array,
+      :class,
+      :constant,
+      :constant_path,
+      :hash,
+      :identifier,
+      :keyword,
+      :method,
+      :method_definition,
+      :module
+    ]
+
+    ##
+    # Hash containing various Node types and the associated Ruby classes.
+    #
+    # @return [Hash]
+    #
+    RUBY_CLASSES = {
+      :string  => 'String',
+      :symbol  => 'Symbol',
+      :integer => 'Fixnum',
+      :float   => 'Float',
+      :regexp  => 'Regexp',
+      :array   => 'Array',
+      :hash    => 'Hash',
+      :range   => 'Range',
+      :lambda  => 'Proc'
+    }
+
+    (VARIABLE_TYPES + PREDICATE_METHODS).each do |type|
+      define_method("#{type}?") do
+        return @type == type
+      end
+    end
+
+    ##
+    # Returns `true` if the current node is a variable node.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    def variable?
+      return VARIABLE_TYPES.include?(@type)
+    end
+
+    ##
+    # @return [TrueClass|FalseClass]
+    #
+    def constant?
+      return @type == :constant || @type == :module || @type == :class
+    end
+
+    ##
+    # Returns `true` if the object type is a Ruby scalar such as a string or
+    # integer.
+    #
+    def scalar?
+      return SCALAR_TYPES.include?(@type)
+    end
+
+    ##
+    # Indicates if the node is a collection of values.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    def collection?
+      return array? || hash?
+    end
+
+    ##
+    # @return [String]
+    #
+    def ruby_class
+      return RUBY_CLASSES[type]
+    end
+  end # VariablePredicates
+end # RubyLint