zombie-killer 0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45c9c420e1362bc5ed2354d40b1a7c5951530f50
+  data.tar.gz: 8a2d7b00e756ebc906b73120c139bda02d734912
+SHA512:
+  metadata.gz: 157976c4b7e1cc94cc8c0384b91d69bd5909eefc1ffb15569497e9fef8fff8046a5c326b9a211e703cc4192601d1ea79a977c9c3618a33370bb6ddeba1bf2922
+  data.tar.gz: a8e31e77e9bab7316b6fac67ce1d36eafbdfb301aa60ae56f5239f3f8005e8e44bc501a3681235a62ddb449225b7609c24c867e8227cd9d1de1b617ba0f3f672

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 SUSE LLC
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+Zombie Killer
+=============
+
+In [YaST][y] we have tons of Ruby code which is ugly, because it was
+[translated from a legacy language][yk], striving for bug-compatibility.
+
+Zombie Killer analyzes the code for situations where it is safe
+to replace the ugly variants with nice ones.
+
+See the [runnable specification][spec] for details.
+
+[y]:    https://github.com/yast
+[yk]:   http://mvidner.blogspot.cz/2013/08/yast-in-ruby.html
+[spec]: spec/zombie_killer_spec.md
+
+Installation
+------------
+
+Source: clone the git repository.
+
+Dependencies: run `bundle`.
+(On openSUSE, most dependencies are packaged as rubygem-*.rpm except `unparser`)
+
+Usage
+-----
+
+`zk [FILES...]` works in place, so it is best to use in a Git checkout.
+By default it finds all `*.rb` files under the current directory.

data/bin/zk

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require "docopt"
+
+require_relative "../lib/zombie_killer"
+
+doc = <<-EOT
+Zombie Killer -- tool to kill YCP zombies
+
+Usage: zk [options] [FILES...]
+
+Arguments:
+  FILES  Files to operate on, patterns allowed [default: **/*.rb]
+Options:
+  -u, --unsafe               Translate even constructs not known to be safe.
+  -s, --stats                Also print statistics about node types.
+  -v, --version              Print version information and exit.
+  -h, --help                 Print help and exit.
+EOT
+
+begin
+  options = Docopt.docopt(doc, help: true, version: ZombieKiller::VERSION)
+
+  killer = ZombieKiller.new
+
+  files = options["FILES"]
+  files << "**/*.rb" if files.empty?
+  files = files.flat_map do |pattern|
+    if pattern.include? "*"
+      Dir[pattern]
+    else
+      pattern
+    end
+  end
+  files.each do |file|
+    killer.kill_file(file, file, unsafe: options["--unsafe"])
+
+    if options["--stats"]
+      counter = NodeTypeCounter.new(file)
+      counter.print($stderr)
+    end
+  end
+rescue Docopt::Exit => e
+  abort e.message
+end

data/lib/zombie_killer.rb

@@ -0,0 +1,4 @@
+require_relative "zombie_killer/killer"
+require_relative "zombie_killer/node_type_counter"
+require_relative "zombie_killer/rewriter"
+require_relative "zombie_killer/version"

data/lib/zombie_killer/code_histogram.rb

@@ -0,0 +1,50 @@
+class CodeHistogram
+  attr_reader :counts
+
+  def initialize
+    @counts = Hash.new do |hash, key|
+      hash[key] = 0
+    end
+  end
+
+  def increment(key, value = 1)
+    @counts[key] += value
+  end
+
+  def print_by_frequency(io)
+    count_to_methods = invert_hash_preserving_duplicates(@counts)
+
+    count_to_methods.keys.sort.each do |c|
+      count_to_methods[c].sort.each do |method|
+        io.printf("%4d %s\n", c, method)
+      end
+    end
+  end
+
+  def self.parse_by_frequency(lines)
+    histogram = CodeHistogram.new
+    lines.each do |line|
+      /^\s*(\d*)\s*(.*)/.match(line.chomp) do |m|
+        histogram.increment(m[2], m[1].to_i)
+      end
+    end
+    histogram
+  end
+
+  def merge!(other)
+    counts.merge!(other.counts) do |key, count, other_count|
+      count + other_count
+    end
+  end
+
+  private
+
+  def invert_hash_preserving_duplicates(h)
+    ih = {}
+    h.each do |k, v|
+      ih[v] = [] unless ih.has_key?(v)
+      ih[v] << k
+    end
+    ih
+  end
+end

data/lib/zombie_killer/killer.rb

@@ -0,0 +1,35 @@
+require "parser"
+require "parser/current"
+
+require_relative "rewriter"
+
+class ZombieKiller
+  # @returns new string
+  def kill_string(code, filename = "(inline code)", unsafe: false)
+    fixed_point(code) do |c|
+      parser   = Parser::CurrentRuby.new
+      rewriter = ZombieKillerRewriter.new(unsafe: unsafe)
+      buffer   = Parser::Source::Buffer.new(filename)
+      buffer.source = c
+      rewriter.rewrite(buffer, parser.parse(buffer))
+    end
+  end
+  alias_method :kill, :kill_string
+
+  # @param new_filename may be the same as *filename*
+  def kill_file(filename, new_filename, unsafe: false)
+    new_string = kill_string(File.read(filename), filename, unsafe: unsafe)
+
+    File.write(new_filename, new_string)
+  end
+
+  private
+
+  def fixed_point(x, &lambda_x)
+    while true
+      y = lambda_x.call(x)
+      return y if y == x
+      x = y
+    end
+  end
+end

data/lib/zombie_killer/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
+    return args.size == arity && args.all?{ |a| nice(a) }
+  end
+
+  def nice_begin(node)
+    node.type == :begin && nice(node.children.last)
+  end
+end

data/lib/zombie_killer/node_type_counter.rb

@@ -0,0 +1,29 @@
+require "parser"
+
+require_relative "code_histogram"
+
+class NodeTypeCounter < Parser::Rewriter
+  attr_reader :node_types
+
+  def initialize(filename)
+    @node_types = CodeHistogram.new
+    @filename = filename
+  end
+
+  def process(node)
+    return if node.nil?
+    @node_types.increment(node.type)
+    super
+  end
+
+  def print(io)
+    parser = Parser::CurrentRuby.new
+    buffer = Parser::Source::Buffer.new(@filename)
+    buffer.read
+    ast    = parser.parse(buffer)
+
+    process(ast)
+
+    @node_types.print_by_frequency(io)
+  end
+end

data/lib/zombie_killer/rewriter.rb

@@ -0,0 +1,303 @@
+require "parser"
+require "parser/current"
+require "set"
+require "unparser"
+
+require_relative "niceness"
+require_relative "variable_scope"
+
+# We have encountered code that does satisfy our simplifying assumptions,
+# translating it would not be correct.
+class TooComplexToTranslateError < Exception
+end
+
+class ZombieKillerRewriter < Parser::Rewriter
+  include Niceness
+
+  attr_reader :scopes
+
+  def initialize(unsafe: false)
+    @scopes = VariableScopeStack.new
+    @unsafe = unsafe
+  end
+
+  def warning(message)
+    $stderr.puts message if $VERBOSE
+  end
+
+  def rewrite(buffer, ast)
+    super
+  rescue TooComplexToTranslateError
+    warning "(outer scope) is too complex to translate"
+    buffer.source
+  end
+
+  # FIXME
+  # How can we ensure that code modifications do not make some unhandled again?
+  HANDLED_NODE_TYPES = [
+    :alias,                     # Method alias
+    :and,                       # &&
+    :and_asgn,                  # &&=
+    :arg,                       # One argument
+    :args,                      # All arguments
+    :back_ref,                  # Regexp backreference, $`; $&; $'
+    :begin,                     # A simple sequence
+    :block,                     # A closure, not just any scope
+    :block_pass,                # Pass &foo as an arg which is a block, &:foo
+    :blockarg,                  # An argument initialized with a block def m(&b)
+    :break,                     # Break statement
+    :case,                      # Case statement
+    :casgn,                     # Constant assignment/definition
+    :cbase,                     # Base/root of constant tree, ::Foo
+    :class,                     # Class body
+    :cvar,                      # Class @@variable
+    :cvasgn,                    # Class @@variable = assignment
+    :const,                     # Name of a class/module or name of a value
+    :def,                       # Method definition
+    :defined?,                  # defined? statement
+    :defs,                      # Method definition on self
+    :ensure,                    # Exception ensuring
+    :for,                       # For v in enum;
+    :gvar,                      # Global $variable
+    :gvasgn,                    # Global $variable = assignment
+    :if,                        # If and Unless
+    :ivar,                      # Instance variable value
+    :ivasgn,                    # Instance variable assignment
+    :kwbegin,                   # A variant of begin; for rescue and while_post
+    :kwoptarg,                  # Keyword optional argument, def m(a: 1)
+    :lvar,                      # Local variable value
+    :lvasgn,                    # Local variable assignment
+    :masgn,                     # Multiple assigment: a, b = c, d
+    :mlhs,                      # Left-hand side of a multiple assigment: a, b = c, d
+    :module,                    # Module body
+    :next,                      # Next statement
+    :nil,                       # nil literal
+    :nth_ref,                   # Regexp back references: $1, $2...
+    :op_asgn,                   # a %= b where % is any operator except || &&
+    :optarg,                    # Optional argument
+    :or,                        # ||
+    :or_asgn,                   # ||=
+    :postexe,                   # END { }
+    :regopt,                    # options tacked on a :regexp
+    :resbody,                   # One rescue clause in a :rescue construct
+    :rescue,                    # Groups the begin and :resbody
+    :restarg,                   # Rest of arguments, (..., *args)
+    :retry,                     # Retry a begin-rescue block
+    :return,                    # Method return
+    :sclass,                    # Singleton class, class << foo
+    :send,                      # Send a message AKA Call a method
+    :splat,                     # Array *splatting
+    :super,                     # Call the ancestor method
+    :unless,                    # Unless AKA If-Not
+    :until,                     # Until AKA While-Not
+    :until_post,                # Until with post-condtion
+    :when,                      # When branch of an Case statement
+    :while,                     # While loop
+    :while_post,                # While loop with post-condition
+    :xstr,                      # Executed `string`, backticks
+    :yield,                     # Call the unnamed block
+    :zsuper                     # Zero argument :super
+  ].to_set + NICE_LITERAL_NODE_TYPES
+
+  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
+    super
+  end
+
+  # currently visible scope
+  def scope
+    scopes.innermost
+  end
+
+  def with_new_scope_rescuing_oops(&block)
+    scopes.with_new do
+      block.call
+    end
+  rescue => e
+    oops(node, e)
+  end
+
+  def on_def(node)
+    with_new_scope_rescuing_oops { super }
+  end
+
+  def on_defs(node)
+    with_new_scope_rescuing_oops { super }
+  end
+
+  def on_module(node)
+    with_new_scope_rescuing_oops { super }
+  end
+
+  def on_class(node)
+    with_new_scope_rescuing_oops { super }
+  end
+
+  def on_sclass(node)
+    with_new_scope_rescuing_oops { 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
+  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)
+    super
+    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)
+    super
+    var, value = * node
+    return if var.type != :lvasgn
+    name = var.children[0]
+
+    scope[name].nice &&= nice(value)
+  end
+
+  def on_or_asgn(node)
+    super
+    var, value = * node
+    return if var.type != :lvasgn
+    name = var.children[0]
+
+    scope[name].nice ||= nice(value)
+  end
+
+  def on_send(node)
+    super
+    if is_call(node, :Ops, :add)
+      new_op = :+
+
+      _ops, _add, a, b = *node
+      if nice(a) && nice(b)
+        replace_node node, Parser::AST::Node.new(:send, [a, new_op, b])
+      end
+    end
+  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
+
+    @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
+
+  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
+    super
+  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
+    raise TooComplexToTranslateError
+  end
+
+  private
+
+  def oops(node, exception)
+    puts "Node exception @ #{node.loc.expression}"
+    puts "Offending node: #{node.inspect}"
+    raise exception
+  end
+
+  def is_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 replace_node(old_node, new_node)
+    source_range = old_node.loc.expression
+    if !contains_comment?(source_range.source)
+      replace(source_range, Unparser.unparse(new_node))
+    end
+  end
+
+  def contains_comment?(string)
+    /^[^'"\n]*#/.match(string)
+  end
+end