reek 1.3.4 → 1.3.5

data/lib/reek/source/config_file.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'reek/config_file_exception'
 
 module Reek
   module Source
@@ -43,26 +44,25 @@ module Reek
       end
 
       #
-      # Load the file path with which this was initialized,
-      # unless it is already known to be a bad configuration file.
-      # If it won't load, then it is considered a bad file.
+      # Load the file path with which this was initialized.
+      # Empty files are ignored with a warning. All other errors are to be
+      # handled farther up the stack.
       #
       def load
-        unless @@bad_config_files.include?(@file_path)
-          begin
-            result = YAML.load_file(@file_path) || {}
-            if Hash === result
-              return result
-            else
-              @@bad_config_files << @file_path                            # poop
-              problem('Not a hash')
-            end
-          rescue Exception => err
-            @@bad_config_files << @file_path                              # poop
-            problem(err.to_s)
-          end
+        if File.size(@file_path) == 0
+          problem('Empty file')
+          return {}
         end
-        return {}
+
+        begin
+          result = YAML.load_file(@file_path) || {}
+        rescue => e
+          error(e.to_s)
+        end
+
+        error('Not a hash') unless Hash === result
+
+        result
       end
 
       #
@@ -70,8 +70,19 @@ module Reek
       # Error.
       #
       def problem(reason)
-        $stderr.puts "Error: Invalid configuration file \"#{File.basename(@file_path)}\" -- #{reason}"
-        # SMELL: Duplication of 'Error:'
+        $stderr.puts "Warning: #{message(reason)}"
+      end
+
+      #
+      # Report invalid configuration file to standard
+      # Error.
+      #
+      def error(reason)
+        raise ConfigFileException.new message(reason)
+      end
+
+      def message(reason)
+        "Invalid configuration file \"#{File.basename(@file_path)}\" -- #{reason}"
       end
     end
   end

data/lib/reek/source/sexp_extensions.rb

@@ -0,0 +1,139 @@
+require 'reek/source/sexp_node'
+
+module Reek
+  module Source
+    module SexpExtensions
+      module AndNode
+        def condition() self[1..2].tap {|b| b.extend SexpNode } end
+      end
+
+      module OrNode
+        def condition() self[1..2].tap {|b| b.extend SexpNode } end
+      end
+
+      module AttrasgnNode
+        def args() self[3] end
+      end
+
+      module CaseNode
+        def condition() self[1] end
+      end
+
+      module CallNode
+        def receiver() self[1] end
+        def method_name() self[2] end
+        def args() self[3..-1] end
+        def arg_names
+          args.map {|arg| arg[1]}
+        end
+      end
+
+      module CvarNode
+        def name() self[1] end
+      end
+
+      CvasgnNode = CvarNode
+      CvdeclNode = CvarNode
+
+      module LvarNode
+        def value() self[1] end
+      end
+
+      module MethodNode
+        def arg_names
+          @args ||= parameter_names.reject {|param| param.to_s =~ /^&/}
+        end
+        def parameter_names
+          @param_names ||= argslist[1..-1].map { |param| Sexp === param ?  param[1] : param }
+        end
+      end
+
+      module DefnNode
+        def name() self[1] end
+        def argslist() self[2] end
+        def body()
+          self[3..-1].extend SexpNode
+        end
+        include MethodNode
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}#"
+          "#{prefix}#{name}"
+        end
+      end
+
+      module DefsNode
+        def receiver() self[1] end
+        def name() self[2] end
+        def argslist() self[3] end
+        def body()
+          self[4..-1].extend SexpNode
+        end
+        include MethodNode
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}#"
+          "#{prefix}#{SexpNode.format(receiver)}.#{name}"
+        end
+      end
+
+      module IfNode
+        def condition() self[1] end
+      end
+
+      module IterNode
+        def call() self[1] end
+        def args() self[2] end
+        def block() self[3] end
+        def parameters() self[2] || [] end
+        def parameter_names
+          parameters[1..-1].to_a
+        end
+      end
+
+      module LitNode
+        def value() self[1] end
+      end
+
+      module Colon2Node
+        def name
+          self[2]
+        end
+
+        def simple_name
+          if name.is_a? Colon2Node
+            name.simple_name
+          else
+            name
+          end
+        end
+      end
+
+      module ModuleNode
+        def name() self[1] end
+
+        def simple_name
+          Sexp === name ? name.simple_name : name
+        end
+
+        def full_name(outer)
+          prefix = outer == '' ? '' : "#{outer}::"
+          "#{prefix}#{text_name}"
+        end
+        def text_name
+          SexpNode.format(name)
+        end
+      end
+
+      module ClassNode
+        include ModuleNode
+        def superclass() self[2] end
+      end
+
+      module YieldNode
+        def args() self[1..-1] end
+        def arg_names
+          args.map {|arg| arg[1]}
+        end
+      end
+    end
+  end
+end

data/lib/reek/source/sexp_node.rb

@@ -0,0 +1,64 @@
+module Reek
+  module Source
+    #
+    # Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
+    # syntax tree more easily.
+    #
+    module SexpNode
+      def self.format(expr)
+        case expr
+        when Sexp then expr.format_ruby
+        else expr.to_s
+        end
+      end
+
+      def hash
+        self.inspect.hash
+      end
+
+      def is_language_node?
+        Symbol === first
+      end
+
+      def has_type?(type)
+        is_language_node? and first == type
+      end
+
+      def each_node(type, ignoring, &blk)
+        if block_given?
+          look_for(type, ignoring, &blk)
+        else
+          result = []
+          look_for(type, ignoring) {|exp| result << exp}
+          result
+        end
+      end
+
+      def each_sexp
+        each { |elem| yield elem if Sexp === elem }
+      end
+
+      #
+      # Carries out a depth-first traversal of this syntax tree, yielding
+      # every Sexp of type +target_type+. The traversal ignores any node
+      # whose type is listed in the Array +ignoring+.
+      #
+      def look_for(target_type, ignoring, &blk)
+        each do |elem|
+          if Sexp === elem then
+            elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.first)
+          end
+        end
+        blk.call(self) if first == target_type
+      end
+
+      def format_ruby
+        Ruby2Ruby.new.process(deep_copy)
+      end
+
+      def deep_copy
+        Sexp.new(*map { |elem| Sexp === elem ? elem.deep_copy : elem })
+      end
+    end
+  end
+end

data/lib/reek/source/source_code.rb

@@ -33,7 +33,7 @@ module Reek
       def syntax_tree
         begin
           ast = @parser.parse(@source, @desc)
-        rescue Exception => error
+        rescue Racc::ParseError, RubyParser::SyntaxError => error
           @@err_io.puts "#{desc}: #{error.class.name}: #{error}"
         end
         ast ||= s()

data/lib/reek/source/tree_dresser.rb

@@ -1,191 +1,46 @@
+require 'reek/source/sexp_node'
+require 'reek/source/sexp_extensions'
+
 module Reek
   module Source
-
     #
-    # Extensions to +Sexp+ to allow +CodeParser+ to navigate the abstract
-    # syntax tree more easily.
+    # Adorns an abstract syntax tree with mix-in modules to make accessing
+    # the tree more understandable and less implementation-dependent.
     #
-    module SexpNode
-      def self.format(expr)
-        case expr
-        when Sexp then expr.format_ruby
-        else expr.to_s
-        end
-      end
-
-      def hash
-        self.inspect.hash
-      end
-
-      def is_language_node?
-        Symbol === first
-      end
-
-      def has_type?(type)
-        is_language_node? and first == type
-      end
-
-      def each_node(type, ignoring, &blk)
-        if block_given?
-          look_for(type, ignoring, &blk)
-        else
-          result = []
-          look_for(type, ignoring) {|exp| result << exp}
-          result
-        end
-      end
-
-      #
-      # Carries out a depth-first traversal of this syntax tree, yielding
-      # every Sexp of type +target_type+. The traversal ignores any node
-      # whose type is listed in the Array +ignoring+.
-      #
-      def look_for(target_type, ignoring, &blk)
-        each do |elem|
-          if Sexp === elem then
-            elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.first)
-          end
-        end
-        blk.call(self) if first == target_type
-      end
-
-      def format_ruby
-        Ruby2Ruby.new.process(deep_copy)
-      end
-
-      def deep_copy
-        Sexp.new(*map { |elem| Sexp === elem ? elem.deep_copy : elem })
-      end
-    end
-
-    module SexpExtensions
-      module AttrasgnNode
-        def args() self[3] end
-      end
-
-      module CaseNode
-        def condition() self[1] end
-      end
-
-      module CallNode
-        def receiver() self[1] end
-        def method_name() self[2] end
-        def args() self[3..-1] end
-        def arg_names
-          args.map {|arg| arg[1]}
-        end
-      end
-
-      module CvarNode
-        def name() self[1] end
-      end
-
-      CvasgnNode = CvarNode
-      CvdeclNode = CvarNode
-
-      module MethodNode
-        def arg_names
-          @args ||= parameter_names.reject {|param| param.to_s =~ /^&/}
-        end
-        def parameter_names
-          @param_names ||= argslist[1..-1].map { |param| Sexp === param ?  param[1] : param }
-        end
-      end
-
-      module DefnNode
-        def name() self[1] end
-        def argslist() self[2] end
-        def body()
-          self[3..-1].tap {|b| b.extend SexpNode }
-        end
-        include MethodNode
-        def full_name(outer)
-          prefix = outer == '' ? '' : "#{outer}#"
-          "#{prefix}#{name}"
-        end
-      end
-
-      module DefsNode
-        def receiver() self[1] end
-        def name() self[2] end
-        def argslist() self[3] end
-        def body()
-          self[4..-1].tap {|b| b.extend SexpNode }
-        end
-        include MethodNode
-        def full_name(outer)
-          prefix = outer == '' ? '' : "#{outer}#"
-          "#{prefix}#{SexpNode.format(receiver)}.#{name}"
-        end
-      end
-
-      module IfNode
-        def condition() self[1] end
-      end
-
-      module IterNode
-        def call() self[1] end
-        def args() self[2] end
-        def block() self[3] end
-        def parameters() self[2] || [] end
-        def parameter_names
-          parameters[1..-1].to_a
-        end
-      end
-
-      module LitNode
-        def value() self[1] end
+    class TreeDresser
+      def initialize(extensions_module = SexpExtensions, node_module = SexpNode)
+        @extensions_module = extensions_module
+        @node_module = node_module
       end
 
-      module ModuleNode
-        def name() self[1] end
-        def simple_name
-          expr = name
-          while Sexp === expr and expr[0] == :colon2
-            expr = expr[2]
-          end
-          expr
-        end
-        def full_name(outer)
-          prefix = outer == '' ? '' : "#{outer}::"
-          "#{prefix}#{text_name}"
-        end
-        def text_name
-          SexpNode.format(name)
-        end
+      def dress(sexp)
+        extend_sexp(sexp)
+        sexp.each_sexp { |sub| dress(sub) }
+        sexp
       end
 
-      module ClassNode
-        include ModuleNode
-        def superclass() self[2] end
-      end
+      private
 
-      module YieldNode
-        def args() self[1..-1] end
-        def arg_names
-          args.map {|arg| arg[1]}
-        end
+      def extend_sexp(sexp)
+        sexp.extend(@node_module)
+        extension_module = extension_for(sexp)
+        sexp.extend(extension_module) if extension_module
       end
-    end
 
-    #
-    # Adorns an abstract syntax tree with mix-in modules to make accessing
-    # the tree more understandable and less implementation-dependent.
-    #
-    class TreeDresser
-
-      def dress(sexp)
-        sexp.extend(SexpNode)
-        module_name = extensions_for(sexp.sexp_type)
-        if SexpExtensions.const_defined?(module_name)
-          sexp.extend(SexpExtensions.const_get(module_name))
-        end
-        sexp[0..-1].each { |sub| dress(sub) if Array === sub }
-        sexp
+      def extension_for(sexp)
+        extension_map[sexp.sexp_type]
       end
 
-      def extensions_for(node_type)
-        "#{node_type.to_s.capitalize}Node"
+      def extension_map
+        @extension_map ||= begin
+                             assoc = @extensions_module.constants.map { |const|
+                               [
+                                 const.to_s.sub(/Node$/, '').downcase.to_sym,
+                                 @extensions_module.const_get(const)
+                               ]
+                             }
+                             Hash[assoc]
+                           end
       end
     end
   end