rephrase 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35b9da1b746b755618ad23cc57fa70559f35064277b61965278544333d678f1d
+  data.tar.gz: 0467c2c8bc54226c445ed39cedb4a16ca85a945c326bd3bae26abf049f5622b2
+SHA512:
+  metadata.gz: '0912d93aac2a5fdbdf6c69490947530b6147f2fb55eff205c3839fdc1ad48dd6adddf35d2db868cef4da109b82fdae5b74a489f93d73d6dfed3a65ee8cd8d381'
+  data.tar.gz: aa45eefab2311a46c513af8f161345065cb08e2efdd56f7cbfc20e75c56bccf9b1907a90ba4a97e43976fc00efac096387b272895e68a49d212694e1ed7b9f92

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1 2021-11-16
+
+- First working version

data/README.md

@@ -0,0 +1,5 @@
+# Rephrase - a gem for manipulating Ruby code
+
+[![Gem Version](https://badge.fury.io/rb/rephrase.svg)](http://rubygems.org/gems/rephrase)
+[![Modulation Test](https://github.com/digital-fabric/rephrase/workflows/Tests/badge.svg)](https://github.com/digital-fabric/rephrase/actions?query=workflow%3ATests)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/rephrase/blob/master/LICENSE)

data/lib/rephrase/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Rephrase
+  VERSION = '0.1'
+end

data/lib/rephrase.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+# for use with IRB, see https://dev.to/okinawarb/how-can-i-use-rubyvm-abstractsyntaxtree-in-irb-m2k
+# for use in Pry, see https://dev.to/okinawarb/using-rubyvm-abstractsyntaxtree-of-in-pry-4cm3
+
+class Rephrase
+  class FakeNode
+    def self.list(children)
+      new(:LIST_EMBEDDED, children)
+    end
+
+    def self.iter_scope(children)
+      new(:ITER_SCOPE, children)
+    end
+
+    attr_reader :type, :children
+    
+    def initialize(type, children)
+      @type = type
+      @children = children
+    end
+  end
+
+  def convert(ctx, node)
+    ctx[:buffer] ||= +''
+    ctx[:indent] ||= 0
+    method_name = :"on_#{node.type.downcase}"
+    if respond_to?(method_name)
+      send(method_name, ctx, node)
+      ctx[:buffer]
+    else
+      raise "Could not convert #{node.type} node to ruby"
+    end
+  end
+
+  def on_scope(ctx, node)
+    body = node.children.last
+    # if body.type != :BLOCK
+    #   body = FakeNode.new(:BLOCK, [body])
+    # end
+    emit(ctx, "proc do", [body], "end")
+  end
+
+  def on_block(ctx, node)
+    last_idx = node.children.size - 1
+    node.children.each_with_index do |c, idx|
+      emit(ctx, c)
+      emit(ctx, "\n") if idx < last_idx
+    end
+  end
+
+  def on_iter(ctx, node)
+    call, scope = node.children
+    emit(ctx, call)
+    emit(ctx, FakeNode.iter_scope(scope.children))
+  end
+
+  def on_iter_scope(ctx, node)
+    args, arg_spec, body = node.children
+    emit(ctx, " do")
+    emit(ctx, " |", args.map(&:to_s).join(", "), "|") unless args.empty?
+    emit(ctx, "\n")
+    emit(ctx, body)
+    emit(ctx, "\nend")
+  end
+
+  def on_const(ctx, node)
+    emit(ctx, node.children.first.to_s)
+  end
+
+  def on_colon2(ctx, node)
+    left, right = node.children
+    emit(ctx, left, "::", right.to_s)
+  end
+
+  def on_call(ctx, node)
+    receiver, method, args = node.children
+    args = args && FakeNode.list(args.children)
+    case method
+    when :[]
+      emit(ctx, receiver, "[", args, "]")
+    else
+      if args
+        emit(ctx, receiver, ".", "#{method}(", args, ")")
+      else
+        emit(ctx, receiver, ".", "#{method}()")
+      end
+    end
+  end
+
+  def on_fcall(ctx, node)
+    method, args = node.children
+    args = args && FakeNode.list(args.children)
+    emit(ctx, "#{method}(", args, ")")
+  end
+
+  def on_vcall(ctx, node)
+    emit(ctx, node.children.first.to_s, "()")
+  end
+
+  def on_opcall(ctx, node)
+    left, op, right = node.children
+    if op == :!
+      emit(ctx, "!(", left, ")")
+    else
+      emit(ctx, left, " #{op} ", right.children.first)
+    end
+  end
+
+  def on_dasgn_curr(ctx, node)
+    left, right = node.children
+    emit(ctx, left.to_s, " = ", right)
+  end
+
+  def on_iasgn(ctx, node)
+    left, right = node.children
+    emit(ctx, left.to_s, " = ", right)
+  end
+
+  def on_if(ctx, node)
+    cond, branch1, branch2 = node.children
+    if branch2
+      emit(ctx, "if ", cond, "\n", branch1, "\nelse\n", branch2, "\nend")
+    else
+      emit(ctx, "if ", cond, "\n", branch1, "\nend")
+    end
+  end
+
+  def on_unless(ctx, node)
+    cond, branch1, branch2 = node.children
+    if branch2
+      emit(ctx, "unless ", cond, "\n", branch1, "\nelse\n", branch2, "\nend")
+    else
+      emit(ctx, "unless ", cond, "\n", branch1, "\nend")
+    end
+  end
+
+  def on_while(ctx, node)
+    cond, body = node.children
+    emit(ctx, "while ", cond, "\n", body, "\nend")
+  end
+
+  def on_lit(ctx, node)
+    emit(ctx, node.children.first.inspect)
+  end
+
+  def on_nil(ctx, node)
+    emit(ctx, "nil")
+  end
+
+  def on_true(ctx, node)
+    emit(ctx, "true")
+  end
+
+  def on_false(ctx, node)
+    emit(ctx, "false")
+  end
+
+  def on_dvar(ctx, node)
+    emit(ctx, node.children.first.to_s)
+  end
+
+  def on_ivar(ctx, node)
+    emit(ctx, node.children.first.to_s)
+  end
+
+  def on_str(ctx, node)
+    emit(ctx, node.children.first.inspect)
+  end
+
+  def on_dstr(ctx, node)
+    prefix, evstr1, rest = node.children
+    emit(ctx, "\"", prefix.inspect[1..-2], evstr1)
+    if rest
+      rest.children.compact.each do |n|
+        case n.type
+        when :STR
+          emit(ctx, n.children.first.inspect[1..-2])
+        when :EVSTR
+          emit(ctx, n)
+        else
+          raise "Unexpected node #{n.type.inspect} encountered in DSTR"
+        end
+      end
+    end
+    emit(ctx, "\"")
+  end
+
+  def on_evstr(ctx, node)
+    emit(ctx, "\#{", node.children.first, "}")
+  end
+
+  def on_and(ctx, node)
+    left, right = node.children
+    emit(ctx, left, " && ", right)
+  end
+
+  def on_or(ctx, node)
+    left, right = node.children
+    emit(ctx, left, " || ", right)
+  end
+
+  def on_list(ctx, node)
+    items = node.children[0..-2]
+    last_idx = items.size - 1
+    emit(ctx, "[")
+    items.each_with_index do |c, idx|
+      emit(ctx, c)
+      emit(ctx, ", ") if idx < last_idx
+    end
+    emit(ctx, "]")
+  end
+
+  def on_list_embedded(ctx, node)
+    items = node.children.compact
+    last_idx = items.size - 1
+    items.each_with_index do |c, idx|
+      emit(ctx, c)
+      emit(ctx, ", ") if idx < last_idx
+    end
+  end
+
+  def on_hash(ctx, node)
+    list = node.children.first
+    idx = 0
+    emit(ctx, "{")
+    while true
+      k, v = list.children[idx, 2]
+      break unless k
+
+      emit(ctx, ", ") if idx > 0
+      idx += 2
+      emit(ctx, k, " => ", v)
+    end
+    emit(ctx, "}")
+  end
+
+  def on_attrasgn(ctx, node)
+    left, op, args = node.children
+    emit(ctx, left)
+    case op
+    when :[]=
+      args_list = args.children[0..-2]
+      subscript = FakeNode.list(args_list[0..-2])
+      right = args_list.last
+      emit(ctx, "[", subscript, "] = ", right)
+    else
+      raise "Unsupported ATTRASGN op #{op.inspect}"
+    end
+  end
+
+  def on_rescue(ctx, node)
+    code, rescue_body = node.children
+    emit(ctx, code)
+    emit(ctx, " rescue ", rescue_body.children[1])
+  end
+
+  def emit(ctx, *entries)
+    entries.each do |e|
+      case e
+      when RubyVM::AbstractSyntaxTree::Node, FakeNode
+        convert(ctx, e)
+      when Array
+        ctx[:buffer] << "\n"
+        e.each { |e2| convert(ctx, e2) }
+        ctx[:buffer] << "\n"
+      when String
+        ctx[:buffer] << e
+      when nil
+        # ignore
+      else
+        raise "Invalid entry #{e.inspect}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: rephrase
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Sharon Rosner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 5.11.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: 
+email: ciconia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- README.md
+- lib/rephrase.rb
+- lib/rephrase/version.rb
+homepage: http://github.com/digital-fabric/rephrase
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/digital-fabric/rephrase
+post_install_message: 
+rdoc_options:
+- "--title"
+- Rephrase
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: 'Rephrase: a gem for manipulating Ruby code'
+test_files: []