sexp2ruby 0.0.1 → 0.0.2

data/lib/sexp2ruby/node/ensure.rb

@@ -0,0 +1,18 @@
+module Sexp2Ruby
+  module Node
+    class Ensure < Base
+      def to_s(exp)
+        body = process exp.shift
+        ens  = exp.shift
+        ens  = nil if ens == s(:nil)
+        ens  = process(ens) || "# do nothing"
+        ens = "begin\n#{ens}\nend\n" if ens =~ /(^|\n)rescue/
+
+        body.sub!(/\n\s*end\z/, '')
+        body = indent(body) unless body =~ /(^|\n)rescue/
+
+        "#{body}\nensure\n#{indent ens}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/evstr.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Evstr < Base
+      def to_s(exp)
+        exp.empty? ? '' : process(exp.shift)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/false.rb

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

data/lib/sexp2ruby/node/flip2.rb

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

data/lib/sexp2ruby/node/flip3.rb

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

data/lib/sexp2ruby/node/for.rb

@@ -0,0 +1,17 @@
+module Sexp2Ruby
+  module Node
+    class For < Base
+      def to_s(exp)
+        recv = process exp.shift
+        iter = process exp.shift
+        body = exp.empty? ? nil : process(exp.shift)
+
+        result = ["for #{iter} in #{recv} do"]
+        result << indent(body ? body : "# do nothing")
+        result << "end"
+
+        result.join(LF)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/gasgn.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Gasgn < Base
+      def to_s(exp)
+        process_iasgn(exp)
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/gvar.rb

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

data/lib/sexp2ruby/node/hash.rb

@@ -0,0 +1,53 @@
+module Sexp2Ruby
+  module Node
+    class Hash < Base
+
+      # Some sexp types are OK without parens when appearing as hash values.
+      # This list can include `:call`s because they're always printed with parens
+      # around their arguments. For example:
+      #
+      #     { :foo => (bar("baz")) } # The outer parens are unnecessary
+      #     { :foo => bar("baz") }   # This is the normal code style
+      #
+      HASH_VAL_NO_PAREN = [
+        :call,
+        :false,
+        :lit,
+        :lvar,
+        :nil,
+        :str,
+        :true
+      ]
+
+      def to_s(exp)
+        result = []
+
+        until exp.empty?
+          s = exp.shift
+          t = s.sexp_type
+          ruby19_key = ruby19_hash_key?(s)
+          lhs = process s
+
+          case t
+          when :kwsplat then
+            result << lhs
+          else
+            rhs = exp.shift
+            t = rhs.first
+            rhs = process rhs
+            rhs = "(#{rhs})" unless HASH_VAL_NO_PAREN.include? t
+
+            if hash_syntax == :ruby19 && ruby19_key
+              lhs.gsub!(/\A:/, "")
+              result << "#{lhs}: #{rhs}"
+            else
+              result << "#{lhs} => #{rhs}"
+            end
+          end
+        end
+
+        result.empty? ? "{}" : "{ #{result.join(', ')} }"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/iasgn.rb

@@ -0,0 +1,14 @@
+module Sexp2Ruby
+  module Node
+    class Iasgn < Base
+      def to_s(exp)
+        lhs = exp.shift
+        if exp.empty? # part of an masgn
+          lhs.to_s
+        else
+          "#{lhs} = #{process exp.shift}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/if.rb

@@ -0,0 +1,41 @@
+module Sexp2Ruby
+  module Node
+    class If < Base
+      def to_s(exp)
+        expand = ASSIGN_NODES.include? exp.first.first
+        c = process exp.shift
+        t = process exp.shift
+        f = process exp.shift
+
+        c = "(#{c.chomp})" if c =~ /\n/
+
+        if t
+          unless expand
+            if f
+              r = "#{c} ? (#{t}) : (#{f})"
+              r = nil if r =~ /return/ # HACK - need contextual awareness or something
+            else
+              r = "#{t} if #{c}"
+            end
+            return r if r and (indent_lvl + r).size < LINE_LENGTH and r !~ /\n/
+          end
+
+          r = "if #{c} then\n#{indent(t)}\n"
+          r << "else\n#{indent(f)}\n" if f
+          r << "end"
+
+          r
+        elsif f
+          unless expand
+            r = "#{f} unless #{c}"
+            return r if (indent_lvl + r).size < LINE_LENGTH and r !~ /\n/
+          end
+          "unless #{c} then\n#{indent(f)}\nend"
+        else
+          # empty if statement, just do it in case of side effects from condition
+          "if #{c} then\n#{indent '# do nothing'}\nend"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/iter.rb

@@ -0,0 +1,50 @@
+module Sexp2Ruby
+  module Node
+    class Iter < Base
+      def to_s(exp)
+        iter = process exp.shift
+        args = exp.shift
+        body = exp.empty? ? nil : process(exp.shift)
+
+        args = case args
+        when 0 then
+          ""
+        else
+          " |#{process(args)[1..-2]}|"
+        end
+
+        b, e = if iter == "END"
+          [ "{", "}" ]
+        else
+          [ "do", "end" ]
+        end
+
+        iter.sub!(/\(\)$/, '')
+
+        # REFACTOR: ugh
+        result = []
+        result << "#{iter} {"
+        result << args
+        if body
+          result << " #{body.strip} "
+        else
+          result << ' '
+        end
+        result << "}"
+        result = result.join
+        return result if result !~ /\n/ and result.size < LINE_LENGTH
+
+        result = []
+        result << "#{iter} #{b}"
+        result << args
+        result << LF
+        if body
+          result << indent(body.strip)
+          result << LF
+        end
+        result << e
+        result.join
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/ivar.rb

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

data/lib/sexp2ruby/node/kwsplat.rb

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

data/lib/sexp2ruby/node/lasgn.rb

@@ -0,0 +1,11 @@
+module Sexp2Ruby
+  module Node
+    class Lasgn < Base
+      def to_s(exp)
+        s = "#{exp.shift}"
+        s += " = #{process exp.shift}" unless exp.empty?
+        s
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/lit.rb

@@ -0,0 +1,15 @@
+module Sexp2Ruby
+  module Node
+    class Lit < Base
+      def to_s(exp)
+        obj = exp.shift
+        case obj
+        when Range then
+          "(#{obj.inspect})"
+        else
+          obj.inspect
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/lvar.rb

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

data/lib/sexp2ruby/node/masgn.rb

@@ -0,0 +1,46 @@
+module Sexp2Ruby
+  module Node
+    class Masgn < Base
+
+      # s(:masgn, s(:array, s(:lasgn, :var), ...), s(:to_ary, <val>, ...))
+      # s(:iter, <call>, s(:args, s(:masgn, :a, :b)), <body>)
+      def to_s(exp)
+        case exp.first
+        when Sexp then
+          lhs = exp.shift
+          rhs = exp.empty? ? nil : exp.shift
+
+          case lhs.first
+          when :array then
+            lhs.shift # node type
+            lhs = lhs.map do |l|
+              case l.first
+              when :masgn then
+                "(#{process(l)})"
+              else
+                process(l)
+              end
+            end
+          else
+            raise "no clue: #{lhs.inspect}"
+          end
+
+          if rhs.nil?
+            return lhs.join(", ")
+          else
+            t = rhs.first
+            rhs = process rhs
+            rhs = rhs[1..-2] if t == :array # FIX: bad? I dunno
+            return "#{lhs.join(", ")} = #{rhs}"
+          end
+        when Symbol then # block arg list w/ masgn
+          result = exp.join ", "
+          exp.clear
+          "(#{result})"
+        else
+          raise "unknown masgn: #{exp.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/match.rb

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

data/lib/sexp2ruby/node/match2.rb

@@ -0,0 +1,11 @@
+module Sexp2Ruby
+  module Node
+    class Match2 < Base
+      def to_s(exp)
+        lhs = process(exp.shift)
+        rhs = process(exp.shift)
+        "#{lhs} =~ #{rhs}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/match3.rb

@@ -0,0 +1,17 @@
+module Sexp2Ruby
+  module Node
+    class Match3 < Base
+      def to_s(exp)
+        rhs = process(exp.shift)
+        left_type = exp.first.sexp_type
+        lhs = process(exp.shift)
+
+        if ASSIGN_NODES.include? left_type
+          "(#{lhs}) =~ #{rhs}"
+        else
+          "#{lhs} =~ #{rhs}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/module.rb

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

data/lib/sexp2ruby/node/next.rb

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

data/lib/sexp2ruby/node/nil.rb

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

data/lib/sexp2ruby/node/not.rb

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

data/lib/sexp2ruby/node/nth_ref.rb

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

data/lib/sexp2ruby/node/op_asgn1.rb

@@ -0,0 +1,16 @@
+module Sexp2Ruby
+  module Node
+    class OpAsgn1 < Base
+
+      # [[:lvar, :b], [:arglist, [:lit, 1]], :"||", [:lit, 10]]
+      def to_s(exp)
+        lhs = process(exp.shift)
+        index = process(exp.shift)
+        msg = exp.shift
+        rhs = process(exp.shift)
+
+        "#{lhs}[#{index}] #{msg}= #{rhs}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/op_asgn2.rb

@@ -0,0 +1,17 @@
+module Sexp2Ruby
+  module Node
+    class OpAsgn2 < Base
+
+      # [[:lvar, :c], :var=, :"||", [:lit, 20]]
+      def to_s(exp)
+        lhs = process(exp.shift)
+        index = exp.shift.to_s[0..-2]
+        msg = exp.shift
+
+        rhs = process(exp.shift)
+
+        "#{lhs}.#{index} #{msg}= #{rhs}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/op_asgn_and.rb

@@ -0,0 +1,13 @@
+module Sexp2Ruby
+  module Node
+    class OpAsgnAnd < Base
+
+      # a &&= 1
+      # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
+      def to_s(exp)
+        exp.shift
+        process(exp.shift).sub(/\=/, '&&=')
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/op_asgn_or.rb

@@ -0,0 +1,13 @@
+module Sexp2Ruby
+  module Node
+    class OpAsgnOr < Base
+
+      # a ||= 1
+      # [[:lvar, :a], [:lasgn, :a, [:lit, 1]]]
+      def to_s(exp)
+        exp.shift
+        process(exp.shift).sub(/\=/, '||=')
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/or.rb

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

data/lib/sexp2ruby/node/postexe.rb

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

data/lib/sexp2ruby/node/redo.rb

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

data/lib/sexp2ruby/node/resbody.rb

@@ -0,0 +1,19 @@
+module Sexp2Ruby
+  module Node
+    class Resbody < Base
+      def to_s(exp)
+        args = exp.shift
+        body = finish(exp)
+        body << "# do nothing" if body.empty?
+
+        name =   args.lasgn true
+        name ||= args.iasgn true
+        args = process(args)[1..-2]
+        args = " #{args}" unless args.empty?
+        args += " => #{name[1]}" if name
+
+        "rescue#{args}\n#{indent body.join(LF)}"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/rescue.rb

@@ -0,0 +1,32 @@
+module Sexp2Ruby
+  module Node
+    class Rescue < Base
+      def to_s(exp)
+        body = process(exp.shift) unless exp.first.first == :resbody
+        els  = process(exp.pop)   unless exp.last.first  == :resbody
+
+        body ||= "# do nothing"
+        simple = exp.size == 1 && exp.resbody.size <= 3 &&
+          !exp.resbody.block &&
+          !exp.resbody.return
+
+        resbodies = []
+        until exp.empty? do
+          resbody = exp.shift
+          simple &&= resbody[1] == s(:array)
+          simple &&= resbody[2] != nil && resbody[2].node_type != :block
+          resbodies << process(resbody)
+        end
+
+        if els
+          "#{indent body}\n#{resbodies.join(LF)}\nelse\n#{indent els}"
+        elsif simple
+          resbody = resbodies.first.sub(/\n\s*/, ' ')
+          "#{body} #{resbody}"
+        else
+          "#{indent body}\n#{resbodies.join(LF)}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/retry.rb

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

data/lib/sexp2ruby/node/return.rb

@@ -0,0 +1,13 @@
+module Sexp2Ruby
+  module Node
+    class Return < Base
+      def to_s(exp)
+        if exp.empty?
+          "return"
+        else
+          "return #{process exp.shift}"
+        end
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/sclass.rb

@@ -0,0 +1,9 @@
+module Sexp2Ruby
+  module Node
+    class Sclass < Base
+      def to_s(exp)
+        "class << #{process(exp.shift)}\n#{indent(process_block(exp))}\nend"
+      end
+    end
+  end
+end

data/lib/sexp2ruby/node/self.rb

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