rubocop-yast 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 440ff0688d1a756f31597e9a7bead83c60682fbb
-  data.tar.gz: 1e7593995a22e3ddd79838378aab1d20e848709c
+  metadata.gz: c16c03c56b76dc2b1b8896fda2f2d5765d686c41
+  data.tar.gz: 695426ba9cb0fd0ff1d273d337c3947f8a785b80
 SHA512:
-  metadata.gz: d5465be57775161e935f2a29adf12a91f24dcb17a8f654000d2e39b157e8e3b6483129a6c597b0de87ee5579c26718d9031c4a39887c8bb27de546cd4c10a186
-  data.tar.gz: 851a3358159679e9b4e10404b12e31a402a4e83ad94b3a9d3734b3b95fc87cffd522cb33096083bc54da7df78c71d93e2b48e6d8519e3e7b1176f636faf20805
+  metadata.gz: 5d69f1ac5711c04993f135091ea1ea1d6ac4159c579a45afe7d3c783f6650416af0aef1b4819ec0a0033dfc140fd1ad54f4e994332ef389905096fad1de8ca94
+  data.tar.gz: 5bd8f3cd68cdbd225c148eec3082914ff9c4345926bf14b0819f9d61b39a857277e0be03deebffb2192ee6a3a520d051935a65ea7695c28f13dbd0adc6478d2b

data/config/default.yml

@@ -0,0 +1,8 @@
+Yast/Builtins:
+  Description: "Check for obsolete Builtins.* calls"
+  Enabled: true
+
+Yast/Ops:
+  Description: "Check for obsolete Ops.* calls"
+  Enabled: true
+  SafeMode: true

data/lib/rubocop-yast.rb

@@ -2,5 +2,9 @@
 
 require "rubocop"
 
+require_relative "rubocop/yast/config"
+RuboCop::Yast::Config.load_defaults
+
 require_relative "rubocop/yast/version"
 require_relative "rubocop/cop/yast/builtins"
+require_relative "rubocop/cop/yast/ops"

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

@@ -16,7 +16,13 @@ module RuboCop
           # gettext helpers
           :dgettext,
           :dngettext,
-          :dpgettext
+          :dpgettext,
+          # crypt* helpers
+          :crypt,
+          :cryptmd5,
+          :cryptblowfish,
+          :cryptsha256,
+          :cryptsha512
         ]
 
         BUILTINS_NODES = [
@@ -36,6 +42,27 @@ module RuboCop
 
           add_offense(node, :selector, format(MSG, method_name))
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            _builtins, message, args = *node
+
+            new_code = builtins_replacement(message, args)
+
+            corrector.replace(node.loc.expression, new_code) if new_code
+          end
+        end
+
+        private
+
+        def builtins_replacement(message, args)
+          case message
+          when :getenv
+            "ENV[#{args.loc.expression.source}]"
+          when :time
+            "::Time.now.to_i"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,226 @@
+# 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 Cop
+    module Yast
+      # This cop checks for Ops.* calls, it can autocorrect safe places or
+      # all places in unsafe mode
+      class Ops < Cop
+        include Niceness
+
+        # Ops replacement mapping
+        REPLACEMENT = {
+          add: "+"
+        }
+
+        MSG = "Obsolete Ops.%s call found"
+
+        def initialize(config = nil, options = nil)
+          super(config, options)
+
+          @scopes = VariableScopeStack.new
+          @safe_mode = cop_config["SafeMode"]
+          @replaced_nodes = []
+        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
+          return if var.type != :lvasgn
+          name = var.children[0]
+
+          scope[name].nice &&= nice(value)
+        end
+
+        def on_or_asgn(node)
+          var, value = * node
+          return if var.type != :lvasgn
+          name = var.children[0]
+
+          scope[name].nice ||= nice(value)
+        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))
+        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 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
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            _ops, message, arg1, arg2 = *node
+
+            new_ops = REPLACEMENT[message]
+            return unless new_ops
+
+            corrector.replace(node.loc.expression,
+              ops_replacement(new_ops, arg1, arg2))
+          end
+        end
+
+        def ops_replacement(new_ops, arg1, arg2)
+          "#{arg1.loc.expression.source} #{new_ops} " \
+            "#{arg2.loc.expression.source}"
+        end
+
+        attr_reader :scopes, :safe_mode
+      end
+    end
+  end
+end

data/lib/rubocop/yast/config.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require "yaml"
+
+module RuboCop
+  module Yast
+    # patch the Rubocop config - include the plugin defaults
+    module Config
+      DEFAULT = File.expand_path("../../../../config/default.yml", __FILE__)
+
+      def self.load_defaults
+        plugin_config = YAML.load_file(DEFAULT)
+        config = ConfigLoader.merge_with_default(plugin_config, DEFAULT)
+
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/rubocop/yast/niceness.rb

@@ -0,0 +1,60 @@
+require "set"
+
+# Niceness of a node means that it cannot be nil.
+#
+# Note that the module depends on the includer
+# to provide #scope (for #nice_variable)
+module Niceness
+  # Literals are nice, except the nil literal.
+  NICE_LITERAL_NODE_TYPES = [
+    :self,
+    :false, :true,
+    :int, :float,
+    :str, :sym, :regexp,
+    :array, :hash, :pair, :irange, # may contain nils but they are not nil
+    :dstr,                      # "String #{interpolation}" mixes :str, :begin
+    :dsym                       # :"#{foo}"
+  ].to_set
+
+  def nice(node)
+    nice_literal(node) || nice_variable(node) || nice_send(node) ||
+      nice_begin(node)
+  end
+
+  def nice_literal(node)
+    NICE_LITERAL_NODE_TYPES.include? node.type
+  end
+
+  def nice_variable(node)
+    node.type == :lvar && scope[node.children.first].nice
+  end
+
+  # Methods that preserve niceness if all their arguments are nice
+  # These are global, called with a nil receiver
+  NICE_GLOBAL_METHODS = {
+    # message, number of arguments
+    _: 1
+  }.freeze
+
+  NICE_OPERATORS = {
+    # message, number of arguments (other than receiver)
+    :+ => 1
+  }.freeze
+
+  def nice_send(node)
+    return false unless node.type == :send
+    receiver, message, *args = *node
+
+    if receiver.nil?
+      arity = NICE_GLOBAL_METHODS.fetch(message, -1)
+    else
+      return false unless nice(receiver)
+      arity = NICE_OPERATORS.fetch(message, -1)
+    end
+    args.size == arity && args.all? { |a| nice(a) }
+  end
+
+  def nice_begin(node)
+    node.type == :begin && nice(node.children.last)
+  end
+end

data/lib/rubocop/yast/variable_scope.rb

@@ -0,0 +1,62 @@
+# Tracks state for a variable
+class VariableState
+  attr_accessor :nice
+end
+
+# Tracks state for local variables visible at certain point.
+# Keys are symbols, values are VariableState
+class VariableScope < Hash
+  def initialize
+    super do |hash, key|
+      hash[key] = VariableState.new
+    end
+  end
+
+  # Deep copy the VariableState values
+  def dup
+    copy = self.class.new
+    each do |k, v|
+      copy[k] = v.dup
+    end
+    copy
+  end
+
+  # @return [VariableState] state
+  def [](varname)
+    super
+  end
+
+  # Set state for a variable
+  def []=(varname, state)
+    super
+  end
+end
+
+# A stack of VariableScope
+class VariableScopeStack
+  def initialize
+    outer_scope = VariableScope.new
+    @stack = [outer_scope]
+  end
+
+  # The innermost, or current VariableScope
+  def innermost
+    @stack.last
+  end
+
+  # Run *block* using a new clean scope
+  # @return the scope as the block left it, popped from the stack
+  def with_new(&block)
+    @stack.push VariableScope.new
+    block.call
+    @stack.pop
+  end
+
+  # Run *block* using a copy of the innermost scope
+  # @return the scope as the block left it, popped from the stack
+  def with_copy(&block)
+    @stack.push innermost.dup
+    block.call
+    @stack.pop
+  end
+end

data/lib/rubocop/yast/version.rb

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

data/rubocop-yast.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
   spec.files = Dir[
-    "{lib,spec}/**/*",
+    "{config,lib,spec}/**/*",
     "*.md",
     "*.gemspec",
     "Gemfile",
@@ -28,7 +28,8 @@ Gem::Specification.new do |spec|
   spec.test_files = spec.files.grep(/^spec\//)
   spec.extra_rdoc_files = ["LICENSE", "README.md"]
 
-  spec.add_development_dependency("rubocop", "~> 0.27")
+  spec.add_runtime_dependency("rubocop", "~> 0.27")
+
   spec.add_development_dependency("rake")
   spec.add_development_dependency("rspec", "~> 3.1.0")
   spec.add_development_dependency("simplecov")

data/spec/builtins_spec.rb

@@ -6,7 +6,7 @@ def expect_y2milestone_offense(cop)
   expect(cop.offenses.size).to eq(1)
   expect(cop.offenses.first.line).to eq(1)
   expect(cop.messages).to eq(["Builtin call `y2milestone` is obsolete, " \
-    "use native Ruby function instead."])
+        "use native Ruby function instead."])
 end
 
 describe RuboCop::Cop::Yast::Builtins do
@@ -48,4 +48,18 @@ describe RuboCop::Cop::Yast::Builtins do
     expect(cop.offenses).to be_empty
   end
 
+  it "auto-corrects Builtins.time with ::Time.now.to_i" do
+    new_source = autocorrect_source(cop, "Builtins.time")
+    expect(new_source).to eq("::Time.now.to_i")
+  end
+
+  it 'auto-corrects Builtins.getenv("foo") with ENV["foo"]' do
+    new_source = autocorrect_source(cop, 'Builtins.getenv("foo")')
+    expect(new_source).to eq('ENV["foo"]')
+  end
+
+  it "auto-corrects Builtins.getenv(foo) with ENV[foo]" do
+    new_source = autocorrect_source(cop, "Builtins.getenv(foo)")
+    expect(new_source).to eq("ENV[foo]")
+  end
 end

data/spec/ops_spec.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+def config(safe_mode: true)
+  conf = { "Yast/Ops" => { "SafeMode" => safe_mode } }
+  RuboCop::Config.new(conf)
+end
+
+describe RuboCop::Cop::Yast::Ops do
+  context("In safe mode") do
+    subject(:cop) { described_class.new(config(safe_mode: true)) }
+
+    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
+    subject(:cop) { described_class.new(config(safe_mode: false)) }
+
+    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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-yast
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Ladislav Slezák
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-02 00:00:00.000000000 Z
+date: 2014-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -17,7 +17,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.27'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -81,11 +81,17 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- config/default.yml
 - lib/rubocop-yast.rb
 - lib/rubocop/cop/yast/builtins.rb
+- lib/rubocop/cop/yast/ops.rb
+- lib/rubocop/yast/config.rb
+- lib/rubocop/yast/niceness.rb
+- 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:
@@ -113,4 +119,5 @@ specification_version: 4
 summary: Specific YaST Rubocop checks
 test_files:
 - spec/builtins_spec.rb
+- spec/ops_spec.rb
 - spec/spec_helper.rb