code_analyzer 0.4.8 → 0.5.3

data/lib/code_analyzer/sexp.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'sexp'
 
 class Sexp
@@ -13,22 +14,23 @@ class Sexp
   #
   #     s(:@ident, "test", s(2, 12)
   #       => 2
+
   def line_number
     case sexp_type
-    when :def, :defs, :command, :command_call, :call, :fcall, :method_add_arg, :method_add_block,
-         :var_ref, :vcall, :const_ref, :const_path_ref, :class, :module,
-         :if, :unless, :elsif, :ifop, :if_mod, :unless_mod, :binary,
-         :alias, :symbol_literal, :symbol, :aref, :hash, :assoc_new, :string_literal,
-         :massign
+    when :def, :defs, :command, :command_call, :call, :fcall, :method_add_arg, :method_add_block, :var_ref, :vcall,
+         :const_ref, :top_const_ref, :const_path_ref, :class, :module, :if, :unless, :elsif, :ifop, :if_mod, :unless_mod, :binary, :alias,
+         :symbol_literal, :symbol, :aref, :hash, :assoc_new, :string_literal, :massign, :var_field, :assign, :paren, :dot2, :dot3
       self[1].line_number
     when :assoclist_from_args, :bare_assoc_hash
       self[1][0].line_number
-    when :string_add, :opassign
+    when :string_add, :opassign, :unary, :stmts_add
       self[2].line_number
     when :array
       array_values.first.line_number
     when :mlhs_add
       self.last.line_number
+    when :params
+      self[1][0].line_number if self[1].is_a? Array
     else
       self.last.first if self.last.is_a? Array
     end
@@ -38,7 +40,7 @@ class Sexp
   #
   # @return [Array] child nodes.
   def children
-    find_all { | sexp | Sexp === sexp }
+    find_all { |sexp| Sexp === sexp }
   end
 
   # recursively find all child nodes, and yeild each child node.
@@ -68,10 +70,17 @@ class Sexp
     message = options[:message]
     to_s = options[:to_s]
     self.recursive_children do |child|
-      if (!sexp_type || (sexp_type.is_a?(Array) ? sexp_type.include?(child.sexp_type) : sexp_type == child.sexp_type)) &&
-         (!receiver || (receiver.is_a?(Array) ? receiver.include?(child.receiver.to_s) : receiver == child.receiver.to_s)) &&
-         (!message || (message.is_a?(Array) ? message.include?(child.message.to_s) : message == child.message.to_s)) &&
-         (!to_s || (to_s.is_a?(Array) ? to_s.include?(child.to_s) : to_s == child.to_s))
+      if (
+           !sexp_type || (sexp_type.is_a?(Array) ? sexp_type.include?(child.sexp_type) : sexp_type == child.sexp_type)
+         ) &&
+           (
+             !receiver ||
+               (receiver.is_a?(Array) ? receiver.include?(child.receiver.to_s) : receiver == child.receiver.to_s)
+           ) &&
+           (
+             !message || (message.is_a?(Array) ? message.include?(child.message.to_s) : message == child.message.to_s)
+           ) &&
+           (!to_s || (to_s.is_a?(Array) ? to_s.include?(child.to_s) : to_s == child.to_s))
         yield child
       end
     end
@@ -91,7 +100,10 @@ class Sexp
   # the condition value can be Symbol, Array or Sexp.
   def grep_node(options)
     result = CodeAnalyzer::Nil.new
-    grep_nodes(options) { |node| result = node; break; }
+    grep_nodes(options) do |node|
+      result = node
+      break
+    end
     result
   end
 
@@ -138,9 +150,7 @@ class Sexp
   #
   # @return [Sexp] module name node
   def module_name
-    if :module == sexp_type
-      self[1]
-    end
+    self[1] if :module == sexp_type
   end
 
   # Get the class name of the class node.
@@ -154,9 +164,7 @@ class Sexp
   #
   # @return [Sexp] class name node
   def class_name
-    if :class == sexp_type
-      self[1]
-    end
+    self[1] if :class == sexp_type
   end
 
   # Get the base class of the class node.
@@ -170,9 +178,7 @@ class Sexp
   #
   # @return [Sexp] base class of class node
   def base_class
-    if :class == sexp_type
-      self[2]
-    end
+    self[2] if :class == sexp_type
   end
 
   # Get the left value of the assign node.
@@ -185,9 +191,7 @@ class Sexp
   #
   # @return [Symbol] left value of lasgn or iasgn node
   def left_value
-    if :assign == sexp_type
-      self[1]
-    end
+    self[1] if :assign == sexp_type
   end
 
   # Get the right value of assign node.
@@ -200,9 +204,7 @@ class Sexp
   #
   # @return [Sexp] right value of assign node
   def right_value
-    if :assign == sexp_type
-      self[2]
-    end
+    self[2] if :assign == sexp_type
   end
 
   # Get the message node.
@@ -277,9 +279,7 @@ class Sexp
   #
   # @return [Sexp] argument node
   def argument
-    if :binary == sexp_type
-      self[3]
-    end
+    self[3] if :binary == sexp_type
   end
 
   # Get all arguments.
@@ -305,7 +305,7 @@ class Sexp
       else
         node = self[1]
         while true
-          if [:args_add, :args_add_star].include? node.sexp_type
+          if %i[args_add args_add_star].include? node.sexp_type
             nodes.unshift node[2]
             node = node[1]
           elsif :args_new == node.sexp_type
@@ -330,9 +330,7 @@ class Sexp
   #
   # @return [Sexp] conditional statement of if node
   def conditional_statement
-    if [:if, :unless, :elsif, :ifop, :if_mod, :unless_mod].include? sexp_type
-      self[1]
-    end
+    self[1] if %i[if unless elsif ifop if_mod unless_mod].include? sexp_type
   end
 
   # Get all condition nodes.
@@ -366,13 +364,13 @@ class Sexp
   # @return [Array] all condition nodes
   def all_conditions
     nodes = []
-    if :binary == sexp_type && %w(&& || and or).include?(self[2].to_s)
-      if :binary == self[1].sexp_type && %w(&& || and or).include?(self[1][2].to_s)
+    if :binary == sexp_type && %w[&& || and or].include?(self[2].to_s)
+      if :binary == self[1].sexp_type && %w[&& || and or].include?(self[1][2].to_s)
         nodes += self[1].all_conditions
       else
         nodes << self[1]
       end
-      if :binary == self[3].sexp_type && %w(&& || and or).include?(self[3][2].to_s)
+      if :binary == self[3].sexp_type && %w[&& || and or].include?(self[3][2].to_s)
         nodes += self[3].all_conditions
       else
         nodes << self[3]
@@ -392,6 +390,7 @@ class Sexp
   #         => s(:@ident, "show", s(1, 4)),
   #
   # @return [Sexp] method name node
+
   def method_name
     case sexp_type
     when :def
@@ -399,6 +398,7 @@ class Sexp
     when :defs
       self[3]
     else
+
     end
   end
 
@@ -428,6 +428,7 @@ class Sexp
   #            )
   #
   # @return [Sexp] body node
+
   def body
     case sexp_type
     when :else
@@ -506,13 +507,15 @@ class Sexp
   # @return [Array] all statements
   def statements
     stmts = []
-    node = case sexp_type
-           when :do_block, :brace_block
-             self[2]
-           when :bodystmt
-             self[1]
-           else
-           end
+    node =
+      case sexp_type
+      when :do_block, :brace_block
+        self[2][1]
+      when :bodystmt
+        self[1]
+      else
+
+      end
     if node
       while true
         if :stmts_add == node.sexp_type && s(:void_stmt) != node[2]
@@ -542,6 +545,7 @@ class Sexp
   def exception_classes
     if :rescue == sexp_type
       return [] unless self[1]
+
       if :mrhs_add == self[1].sexp_type
         exceptions = Array.new(self[1][2])
         arg_nodes = self[1][1][1]
@@ -566,9 +570,7 @@ class Sexp
   #     )
   #         => s(:var_field, s(:@ident, "e", s(1, 20)))
   def exception_variable
-    if :rescue == sexp_type
-      self[2]
-    end
+    self[2] if :rescue == sexp_type
   end
 
   # Get hash value node.
@@ -585,20 +587,17 @@ class Sexp
   #
   # @return [Sexp] hash value node
   def hash_value(key)
-    pair_nodes = case sexp_type
-                 when :bare_assoc_hash
-                   self[1]
-                 when :hash
-                   self[1][1]
-                 else
-                 end
-    if pair_nodes
-      pair_nodes.size.times do |i|
-        if key == pair_nodes[i][1].to_s
-          return pair_nodes[i][2]
-        end
+    pair_nodes =
+      case sexp_type
+      when :bare_assoc_hash
+        self[1]
+      when :hash
+        self[1][1]
+      else
+
       end
-    end
+
+    pair_nodes.size.times { |i| return pair_nodes[i][2] if key == pair_nodes[i][1].to_s } if pair_nodes
     CodeAnalyzer::Nil.new
   end
 
@@ -640,18 +639,18 @@ class Sexp
   #
   # @return [Array] hash keys
   def hash_keys
-    pair_nodes = case sexp_type
-                 when :bare_assoc_hash
-                   self[1]
-                 when :hash
-                   self[1][1]
-                 else
-                 end
+    pair_nodes =
+      case sexp_type
+      when :bare_assoc_hash
+        self[1]
+      when :hash
+        self[1][1]
+      else
+
+      end
     if pair_nodes
       keys = []
-      pair_nodes.size.times do |i|
-        keys << pair_nodes[i][1].to_s
-      end
+      pair_nodes.size.times { |i| keys << pair_nodes[i][1].to_s }
       keys
     end
   end
@@ -673,22 +672,44 @@ class Sexp
   #
   # @return [Array] hash values
   def hash_values
-    pair_nodes = case sexp_type
-                 when :bare_assoc_hash
-                   self[1]
-                 when :hash
-                   self[1][1]
-                 else
-                 end
+    pair_nodes =
+      case sexp_type
+      when :bare_assoc_hash
+        self[1]
+      when :hash
+        self[1][1]
+      else
+
+      end
     if pair_nodes
       values = []
-      pair_nodes.size.times do |i|
-        values << pair_nodes[i][2]
-      end
+      pair_nodes.size.times { |i| values << pair_nodes[i][2] }
       values
     end
   end
 
+  # Get the hash key
+  #
+  #     s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14)))))
+  #     =>
+  #     s(:@label, "first_name:", s(1, 1))
+  def key
+    if :assoc_new == sexp_type
+      self[1].to_s
+    end
+  end
+
+  # Get the hash value
+  #
+  #     s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14)))))
+  #     =>
+  #     s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))
+  def value
+    if :assoc_new == sexp_type
+      self[2].to_s
+    end
+  end
+
   # Get the array size.
   #
   #     s(:array,
@@ -709,9 +730,7 @@ class Sexp
           array_size += 1
           first_node = s(:args_new) == first_node[1] ? first_node[2] : first_node[1]
           if :args_add != first_node.sexp_type
-            if :array == first_node.sexp_type
-              array_size += first_node.array_size
-            end
+            array_size += first_node.array_size if :array == first_node.sexp_type
             break
           end
         end
@@ -737,9 +756,9 @@ class Sexp
   def array_values
     case sexp_type
     when :array
-      if nil == self[1] || [:words_new, :qwords_new, :symbols_new, :qsymbols_new].include?(self[1].sexp_type)
+      if nil == self[1] || %i[words_new qwords_new symbols_new qsymbols_new].include?(self[1].sexp_type)
         []
-      elsif [:words_add, :qwords_add, :symbols_add, :qsymbols_add].include? self[1].sexp_type
+      elsif %i[words_add qwords_add symbols_add qsymbols_add].include? self[1].sexp_type
         self[1].array_values
       else
         arguments.all
@@ -748,10 +767,10 @@ class Sexp
       values = []
       node = self
       while true
-        if [:words_add, :qwords_add, :symbols_add, :qsymbols_add].include? node.sexp_type
+        if %i[words_add qwords_add symbols_add qsymbols_add].include? node.sexp_type
           values.unshift node[2]
           node = node[1]
-        elsif [:words_new, :qwords_new, :symbols_new, :qsymbols_new].include? node.sexp_type
+        elsif %i[words_new qwords_new symbols_new qsymbols_new].include? node.sexp_type
           break
         end
       end
@@ -808,22 +827,13 @@ class Sexp
   # @return [String] to_s
   def to_s
     case sexp_type
-    when :string_literal, :xstring_literal, :string_content, :const_ref, :symbol_literal, :symbol,
-         :args_add_block, :var_ref, :vcall, :var_field,
-         :@ident, :@tstring_content, :@const, :@ivar, :@kw, :@gvar, :@cvar
+    when :string_literal, :xstring_literal, :string_content, :const_ref, :symbol_literal, :symbol, :args_add_block, :var_ref,
+         :vcall, :var_field, :@ident, :@tstring_content, :@const, :@ivar, :@kw, :@gvar, :@cvar, :@period
       self[1].to_s
     when :string_add
-      if s(:string_content) == self[1]
-        self[2].to_s
-      else
-        self[1].to_s
-      end
+      s(:string_content) == self[1] ? self[2].to_s : self[1].to_s
     when :args_add
-      if s(:args_new) == self[1]
-        self[2].to_s
-      else
-        self[1].to_s
-      end
+      s(:args_new) == self[1] ? self[2].to_s : self[1].to_s
     when :qwords_add
       self[2].to_s
     when :word_add
@@ -839,13 +849,13 @@ class Sexp
     when :top_const_ref
       "::#{self[1]}"
     else
-      ""
+      ''
     end
   end
 
   # check if the self node is a const.
   def const?
-    :@const == self.sexp_type || ([:var_ref, :vcall].include?(self.sexp_type) && :@const == self[1].sexp_type)
+    :@const == self.sexp_type || (%i[var_ref vcall].include?(self.sexp_type) && :@const == self[1].sexp_type)
   end
 
   # true
@@ -865,22 +875,33 @@ class Sexp
     if Sexp === last_node && last_node.size == 2 && last_node.first.is_a?(Integer) && last_node.last.is_a?(Integer)
       node.delete_at(-1)
     end
-    node.sexp_body.each_with_index do |child, index|
-      if Sexp === child
-        node[index+1] = child.remove_line_and_column
-      end
-    end
+    node.sexp_body.each_with_index { |child, index| node[index + 1] = child.remove_line_and_column if Sexp === child }
     node
   end
 
   # if the return value of these methods is nil, then return CodeAnalyzer::Nil.new instead
-  [:sexp_type, :receiver, :message, :arguments, :argument, :class_name, :base_class, :method_name,
-   :body, :block_node, :conditional_statement, :left_value, :right_value].each do |method|
+  %i[
+    sexp_type
+    receiver
+    message
+    arguments
+    argument
+    class_name
+    base_class
+    method_name
+    body
+    block_node
+    conditional_statement
+    left_value
+    right_value
+  ].each do |method|
     class_eval <<-EOS
       alias_method :origin_#{method}, :#{method}
 
       def #{method}
-        ret = origin_#{method}
+        ret = origin_#{
+      method
+    }
         ret.nil? ? CodeAnalyzer::Nil.new : ret
       end
     EOS

data/lib/code_analyzer/version.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module CodeAnalyzer
-  VERSION = "0.4.8"
+  VERSION = '0.5.3'
 end

data/lib/code_analyzer/warning.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module CodeAnalyzer
   # Warning is the violation.
   #
@@ -6,7 +7,7 @@ module CodeAnalyzer
   class Warning
     attr_reader :filename, :line_number, :message
 
-    def initialize(options={})
+    def initialize(options = {})
       @filename = options[:filename]
       @line_number = options[:line_number].to_s
       @message = options[:message]

data/lib/code_analyzer.rb

@@ -1,12 +1,13 @@
-# encoding: utf-8
-require "ripper"
-require "code_analyzer/version"
-require "code_analyzer/nil"
-require "code_analyzer/sexp"
+# frozen_string_literal: true
+
+require 'ripper'
+require 'code_analyzer/version'
+require 'code_analyzer/nil'
+require 'code_analyzer/sexp'
 
 module CodeAnalyzer
-   autoload :AnalyzerException, "code_analyzer/analyzer_exception"
-   autoload :Checker, "code_analyzer/checker"
-   autoload :CheckingVisitor, "code_analyzer/checking_visitor"
-   autoload :Warning, "code_analyzer/warning"
+  autoload :AnalyzerException, 'code_analyzer/analyzer_exception'
+  autoload :Checker, 'code_analyzer/checker'
+  autoload :CheckingVisitor, 'code_analyzer/checking_visitor'
+  autoload :Warning, 'code_analyzer/warning'
 end

data/spec/code_analyzer/checker_spec.rb

@@ -1,58 +1,60 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module CodeAnalyzer
   describe Checker do
     let(:checker) { Checker.new }
 
-    context "interesting_nodes" do
-      it "should get empty interesting nodes" do
+    context 'interesting_nodes' do
+      it 'should get empty interesting nodes' do
         expect(checker.interesting_nodes).to eq []
       end
 
-      it "should add interesting nodes" do
+      it 'should add interesting nodes' do
         Checker.interesting_nodes :class, :def
-        expect(checker.interesting_nodes).to eq [:class, :def]
+        expect(checker.interesting_nodes).to eq %i[class def]
       end
     end
 
-    context "interesting_files" do
-      it "should match none of interesting files" do
+    context 'interesting_files' do
+      it 'should match none of interesting files' do
         expect(checker.interesting_files).to eq []
       end
 
-      it "should add interesting files" do
+      it 'should add interesting files' do
         Checker.interesting_files /lib/, /spec/
         expect(checker.interesting_files).to eq [/lib/, /spec/]
       end
     end
 
-    context "#parse_file?" do
-      it "should return true if node_file matches pattern" do
-        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/, /lib\/.*\.rb/])
-        expect(checker.parse_file?("lib/code_analyzer.rb")).to be true
+    context '#parse_file?' do
+      it 'should return true if node_file matches pattern' do
+        allow(checker).to receive(:interesting_files).and_return([%r{spec\/.*\.rb}, %r{lib\/.*\.rb}])
+        expect(checker.parse_file?('lib/code_analyzer.rb')).to be true
       end
 
       it "should return false if node_file doesn't match pattern" do
-        allow(checker).to receive(:interesting_files).and_return([/spec\/.*\.rb/])
-        expect(checker.parse_file?("lib/code_analyzer.rb")).to be false
+        allow(checker).to receive(:interesting_files).and_return([%r{spec\/.*\.rb}])
+        expect(checker.parse_file?('lib/code_analyzer.rb')).to be false
       end
     end
 
-    context "callback" do
-      it "should add callback to start_call" do
+    context 'callback' do
+      it 'should add callback to start_call' do
         block = Proc.new {}
         Checker.add_callback(:start_call, &block)
         expect(Checker.get_callbacks(:start_call)).to eq [block]
       end
 
-      it "should add callback to both start_class and end_class" do
+      it 'should add callback to both start_class and end_class' do
         block = Proc.new {}
         Checker.add_callback(:start_class, :end_class, &block)
         expect(Checker.get_callbacks(:start_class)).to eq [block]
         expect(Checker.get_callbacks(:end_class)).to eq [block]
       end
 
-      it "should add multiple callbacks to end_call" do
+      it 'should add multiple callbacks to end_call' do
         block1 = Proc.new {}
         block2 = Proc.new {}
         Checker.add_callback(:end_call, &block1)

data/spec/code_analyzer/checking_visitor/base_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module CodeAnalyzer

data/spec/code_analyzer/checking_visitor/default_spec.rb

@@ -1,14 +1,16 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module CodeAnalyzer::CheckingVisitor
   describe Default do
-    let(:checker1) { double(:checker, interesting_nodes: [:class, :def]) }
-    let(:checker2) { double(:checker, interesting_nodes: [:def, :call]) }
+    let(:checker1) { double(:checker, interesting_nodes: %i[class def]) }
+    let(:checker2) { double(:checker, interesting_nodes: %i[def call]) }
     let(:visitor) { Default.new(checkers: [checker1, checker2]) }
 
-    it "should check def node by all checkers" do
-      filename = "filename"
-      content = "def test; end"
+    it 'should check def node by all checkers' do
+      filename = 'filename'
+      content = 'def test; end'
       allow(checker1).to receive(:parse_file?).with(filename).and_return(true)
       allow(checker2).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker1).to receive(:node_start)
@@ -19,9 +21,9 @@ module CodeAnalyzer::CheckingVisitor
       visitor.check(filename, content)
     end
 
-    it "should check class node by only checker1" do
-      filename = "filename"
-      content = "class Test; end"
+    it 'should check class node by only checker1' do
+      filename = 'filename'
+      content = 'class Test; end'
       allow(checker1).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker1).to receive(:node_start)
       expect(checker1).to receive(:node_end)
@@ -29,9 +31,9 @@ module CodeAnalyzer::CheckingVisitor
       visitor.check(filename, content)
     end
 
-    it "should check call node by only checker2" do
-      filename = "filename"
-      content = "obj.message"
+    it 'should check call node by only checker2' do
+      filename = 'filename'
+      content = 'obj.message'
       allow(checker2).to receive(:parse_file?).with(filename).and_return(true)
       expect(checker2).to receive(:node_start)
       expect(checker2).to receive(:node_end)

data/spec/code_analyzer/checking_visitor/plain_spec.rb

@@ -1,4 +1,6 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 module CodeAnalyzer::CheckingVisitor
   describe Plain do
@@ -6,9 +8,9 @@ module CodeAnalyzer::CheckingVisitor
     let(:checker2) { double(:checker) }
     let(:visitor) { Plain.new(checkers: [checker1, checker2]) }
 
-    it "should check by all checkers" do
-      filename = "filename"
-      content = "content"
+    it 'should check by all checkers' do
+      filename = 'filename'
+      content = 'content'
       expect(checker1).to receive(:parse_file?).and_return(false)
       expect(checker2).to receive(:parse_file?).and_return(true)
       expect(checker1).not_to receive(:check).with(filename, content)