sexp2ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a09363137ce2f11cc78ad2733dce55fcf56c27c
-  data.tar.gz: 804d653482abc54b86ef47119067f80657df796b
+  metadata.gz: e6521d5161ee2027c4a9fcfbfa58a6f8800a1032
+  data.tar.gz: dd984a8d70a35a285dae0b591e4cc523424c1417
 SHA512:
-  metadata.gz: 7a7d4b703d320e202289deee5eb673d27e1457e25fb0b42e3adb894bddb811ba41816933dda1766ee2bbd08be78c1cff7105d12d598adf5bc9636a89dcabb636
-  data.tar.gz: b91c818789cc96b280af027092ce11dce5d38e4d1648c2e35e4806d216b2288d75c7f20923f802155421294b8a04a5d92dfece52aa314565a6d6cde13f520920
+  metadata.gz: f87f34c8f9ca2006e15738e8329289ae087bc928b2d0c0eb06e9d813f20f7346796c0935347f0913841ff466cbe5b0f486856264944ee9e87dca4af76f2e77b2
+  data.tar.gz: 43e0e32832b2a01b3966770a812c917bc130f3489bb29d4900c5d554d110ee80badd8b50967a245c170aec0e15c510772277b00feb2dc12a2e6b7a6f3c9d2fd0

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+

data/.travis.yml

@@ -1,10 +1,9 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.3
   - 2.0.0
   - 2.1.6
   - 2.2.2
-script: bundle exec rspec
+script: bundle exec rspec --require spec_helper
 notifications:
   email: false

data/README.md

@@ -1,11 +1,15 @@
 sexp2ruby
 =========
 
+[![Build Status][5]][6] [![Code Climate][7]][8]
+
 `sexp2ruby` generates ruby from RubyParser S-expressions.
 It is a fork of [ruby2ruby][1] with slightly different goals.
 
 - Generates ruby that follows [ruby-style-guide][3] where possible
 - Prefers OO design over performance
+- Drops support for ruby 1.8.7
+- Depends on [activesupport][4]
 - Uses bundler instead of hoe
 - Uses rspec instead of minitest
 
@@ -30,3 +34,8 @@ so `deep_clone` if you need to preserve it.
 [1]: https://github.com/seattlerb/ruby2ruby
 [2]: http://docs.seattlerb.org/ruby2ruby
 [3]: https://github.com/bbatsov/ruby-style-guide
+[4]: https://rubygems.org/gems/activesupport
+[5]: https://travis-ci.org/jaredbeck/sexp2ruby.svg
+[6]: https://travis-ci.org/jaredbeck/sexp2ruby
+[7]: https://codeclimate.com/github/jaredbeck/sexp2ruby/badges/gpa.svg
+[8]: https://codeclimate.com/github/jaredbeck/sexp2ruby

data/lib/sexp2ruby/node/alias.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Alias < Base
+      def to_s(exp)
+        parenthesize "alias #{process(exp.shift)} #{process(exp.shift)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/and.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class And < Base
+      def to_s(exp)
+        parenthesize "#{process exp.shift} and #{process exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/arglist.rb

@@ -0,0 +1,16 @@
+module Sexp2Ruby
+  module Node
+    class Arglist < Base
+      def to_s(exp)
+        code = []
+        until exp.empty? do
+          arg = exp.shift
+          to_wrap = arg.first == :rescue
+          arg_code = process arg
+          code << (to_wrap ? "(#{arg_code})" : arg_code)
+        end
+        code.join ', '
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/args.rb

@@ -0,0 +1,33 @@
+module Sexp2Ruby
+  module Node
+    class Args < Base
+      def to_s(exp)
+        args = []
+
+        until exp.empty? do
+          arg = exp.shift
+          case arg
+          when Symbol then
+            args << arg
+          when Sexp then
+            case arg.first
+            when :lasgn then
+              args << process(arg)
+            when :masgn then
+              args << process(arg)
+            when :kwarg then
+              _, k, v = arg
+              args << "#{k}: #{process v}"
+            else
+              raise "unknown arg type #{arg.first.inspect}"
+            end
+          else
+            raise "unknown arg type #{arg.inspect}"
+          end
+        end
+
+        "(#{args.join ', '})"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/array.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Array < Base
+      def to_s(exp)
+        "[#{process_arglist(exp)}]"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/attrasgn.rb

@@ -0,0 +1,27 @@
+module Sexp2Ruby
+  module Node
+    class Attrasgn < Base
+      def to_s(exp)
+        receiver = process exp.shift
+        name = exp.shift
+        rhs  = exp.pop
+        args = s(:array, *exp)
+        exp.clear
+
+        case name
+        when :[]= then
+          args = process args
+          "#{receiver}#{args} = #{process rhs}"
+        else
+          raise "dunno what to do: #{args.inspect}" unless args.size == 1 # s(:array)
+          name = name.to_s.sub(/=$/, '')
+          if rhs && rhs != s(:arglist)
+            "#{receiver}.#{name} = #{process(rhs)}"
+          else
+            raise "dunno what to do: #{rhs.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/back_ref.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class BackRef < Base
+      def to_s(exp)
+        "$#{exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/base.rb

@@ -0,0 +1,36 @@
+module Sexp2Ruby
+  module Node
+
+    # A node in the AST.
+    class Base
+      ASSIGN_NODES = Processor::ASSIGN_NODES
+      LF = Processor::LF
+      LINE_LENGTH = 78 # cutoff for one-liners
+
+      attr_reader :processor
+      delegate(
+        :call_push,
+        :call_pop,
+        :cond_loop,
+        :hash_syntax,
+        :in_context,
+        :indent,
+        :indent_lvl,
+        :finish,
+        :parenthesize,
+        :process,
+        :process_arglist,
+        :process_dregx,
+        :process_iasgn,
+        :ruby19_hash_key?,
+        :util_dthing,
+        :util_module_or_class,
+        to: :processor
+      )
+
+      def initialize(processor)
+        @processor = processor
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/begin.rb

@@ -0,0 +1,19 @@
+module Sexp2Ruby
+  module Node
+
+    # TODO: figure out how to do rescue and ensure ENTIRELY w/o begin
+    class Begin < Base
+      def to_s(exp)
+        code = []
+        code << "begin"
+        until exp.empty?
+          src = process(exp.shift)
+          src = indent(src) unless src =~ /(^|\n)(rescue|ensure)/ # ensure no level 0 rescues
+          code << src
+        end
+        code << "end"
+        code.join(LF)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/block.rb

@@ -0,0 +1,24 @@
+module Sexp2Ruby
+  module Node
+    class Block < Base
+      def to_s(exp)
+        result = []
+
+        exp << nil if exp.empty?
+        until exp.empty? do
+          code = exp.shift
+          if code.nil? or code.first == :nil
+            result << "# do nothing\n"
+          else
+            result << process(code)
+          end
+        end
+
+        result = parenthesize result.join LF
+        result += LF unless result.start_with? "("
+
+        result
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/block_pass.rb

@@ -0,0 +1,10 @@
+module Sexp2Ruby
+  module Node
+    class BlockPass < Base
+      def to_s(exp)
+        raise "huh?: #{exp.inspect}" if exp.size > 1
+        "&#{process exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/break.rb

@@ -0,0 +1,14 @@
+module Sexp2Ruby
+  module Node
+    class Break < Base
+      def to_s(exp)
+        val = exp.empty? ? nil : process(exp.shift)
+        if val
+          "break #{val}"
+        else
+          "break"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/call.rb

@@ -0,0 +1,70 @@
+module Sexp2Ruby
+  module Node
+    class Call < Base
+
+      # binary operation messages
+      BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**, :'!=']
+
+      def to_s(exp)
+        receiver_node_type = exp.first.nil? ? nil : exp.first.first
+        receiver = process exp.shift
+        receiver = "(#{receiver})" if ASSIGN_NODES.include? receiver_node_type
+
+        name = exp.shift
+        args = []
+
+        # this allows us to do both old and new sexp forms:
+        exp.push(*exp.pop[1..-1]) if exp.size == 1 && exp.first.first == :arglist
+
+        call_push(name)
+
+        in_context :arglist do
+          until exp.empty? do
+            arg_type = exp.first.sexp_type
+            is_empty_hash = (exp.first == s(:hash))
+            arg = process exp.shift
+
+            next if arg.empty?
+
+            strip_hash = (arg_type == :hash and
+              not BINARY.include? name and
+              not is_empty_hash and
+              (exp.empty? or exp.first.sexp_type == :splat))
+            wrap_arg = ASSIGN_NODES.include? arg_type
+
+            arg = arg[2..-3] if strip_hash
+            arg = "(#{arg})" if wrap_arg
+
+            args << arg
+          end
+        end
+
+        case name
+        when *BINARY then
+          "(#{receiver} #{name} #{args.join(', ')})"
+        when :[] then
+          receiver ||= "self"
+          "#{receiver}[#{args.join(', ')}]"
+        when :[]= then
+          receiver ||= "self"
+          rhs = args.pop
+          "#{receiver}[#{args.join(', ')}] = #{rhs}"
+        when :"!" then
+          "(not #{receiver})"
+        when :"-@" then
+          "-#{receiver}"
+        when :"+@" then
+          "+#{receiver}"
+        else
+          args     = nil                    if args.empty?
+          args     = "(#{args.join(', ')})" if args
+          receiver = "#{receiver}."         if receiver
+
+          "#{receiver}#{name}#{args}"
+        end
+      ensure
+        call_pop
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/case.rb

@@ -0,0 +1,27 @@
+module Sexp2Ruby
+  module Node
+    class Case < Base
+      def to_s(exp)
+        result = []
+        expr = process exp.shift
+        if expr
+          result << "case #{expr}"
+        else
+          result << "case"
+        end
+        until exp.empty?
+          pt = exp.shift
+          if pt and pt.first == :when
+            result << "#{process(pt)}"
+          else
+            code = indent(process(pt))
+            code = indent("# do nothing") if code =~ /^\s*$/
+            result << "else\n#{code}"
+          end
+        end
+        result << "end"
+        result.join(LF)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/cdecl.rb

@@ -0,0 +1,17 @@
+module Sexp2Ruby
+  module Node
+    class Cdecl < Base
+      def to_s(exp)
+        lhs = exp.shift
+        lhs = process lhs if Sexp === lhs
+
+        if exp.empty?
+          lhs.to_s
+        else
+          rhs = process(exp.shift)
+          "#{lhs} = #{rhs}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/class.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Class < Base
+      def to_s(exp)
+        "#{exp.comments}class #{util_module_or_class(exp, true)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/colon2.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Colon2 < Base
+      def to_s(exp)
+        "#{process(exp.shift)}::#{exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/colon3.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Colon3 < Base
+      def to_s(exp)
+        "::#{exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/const.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Const < Base
+      def to_s(exp)
+        exp.shift.to_s
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/cvar.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Cvar < Base
+      def to_s(exp)
+        "#{exp.shift}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/cvasgn.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Cvasgn < Base
+      def to_s(exp)
+        "#{exp.shift} = #{process(exp.shift)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/cvdecl.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Cvdecl < Base
+      def to_s(exp)
+        "#{exp.shift} = #{process(exp.shift)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/defined.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Defined < Base
+      def to_s(exp)
+        "defined? #{process(exp.shift)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/defn.rb

@@ -0,0 +1,66 @@
+module Sexp2Ruby
+  module Node
+    class Defn < Base
+      def to_s(exp)
+        type1 = exp[1].first
+        type2 = exp[2].first rescue nil
+        expect = [:ivar, :iasgn, :attrset]
+
+        # s(name, args, ivar|iasgn|attrset)
+        if exp.size == 3 and type1 == :args and expect.include? type2
+          name = exp.first # don't shift in case we pass through
+          case type2
+          when :ivar then
+            ivar_name = exp.ivar.last
+
+            meth_name = ivar_name.to_s[1..-1].to_sym
+            expected = s(meth_name, s(:args), s(:ivar, ivar_name))
+
+            if exp == expected
+              exp.clear
+              return "attr_reader #{name.inspect}"
+            end
+          when :attrset then
+            # TODO: deprecate? this is a PT relic
+            exp.clear
+            return "attr_writer :#{name.to_s[0..-2]}"
+          when :iasgn then
+            ivar_name = exp.iasgn[1]
+            meth_name = "#{ivar_name.to_s[1..-1]}=".to_sym
+            arg_name = exp.args.last
+            expected = s(meth_name, s(:args, arg_name),
+              s(:iasgn, ivar_name, s(:lvar, arg_name)))
+
+            if exp == expected
+              exp.clear
+              return "attr_writer :#{name.to_s[0..-2]}"
+            end
+          else
+            raise "Unknown defn type: #{exp.inspect}"
+          end
+        end
+
+        comm = exp.comments
+        name = exp.shift
+        args = process exp.shift
+        args = "" if args == "()"
+
+        exp.shift if exp == s(s(:nil)) # empty it out of a default nil expression
+
+        # REFACTOR: use process_block but get it happier wrt parenthesize
+        body = []
+        until exp.empty? do
+          body << process(exp.shift)
+        end
+
+        body << "# do nothing" if body.empty?
+        body = body.join(LF)
+        body = body.lines.to_a[1..-2].join(LF) if
+          body =~ /^\Abegin/ && body =~ /^end\z/
+        body = indent(body) unless body =~ /(^|\n)rescue/
+
+        "#{comm}def #{name}#{args}\n#{body}\nend".gsub(/\n\s*\n+/, LF)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/defs.rb

@@ -0,0 +1,17 @@
+module Sexp2Ruby
+  module Node
+    class Defs < Base
+      def to_s(exp)
+        lhs  = exp.shift
+        var = [:self, :cvar, :dvar, :ivar, :gvar, :lvar].include? lhs.first
+        name = exp.shift
+
+        lhs = process(lhs)
+        lhs = "(#{lhs})" unless var
+
+        exp.unshift "#{lhs}.#{name}"
+        process_defn(exp)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dot2.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Dot2 < Base
+      def to_s(exp)
+        "(#{process exp.shift}..#{process exp.shift})"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dot3.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Dot3 < Base
+      def to_s(exp)
+        "(#{process exp.shift}...#{process exp.shift})"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dregx.rb

@@ -0,0 +1,19 @@
+module Sexp2Ruby
+  module Node
+    class Dregx < Base
+      def to_s(exp)
+        options = re_opt exp.pop if Fixnum === exp.last
+        "/" << util_dthing(:dregx, exp) << "/#{options}"
+      end
+
+      private
+
+      # Return the appropriate regexp flags for a given numeric code.
+      def re_opt options
+        bits = (0..8).map { |n| options[n] * 2**n }
+        bits.delete 0
+        bits.map { |n| Regexp::CODES[n] }.join
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dregx_once.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class DregxOnce < Base
+      def to_s(exp)
+        process_dregx(exp) + "o"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dstr.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Dstr < Base
+      def to_s(exp)
+        "\"#{util_dthing(:dstr, exp)}\""
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dsym.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Dsym < Base
+      def to_s(exp)
+        ":\"#{util_dthing(:dsym, exp)}\""
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/dxstr.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Dxstr < Base
+      def to_s(exp)
+        "`#{util_dthing(:dxstr, exp)}`"
+      end
+    end
+  end
+end