rubocop-yast 0.0.4 → 0.0.5

data/lib/rubocop/yast/builtins/builtin.rb

@@ -0,0 +1,38 @@
+
+# RuboCop::Cop::CorrectionNotPossible exception
+require "rubocop/cop/cop"
+
+module RuboCop
+  module Yast
+    module Builtins
+      # generic class for handling Yast builtins, base class for specific
+      # builtins zombie killers
+      class Builtin
+        # white list of allowed Builtins calls
+        ALLOWED_FUNCTIONS = [
+          # locale dependent sorting in not available in Ruby stdlib
+          :lsort,
+          # gettext helpers
+          :dgettext,
+          :dngettext,
+          :dpgettext,
+          # crypt* helpers
+          :crypt,
+          :cryptmd5,
+          :cryptblowfish,
+          :cryptsha256,
+          :cryptsha512
+        ]
+
+        def offense?(node)
+          _receiver, method_name, *_args = *node
+          !ALLOWED_FUNCTIONS.include?(method_name)
+        end
+
+        def correction(_node)
+          raise RuboCop::Cop::CorrectionNotPossible
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/yast/builtins/getenv.rb

@@ -0,0 +1,19 @@
+
+require "rubocop/yast/builtins/builtin"
+
+module RuboCop
+  module Yast
+    module Builtins
+      # getenv() convertor
+      class Getenv < Builtin
+        def correction(node)
+          lambda do |corrector|
+            _builtins, _message, *args = *node
+            new_code = "ENV[#{args.first.loc.expression.source}]"
+            corrector.replace(node.loc.expression, new_code)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/yast/builtins/time.rb

@@ -0,0 +1,16 @@
+require "rubocop/yast/builtins/builtin"
+
+module RuboCop
+  module Yast
+    module Builtins
+      # time() convertor
+      class Time < Builtin
+        def correction(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, "::Time.now.to_i")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/yast/builtins/y2log.rb

@@ -0,0 +1,138 @@
+require "rubocop/yast/builtins/builtin"
+require "rubocop/yast/reformatter"
+require "rubocop/yast/node_helpers"
+
+module RuboCop
+  module Yast
+    module Builtins
+      # generic class for handling logging builtins
+      class Y2log < Builtin
+        include Reformatter
+        include NodeHelpers
+
+        attr_reader :added_includes
+
+        LOGGING_REPLACEMENENTS = {
+          y2debug: "debug",
+          y2milestone: "info",
+          y2warning: "warn",
+          y2error: "error",
+          y2security: "error",
+          y2internal: "fatal"
+        }
+
+        ASGN_TYPES = [
+          :lvasgn,
+          :op_asgn,
+          :or_asgn,
+          :and_asgn
+        ]
+
+        TYPES_WITHOUT_ARG = [
+          :dstr,
+          :send,
+          :lvar
+        ]
+
+        def initialize
+          @added_includes = []
+        end
+
+        def correction(node)
+          _receiver, _method_name, format, *params = *node
+
+          # we can replace only standard logging, not backtraces like
+          # Builtins.y2milestone(-1, "foo") or unsafe code like
+          # fmt = "%1: %2"; Builtins.y2milestone(fmt, foo, bar)
+          if !((TYPES_WITHOUT_ARG.include?(format.type) && params.empty?) ||
+               (format.str_type?)) || ignore_node?(node)
+            raise RuboCop::Cop::CorrectionNotPossible
+          end
+
+          correction_lambda(node)
+        end
+
+        private
+
+        def correction_lambda(node)
+          lambda do |corrector|
+            add_missing_logger(node, corrector)
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        def replacement(node)
+          _receiver, method_name, format, *params = *node
+          method = LOGGING_REPLACEMENENTS[method_name]
+          src_format = format.loc.expression.source
+
+          if format.str_type?
+            src_params = params.map { |p| p.loc.expression.source }
+
+            "log.#{method} #{interpolate(src_format, src_params)}"
+          else
+            "log.#{method} #{src_format}"
+          end
+        end
+
+        def ignore_node?(node)
+          target_node = parent_node_type(node, [:class, :module])
+
+          log_descendant = target_node.each_descendant.find do |n|
+            n && ASGN_TYPES.include?(n.type) && n.loc.name.source == "log"
+          end
+
+          log_descendant
+        end
+
+        # Add Yast::Logger include somewhere up in the tree
+        def add_missing_logger(node, corrector)
+          target_node = parent_node_type(node, [:class, :module])
+
+          # already added or already present
+          return if added_includes.include?(target_node) ||
+              logger_included?(target_node)
+
+          add_include_to_node(target_node, corrector)
+
+          added_includes << target_node
+        end
+
+        # add the Yast::LOgger statement include to this node
+        def add_include_to_node(node, corrector)
+          if node.class_type? || node.module_type?
+            # indent the include statement
+            corrector.insert_after(class_logger_pos(node),
+              logger_include_code(node.loc.keyword.column))
+          else
+            # otherwise put it at the top
+            corrector.insert_before(node.loc.expression, logger_include_code)
+          end
+        end
+
+        # insert after "class Foo" or "class Foo < Bar" statement
+        def class_logger_pos(node)
+          node.loc.operator ? node.children[1].loc.expression :  node.loc.name
+        end
+
+        # simple check for already present include
+        def logger_included?(node)
+          return false if node.nil? || node.loc.nil?
+
+          source = node.loc.expression.source
+          # TODO: better check for the include call, this is a simple "grep"...
+          !source.match(/include\s+(Yast::|)Logger/).nil?
+        end
+
+        # format the include statement
+        def logger_include_code(indent = nil)
+          code = "include Yast::Logger\n"
+          return code unless indent
+
+          indent_str = "\n" + " " * (indent + 2)
+          indent_str + code
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/yast/node_helpers.rb

@@ -0,0 +1,22 @@
+
+module RuboCop
+  module Yast
+    # helpers for traversing the AST tree
+    module NodeHelpers
+      # Find the parend node of the requested type
+      # @param [Array<Symbol>] types requested node types
+      # @param node
+      # @return the requested type node or the root node if not found
+      def parent_node_type(node, types)
+        target_node = node
+
+        # find parent "class" node or the root node
+        while !target_node.root? && !types.include?(target_node.type)
+          target_node = target_node.parent
+        end
+
+        target_node
+      end
+    end
+  end
+end

data/lib/rubocop/yast/reformatter.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require "yaml"
+
+module RuboCop
+  module Yast
+    # patch the Rubocop config - include the plugin defaults
+    module Reformatter
+      # converts YCP format string to Ruby interpolation
+      # @param [String] format YCP format string (e.g. "foo: %1")
+      # @param [Array<String>] args argument list
+      # @return [String] String with Ruby interpolation
+      def interpolate(format, args)
+        single_to_double(format).gsub(/%./) do |match|
+          case match
+          when "%%"
+            "%"
+          when /%([1-9])/
+            pos = Regexp.last_match[1].to_i - 1
+            "\#{" + args[pos] + "}" if pos < args.size
+          end
+        end
+      end
+
+      # convert single quoted string to double quoted to allow using string
+      # interpolation
+      def single_to_double(str)
+        ret = str.dup
+        return ret if str.start_with?("\"")
+
+        # esacpe interpolation start (ignred in single quoted string)
+        ret.gsub!("\#{", "\\\#{")
+        # esacpe double quotes (not needed in single quoted string)
+        ret.gsub!("\"", "\\\"")
+
+        # replace the around quotes
+        ret[0] = "\""
+        ret[-1] = "\""
+        ret
+      end
+    end
+  end
+end

data/lib/rubocop/yast/track_variable_scope.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+
+require "rubocop/yast/niceness"
+require "rubocop/yast/variable_scope"
+
+# We have encountered code that does satisfy our simplifying assumptions,
+# translating it would not be correct.
+class TooComplexToTranslateError < Exception
+end
+
+module RuboCop
+  module Yast
+    # This module tracks variable usage
+    module TrackVariableScope
+      include Niceness
+
+      def scopes
+        @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
+      end
+
+      def with_new_scope_rescuing_oops(node, &block)
+        scopes.with_new do
+          block.call if block_given?
+        end
+      rescue => e
+        oops(node, e)
+      end
+
+      def on_def(node)
+        with_new_scope_rescuing_oops(node)
+      end
+
+      def on_defs(node)
+        with_new_scope_rescuing_oops(node)
+      end
+
+      def on_module(node)
+        with_new_scope_rescuing_oops(node)
+      end
+
+      def on_class(node)
+        with_new_scope_rescuing_oops(node)
+      end
+
+      def on_sclass(node)
+        with_new_scope_rescuing_oops(node)
+      end
+
+      # def on_unless
+      # Does not exist.
+      # `unless` is parsed as an `if` with then_body and else_body swapped.
+      # Compare with `while` and `until` which cannot do that and thus need
+      # distinct node types.
+      # end
+
+      def on_case(node)
+        expr, *cases = *node
+        process(expr)
+
+        cases.each do |case_|
+          scopes.with_copy do
+            process(case_)
+          end
+        end
+
+        # clean slate
+        scope.clear
+      end
+
+      def on_lvasgn(node)
+        name, value = * node
+        return if value.nil? # and-asgn, or-asgn, resbody do this
+        scope[name].nice = nice(value)
+      end
+
+      def on_and_asgn(node)
+        var, value = *node
+        bool_op_asgn(var, value, :and)
+      end
+
+      def on_or_asgn(node)
+        var, value = *node
+        bool_op_asgn(var, value, :or)
+      end
+
+      def on_block(_node)
+        # ignore body, clean slate
+        scope.clear
+      end
+      alias_method :on_for, :on_block
+
+      def on_while(_node)
+        # ignore both condition and body,
+        # with a simplistic scope we cannot handle them
+
+        # clean slate
+        scope.clear
+      end
+      alias_method :on_until, :on_while
+
+      # Exceptions:
+      # `raise` is an ordinary :send for the parser
+
+      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"
+        #  end
+      end
+
+      def on_resbody(_node)
+        # How it is parsed:
+        # (:resbody, exception-types-or-nil, exception-variable-or-nil, body)
+        # exception-types is an :array
+        # exception-variable is a (:lvasgn, name), without a value
+
+        # A rescue means that *some* previous code was skipped.
+        # We know nothing. We could process the resbodies individually,
+        # and join begin-block with else-block, but it is little worth
+        # because they will contain few zombies.
+        scope.clear
+      end
+
+      def on_ensure(_node)
+        # (:ensure, guarded-code, ensuring-code)
+        # guarded-code may be a :rescue or not
+
+        scope.clear
+      end
+
+      def on_retry(_node)
+        # that makes the :rescue a loop, top-down data-flow fails
+        # FIXME
+        # raise TooComplexToTranslateError
+      end
+
+      private
+
+      def oops(node, exception)
+        puts "Node exception @ #{node.loc.expression}"
+        puts "Offending node: #{node.inspect}"
+        raise exception unless exception.is_a?(TooComplexToTranslateError)
+      end
+
+      def bool_op_asgn(var, value, op)
+        return if var.type != :lvasgn
+        name = var.children[0]
+
+        case op
+        when :and
+          scope[name].nice &&= nice(value)
+        when :or
+          scope[name].nice ||= nice(value)
+        else
+          raise "Unknown operator: #{op}"
+        end
+      end
+    end
+  end
+end