rubocop-yast 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c16c03c56b76dc2b1b8896fda2f2d5765d686c41
-  data.tar.gz: 695426ba9cb0fd0ff1d273d337c3947f8a785b80
+  metadata.gz: 8f14f2792588ff28f55867a356603deeeafe6deb
+  data.tar.gz: 03433493409f9d50a333391b4e05c8782a525064
 SHA512:
-  metadata.gz: 5d69f1ac5711c04993f135091ea1ea1d6ac4159c579a45afe7d3c783f6650416af0aef1b4819ec0a0033dfc140fd1ad54f4e994332ef389905096fad1de8ca94
-  data.tar.gz: 5bd8f3cd68cdbd225c148eec3082914ff9c4345926bf14b0819f9d61b39a857277e0be03deebffb2192ee6a3a520d051935a65ea7695c28f13dbd0adc6478d2b
+  metadata.gz: 3fed38028da0bd94e103e5a5091e1723857c3c5b1995216fa175f8dc6fadaefc81f77f6182abf80a6cbe7c5e7b41fda716f44150ce6a4dc3aa2a599b7cec01f6
+  data.tar.gz: 32e08248270ec322da28aabf4ff9fa27fc8be17729b3b64d92336106e92cf946a65d3462c4634cca7467ace025eba6ffe41b593aff467af02d09f38c16bd3d8c

data/Gemfile

@@ -6,4 +6,5 @@ gemspec
 
 group :test do
   gem "coveralls", require: false if ENV["TRAVIS"]
+  gem "byebug", require: false if ENV["DEBUGGER"]
 end

data/README.md

@@ -9,3 +9,125 @@ rubocop-yast
 [![Inline docs](http://inch-ci.org/github/lslezak/rubocop-yast.svg?branch=master)](http://inch-ci.org/github/lslezak/rubocop-yast)
 
 
+This is a plugin for [RuboCop](https://github.com/bbatsov/rubocop)
+a Ruby static code analyzer. It was inspired by [Rubocop-Rspec](https://github.com/nevir/rubocop-rspec)
+and [YCP Zombie Killer](https://github.com/yast/zombie-killer).
+
+The goal is to create a Rubocop plugin which can check for
+[YaST](http://yast.github.io/) specific issues. Optionally it should allow to
+covert some ugly code parts introduced by the automatic code conversion done by
+[YCP Killer](https://github.com/yast/ycp-killer) (conversion from YCP to Ruby).
+
+Check [the test descriptions](spec/builtins_spec.md) to see the examples of offense
+detection and code conversion.
+
+*The plugin is currently in early development, always manually check the chages
+done by the plugin! It can eat your code... ;-)*
+
+
+Installation
+------------
+
+The plugin is published at [rubygems.org](https://rubygems.org/gems/rubocop-yast),
+you can install it using the `gem` command:
+
+```shell
+sudo gem install rubocop-yast
+```
+
+Usage
+-----
+
+You need to manually load the Yast plugin into RuboCop to run the extra checks.
+There are two options:
+
+- Use `--require rubocop-yast` command line option when invoking `rubocop`
+- Enable the plugin in `.rubocop.yml` file:
+```yaml
+require:
+ - rubocop-yast
+```
+
+See the [RuboCop documentation](https://github.com/bbatsov/rubocop#loading-extensions).
+
+Configuration
+-------------
+
+You can configure Rubocop-Yast the same way as the standard RuboCop checks
+(see the [RuboCop configuration](https://github.com/bbatsov/rubocop#configuration)):
+
+```yaml
+# Check for obsolete Builtins.* calls
+Yast/Builtins:
+  Enabled: true
+
+# Check for obsolete Ops.* calls
+Yast/Ops:
+  Enabled: true
+  # in the safe mode only safe places are reported and fixed
+  SafeMode: true
+```
+
+Development
+-----------
+
+### Prerequisites
+
+For development you need some extra development gems. The best way is to install them with [Bundler](http://bundler.io/). To avoid a possible collision with system gems it is recommended
+to install the gems into a local subdirectory using
+
+```shell
+bundle install --path vendor/bundle
+```
+
+### Source Directories
+
+* [`config/default.yml`](config/default.yml) contains the default Cop configurations
+* [`lib/rubocop/cop/yast`](lib/rubocop/yast) contains Yast Cops (the checks which are called
+  from the main rubocop script)
+* [`lib/rubocop/yast`](lib/rubocop/yast) contains libraries used by the Cops
+* [`spec`](spec) contains tests, some tests are automatically generated from a MarkDown
+  documentation
+
+### Running Tests
+
+```
+bundle exec rake
+```
+ 
+By default the tests check the code coverage, if it is below 95% the test fails although
+there was no test failure.
+ 
+### Autocorrecting Rubocop Issues
+ 
+```
+bundle exec rake rubocop:auto_correct
+```
+ 
+You can also load the plugin itself to verify that plugin loading works correctly.
+(Plugin loading is not covered by tests as it needs the base Rubocop framework.)
+
+```
+bundle exec rubocop -r rubocop-yast
+```
+
+### Building a Gem
+
+```
+bundle exec rake build
+```
+
+This builds `pkg/rubocop-yast-<version>.gem` gem file, it can be installed locally using
+```
+sudo gem install --local pkg/rubocop-yast-<version>.gem
+```
+
+### Publishing the Gem to Rubygems.org
+
+Increase the version in [`lib/rubocop/yast/version.rb`](lib/rubocop/yast/version.rb) file
+and then run:
+
+```
+bundle exec rake release
+```
+

data/Rakefile

@@ -10,8 +10,32 @@ rescue Bundler::BundlerError => e
   exit e.status_code
 end
 
+require "redcarpet"
+require_relative "spec/rspec_renderer"
+
+def render_markdown(renderer_class, task)
+  puts "Rendering file: #{task.name}"
+  markdown = Redcarpet::Markdown.new(renderer_class, fenced_code_blocks: true)
+
+  string = markdown.render(File.read(task.prerequisites[0]))
+  File.write(task.name, string)
+end
+
+renderer = "spec/rspec_renderer.rb"
+
+file "spec/builtins_spec.rb" => ["spec/builtins_spec.md", renderer] do |t|
+  render_markdown(RSpecRenderer, t)
+end
+
+file "spec/builtins_spec.html" => ["spec/builtins_spec.md", renderer] do |t|
+  render_markdown(Redcarpet::Render::HTML, t)
+end
+desc "Render the specification to HTML locally"
+task html: ["spec/builtins_spec.html"]
+
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
+task spec: ["spec/builtins_spec.rb"]
 
 require "rubocop/rake_task"
 RuboCop::RakeTask.new(:rubocop)

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

@@ -1,5 +1,10 @@
 # encoding: utf-8
 
+require "rubocop/yast/builtins/builtin"
+require "rubocop/yast/builtins/getenv"
+require "rubocop/yast/builtins/time"
+require "rubocop/yast/builtins/y2log"
+
 module RuboCop
   module Cop
     module Yast
@@ -7,23 +12,9 @@ module RuboCop
       class Builtins < Cop
         include AST::Sexp
 
-        MSG = "Builtin call `%s` is obsolete, use native Ruby function instead."
+        attr_reader :handlers, :default_handler
 
-        # 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
-        ]
+        MSG = "Builtin call `%s` is obsolete, use native Ruby function instead."
 
         BUILTINS_NODES = [
           # Builtins.*
@@ -34,34 +25,52 @@ module RuboCop
           s(:const, s(:const, s(:cbase), :Yast), :Builtins)
         ]
 
+        def initialize(config = nil, options = nil)
+          super(config, options)
+
+          @handlers = builtin_mapping
+          @default_handler = RuboCop::Yast::Builtins::Builtin.new
+        end
+
         def on_send(node)
           receiver, method_name, *_args = *node
 
+          # not an Yast builtin call or not an offense
           return if !BUILTINS_NODES.include?(receiver) ||
-              ALLOWED_FUNCTIONS.include?(method_name)
+              !builtin_handler(method_name).offense?(node)
 
           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)
+          _builtins, method_name, *_args = *node
 
-            corrector.replace(node.loc.expression, new_code) if new_code
-          end
+          @corrections << builtin_handler(method_name).correction(node)
         end
 
         private
 
-        def builtins_replacement(message, args)
-          case message
-          when :getenv
-            "ENV[#{args.loc.expression.source}]"
-          when :time
-            "::Time.now.to_i"
-          end
+        # rubocop:disable Metrics/MethodLength
+        def builtin_mapping
+          # use the same instance for all logging functions
+          logging = RuboCop::Yast::Builtins::Y2log.new
+
+          {
+            y2debug: logging,
+            y2milestone: logging,
+            y2warning: logging,
+            y2error: logging,
+            y2security: logging,
+            y2internal: logging,
+
+            getenv: RuboCop::Yast::Builtins::Getenv.new,
+            time: RuboCop::Yast::Builtins::Time.new
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def builtin_handler(method)
+          handlers[method] || default_handler
         end
       end
     end

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

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
-require "rubocop/yast/niceness"
-require "rubocop/yast/variable_scope"
+require "rubocop/yast/track_variable_scope"
 
 # We have encountered code that does satisfy our simplifying assumptions,
 # translating it would not be correct.
@@ -14,7 +13,7 @@ module RuboCop
       # This cop checks for Ops.* calls, it can autocorrect safe places or
       # all places in unsafe mode
       class Ops < Cop
-        include Niceness
+        include RuboCop::Yast::TrackVariableScope
 
         # Ops replacement mapping
         REPLACEMENT = {
@@ -26,96 +25,10 @@ module RuboCop
         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)
 
@@ -125,75 +38,8 @@ module RuboCop
           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 &&
@@ -219,7 +65,7 @@ module RuboCop
             "#{arg2.loc.expression.source}"
         end
 
-        attr_reader :scopes, :safe_mode
+        attr_reader :safe_mode
       end
     end
   end