farleyknight-ionize 0.1.0

data/lib/ionize/translate.rb

@@ -0,0 +1,34 @@
+
+load 'ionize/translate/debug.rb'
+load 'ionize/translate/ext.rb'
+load 'ionize/translate/translator.rb'
+load 'ionize/translate/function_args.rb'
+load 'ionize/translate/statements.rb'
+load 'ionize/translate/rewrites.rb'
+load 'ionize/translate/php_to_ruby.rb'
+
+module Ionize
+  module Php
+    module Translate
+      def self.flatten(node)
+        if node.is_a? Array
+          node.collect {|n| flatten(n) }
+        elsif node.is_a? Dhaka::ParseSuccessResult
+          flatten(node.child_nodes)
+        elsif node.is_a? Dhaka::ParseTreeCompositeNode
+          {node.production.name.to_sym => flatten(node.child_nodes)}
+        elsif node.is_a? Dhaka::ParseTreeLeafNode
+          flatten(node.token)
+        elsif node.is_a? Dhaka::Token
+          {node.symbol_name.to_sym => node.value}
+        else
+          raise "Cannot handle type #{node.class}!"
+        end
+      end
+
+      def self.translate(ast)
+        Statements.new(self).transform(flatten(ast)).to_block
+      end
+    end
+  end
+end

data/lib/ionize/translate/composite_string_statements.rb

@@ -0,0 +1,79 @@
+module Ionize
+  module Php
+    module Translate
+      module CompositeStringStatements        
+        def handle_multiple_nodes(node)
+          debug "Multiple nodes #{node.inspect}"
+
+          first  = transform(node.first) 
+          second = transform(node.second)
+
+          debug "Multiple nodes results #{first.inspect} #{second.inspect}"
+          
+          if second.nil?
+            first
+          elsif second.composite_node?
+            if first.composite_node?
+              first + second
+            else
+              [first] + second
+            end
+          elsif first.composite_node?
+            first + [second]
+          else
+            [first, second]
+          end
+        end
+
+        def handle_open_double_quoted_string(node)
+          node
+        end
+
+        def handle_double_quoted_string_node(node)
+          #        puts "double_quoted_string_node #{node.inspect}"
+          #        string = eval(node)
+          string = node
+          (string.empty?) ? nil : [:str, string]
+        end
+
+        def handle_single_node(node)
+          transform(node)
+        end
+
+        def handle_double_string_within_string(node)
+          transform(node)
+        end
+
+        def handle_variable_within_string(node)
+          [:evstr, transform(node.first)]
+        end
+
+        def handle_array_lookup_within_string(node)
+          transform(node)
+        end
+
+        def handle_array_lookup_node(node)
+          param = if node =~ /(\$.*?)\[(\$.*)\]/
+                    match = node.match(/(\$.*?)\[(\$.*)\]/)
+                    [:lvar, match[2].to_s.gsub("$", "").to_sym]
+                  elsif node =~ /(\$.*?)\[(.*)\]/
+                    match = node.match(/(\$.*?)\[(.*)\]/)
+                    [:str, match[2]]
+                  end
+          [:evstr, [:call, transform(:variable => match[1]), :[], [:array, param]]]
+        end
+
+        def handle_composite_double_string(node)
+          initial = transform(node.first)
+          body    = transform(node.second)
+
+          if body.composite_node?
+            [:dstr, initial] + body
+          else
+            [:dstr, initial, body]
+          end
+        end        
+      end
+    end
+  end
+end

data/lib/ionize/translate/debug.rb

@@ -0,0 +1,16 @@
+
+module Ionize
+  module Php
+    module Translate
+      module Debug
+        def logger
+          @logger ||= Logger.new("debug.log")
+        end
+
+        def debug(msg)
+          logger.debug(msg)
+        end
+      end
+    end
+  end
+end

data/lib/ionize/translate/ext.rb

@@ -0,0 +1,47 @@
+
+class Array
+  {:first => 0, :second => 1, :third => 2, :fourth => 3, :fifth => 4, :sixth => 5}.each do |name, value|
+    define_method(name) { self[value] }
+  end
+
+  def rest
+    self[1..-1]
+  end
+
+  def replace_pattern(pattern, value)
+    copy = self.dup
+    (0..copy.length).each do |i|
+      if copy[i] == pattern
+        copy[i] = value
+      elsif copy[i].is_a? Array
+        copy[i] = copy[i].replace_pattern(pattern, value)
+      end 
+    end   
+    copy
+  end  
+
+  def composite_node?
+    self.first.is_a? Array
+  end
+
+  def to_block
+    if self.composite_node?
+      [:block] + self
+    else
+      self
+    end
+  end
+end
+
+class Symbol
+  def to_global_variable
+    [:gvar, ("$" + self.to_s.gsub("$", "")).to_sym]    
+  end
+end
+
+class Hash
+  def node_type
+    raise "Cannot use hash as node with more than one key!" unless keys.length == 1
+    keys.first
+  end
+end

data/lib/ionize/translate/function_args.rb

@@ -0,0 +1,132 @@
+module Ionize
+  module Php
+    module Translate
+      class FunctionArgs < Translator
+        include Debug
+
+        attr_accessor :assigns
+
+        def handle_term(node)
+          transform(node)
+        end
+
+        def handle_single_arg(node)
+          transform(node)
+        end
+
+        def handle_word(node)
+          node
+        end
+
+        def handle_no_args(node)
+          [:args]
+        end
+
+        def handle_user_constant(node)
+          [:const, transform(node).to_sym]
+        end
+
+        # Perhaps these two can be
+        # cleaned up? Not sure..
+
+        def handle_variable(node)
+          debug "Variable #{node.inspect}"
+          node.first.gsub("$", "").to_sym
+        end
+
+        def handle_a_variable(node)          
+          debug "Variable inside function args #{node.inspect}"
+          transform(node.first)
+        end
+
+        def handle_reference_term(node)
+          # For now, I say screw references..
+          transform(node.second)
+          # TODO: But we might change this in the future.. Who knows.
+        end
+        
+        ################
+        ### literals ###
+        ################
+
+        def handle_single_quoted_string(node)
+          [:str, node]
+        end
+
+        def handle_double_quoted_string(node)
+          [:str, node]
+        end
+
+        def handle_regular_fun_call(node)
+          debug "Regular fun call #{node.inspect}"
+          name = transform(node.first).to_sym
+          if node.third.keys == [:no_args]
+            [:fcall, name]
+          else
+            args = transform(node.third)
+            if args.nil?
+              [:fcall, name]
+            else
+              [:fcall, name, args]
+            end
+          end
+        end
+
+        ############
+        ### args ###
+        ############
+
+        def handle_fun_args_within_call(node)
+          args = node.first.to_a.first.last
+          result = transform(args)
+          debug "Fun args within call result #{result.inspect}"
+          if result.empty?
+            nil
+          else
+            [:array] + result
+          end
+        end
+
+        def handle_term_assign(node)
+          term, op, expr = *node
+          debug "Term assign #{node.inspect}"
+          result   = transform(expr)
+          variable = transform(term)
+
+          # Okay, so this is kind of crazy but, in Ruby,  if you ever use the 
+          # assignment operation inside the formal parameters, it creates
+          # a block inside the function header AST. Run a ParseTree on
+          # on a method which has defaults to see what I mean.
+          
+          # AFAICT, the most efficient way to handle this crazy *#$@-ing case
+          # is to store the assignments later and only give back just the 
+          # variable being assigned. The assignment statements are appended 
+          # later in the transform 
+          
+          self.assigns[variable] = if result.is_a? Array
+                                     [:lasgn, variable, result]
+                                   else
+                                     [:lasgn, variable, [result]]
+                                   end
+          
+          variable
+        end
+
+        def handle_multiple_args(node)
+          debug "Multiple args on FunctionArgs side #{node.inspect}"
+
+          # Clear the assignment statements and perform the transformation
+          self.assigns = {}
+          result = transform(node.select {|c| c.values.first != "," })
+          
+          # Append the assignment statements spoken of in "term_assign"
+          unless self.assigns.empty?
+            result.flatten + [[:block, self.assigns.values.first]]
+          else
+            result.flatten
+          end
+        end        
+      end
+    end
+  end
+end

data/lib/ionize/translate/if_statements.rb

@@ -0,0 +1,42 @@
+module Ionize
+  module Php
+    module Translate
+      module IfStatements
+        def handle_if_statement0(node)
+          debug "If statement0 #{node.inspect}"      
+          condition = transform(node.third)
+          body      = transform(node[4]).to_block
+          if condition.first == :not
+              [:if, condition.second, nil, body]
+          else
+            [:if, condition, body, nil]
+          end
+        end
+
+        def handle_if_statement_b(node)
+          condition = transform(node.third)
+          body      = transform(node[5]).to_block
+          if condition.first == :not
+              [:if, condition.second, nil, body]
+          else
+            [:if, condition, body, nil]
+          end
+        end
+
+        def handle_if_else_statement1(node)
+          debug "If else statement1 #{node.inspect}"
+          [:if, transform(node.third), transform(node[4]).to_block, transform(node[6]).to_block]
+        end
+
+        def handle_if_else_statement_b(node)
+          [:if, transform(node.third), transform(node[5]).to_block, transform(node[9]).to_block]
+        end
+
+        def handle_if_else_statement_b1(node)
+          debug "If else statement b1 #{node.inspect}"
+          [:if, transform(node.third), transform(node[5]).to_block, transform(node[8]).to_block]
+        end
+      end
+    end
+  end
+end

data/lib/ionize/translate/multiple_statements.rb

@@ -0,0 +1,22 @@
+module Ionize
+  module Php
+    module Translate
+      module MultipleStatements    
+        def level     
+          @level ||= 0 
+        end
+        
+        def level=(other)
+          @level = other
+        end
+        
+        def multiple_statements
+          self.level += 1
+          result = yield
+          self.level -= 1
+          result
+        end
+      end       
+    end
+  end
+end

data/lib/ionize/translate/php_to_ruby.rb

@@ -0,0 +1,40 @@
+
+require 'ruby2ruby'
+
+module Ionize
+  module Php
+    module Translate      
+      class Php2Ruby < Ruby2Ruby
+        def process_hash(exp)
+          result = []
+          until exp.empty?
+            result << "#{process(exp.shift)} => #{process(exp.shift)}"
+          end
+          "{#{result.join(', ')}}"
+        end
+
+        def process_php(exp)
+          str = ""
+          until exp.empty?
+            subexp = exp.shift
+            str << process(subexp)
+          end
+          str
+        end
+
+        def process_html(exp)
+          exp.shift
+        end
+
+        def process_erb_start(exp)          
+          exp.shift
+        end
+
+        def process_erb_end(exp)
+          exp.shift
+        end
+      end
+    end
+  end
+end
+

data/lib/ionize/translate/rails_for_php.rb

@@ -0,0 +1,191 @@
+module Ionize
+  module Php
+    module Translate   
+      module RailsForPhp
+        # lasgn rewrites
+        def rewrite_lasgn_preg_match(var, expr)
+          regex, object, matches = *expr.last.rest
+
+          [:masgn, 
+           [:array, [:lasgn, var], [:lasgn, matches.last]], 
+           [:to_ary, [:call, object, :preg_match, [:array, [:lit, eval(regex.last)]]]]]
+        end
+
+        def rewrite_lasgn_preg_match_all(var, expr)
+          regex, object, matches = *expr.last.rest
+          
+          [:masgn, 
+           [:array, [:lasgn, var], [:lasgn, matches.last]], 
+           [:to_ary, [:call, object, :preg_match_all, [:array, [:lit, eval(regex.last)]]]]]          
+        end
+
+        # fcall rewrites..
+
+        def rewrite_fcall_implode(args)
+          [:call, args.third, :join, [:array, args.second]]
+        end
+
+        def rewrite_fcall_explode(args)
+          [:call, args.third, :split, [:array, args.second]]
+        end
+
+        def rewrite_fcall_in_array(args)
+          if args.last == [:true]
+            [:call, args.third, :include?, [:array, args.second]]
+          else
+            raise "Cannot handle non-strict version of in_array!"
+          end
+        end
+
+        # files
+        
+        def rewrite_fcall_file(args)
+          [:call, [:const, :File], :readlines, args]
+        end
+
+        # hashing algorithms..
+
+        def rewrite_fcall_md5(args)
+          [:call, [:colon2, [:const, :Digest], :MD5], :hexdigest, [:array, args.second]]
+        end
+
+        def rewrite_fcall_md5_file(args)
+          [:call, [:colon2, [:const, :Digest], :MD5], :hexdigest, [:array, [:call, [:const, :File], :read, [:array, args.second]]]]
+        end
+
+        def rewrite_fcall_sha1(args)
+          [:call, [:colon2, [:const, :Digest], :SHA1], :hexdigest, [:array, args.second]]
+        end
+
+        def rewrite_fcall_sha1_file(args)
+          [:call, [:colon2, [:const, :Digest], :SHA1], :hexdigest, [:array, [:call, [:const, :File], :read, [:array, args.second]]]]
+        end
+
+        # arrays
+
+        def rewrite_fcall_count(args)
+          [:call, args.second, :length]
+        end
+
+        def rewrite_fcall_array_combine(args)
+          [:call, args.second, :combine, [:array, args.third]]
+        end
+
+        def rewrite_fcall_array_merge(args)
+          [:call, args.second, :merge, [:array, args.third]]
+        end
+
+        # strings..
+
+        def rewrite_fcall_strrev(args)
+          [:call, args.second, :reverse]
+        end
+
+        def rewrite_fcall_stripslashes(args)
+          [:call, args.second, :gsub, [:array, [:str, "\\"], [:str, ""]]]
+        end
+        
+        def rewrite_fcall_strlen(args)
+          [:call, args.second, :length]
+        end
+
+        def rewrite_fcall_rtrim(args)
+          if args.length == 2
+            [:call, args.second, :rstrip]
+          elsif args.length == 3
+            regex = [:lit, eval(Regexp.new("[#{args.third.last}]+$").inspect)]
+            [:call, args.second, :gsub, [:array, regex, [:str, '']]]
+          end
+        end
+
+        def rewrite_fcall_ltrim(args)
+          if args.length == 2
+            [:call, args.second, :lstrip]
+          elsif args.length == 3
+            regex = [:lit, eval(Regexp.new("^[#{args.third.last}]+").inspect)]
+            [:call, args.second, :gsub, [:array, regex, [:str, '']]]
+          end
+        end
+
+        def rewrite_fcall_trim(args)
+          if args.length == 2
+            [:call, args.second, :strip]
+          elsif args.length == 3
+            regex = [:lit, eval(Regexp.new("^[#{args.third.last}]+|[#{args.third.last}]+$").inspect)]
+            [:call, args.second, :gsub, [:array, regex, [:str, '']]]
+          end          
+        end
+
+        def rewrite_fcall_ucfirst(args)
+          [:call, args.second, :capitalize]
+        end
+
+        def rewrite_fcall_strtolower(args)
+          [:call, args.second, :downcase]
+        end
+
+        def rewrite_fcall_strtoupper(args)
+          [:call, args.second, :upcase]
+        end
+
+        def rewrite_fcall_strtr(args)
+          [:call, args.second, :tr, [:array, args.third, args.fourth]]
+        end
+
+        def rewrite_fcall_strpos(args)
+          [:call, args.second, :index, [:array, args.third]]
+        end
+
+        def rewrite_fcall_strrpos(args)
+          [:call, args.second, :rindex, [:array, args.third]]
+        end
+
+        def rewrite_fcall_substr(args)
+          if args.length == 4
+            [:call, args.second, :slice, [:array, args.third, args.fourth]]
+          elsif args.length == 3
+            single_arg = args.third.last
+            if single_arg < 0
+              positive_arg = [:lit, (-single_arg)]
+              [:call, args.second, :slice, [:array, args.third, positive_arg]]
+            else
+              range = [:lit, eval(single_arg.to_s + "..-1")]
+              [:call, args.second, :slice, [:array, range]]
+            end
+          end
+        end
+
+        # string replacement
+
+        def rewrite_fcall_substr_replace(args)
+          if args.length == 5
+            [:attrasgn, args.second, :[]=, [:array, args.fourth, args.fifth, args.third]]
+          elsif args.length == 4
+            single_arg = args.fourth.last
+            range = [:lit, eval(single_arg.to_s + "..-1")]
+            [:attrasgn, args.second, :[]=, [:array, range, args.third]]
+          end
+        end
+
+        def rewrite_fcall_str_replace(args)
+          [:call, args.fourth, :gsub, [:array, args.second, args.third]]
+        end
+
+        def rewrite_fcall_str_ireplace(args)
+          regex = [:lit, eval(Regexp.new(args.second.last, Regexp::IGNORECASE).inspect)]
+          [:call, args.fourth, :gsub, [:array, regex, args.third]]
+        end
+
+        def rewrite_fcall_preg_replace(args)
+          regex = [:lit, eval(args.second.last)]
+          [:call, args.fourth, :gsub, [:array, regex, args.third]]
+        end
+
+        def rewrite_fcall_preg_split(args)
+          regex = [:lit, eval(args.second.last)]
+          [:call, args.third, :split, [:array, regex]]
+        end
+      end
+    end
+  end
+end