rubocop-yast 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c59e960c99f00013d3881020fe1d576e9d67ab91
-  data.tar.gz: 89d463fb18eb4d31ad00df25be33621cd4309446
+  metadata.gz: ab9d34ebc702b4f960ea9052af25796369d11d60
+  data.tar.gz: 0562543d6aca25bd76a0f933fcfd8670cde680cf
 SHA512:
-  metadata.gz: f6f08655ccfef688328df7f9f245df9c963ed4a55c963ae81b40395e71befa4fca00f50c8fba339f80223689863a24d51c49ff41e923d166880555d2efb02087
-  data.tar.gz: ea903ebf6261f79f6a7e7b3646648d198ae0432b3da2e301dbc2b29a1d07e23a7c8b9ddcf849f4d3c46b221b6d0ff11ef97879952bedbde3c66e8bc4d2fb834e
+  metadata.gz: 8f8c2c95efd7d2e58b78258fae535b1e3c671dbfdb3a108daf9231ae7224f46d21b81912622951635065c0c5364faaa0f509b68b95815992427412e8ee6a5784
+  data.tar.gz: 9fe4dfebd32eea8427cf671018187e60361d99fdb5089e3e4c1d35c2db30278ac11689a1823b233bf5e5dadb5f45e53b37828977dc8e85354d46acbc5392d06e

data/CHANGELOG.md

@@ -2,7 +2,24 @@
 
 ## master (unreleased)
 
-## 0.0.6 (15/12/2014)
+## 0.0.8 (2015-12-11)
+
+### New Features
+
+- Nearly all Cucumber features converted from Zombie Killer work.
+  The exception is a `retry` in `rescue`.
+
+## 0.0.7 (2015-12-08)
+
+### Changes
+
+- Added Cucumber features converted from the Zombie Killer spec.
+  Some of them are marked as pending because they don't work yet.
+- SafeMode config removed, it is always enabled instead.
+- StrictMode config added, enabled by default: report all Ops, even if they
+  cannot be autocorrected.
+
+## 0.0.6 (2014-12-15)
 
 ### New Features
 

data/README.md

@@ -67,8 +67,9 @@ Yast/Builtins:
 # Check for obsolete Ops.* calls
 Yast/Ops:
   Enabled: true
-  # in the safe mode only safe places are reported and fixed
-  SafeMode: true
+  # in strict mode all Ops calls are reported
+  # even if they cannot be autocorrected
+  StrictMode: true
 ```
 
 Development

data/Rakefile

@@ -13,10 +13,7 @@ end
 require "cucumber/rake/task"
 Cucumber::Rake::Task.new(:features)
 
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new(:spec)
-
 require "rubocop/rake_task"
 RuboCop::RakeTask.new(:rubocop)
 
-task default: [:spec, :features, :rubocop]
+task default: [:features, :rubocop]

data/config/default.yml

@@ -5,7 +5,7 @@ Yast/Builtins:
 Yast/Ops:
   Description: "Check for obsolete Ops.* calls"
   Enabled: true
-  SafeMode: true
+  StrictMode: true
 
 Yast/LogVariable:
   Description: "Check for using 'log' variable"

data/lib/rubocop-yast.rb

@@ -6,6 +6,7 @@ require_relative "rubocop/yast/config"
 RuboCop::Yast::Config.load_defaults
 
 require_relative "rubocop/yast/version"
+require_relative "rubocop/yast/logger"
 require_relative "rubocop/cop/yast/builtins"
 require_relative "rubocop/cop/yast/ops"
 require_relative "rubocop/cop/yast/log_variable"

data/lib/rubocop/cop/yast/ops.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require "rubocop/yast/track_variable_scope"
+require "unparser"
 
 # We have encountered code that does satisfy our simplifying assumptions,
 # translating it would not be correct.
@@ -10,63 +11,98 @@ end
 module RuboCop
   module Cop
     module Yast
-      # This cop checks for Ops.* calls, it can autocorrect safe places or
-      # all places in unsafe mode
+      # This cop checks for Ops.* calls aka Zombies.
+      # Some of these can be autocorrected, mostly when we can prove
+      # that their arguments cannot be nil.
+      # In Strict Mode, it reports all zombies.
+      # In Permissive Mode, it report only zombies that can be autocorrected.
       class Ops < Cop
-        include RuboCop::Yast::TrackVariableScope
-
         # Ops replacement mapping
         REPLACEMENT = {
-          add: "+"
+          add: :+,
+          # divide: :/,          # must also check divisor nonzero
+          # greater_than::>,      # handle ycp comparison
+          # greater_or_equal: :>=,# handle ycp comparison
+          # less_than: :<,        # handle ycp comparison
+          # less_or_equal: :<=,   # handle ycp comparison
+          modulo: :%,
+          multiply: :*,
+          subtract: :-
         }
 
-        MSG = "Obsolete Ops.%s call found"
-
         def initialize(config = nil, options = nil)
           super(config, options)
 
-          @safe_mode = cop_config && cop_config["SafeMode"]
+          @strict_mode = cop_config && cop_config["StrictMode"]
           @replaced_nodes = []
+          @processor = OpsProcessor.new(self)
         end
 
-        def on_send(node)
-          return unless call?(node, :Ops, :add)
-
-          _ops, method, a, b = *node
-          return if !(nice(a) && nice(b)) && safe_mode
-
-          add_offense(node, :selector, format(MSG, method))
+        def investigate(processed_source)
+          @processor.investigate(processed_source)
         end
 
-        private
+        attr_reader :strict_mode
 
-        def call?(node, namespace, message)
-          n_receiver, n_message = *node
-          n_receiver && n_receiver.type == :const &&
-            n_receiver.children[0].nil? &&
-            n_receiver.children[1] == namespace &&
-            n_message == message
-        end
+        private
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            _ops, message, arg1, arg2 = *node
+          return unless @processor.autocorrectable?(node)
+
+          _ops, message, arg1, arg2 = *node
 
-            new_ops = REPLACEMENT[message]
-            return unless new_ops
+          new_op = REPLACEMENT[message]
+          return unless new_op
 
-            corrector.replace(node.loc.expression,
-              ops_replacement(new_ops, arg1, arg2))
+          @corrections << lambda do |corrector|
+            source_range = node.loc.expression
+            next if contains_comment?(source_range.source)
+            new_node = Parser::AST::Node.new(:send, [arg1, new_op, arg2])
+            corrector.replace(source_range, Unparser.unparse(new_node))
           end
         end
 
-        def ops_replacement(new_ops, arg1, arg2)
-          "#{arg1.loc.expression.source} #{new_ops} " \
-            "#{arg2.loc.expression.source}"
+        def contains_comment?(string)
+          /^[^'"\n]*#/.match(string)
         end
-
-        attr_reader :safe_mode
       end
     end
   end
 end
+
+# Niceness processor really
+class OpsProcessor < Parser::AST::Processor
+  include RuboCop::Yast::TrackVariableScope
+  include RuboCop::Cop::Util # const_name
+
+  attr_reader :cop
+
+  def initialize(cop)
+    @cop = cop
+  end
+
+  def investigate(processed_source)
+    process(processed_source.ast)
+  end
+
+  MSG = "Obsolete Ops.%s call found"
+
+  def on_send(node)
+    super
+
+    receiver, message = *node
+    return unless const_name(receiver) == "Ops"
+    return unless RuboCop::Cop::Yast::Ops::REPLACEMENT.key?(message)
+    return unless cop.strict_mode || autocorrectable?(node)
+    cop.add_offense(node, :selector, format(MSG, message))
+  end
+
+  # assumes node is an Ops.add
+  def autocorrectable?(node)
+    RuboCop::Yast.logger.debug "AUTOCORRECTABLE?(#{node.inspect})"
+    RuboCop::Yast.logger.debug "CUR SCOPE #{scope.inspect}"
+
+    _ops, _method, a, b = *node
+    nice(a) && nice(b)
+  end
+end

data/lib/rubocop/yast/logger.rb

@@ -0,0 +1,28 @@
+require "logger"
+
+module RuboCop
+  # Yast specific helpers
+  module Yast
+    def logger
+      return @logger if @logger
+
+      @logger = ::Logger.new(STDERR)
+      @logger.level = ::Logger::WARN
+      @logger.level = ::Logger::DEBUG if $DEBUG
+      @logger
+    end
+    module_function :logger
+
+    def backtrace(skip_frames: 0)
+      c = caller
+      lines = []
+      c.reverse.drop(skip_frames).each_with_index do |frame, i|
+        lines << "#{i}: #{frame}"
+      end
+      lines.reverse_each do |l|
+        puts l
+      end
+    end
+    module_function :backtrace
+  end
+end

data/lib/rubocop/yast/niceness.rb

@@ -18,7 +18,7 @@ module Niceness
 
   def nice(node)
     nice_literal(node) || nice_variable(node) || nice_send(node) ||
-      nice_begin(node)
+      nice_sformat(node) || nice_begin(node)
   end
 
   def nice_literal(node)
@@ -54,7 +54,25 @@ module Niceness
     args.size == arity && args.all? { |a| nice(a) }
   end
 
+  # Builtins.sformat is special in that it can produce nil
+  # but only if the format string is nil which is fortunately
+  # easy to rule out. Other args may be ugly but we don't care.
+  def nice_sformat(node)
+    return false unless node.type == :send
+    return false unless call?(node, :Builtins, :sformat)
+    _builtins, _sformat, format_string, *_other_args = *node
+    nice(format_string)
+  end
+
   def nice_begin(node)
     node.type == :begin && nice(node.children.last)
   end
+
+  def call?(node, namespace, message)
+    n_receiver, n_message = *node
+    n_receiver && n_receiver.type == :const &&
+      n_receiver.children[0].nil? &&
+      n_receiver.children[1] == namespace &&
+      n_message == message
+  end
 end

data/lib/rubocop/yast/track_variable_scope.rb

@@ -18,15 +18,6 @@ module RuboCop
         @scopes ||= VariableScopeStack.new
       end
 
-      # FIXME
-      def process(node)
-        return if node.nil?
-        #  if ! @unsafe
-        #  oops(node, RuntimeError.new("Unknown node type #{node.type}")) \
-        #    unless HANDLED_NODE_TYPES.include? node.type
-        #  end
-      end
-
       # currently visible scope
       def scope
         scopes.innermost
@@ -41,23 +32,46 @@ module RuboCop
       end
 
       def on_def(node)
-        with_new_scope_rescuing_oops(node)
+        name, _, _ = *node
+        RuboCop::Yast.logger.debug "ONDEF #{name}"
+        RuboCop::Yast.logger.debug "CUR SCOPE #{scope.inspect}"
+        RuboCop::Yast.backtrace skip_frames: 50 if $DEBUG
+
+        with_new_scope_rescuing_oops(node) { super }
       end
 
       def on_defs(node)
-        with_new_scope_rescuing_oops(node)
+        with_new_scope_rescuing_oops(node) { super }
       end
 
       def on_module(node)
-        with_new_scope_rescuing_oops(node)
+        with_new_scope_rescuing_oops(node) { super }
       end
 
       def on_class(node)
-        with_new_scope_rescuing_oops(node)
+        with_new_scope_rescuing_oops(node) { super }
       end
 
       def on_sclass(node)
-        with_new_scope_rescuing_oops(node)
+        with_new_scope_rescuing_oops(node) { super }
+      end
+
+      def on_if(node)
+        cond, then_body, else_body = *node
+        process(cond)
+
+        scopes.with_copy do
+          process(then_body)
+        end
+
+        scopes.with_copy do
+          process(else_body)
+        end
+
+        # clean slate
+        scope.clear
+
+        node
       end
 
       # def on_unless
@@ -79,36 +93,46 @@ module RuboCop
 
         # clean slate
         scope.clear
+
+        node
       end
 
       def on_lvasgn(node)
+        super
         name, value = * node
         return if value.nil? # and-asgn, or-asgn, resbody do this
         scope[name].nice = nice(value)
+        node
       end
 
       def on_and_asgn(node)
+        super
         var, value = *node
         bool_op_asgn(var, value, :and)
+        node
       end
 
       def on_or_asgn(node)
+        super
         var, value = *node
         bool_op_asgn(var, value, :or)
+        node
       end
 
-      def on_block(_node)
+      def on_block(node)
         # ignore body, clean slate
         scope.clear
+        node
       end
       alias_method :on_for, :on_block
 
-      def on_while(_node)
+      def on_while(node)
         # ignore both condition and body,
         # with a simplistic scope we cannot handle them
 
         # clean slate
         scope.clear
+        node
       end
       alias_method :on_until, :on_while
 
@@ -117,22 +141,24 @@ module RuboCop
 
       def on_rescue(node)
         # (:rescue, begin-block, resbody..., else-block-or-nil)
-        _begin_body, *_rescue_bodies, _else_body = *node
-
-        # FIXME
-        #  @source_rewriter.transaction do
-        #    process(begin_body)
-        #    process(else_body)
-        #    rescue_bodies.each do |r|
-        #      process(r)
-        #    end
-        #  end
-        #  rescue TooComplexToTranslateError
-        #    warning "begin-rescue is too complex to translate due to a retry"
+        begin_body, *rescue_bodies, else_body = *node
+
+        # FIXME: the transaction must be rolled back
+        # by the TooComplexToTranslateError
+        # @source_rewriter.transaction do
+        process(begin_body)
+        process(else_body)
+        rescue_bodies.each do |r|
+          process(r)
+        end
         #  end
+        node
+      rescue TooComplexToTranslateError
+        warn "begin-rescue is too complex to translate due to a retry"
+        node
       end
 
-      def on_resbody(_node)
+      def on_resbody(node)
         # How it is parsed:
         # (:resbody, exception-types-or-nil, exception-variable-or-nil, body)
         # exception-types is an :array
@@ -143,19 +169,20 @@ module RuboCop
         # and join begin-block with else-block, but it is little worth
         # because they will contain few zombies.
         scope.clear
+        super
       end
 
-      def on_ensure(_node)
+      def on_ensure(node)
         # (:ensure, guarded-code, ensuring-code)
         # guarded-code may be a :rescue or not
 
         scope.clear
+        node
       end
 
       def on_retry(_node)
         # that makes the :rescue a loop, top-down data-flow fails
-        # FIXME
-        # raise TooComplexToTranslateError
+        raise TooComplexToTranslateError
       end
 
       private

data/lib/rubocop/yast/variable_scope.rb

@@ -1,6 +1,15 @@
 # Tracks state for a variable
 class VariableState
-  attr_accessor :nice
+  def nice
+    RuboCop::Yast.logger.debug "GETN #{inspect}"
+    @nice
+  end
+
+  def nice=(v)
+    @nice = v
+    RuboCop::Yast.logger.debug "SETN #{inspect}"
+    v
+  end
 end
 
 # Tracks state for local variables visible at certain point.
@@ -23,11 +32,14 @@ class VariableScope < Hash
 
   # @return [VariableState] state
   def [](varname)
-    super
+    v = super
+    RuboCop::Yast.logger.debug "GET #{varname} -> #{v}"
+    v
   end
 
   # Set state for a variable
   def []=(varname, state)
+    RuboCop::Yast.logger.debug "SET #{varname} -> #{state}"
     super
   end
 
@@ -50,6 +62,7 @@ class VariableScopeStack
   # @return the scope as the block left it, popped from the stack
   def with_new(&block)
     @stack.push VariableScope.new
+    RuboCop::Yast.logger.debug "SCOPES #{@stack.inspect}"
     block.call
     @stack.pop
   end

data/lib/rubocop/yast/version.rb

@@ -3,6 +3,6 @@
 module RuboCop
   # Yast plugin settings
   module Yast
-    VERSION = "0.0.6"
+    VERSION = "0.0.8"
   end
 end

data/rubocop-yast.gemspec

@@ -24,11 +24,12 @@ Gem::Specification.new do |spec|
     "*.gemspec",
     "Gemfile",
     "Rakefile"
-  ]
+  ].reject { |f| f =~ /~$/ }
   spec.test_files = spec.files.grep(/^spec\//)
   spec.extra_rdoc_files = ["LICENSE", "README.md"]
 
-  spec.add_runtime_dependency("rubocop", "~> 0.27")
+  spec.add_runtime_dependency("rubocop", "~> 0.29.1")
+  spec.add_runtime_dependency("unparser", "~> 0")
 
   spec.add_development_dependency("rake")
   spec.add_development_dependency("rspec", "~> 3.1.0")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-yast
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Ladislav Slezák
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2015-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: 0.29.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.27'
+        version: 0.29.1
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +120,7 @@ files:
 - lib/rubocop/yast/builtins/time.rb
 - lib/rubocop/yast/builtins/y2log.rb
 - lib/rubocop/yast/config.rb
+- lib/rubocop/yast/logger.rb
 - lib/rubocop/yast/niceness.rb
 - lib/rubocop/yast/node_helpers.rb
 - lib/rubocop/yast/reformatter.rb
@@ -113,9 +128,6 @@ files:
 - lib/rubocop/yast/variable_scope.rb
 - lib/rubocop/yast/version.rb
 - rubocop-yast.gemspec
-- spec/builtins_spec.rb
-- spec/ops_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/yast/rubocop-yast
 licenses:
 - MIT
@@ -140,7 +152,4 @@ rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Specific YaST Rubocop checks
-test_files:
-- spec/builtins_spec.rb
-- spec/ops_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/spec/builtins_spec.rb

@@ -1,560 +0,0 @@
-# Automatically generated -- DO NOT EDIT!
-
-require "spec_helper"
-
-describe "RuboCop::Cop::Yast::Builtins" do
-  describe "Generic Tests:" do
-    it "It reports y2milestone builtin as offense" do
-      code = code_cleanup(<<-EOT)
-        Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "It finds builtin in explicit Yast namespace" do
-      code = code_cleanup(<<-EOT)
-        Yast::Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "It finds builtin in explicit ::Yast namespace" do
-      code = code_cleanup(<<-EOT)
-        ::Yast::Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "Builtins in the ::Builtins name space are ignored" do
-      code = code_cleanup(<<-EOT)
-        ::Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses).to be_empty
-    end
-
-    it "Builtins in non Yast name space are ignored" do
-      code = code_cleanup(<<-EOT)
-        Foo::Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses).to be_empty
-    end
-
-    it "lsort(), crypt and gettext builtins are allowed" do
-      code = code_cleanup(<<-EOT)
-        Builtins.lsort(["foo"])
-        Builtins.crypt("foo")
-        Builtins.dgettext("domain", "foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses).to be_empty
-    end
-
-    it "It does not change unknown builtins" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.foo()
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        Builtins.foo()
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-  end
-
-  describe "Builtins.getenv():" do
-    it "With string literal parameter is translated to ENV equivalent" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.getenv("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        ENV["foo"]
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "Variable as parameter is preserved" do
-      original_code = code_cleanup(<<-EOT)
-        foo = bar
-        Builtins.getenv(foo)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        foo = bar
-        ENV[foo]
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "Any other statement is preserved" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.getenv(Ops.add(foo, bar))
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        ENV[Ops.add(foo, bar)]
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-  end
-
-  describe "Logging - Builtins.y2debug(), ...:" do
-    it "It translates `y2debug` to `log.debug`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2debug("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.debug "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It translates `y2milestone` to `log.info`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It translates `y2warning` to `log.warn`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It translates `y2error` to `log.error`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2error("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.error "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It translates `y2security` to `log.error`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2security("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.error "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It translates `y2internal` to `log.fatal`" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2internal("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.fatal "foo"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It adds the include statement only once" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone("foo")
-        Builtins.y2milestone("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info \"foo\"
-        log.info \"foo\"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts YCP sformat to Ruby interpolation" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone("foo: %1", foo)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info "foo: \#{foo}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts %% in the format string to simple %" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone("foo: %1%%", foo)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info "foo: \#{foo}%"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It replaces repeated % placeholders in the format string" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("%1 %1", foo)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "\#{foo} \#{foo}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "The % placeholders do not need to start from 1" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("%2 %2", foo, bar)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "\#{bar} \#{bar}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "The % placeholders do not need to be in ascending order" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("%2 %1", foo, bar)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "\#{bar} \#{foo}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It keeps the original statements in interpolated string" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("%1", foo + bar)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "\#{foo + bar}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts a log with string interpolation" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning("foo: \#{foo}")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn "foo: \#{foo}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts a log with a message variable" do
-      original_code = code_cleanup(<<-EOT)
-        msg = "message"
-        Builtins.y2warning(msg)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        msg = "message"
-        log.warn msg
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts a log with function call" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning(msg)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn msg
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It doesn't convert a log with extra parameters" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning(msg, arg1, arg2)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        Builtins.y2warning(msg, arg1, arg2)
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts log with operator call" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2warning(msg1 + msg2)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.warn msg1 + msg2
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It adds logger include to the class definition" do
-      original_code = code_cleanup(<<-EOT)
-        class Foo
-          Builtins.y2error('foo')
-        end
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        class Foo
-          include Yast::Logger
-
-          log.error "foo"
-        end
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It adds logger include with correct indentation" do
-      original_code = code_cleanup(<<-EOT)
-          class Foo
-            Builtins.y2error('foo')
-          end
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-          class Foo
-            include Yast::Logger
-
-            log.error "foo"
-          end
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It does not add the logger include if already present" do
-      original_code = code_cleanup(<<-EOT)
-        class Foo
-          include Yast::Logger
-          Builtins.y2error('foo')
-        end
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        class Foo
-          include Yast::Logger
-          log.error "foo"
-        end
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It adds the logger include after the parent class name if present" do
-      original_code = code_cleanup(<<-EOT)
-        class Foo < Bar
-          Builtins.y2error('foo')
-        end
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        class Foo < Bar
-          include Yast::Logger
-
-          log.error "foo"
-        end
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It adds logger include once to a derived class in a module" do
-      original_code = code_cleanup(<<-EOT)
-        module Yast
-          class TestClass < Module
-            def test
-              Builtins.y2error("foo")
-              Builtins.y2debug("foo")
-            end
-          end
-        end
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        module Yast
-          class TestClass < Module
-            include Yast::Logger
-
-            def test
-              log.error "foo"
-              log.debug "foo"
-            end
-          end
-        end
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It converts the single quoted format string to double quoted" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone('foo: %1', foo)
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info "foo: \#{foo}"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It escapes double quotes and interpolations" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone('"\#{foo}"')
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        include Yast::Logger
-        log.info "\\"\\\#{foo}\\""
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It does not convert logging with backtrace" do
-      original_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone(-1, "foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        Builtins.y2milestone(-1, "foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It does not convert code with a local variable 'log'" do
-      original_code = code_cleanup(<<-EOT)
-        log = 1
-        Builtins.y2milestone("foo")
-      EOT
-
-      translated_code = code_cleanup(<<-EOT)
-        log = 1
-        Builtins.y2milestone("foo")
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
-    end
-
-    it "It finds an offense with missing parenthesis around argument" do
-      code = code_cleanup(<<-EOT)
-        Builtins.y2milestone "Executing hook '\#{name}'"
-      EOT
-
-      cop = RuboCop::Cop::Yast::Builtins.new
-      inspect_source(cop, [code])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-end

data/spec/ops_spec.rb

@@ -1,119 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-describe RuboCop::Cop::Yast::Ops do
-  context("In safe mode") do
-    let(:config) do
-      conf = { "Yast/Ops" => { "SafeMode" => true } }
-      RuboCop::Config.new(conf)
-    end
-
-    subject(:cop) { described_class.new(config) }
-
-    it "finds trivial Ops.add call" do
-      inspect_source(cop, ["Ops.add(2, 4)"])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "finds Ops.add call with variable" do
-      inspect_source(cop, ["foo = 2\n Ops.add(foo, 4)"])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "finds Ops.add call with variable inside condition" do
-      inspect_source(cop, ["foo = 1\nif true\nOps.add(foo, 4)\nend"])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "ignores unsafe calls" do
-      inspect_source(cop, ["if true\nOps.add(foo, 4)\nend"])
-
-      expect(cop.offenses).to be_empty
-    end
-
-    # check that all node types are handled properly
-    it "parses complex code" do
-      src = <<-EOF
-      module Foo
-        class Bar
-          def baz(arg)
-            case arg
-            when :foo
-              a &&= true
-              b ||= true
-            end
-          rescue e
-            while false
-              find.foo do
-              end
-              retry
-            end
-          ensure
-            sure
-          end
-          class << foo
-          end
-          def self.foo
-          end
-        end
-      end
-      EOF
-
-      inspect_source(cop, src)
-
-      expect(cop.offenses).to be_empty
-    end
-
-    it "auto-corrects Ops.add(2, 4) with 2 + 4" do
-      new_source = autocorrect_source(cop, "Ops.add(2, 4)")
-      expect(new_source).to eq("2 + 4")
-    end
-
-    it "auto-corrects Ops.add(a, b) with a + b" do
-      new_source = autocorrect_source(cop, "a = 1; b = 2; Ops.add(a, b)")
-      expect(new_source).to eq("a = 1; b = 2; a + b")
-    end
-
-    it 'auto-corrects Ops.add("foo", "bar") with "foo" + "bar"' do
-      new_source = autocorrect_source(cop, 'Ops.add("foo", "bar")')
-      expect(new_source).to eq('"foo" + "bar"')
-    end
-
-    # FIXME: auto-correct does not work work recursively
-    xit "auto-corrects nested Ops.add calls" do
-      new_source = autocorrect_source(cop,
-        'Ops.add("foo", Ops.add("bar", "baz"))')
-      expect(new_source).to eq('"foo" + "bar + baz"')
-    end
-
-    it "keeps unsafe call Ops.add(foo, bar)" do
-      source = "foo = 1; Ops.add(foo, bar)"
-      new_source = autocorrect_source(cop, source)
-      expect(new_source).to eq(source)
-    end
-  end
-
-  context("In unsafe mode") do
-    let(:config) do
-      conf = { "Yast/Ops" => { "SafeMode" => false } }
-      RuboCop::Config.new(conf)
-    end
-
-    subject(:cop) { described_class.new(config) }
-
-    it "finds unsafe Ops.add calls" do
-      inspect_source(cop, ["if true\nOps.add(foo, 4)\nend"])
-
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "auto-corrects unsafe call Ops.add(foo, bar) with foo + bar" do
-      new_source = autocorrect_source(cop, "Ops.add(foo, bar)")
-      expect(new_source).to eq("foo + bar")
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require "simplecov"
-
-SimpleCov.start do
-  # don't check code coverage in these subdirectories
-  add_filter "/vendor/"
-  add_filter "/spec/"
-end
-
-# allow only the new "expect" RSpec syntax
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.mock_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-# reuse the Rubocop helper, provides some nice methods used in tests
-require File.join(
-  Gem::Specification.find_by_name("rubocop").gem_dir, "spec", "spec_helper.rb"
-)
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-
-require "rubocop-yast"