zombie-killer 0.4 → 0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e180c7784f993ba500fad7e16198be9e6478ba85d7c6817e701fa7b2ba85e7e
-  data.tar.gz: cabad90fad0492478d2ded00b62b1d45435cbc5750fcc1010a36483bac314710
+  metadata.gz: b796ce723f6b571b0e16446ca9c2edce61ed9f92c4a71d4f095f9f87de8175b5
+  data.tar.gz: e4e254e3a0b2f958e29a66e22a71ed4a87e13f7be1deb1becfc434dfff9a4134
 SHA512:
-  metadata.gz: c27fc0f8f743e91a93dc3c0edd041538c5933015f0c30ede75e537267e3baadce783c8e3d2491f063dad3b1c9d782e8045851e5371344b15e52e3bb4ef6b41d5
-  data.tar.gz: 61a29a2baee22c6190718405e436cc7889c3315cfcb1831864091ead8ae5d551637cc783a42b649167e7f314b926389e559aa00a1490a11f772a5d8715e222bf
+  metadata.gz: 4290278f9a662ba0ac56781e0fdfe7f783d2632d9db446a0deb9ef69f5901f7491f8850459155c4bd18f5ab9ed89703c662dcec268be35442351f535cb8d1b70
+  data.tar.gz: c3236fc0b1553aea76e960d49ec84f41f2fcdc91a284a728633836484e31c3475e9825d5e13dbe6921f426e09cf517099e78452ee44cf96255cac6c4ffd19e7b

data/NEWS.md

@@ -2,6 +2,32 @@
 
 ## unreleased
 
+## 0.5, 2018-11-08
+
+- zk: find all *.rb files in subdirectories if an argument is a directory
+- Eager mode replacements:
+    ```rb
+    Builtins.size(foo)
+    if Builtins.size(bar) == 0 || Builtins.size(qux) > 0
+      Builtins.sformat("... %1 ...", val)
+    end
+
+    a = a + foo
+    @b = @b * bar
+    @@c = @@c - qux
+    ```
+    becomes
+    ```rb
+    foo.size
+    if bar.empty? || !qux.empty?
+      "... #{val} ..."
+    end
+
+    a += foo
+    @b *= bar
+    @@c -= baz
+    ```
+
 ## 0.4, 2018-11-02
 
 - Added zk -e, EagerRewriter (don't care about niceness, replace all)

data/bin/count_method_calls

@@ -1,4 +1,6 @@
 #! /usr/bin/env ruby
+# frozen_string_literal: true
+
 usage = <<'EOT'
 Usage:
   count_method_calls PATTERN RUBY_FILE
@@ -13,6 +15,7 @@ EOT
 require "parser"
 require "parser/current"
 
+# Count occurrences of particular methods
 class MethodCounter < Parser::AST::Processor
   def initialize(pattern)
     @pattern = pattern
@@ -29,11 +32,11 @@ class MethodCounter < Parser::AST::Processor
   def on_send(node)
     super
     receiver, message = *node
-    if receiver.nil?
-      method = message.to_s
-    else
-      method = "#{const_to_s(receiver)}.#{message}"
-    end
+    method = if receiver.nil?
+               message.to_s
+             else
+               "#{const_to_s(receiver)}.#{message}"
+             end
     # extglob: {brace,alternatives}
     @count += 1 if File.fnmatch(@pattern, method, File::FNM_EXTGLOB)
   end
@@ -49,7 +52,7 @@ class MethodCounter < Parser::AST::Processor
         "#{const_to_s(parent)}.#{name}"
       end
     else
-      "%"                      # a non-identifier placeholder for "expression"
+      "%" # a non-identifier placeholder for "expression"
     end
   end
 end

data/bin/zk

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "docopt"
 
@@ -25,8 +26,10 @@ begin
   killer = ZombieKiller.new(eager: options["--eager"])
 
   files = options["FILES"]
-  files << "**/*.rb" if files.empty?
+  files << "." if files.empty?
   files = files.flat_map do |pattern|
+    pattern += "/**/*.rb" if File.directory?(pattern)
+
     if pattern.include? "*"
       Dir[pattern]
     else

data/lib/zombie_killer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "zombie_killer/killer"
 require_relative "zombie_killer/node_type_counter"
 require_relative "zombie_killer/rewriter"

data/lib/zombie_killer/code_histogram.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# Keep track of the count of occurences of things (in code)
 class CodeHistogram
   attr_reader :counts
 
@@ -32,7 +35,7 @@ class CodeHistogram
   end
 
   def merge!(other)
-    counts.merge!(other.counts) do |key, count, other_count|
+    counts.merge!(other.counts) do |_key, count, other_count|
       count + other_count
     end
   end
@@ -42,7 +45,7 @@ class CodeHistogram
   def invert_hash_preserving_duplicates(h)
     ih = {}
     h.each do |k, v|
-      ih[v] = [] unless ih.has_key?(v)
+      ih[v] = [] unless ih.key?(v)
       ih[v] << k
     end
     ih

data/lib/zombie_killer/eager_rewriter.rb

@@ -1,9 +1,52 @@
+# frozen_string_literal: true
+
 require "unparser"
 require "set"
 
+require "zombie_killer/rule"
+
 # Rewrite Zombies with their idiomatic replacements
 class EagerRewriter < Parser::TreeRewriter
-  OPS = Parser::AST::Node.new(:const, [nil, :Ops])
+  def self.s(name, *children)
+    Parser::AST::Node.new(name, children)
+  end
+
+  def s(name, *children)
+    self.class.s(name, *children)
+  end
+
+  OPS = s(:const, nil, :Ops)
+  BUILTINS = s(:const, nil, :Builtins)
+  Arg = Rule::Arg
+
+  @rules = {}
+  class << self
+    attr_reader :rules
+  end
+
+  def self.r(**kwargs)
+    rule = Rule.new(**kwargs)
+    type = rule.from.type
+    @rules[type] ||= []
+    @rules[type] << rule
+  end
+
+  [
+    [:lvasgn, :lvar],           # a = b
+    [:ivasgn, :ivar],           # @a = @b
+    [:cvasgn, :cvar],           # @@a = @@b
+  ].each do |xvasgn, xvar|
+    [:+, :-, :*].each do |asop|
+      r from: s(xvasgn,
+                Arg,
+                s(:send, s(xvar, Arg), asop, Arg)), # @ARG1 = @ARG2 + ARG3
+        to:   ->(a, b, c) do # rubocop:disable Style/Lambda
+          if a == b
+            s(:op_asgn, s(xvasgn, a), asop, c) # @ARG1 += ARG3
+          end
+        end
+    end
+  end
 
   INFIX = {
     add: :+,
@@ -21,36 +64,76 @@ class EagerRewriter < Parser::TreeRewriter
     greater_or_equal: :>=
   }.freeze
 
-  def s(name, *children)
-    Parser::AST::Node.new(name, children)
+  INFIX.each do |prefix, infix|
+    r from: s(:send, OPS, prefix, Arg, Arg),   # Ops.add(Arg, ARG2)
+      to:   ->(a, b) { s(:send, a, infix, b) } # Arg + ARG2
   end
 
-  def replace_node(old_node, new_node)
-    source_range = old_node.loc.expression
-    replace(source_range, Unparser.unparse(new_node))
+  r from: s(:send, BUILTINS, :size, Arg), # Builtins.size(Arg)
+    to:   ->(a) { s(:send, a, :size) }    # Arg.size
+
+  r from: s(:send, s(:send, Arg, :size), :>, s(:int, 0)), # Arg.size > 0
+    to:   ->(a) { s(:send, s(:send, a, :empty?), :!) } # !Arg.empty?
+
+  r from: s(:send, s(:send, Arg, :size), :!=, s(:int, 0)), # Arg.size != 0
+    to:   ->(a) { s(:send, s(:send, a, :empty?), :!) } # !Arg.empty?
+
+  r from: s(:send, s(:send, Arg, :size), :==, s(:int, 0)), # Arg.size == 0
+    to:   ->(a) { s(:send, a, :empty?) } # Arg.empty?
+
+  r from: s(:send, s(:send, Arg, :size), :<=, s(:int, 0)), # Arg.size <= 0
+    to:   ->(a) { s(:send, a, :empty?) } # Arg.empty?
+
+  r from: s(:send, s(:send, Arg, :size), :<, s(:int, 1)), # Arg.size < 1
+    to:   ->(a) { s(:send, a, :empty?) } # Arg.empty?
+
+  def self.sformat_replacement1(format_literal, value)
+    verbatims = format_literal.split("%1", -1)
+    return nil unless verbatims.size == 2
+    s(:dstr, s(:str, verbatims[0]), value, s(:str, verbatims[1]))
   end
 
-  def on_send(node)
-    super
-    receiver, name, *args = *node
-    replacement = INFIX[name]
-    if receiver == OPS && replacement && args.size == 2
-      replace_node(node, s(:send, args[0], replacement, args[1]))
-    end
+  r from: s(:send, BUILTINS, :sformat, s(:str, Arg), Arg), # Builtins.sformat("...", val)
+    to:   ->(fmt, val) { sformat_replacement1(fmt, val) }
+
+  # Does not improve readability much, fails on nil. Use foo&.each ?
+  # r from: s(:send, BUILTINS, :foreach, Arg),
+  #   to:   ->(a) { s(:send, a, :each) }
+
+  def unparser_sanitize(code_s)
+    # unparser converts "foo#{bar}baz"
+    # into "#{"foo"}#{bar}#{"baz"}"
+    # so this undoes the escaping of the litetrals
+    code_s.gsub(/
+                  \#
+                  \{"
+                  (
+                  [^"#]*
+                  )
+                  "\}
+                /x,
+                '\1')
   end
 
-  AS_OPS = Set.new [:+, :-]
-  def on_lvasgn(node)
-    super
-    vname1, value = *node
-    return unless value && value.type == :send
-    receiver, oname, *args = *value
-    if vname1 == lvar_vname2(receiver) && AS_OPS.include?(oname)
-      replace_node(node, s(:op_asgn, s(:lvasgn, vname1), oname, args[0]))
-    end
+  def replace_node(old_node, new_node)
+    # puts "OLD #{old_node.inspect}"
+    # puts "NEW #{new_node.inspect}"
+    source_range = old_node.loc.expression
+    unp = Unparser.unparse(new_node)
+    unp = unparser_sanitize(unp)
+    # puts "UNP #{unp.inspect}"
+    replace(source_range, unp)
+    new_node
   end
 
-  def lvar_vname2(receiver)
-    receiver.children.first if receiver && receiver.type == :lvar
+  def process(node)
+    node = super(node)
+    return if node.nil?
+    trules = self.class.rules.fetch(node.type, [])
+    trules.find do |r|
+      replacement = r.match(node)
+      node = replace_node(node, replacement) if replacement
+    end
+    node
   end
 end

data/lib/zombie_killer/killer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parser"
 require "parser/current"
 
@@ -46,7 +48,7 @@ class ZombieKiller
   private
 
   def fixed_point(x, &lambda_x)
-    while true
+    loop do
       y = lambda_x.call(x)
       return y if y == x
       x = y

data/lib/zombie_killer/niceness.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "set"
 
 # Niceness of a node means that it cannot be nil.
@@ -33,12 +35,12 @@ module Niceness
   # These are global, called with a nil receiver
   NICE_GLOBAL_METHODS = {
     # message, number of arguments
-    :_ => 1,
+    _: 1
   }.freeze
 
   NICE_OPERATORS = {
     # message, number of arguments (other than receiver)
-    :+ => 1,
+    :+ => 1
   }.freeze
 
   def nice_send(node)
@@ -51,7 +53,7 @@ module Niceness
       return false unless nice(receiver)
       arity = NICE_OPERATORS.fetch(message, -1)
     end
-    return args.size == arity && args.all?{ |a| nice(a) }
+    args.size == arity && args.all? { |a| nice(a) }
   end
 
   def nice_begin(node)

data/lib/zombie_killer/node_type_counter.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "parser"
 
 require_relative "code_histogram"
 
+# Count node types (:send, :lvar etc)
 class NodeTypeCounter < Parser::Rewriter
   attr_reader :node_types
 
@@ -20,7 +23,7 @@ class NodeTypeCounter < Parser::Rewriter
     parser = Parser::CurrentRuby.new
     buffer = Parser::Source::Buffer.new(@filename)
     buffer.read
-    ast    = parser.parse(buffer)
+    ast = parser.parse(buffer)
 
     process(ast)
 

data/lib/zombie_killer/rewriter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "parser"
 require "parser/current"
 require "set"
@@ -175,10 +177,10 @@ class ZombieKillerRewriter < Parser::Rewriter
   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.
+  # 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)
@@ -222,7 +224,7 @@ class ZombieKillerRewriter < Parser::Rewriter
 
   def on_send(node)
     super
-    if is_call(node, :Ops, :add)
+    if call?(node, :Ops, :add)
       new_op = :+
 
       _ops, _add, a, b = *node
@@ -232,13 +234,13 @@ class ZombieKillerRewriter < Parser::Rewriter
     end
   end
 
-  def on_block(node)
+  def on_block(_node)
     # ignore body, clean slate
     scope.clear
   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
 
@@ -279,33 +281,32 @@ class ZombieKillerRewriter < Parser::Rewriter
     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
   end
 
-  def on_retry(node)
+  def on_retry(_node)
     # that makes the :rescue a loop, top-down data-flow fails
     raise TooComplexToTranslateError
   end
 
   private
 
-  def is_call(node, namespace, message)
+  def call?(node, namespace, message)
     n_receiver, n_message = *node
     n_receiver && n_receiver.type == :const &&
-      n_receiver.children[0] == nil &&
+      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
+    return if contains_comment?(source_range.source)
+    replace(source_range, Unparser.unparse(new_node))
   end
 
   def contains_comment?(string)

data/lib/zombie_killer/rule.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class ARG; end
+class ARG1 < ARG; end
+class ARG2 < ARG; end
+class ARG3 < ARG; end
+
+# Rewriting rule
+class Rule
+  Placeholder = Struct.new(:name) do
+    def inspect
+      name
+    end
+  end
+  Arg = Placeholder.new("Arg")
+  Arg1 = Placeholder.new("Arg1")
+
+  # @return [AST::Node]
+  attr_reader :from
+  # @return [Proc]
+  attr_reader :to
+
+  def initialize(from:, to:)
+    @from = from
+    @to = to
+  end
+
+  def match(node)
+    captures = match2(from, node)
+    return unless captures
+    if to.respond_to? :call
+      to.call(*captures)
+    else
+      to
+    end
+  end
+
+  # @return an array of captured values or nil
+  def match2(expected, actual)
+    # puts "M2 #{expected.inspect} #{actual.inspect}"
+    # p expected.class
+    # p actual.class
+    return [] if expected.nil? && actual.nil?
+    return nil if expected.nil? || actual.nil?
+
+    # if we're a node
+    case expected
+    when AST::Node
+      return nil if expected.type != actual.type
+      return nil if expected.children.size != actual.children.size
+
+      results = expected.children.zip(actual.children).map do |ec, ac|
+        match2(ec, ac)
+      end
+      # puts "#{results.inspect} for #{expected.inspect}"
+      results.flatten(1) if results.all?
+    when Rule::Arg
+      # puts "ARG #{actual.inspect}"
+      [actual]
+    else
+      expected == actual ? [] : nil
+    end
+  end
+end

data/lib/zombie_killer/variable_scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Tracks state for a variable
 class VariableState
   attr_accessor :nice

data/lib/zombie_killer/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ZombieKiller
-  VERSION = "0.4".freeze
+  VERSION = "0.5"
 end

data/spec/rspec_renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "redcarpet"
 
 require_relative "../lib/zombie_killer"
@@ -46,9 +48,7 @@ class Describe
   def render
     parts = []
     parts << "describe #{@description.inspect} do"
-    if !blocks.empty?
-      parts << Code.indent(@blocks.map(&:render).join("\n\n"))
-    end
+    parts << Code.indent(@blocks.map(&:render).join("\n\n")) unless blocks.empty?
     parts << "end"
     parts.join("\n")
   end
@@ -79,7 +79,7 @@ class RSpecRenderer < Redcarpet::Render::Base
 
   def paragraph(text)
     if text =~ /^\*\*(.*)\*\*$/
-      @next_block_type = $1.downcase.to_sym
+      @next_block_type = Regexp.last_match(1).downcase.to_sym
     else
       first_sentence = text.split(/\.(\s+|$)/).first
       @description = first_sentence.sub(/^Zombie Killer /, "").sub(/\n/, " ")
@@ -88,16 +88,16 @@ class RSpecRenderer < Redcarpet::Render::Base
     nil
   end
 
-  def block_code(code, language)
+  def block_code(code, _language)
     case @next_block_type
-      when :original
-        @original_code = code[0..-2]
-      when :translated
-        @translated_code = code[0..-2]
-      when :unchanged
-        @original_code = @translated_code = code[0..-2]
-      else
-        raise "Invalid next code block type: #@next_block_type.\n#{code}"
+    when :original
+      @original_code = code[0..-2]
+    when :translated
+      @translated_code = code[0..-2]
+    when :unchanged
+      @original_code = @translated_code = code[0..-2]
+    else
+      raise "Invalid next code block type: #{@next_block_type}.\n#{code}"
     end
     @next_block_type = :unknown
 
@@ -117,11 +117,11 @@ class RSpecRenderer < Redcarpet::Render::Base
 
   def doc_header
     Code.join([
-      "# Generated from spec/zombie_killer_spec.md -- do not change!",
-      "",
-      "require \"spec_helper\"",
-      "",
-    ])
+                "# Generated from spec/zombie_killer_spec.md -- do not change!",
+                "",
+                "require \"spec_helper\"",
+                ""
+              ])
   end
 
   def doc_footer
@@ -142,9 +142,7 @@ class RSpecRenderer < Redcarpet::Render::Base
 
   def current_describe
     describe = @describe
-    while describe.blocks.last.is_a?(Describe)
-      describe = describe.blocks.last
-    end
+    describe = describe.blocks.last while describe.blocks.last.is_a?(Describe)
     describe
   end
 

data/spec/rule_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "zombie_killer/rule"
+
+describe Rule do
+  include AST::Sexp # the `s` method
+  extend AST::Sexp
+
+  BUILTINS = s(:const, nil, :Builtins)
+
+  context "a simple const rule" do
+    let(:rule) do
+      Rule.new(
+        from: s(:const, nil, :Round),
+        to:   s(:lvar, :square)
+      )
+    end
+
+    describe "#match" do
+      it "matches what it should" do
+        node = s(:const, nil, :Round)
+        expect(!!rule.match(node)).to eq(true)
+      end
+
+      it "does not match nil" do
+        expect(!!rule.match(nil)).to eq(false)
+      end
+
+      it "does not match a different const" do
+        node = s(:const, nil, :Square)
+        expect(!!rule.match(node)).to eq(false)
+      end
+
+      it "does not match a differently namespaced const" do
+        node = s(:const, s(:const, nil, :Square), :Round)
+        expect(!!rule.match(node)).to eq(false)
+      end
+    end
+  end
+
+  context "a capturing rule" do
+    let(:rule) do
+      Rule.new(
+        from: s(:send, BUILTINS, :size, Rule::Arg), # Builtins.size(ARG1)
+        to:   ->(a) { s(:send, a, :size) }          # ARG1.size
+      )
+    end
+    let(:node) { s(:send, BUILTINS, :size, s(:send, nil, :foo)) }
+
+    describe "#match2" do
+      it "returns the captured node" do
+        expect(rule.match2(rule.from, node)).to eq([s(:send, nil, :foo)])
+      end
+    end
+
+    describe "#match" do
+      it "returns the replacement" do
+        expect(rule.match(node)).to eq(s(:send, s(:send, nil, :foo), :size))
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if ENV["COVERAGE"]
   require "simplecov"
   SimpleCov.start

data/spec/zombie_killer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Generated from spec/zombie_killer_spec.md -- do not change!
 
 require "spec_helper"
@@ -86,7 +88,7 @@ describe "ZombieKiller:" do
       expect(ZombieKiller.new.kill(original_code)).to eq(translated_code)
     end
 
-    it "doesn't translate `Ops.add(nice_variable, literal)` when the variable got it's niceness via multiple assignemnt" do
+    it "doesn't translate `Ops.add(nice_variable, literal)` when the variable got it's niceness via multiple assignment" do
       original_code = cleanup(<<-EOT)
         v1, v2 = "Hello", "World"
         Ops.add(v1, v2)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zombie-killer
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
 platform: ruby
 authors:
 - Martin Vidner
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-02 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docopt
@@ -127,6 +127,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.41.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.41.2
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -163,13 +177,15 @@ files:
 - lib/zombie_killer/niceness.rb
 - lib/zombie_killer/node_type_counter.rb
 - lib/zombie_killer/rewriter.rb
+- lib/zombie_killer/rule.rb
 - lib/zombie_killer/variable_scope.rb
 - lib/zombie_killer/version.rb
 - spec/rspec_renderer.rb
+- spec/rule_spec.rb
 - spec/spec_helper.rb
 - spec/zombie_killer_spec.md
 - spec/zombie_killer_spec.rb
-homepage: http://github.org/yast/zombie-killer
+homepage: https://github.com/yast/zombie-killer
 licenses:
 - MIT
 metadata: {}