ruby-lint 0.0.5 → 0.9.0

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

@@ -11,21 +11,21 @@ module RubyLint
       # @return [Numeric]
       #
       def line
-        return location.expression.line
+        return location.expression.line if location
       end
 
       ##
       # @return [Numeric]
       #
       def column
-        return location.expression.column
+        return location.expression.column if location
       end
 
       ##
       # @return [String]
       #
       def file
-        return location.expression.source_buffer.name
+        return location.expression.source_buffer.name if location
       end
 
       ##
@@ -44,6 +44,21 @@ module RubyLint
       def inspect_oneline
         return inspect.gsub(/\s*\n\s*/, ' ')
       end
+
+      ##
+      # Generates a unique SHA1 digest hash based on the current node.
+      #
+      # @return [String]
+      #
+      def sha1
+        input = inspect
+
+        if location and location.expression
+          input << "#{file}#{line}#{column}"
+        end
+
+        return Digest::SHA1.hexdigest(input)
+      end
     end # Node
   end # AST
 end # RubyLint

data/lib/ruby-lint/cache.rb

@@ -0,0 +1,121 @@
+module RubyLint
+  ##
+  # The Cache class is used for storing arbitrary Ruby objects in a cache
+  # directory. The primary use case of this class is to store cached ASTs and
+  # their comment associations (as is done by {RubyLint::Runner}).
+  #
+  # @!attribute [r] directory
+  #  @return [String]
+  #
+  class Cache
+    attr_reader :directory
+
+    ##
+    # The version of the cache format.
+    #
+    # @return [String]
+    #
+    FORMAT_VERSION = '1'
+
+    ##
+    # @param [String] directory Path to the cache directory.
+    #
+    def initialize(directory)
+      @directory = directory
+    end
+
+    ##
+    # Creates the directory specified in {#directory} unless it already exists.
+    #
+    def create_directory!
+      Dir.mkdir(directory) unless File.directory?(directory)
+    end
+
+    ##
+    # Checks if there's a cache entry for the given name.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    def exists?(name)
+      return File.file?(entry_filepath(name))
+    end
+
+    ##
+    # Returns the cache entry for the given name or `nil` if the entry doesn't
+    # exist.
+    #
+    # @param [String] name
+    # @return [Mixed]
+    #
+    def get(name)
+      return unless exists?(name)
+
+      data = File.read(entry_filepath(name))
+
+      return decode(data)
+    end
+
+    ##
+    # Sets the cache entry to the given value. Existing cache entries are
+    # overwritten.
+    #
+    # @param [String] name
+    # @param [Mixed] value
+    #
+    def set(name, value)
+      File.open(entry_filepath(name), 'w') do |handle|
+        handle.write(encode(value))
+      end
+    end
+
+    ##
+    # Removes a cache entry.
+    #
+    # @param [String] name
+    #
+    def delete(name)
+      File.unlink(entry_filepath(name)) if exists?(name)
+    end
+
+    private
+
+    ##
+    # Returns the filename for the given entry name.
+    #
+    # @param [String] name
+    # @return [String]
+    #
+    def entry_filename(name)
+      return "#{name}.#{FORMAT_VERSION}.cache"
+    end
+
+    ##
+    # Returns the full filename of the cache entry's name.
+    #
+    # @param [String] name
+    # @return [String]
+    #
+    def entry_filepath(name)
+      return File.join(directory, entry_filename(name))
+    end
+
+    ##
+    # Decodes a cache entry.
+    #
+    # @param [String] input
+    # @return [Mixed]
+    #
+    def decode(input)
+      return Marshal.load(Zlib::Inflate.inflate(input))
+    end
+
+    ##
+    # Encodes a cache entry.
+    #
+    # @param [String] input
+    #
+    def encode(input)
+      return Zlib::Deflate.deflate(Marshal.dump(input))
+    end
+  end # Cache
+end # RubyLint

data/lib/ruby-lint/cache_entry.rb

@@ -0,0 +1,44 @@
+module RubyLint
+  ##
+  # The CacheEntry class is used to store nodes, comments and file modification
+  # times that belong to a certain root AST. It's primarily used by
+  # {RubyLint::Runner}.
+  #
+  # @!attribute [r] nodes
+  #  @return [Array]
+  #
+  # @!attribute [r] comments
+  #  @return [Hash]
+  #
+  # @!attribute [r] mtimes
+  #  @return [Hash]
+  #
+  class CacheEntry
+    attr_reader :nodes, :comments, :mtimes
+
+    ##
+    # @param [Array] nodes
+    # @param [Hash] comments
+    # @param [Hash] mtimes
+    #
+    def initialize(nodes, comments, mtimes)
+      @nodes    = nodes
+      @comments = comments
+      @mtimes   = mtimes
+    end
+
+    ##
+    # Returns `true` if none of the associated files have been modified,
+    # `false` otherwise.
+    #
+    # @return [TrueClass|FalseClass]
+    #
+    def valid?
+      mtimes.each do |file, mtime|
+        return false if File.mtime(file) != mtime
+      end
+
+      return true
+    end
+  end # CacheEntry
+end # RubyLint

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

@@ -61,6 +61,8 @@ Examples:
   on :b, :benchmark, 'Enables benchmarking mode'
   on :d, :debug, 'Displays debugging output in STDERR'
 
+  on :'disable-cache', 'Disables caching of external files'
+
   ##
   # Returns an Array containing the file paths that exist. If a non existing
   # file is encountered `abort` is called.
@@ -110,6 +112,36 @@ Examples:
     @output_destination = destination
   end
 
+  ##
+  # @param [RubyLint::Configuration] configuration
+  # @param [Hash] opts
+  #
+  def configure(configuration, options)
+    option_mapping.each do |key, setter|
+      configuration.send(setter, options[key]) if options[key]
+    end
+
+    if options[:'disable-cache']
+      configuration.enable_cache = false
+    end
+  end
+
+  ##
+  # @param [String] output
+  # @param [Float] exec_time
+  #
+  def show_benchmark_info(output, exec_time)
+    memory_kb = `ps -o rss= #{Process.pid}`.strip.to_f
+    memory_mb = memory_kb / 1024
+
+    output_destination.puts unless output.empty?
+
+    output_destination.puts "Execution time: #{exec_time.round(4)} seconds"
+
+    output_destination.puts "Memory usage: #{memory_mb.round(2)} MB " \
+      "(#{memory_kb.round(2)} KB)"
+  end
+
   run do |opts, args|
     abort 'You must specify at least one file to analyze' if args.empty?
 
@@ -117,27 +149,14 @@ Examples:
     files         = extract_files(args)
     configuration = RubyLint::Configuration.load_from_file
 
-    option_mapping.each do |key, setter|
-      configuration.send(setter, opts[key]) if opts[key]
-    end
-
-    runner = RubyLint::Runner.new(configuration)
-    output = runner.analyze(files)
-
-    output_destination.puts output unless output.empty?
+    configure(configuration, opts)
 
+    runner    = RubyLint::Runner.new(configuration)
+    output    = runner.analyze(files)
     exec_time = Time.now.to_f - start_time
 
-    if opts[:benchmark]
-      memory_kb = `ps -o rss= #{Process.pid}`.strip.to_f
-      memory_mb = memory_kb / 1024
-
-      output_destination.puts unless output.empty?
-
-      output_destination.puts "Execution time: #{exec_time.round(2)} seconds"
+    output_destination.puts output unless output.empty?
 
-      output_destination.puts "Memory usage: #{memory_mb.round(2)} MB " \
-        "(#{memory_kb.round(2)} KB)"
-    end
+    show_benchmark_info(output, exec_time) if opts[:benchmark]
   end # run do |opts, args|
 end # RubyLint::CLI.options.command

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

@@ -0,0 +1,94 @@
+#:nocov:
+RubyLint::CLI.options.command :plot do
+  banner      'Usage: ruby-lint plot [FILE] [OPTIONS]'
+  description 'Plots analysis time of a single file'
+
+  separator RubyLint::CLI::OPTIONS_HEADER
+
+  RubyLint::CLI.help_option(self)
+
+  on :i=, :iterations=,
+    'The amount of iterations',
+    :as      => Integer,
+    :default => 100
+
+  ##
+  # @param [String] basename
+  # @param [Array] no_cache
+  # @param [Array] cache
+  # @param [Hash] options
+  #
+  def plot_timings(basename, no_cache, cache, options)
+    x_points = (1..options[:iterations]).to_a
+
+    Gnuplot.open do |gp|
+      Gnuplot::Plot.new(gp) do |plot|
+        plot.title "#{basename} with #{options[:iterations]} iterations"
+
+        plot.xlabel 'Iteration'
+        plot.ylabel 'Time (ms)'
+
+        plot.data << Gnuplot::DataSet.new([x_points, no_cache]) do |ds|
+          ds.with  = 'lines'
+          ds.title = 'No caching'
+        end
+
+        plot.data << Gnuplot::DataSet.new([x_points, cache]) do |ds|
+          ds.with  = 'lines'
+          ds.title = 'Caching'
+        end
+      end
+    end
+  end
+
+  ##
+  # Measures the analysis time of a given file.
+  #
+  # @param [String] file
+  # @param [Fixnum] amount
+  # @param [TrueClass|FalseClass] caching
+  #
+  def measure_analysis(file, amount, caching = false)
+    configuration = RubyLint::Configuration.load_from_file
+    configuration.enable_cache = caching
+
+    FileUtils.rm_rf(configuration.cache_directory) if caching
+
+    files   = [file]
+    runner  = RubyLint::Runner.new(configuration)
+    timings = []
+
+    amount.times do
+      timing = Benchmark.measure { runner.analyze(files) }
+
+      timings << timing.real * 1000
+    end
+
+    return timings
+  end
+
+  run do |opts, args|
+    require 'gnuplot'
+    require 'fileutils'
+    require 'benchmark'
+
+    abort 'No files specified' if args.empty?
+
+    abort "The file #{args[0]} does not exist" unless File.file?(args[0])
+
+    puts 'Measuring, this will take a while...'
+
+    no_cache = measure_analysis(args[0], opts[:iterations])
+    cache    = measure_analysis(args[0], opts[:iterations], true)
+
+    plot_timings(File.basename(args[0]), no_cache, cache, opts)
+
+    no_cache_avg = no_cache.inject(:+) / no_cache.length
+    cache_avg    = cache.inject(:+) / cache.length
+
+    puts 'Averages:'
+    puts "Cache disabled: #{no_cache_avg} ms"
+    puts "Cache enabled:  #{cache_avg} ms"
+  end
+end
+#:nocov:

data/lib/ruby-lint/cli.rb

@@ -2,3 +2,4 @@ require 'slop'
 require_relative 'cli/base'
 require_relative 'cli/analyze'
 require_relative 'cli/ast'
+require_relative 'cli/plot'

data/lib/ruby-lint/configuration.rb

@@ -22,9 +22,20 @@ module RubyLint
   # @!attribute [rw] ignore_paths
   #  @return [Array]
   #
+  # @!attribute [rw] enable_cache
+  #  When set to `true` external files and their associated data will be
+  #  cached.
+  #  @return [TrueClass|FalseClass]
+  #
+  # @!attribute [r] cache_directory
+  #  The path to the directory to use for storing cache files.
+  #  @return [String]
+  #
   class Configuration
-    attr_reader :analysis_classes, :report_levels, :presenter, :directories
-    attr_accessor :debug, :ignore_paths
+    attr_reader :analysis_classes, :report_levels, :presenter, :directories,
+      :cache_directory
+
+    attr_accessor :debug, :ignore_paths, :enable_cache
 
     ##
     # Returns an Array of locations from which to load configuration files.
@@ -86,7 +97,8 @@ module RubyLint
     # @param [Hash] options
     #
     def initialize(options = {})
-      @debug = false
+      @debug           = false
+      @enable_cache    = default_cache_value
 
       options.each do |key, value|
         setter = "#{key}="
@@ -101,6 +113,16 @@ module RubyLint
       @presenter        ||= default_presenter
       @directories      ||= default_directories
       @ignore_paths     ||= []
+      @cache_directory  ||= default_cache_directory
+    end
+
+    ##
+    # Expands and sets the path as the cache directory.
+    #
+    # @param [String] path
+    #
+    def cache_directory=(path)
+      @cache_directory = File.expand_path(path)
     end
 
     ##
@@ -217,5 +239,28 @@ module RubyLint
     def default_directories
       return [Dir.pwd]
     end
+
+    ##
+    # @return [TrueClass|FalseClass]
+    #
+    def default_cache_value
+      return ENV['RUBY_LINT_DISABLE_CACHE'] ? false : true
+    end
+
+    ##
+    # The default cache directory to use. Per the XDG specification
+    # (http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html)
+    # this is set to `$XDG_CACHE_HOME`/`$HOME/.cache` by default.
+    #
+    # @return [String]
+    #
+    def default_cache_directory
+      root = ENV['XDG_CACHE_HOME'] || File.join(ENV['HOME'], '.cache')
+
+      # ~/.cache might not exist on non Linux systems.
+      Dir.mkdir(root) unless File.directory?(root)
+
+      return File.join(root, 'ruby-lint')
+    end
   end # Configuration
 end # RubyLint