farleyknight-ionize 0.1.0

data/lib/ionize/translate/rewritable.rb

@@ -0,0 +1,133 @@
+module Ionize
+  module Php
+    module Translate   
+      module Rewritable
+        def transform(*args)
+          parent.transform(*args)
+        end
+                
+        def rewrite_fcall(name, args)          
+          __send__("rewrite_fcall_#{name}", args)
+        end
+
+        def rewrite_lasgn(name, var, expr)
+          __send__("rewrite_lasgn_#{name}", var, expr)
+        end
+
+        def fcall_rewritable?(name)
+          respond_to? "rewrite_fcall_#{name}"
+        end
+
+        def lasgn_rewritable?(name)
+          respond_to? "rewrite_lasgn_#{name}"
+        end
+
+        def handle_regular_fun_call(node)
+          debug "Regular fun call #{node.inspect}"
+          name = parent.transform(node.first).to_sym
+          
+          # TODO: Simplify this condition..
+          result = if node.third[:fun_args_within_call] == [{:no_args => []}] or 
+                       node.third[:fun_args_within_call] == [{:no_args_within_call=>[]}]
+                     args = nil
+                     [:fcall, name]
+                   else
+                     args = parent.transform(node.third)
+                     [:fcall, name, args]
+                   end
+
+          if fcall_rewritable? name
+            rewrite_fcall(name, args)
+          else
+            result
+          end
+        end
+
+        def handle_term_assign_oo_variable(node)
+          debug "The oo assign node is #{node.inspect}"
+          # TODO: Pretty this up some.. If possible..
+          object = parent.transform(node.first)
+
+          debug "The object to be set is #{object.inspect}"
+          object.shift # discard leading :call
+
+          attribute = object.pop
+          debug "The attribute to be set is #{attribute.inspect}"
+          
+          assigned = attribute.to_s + "=" # pop off assigned to var
+          debug "Before transforming, the expression to be set is #{node.third.inspect}"
+          expr = parent.transform(node.third)
+          debug "The expression to be set is #{expr.inspect}"
+          
+          # TODO: Move this rewrite to the Rewrites class
+          object = (if object.first == [:lvar, :this] then [:self] else object.first end)
+
+          [:attrasgn, object, assigned.to_id, [:array, expr]]          
+        end
+
+        def handle_term_assign_oo_array_lookup(node)
+          debug "Term assign oo array lookup is #{node.inspect}"
+          
+          term = transform(node.first)
+          expr = transform(node.third)
+          
+          debug "Term is #{term.inspect}"
+          
+          [:attrasgn] + 
+            [term.second] + 
+            [:[]=] + 
+            [term.fourth + [expr]]
+        end
+
+        def handle_term_assign_oo_variable_variable(node)
+          debug "Term assign oo variable variable is #{node.inspect}"
+          term = transform(node.first)
+          expr = transform(node.third)
+          debug "Term inside oo variable variable is #{term.inspect}"
+          term[0..1]  + [:set] + [term[3] + [expr]]
+        end
+
+        def handle_term_assign_array_lookup(node)
+          term = transform(node.first)
+          expr = transform(node.third)
+          [:attrasgn] + [term[1]] + [:[]=] + [term[3] + [expr]]
+        end
+
+        def handle_term_assign_array_append(node)
+          [:call, transform(node.first), :<<, [:array, transform(node.third)]]
+        end
+
+        def handle_term_assign(node)
+          debug "Term assign node is #{node.inspect}"
+          
+          if node.first.node_type == :oo_variable
+            return handle_term_assign_oo_variable(node)
+          elsif node.first.node_type == :oo_array_lookup
+            return handle_term_assign_oo_array_lookup(node)
+          elsif node.first.node_type == :oo_variable_variable
+            return handle_term_assign_oo_variable_variable(node)
+          elsif node.first.node_type == :array_lookup
+            return handle_term_assign_array_lookup(node)
+          elsif node.first.node_type == :array_append
+            return handle_term_assign_array_append(node)
+          end
+
+          term, op, expr = *node
+          var = parent.transform(term).last
+          debug "Term assign #{term.inspect}"
+
+          expr = parent.transform(expr)
+          if expr.is_a? Array
+            if expr.first == :fcall and lasgn_rewritable? expr.second
+              rewrite_lasgn(expr.second, var, expr)
+            else
+              [:lasgn, var, expr]
+            end
+          else
+            [:lasgn, var, [expr]]
+          end          
+        end
+      end
+    end
+  end
+end

data/lib/ionize/translate/rewrites.rb

@@ -0,0 +1,51 @@
+load 'ionize/translate/rewritable.rb'
+
+module Ionize
+  module Php
+    module Translate   
+      class Rewrites < Translator
+        include Debug, Rewritable, RailsForPhp
+
+        def rewrite_lasgn_ereg(var, expr)
+          regex, object, matches = *expr.last.rest
+          
+          [:masgn, 
+           [:array, [:lasgn, var], [:lasgn, matches.last]], 
+           [:to_ary, [:call, object, :match, [:array, [:lit, eval("/" + regex.last + "/")]]]]]
+        end
+
+        def rewrite_lasgn_eregi(var, expr)
+          regex, object, matches = *expr.last.rest
+          
+          [:masgn, 
+           [:array, [:lasgn, var], [:lasgn, matches.last]], 
+           [:to_ary, [:call, object, :match, [:array, [:lit, eval("/" + regex.last + "/i")]]]]]
+        end
+
+        def rewrite_fcall_var_dump(args)
+          [:fcall, :puts, args]
+        end
+        
+        def rewrite_fcall_define(args)
+          [:cdecl, args.second.second.to_sym, args.third]
+        end
+
+        def rewrite_fcall_function_exists(args)
+          [:fcall, :respond_to?, args]
+        end
+
+        def rewrite_fcall_isset(args)
+          [:call, args.second, :not_nil?]
+        end
+
+        def rewrite_fcall_array_intersect(args)
+          [:call, args.second, :intersect, [:array, args.third]]
+        end
+
+        def rewrite_fcall_mysql_connect(args)
+          [:call, [:const, :Mysql], :new, args]
+        end
+      end
+    end
+  end
+end

data/lib/ionize/translate/statements.rb

@@ -0,0 +1,622 @@
+
+load 'ionize/translate/multiple_statements.rb'
+load 'ionize/translate/if_statements.rb'
+load 'ionize/translate/switch_case_statements.rb'
+load 'ionize/translate/term_statements.rb'
+load 'ionize/translate/composite_string_statements.rb'
+load 'ionize/translate/rails_for_php.rb'
+
+Object.class_eval do
+  def to_id
+    if is_a? String
+      to_sym
+    else
+      self
+    end
+  end
+end
+
+module Ionize
+  module Php
+    module Translate
+      class Statements < Translator
+        include Debug, IfStatements, MultipleStatements
+        include SwitchCaseStatements, TermStatements
+        include CompositeStringStatements
+        
+        attr_writer :globals
+        
+        def globals
+          @globals ||= []
+        end
+
+        IdentityTransforms = [
+                              "one_variable", "unmatched", "term", "single_statement", 
+                              "matched",  "simple", "single_arg", "literal_variable", 
+                              "array_variable", "one_bracket"
+                             ]
+
+        IdentityTransforms.each do |transform|
+          define_method "handle_#{transform}" do |node|
+            transform(node)
+          end
+        end
+
+        # TODO: This is such a stupid name for a node 
+        def handle_regular_fun_call(node)
+          # TODO: Move rewrites into it's own pass,
+          # instead of injecting it into this one..
+          Rewrites.new(self).handle_regular_fun_call(node)
+        end
+
+        def handle_class_method_call(node)
+          [:call, [:const, transform(node.first).to_id], transform(node.third).to_id, transform(node.fifth)]
+        end
+        
+        def handle_multiple_variables(node)
+          first = transform(node.first)
+          rest  = transform(node.third)
+
+          debug "Multiple variables #{first.inspect}, #{rest.inspect}"
+
+          result = if rest.composite_node?
+                     [first] + rest
+                     if first.composite_node?
+                       first + rest
+                     end
+                   elsif first.composite_node?
+                     first + [rest]
+                   else
+                     [first, rest]
+                   end
+
+          debug "Multiple variables result #{result.inspect}"      
+          result
+        end
+
+        ###############
+        ### globals ###
+        ###############
+
+        # We will have to keep track of this at some point
+        # to replace every similar pattern in the entire tree
+        def handle_global_declaration(node)
+          variable = transform(node.second)
+
+          debug "Global variables are #{variable.inspect}"
+
+          # Keeping track of the global variables so we can 
+          # replace them as we encounter local variables
+          if variable.composite_node?
+            multiple_globals = [:array] + variable.map do |lvar|
+              self.globals << lvar.last
+              lvar.last.to_global_variable
+            end
+            [:fcall, :global, multiple_globals]
+          elsif variable.first == :lvar 
+            self.globals << variable.last
+            variable.last.to_global_variable
+          elsif variable.first == :gvar
+            variable
+          else
+            variable.to_global_variable
+          end
+        end
+
+        def handle_break_statement(node)
+          [:break]
+        end
+
+        def handle_exit_statement(node)
+          [:vcall, :exit]
+        end
+
+        def handle_exit_call_statement(node)
+          [:vcall, :exit]
+        end
+
+        def handle_require_statement(node)
+          [:fcall, :require, [:array, transform(node.second)]]
+        end        
+
+        def handle_require_once_statement(node)
+          [:fcall, :require, [:array, transform(node.second)]]
+        end
+
+        def handle_include_statement(node)
+          [:fcall, :load, [:array, transform(node.second)]]
+        end
+
+        def handle_include_once_statement(node)
+          [:fcall, :load, [:array, transform(node.second)]]
+        end
+
+        def handle_for_statement(node)
+          setup       = transform(node.third)
+          condition   = transform(node[4])
+          update      = transform(node[6])
+          body        = transform(node[8])
+
+          while_body  = if body.composite_node?
+                          [:block] + body + [update]
+                        else
+                          [:block] + [body] + [update]
+                        end
+
+          [setup] + [[:while, condition, while_body, true]]
+        end
+
+        # This should get moved to Rewrites..
+        def handle_foreach_statement(node)
+          variable = transform(node[4]).last
+
+          body     = transform(node[6])
+          body     = body.replace_pattern([:lvar, variable], [:dvar, variable])
+
+          [:iter, 
+           [:call, transform(node.third), :each],
+           [:dasgn_curr, variable], body.to_block]
+        end
+
+        def handle_while_statement(node)
+          condition = transform(node.third)
+          body      = transform(node.fifth).to_block
+          
+          [:while, condition, body, true]
+        end
+
+        #######################################
+        ### recursive switch case statement ###
+        #######################################
+
+        def handle_opt_multiple_statements(node)
+          first_node  = [transform(node.first)]
+          
+          second_node = if (result = transform(node.second)).composite_node?
+                          result
+                        else
+                          [result]
+                        end
+          
+          result = [:block] + first_node + second_node
+          debug "Opt multiple statements result is #{result.inspect}"
+          result
+        end
+
+        def handle_opt_no_statements(node)
+          nil
+        end
+
+        ###################
+        ### list assign ###
+        ###################
+
+        # Yes, Php has a destructuring bind.. 
+        # kinda ugly, though
+        def handle_list_assign(node)
+          variables = [:array] + (transform(node.third).rest.map {|v| [:lasgn, v] })
+          [:masgn, variables, 
+           [:splat, transform(node.sixth)]]
+        end      
+
+        #####################
+        ### oo statements ###
+        #####################
+
+        def handle_new_object(node)
+          [:call, [:const, transform(node.second).to_id], :new]
+        end
+
+        def handle_new_object_with_args(node)
+          if node.fourth == {:fun_args_within_call=>[{:no_args_within_call=>[]}]}
+            [:call, [:const, transform(node.second).to_id], :new]
+          else
+            # TODO: Handle this..
+          end
+        end
+
+        def handle_new_variable_class_object(node)
+          [:call, 
+           [:call,
+            [:const, :Object], :const_get,
+            [:array, transform(node.second)]], :new]
+        end
+
+        def handle_class_statement(node)
+          [:class, transform(node.second).to_id, nil, 
+           [:scope, transform(node.fourth).to_block]]
+        end
+
+        def handle_class_extends_statement(node)
+          [:class, transform(node.second).to_id, [:const, transform(node.fourth).to_id],
+           [:scope, transform(node[5]).to_block]]          
+        end
+
+        def handle_class_var_statement(node)
+          [:fcall, :attr_accessor, [:array, [:lit, transform(node.second).last]]]
+        end
+
+        def handle_class_var_with_default_statement(node)
+          [:fcall, :attr_accessor, [:array, [:lit, transform(node.second).last], transform(node.fourth)]]
+        end
+
+        def handle_braced_statements(node)
+          transform(node.second)
+        end
+
+        def handle_print_statement(node)
+          [:fcall, :print, [:array, transform(node).first]]
+        end
+
+        def handle_echo_statement(node)
+          [:fcall, :echo, [:array, transform(node.second)]]
+        end
+
+        def handle_user_constant(node)
+          [:const, transform(node).to_id]
+        end
+
+        def handle_word(node)
+          node
+        end
+
+        def handle_no_args(node)
+          [:args]
+        end
+
+        def handle_no_args_within_call(node)
+          [:args]
+        end
+
+        # Comment this out and see if it can be refactored with the
+        # handler above
+        def handle_a_variable(node)
+          result = transform(node)
+
+          if result.is_a? Array
+            result
+          else
+            [:lvar, result.gsub("$", "").to_id]
+          end
+        end
+
+        def handle_op(node)
+          if node == ".="
+            :<<
+          else
+            node.to_id
+          end
+        end
+
+        def handle_not_var(node)
+          debug "Not var #{node.inspect}"
+          [:not, transform(node.second)]
+        end
+
+        def handle_post_increment_var(node)
+          debug "Post increment var #{node.inspect}"
+          variable = transform(node.first)
+          [:lasgn, variable.second, [:call, variable, :+, [:array, [:lit, 1]]]]
+        end
+
+        def handle_post_decrement_var(node)
+          variable = transform(node.first)
+          [:lasgn, variable.second, [:call, variable, :-, [:array, [:lit, 1]]]]      
+        end
+
+        def handle_negative_var(node)
+          result = transform(node.second)
+          result[1] = (-result[1])
+          result
+        end
+
+        def handle_multiple_args(node)
+          debug "Multiple args #{node.inspect}"
+          args = FunctionArgs.new(self).handle_multiple_args(node)
+          debug "Multiple args transformed is #{args.inspect}"
+          unless args == [:args]
+            [:args] + args
+          else
+            [:args]
+          end
+        end 
+
+        def handle_multiple_args_within_call(node)
+          debug "Multiple args within fun call #{node.inspect}"
+
+          first  = transform(node.first)
+          second = transform(node.third)
+
+          debug "Multiple args first is #{first.inspect} and second is #{second.inspect}"
+
+          result = if first.composite_node?
+                     first + [second]
+                   elsif first.first == :hash and second.first == :hash
+                     first + second.rest
+                   else
+                     [first, second]
+                   end
+
+          debug "Multiple args within fun call result #{result.inspect}"
+          result
+        end
+
+        def handle_single_arg_within_call(node)
+          result = transform(node)      
+          debug "Single arg within fun call #{result.inspect}"
+          result
+        end
+
+        def handle_one_expr_bracket(node)
+          transform(node.second)
+        end
+
+        def handle_array_lookup(node)
+          [:call, transform(node.first), :[], [:array, transform(node.third)]]
+        end
+
+        def handle_braced_lookup(node)
+          [:call, transform(node.first), :[], [:array, transform(node.third)]]
+        end
+
+        def handle_paren_expr(node)
+          transform(node.second)
+        end
+
+        def handle_return_one(node)
+          [:return, transform(node.second)]
+        end
+
+        def handle_return_zero(node)
+          [:return]
+        end
+
+        def handle_tertiary(node)
+          [:if, transform(node.first), transform(node.third), transform(node.fifth)]
+        end
+        
+        def handle_cast(node)
+          node
+        end
+
+        def handle_paren_cast(node)
+          type = ("to_" + transform(node.second).to_s).to_id
+          term = transform(node.fourth)
+
+          [:call, term, type]
+        end
+
+        def handle_fun_define(node)  
+          args = FunctionArgs.new(self).transform(node[3])
+          
+          debug "Args for fun_define are #{args.inspect}"
+          parameters = if args == [:args]
+                         [:args]
+                       elsif args.is_a? Array
+                         [:args] + args
+                       else
+                         [:args, args]
+                       end
+
+          body = transform(node[6])
+          body.shift if body.first == :block
+          debug "Body is #{body.inspect}"
+
+          if body.composite_node?
+            function_block = [:block, parameters] + body
+          else
+            function_block = [:block, parameters, body]
+          end
+
+          [:defn, node.second.to_a.first.second.to_id, 
+           [:scope, function_block]]
+        end
+        
+        def handle_variable(node)
+          result = node.gsub("$", "").to_id
+
+          if self.globals.include? result
+            [:gvar, ("$" + result.to_s.gsub("$", "")).to_id]
+          else
+            [:lvar, result]
+          end
+        end
+
+        def handle_fun_args_within_call(node)
+          debug "Fun args within call #{node.inspect}"
+          result = transform(node)
+          debug "Fun args within call result #{result.inspect}"      
+          if result.empty?
+            nil
+          elsif result.nil?
+            nil
+          elsif result.composite_node?
+            [:array] + result
+          else
+            [:array, result]
+          end
+        end
+
+        def handle_fun_args_with_trailing_comma(node)
+          debug "Fun args with trailing comma #{node.inspect}"
+          result = transform(node.first)
+          
+          if result.empty?
+            nil
+          elsif result.nil?
+            nil
+          elsif result.composite_node?
+            [:array] + result
+          else
+            [:array, result]
+          end
+        end
+
+        
+        ###########################
+        ### multiple statements ###
+        ###########################
+
+        def handle_multiple_statements(node)
+          # This implementation is kind of old
+          # and stinky.. Could probably be done
+          # a lot better
+          
+          multiple_statements do
+            first, second = transform(node.first), transform(node.second)
+            result = if second.composite_node?
+                       if first.composite_node?
+                         first + second
+                       else
+                         [first] + second
+                       end
+                     else
+                       [first, second]
+                     end
+            
+            final_result = if level == 1
+                             [:block] + result
+                           else
+                             result
+                           end            
+            final_result
+          end        
+        end
+
+
+        ################
+        ### oo exprs ###
+        ################
+
+        def handle_oo_assign(node)
+          debug "The oo assign node is #{node.inspect}"
+          # TODO: Pretty this up some.. If possible..
+          object = transform(node.first)
+
+          debug "The object to be set is #{object.inspect}"
+          object.shift # discard leading :call
+
+          attribute = object.pop
+          debug "The attribute to be set is #{attribute.inspect}"
+          
+          assigned = attribute.to_s + "=" # pop off assigned to var
+          expr = transform(node.fifth)
+          
+          # TODO: Move this rewrite to the Rewrites class
+          object = (if object.first == [:lvar, :this] then [:self] else object.first end)
+
+          [:attrasgn, object, assigned.to_id, [:array, expr]]
+        end
+        
+        def handle_oo_array_assign(node)
+          [:attrasgn, 
+           [:call, transform(node.first), transform(node.third).to_id], 
+           :[]=, 
+           [:array, transform(node.fifth), transform(node[7])]]
+        end
+
+        def handle_oo_variable_variable(node)
+          [:call, transform(node.first), :get, [:array, transform(node.third)]]
+        end
+
+        def handle_oo_variable_variable_assign(node)
+          [:attrasgn, transform(node.first), :[]=, [:array, transform(node.third), transform(node.fifth)]]
+        end
+
+        def handle_oo_variable(node)
+          debug "oo_variable #{node.inspect}"
+          term = transform(node.first) 
+          # TODO: Move this rewrite to the Rewrites class
+          object = (if term == [:lvar, :this] then [:self] else term end)
+          [:call, object, transform(node.third).to_id]
+        end
+
+        def handle_single_oo_fragment(node)
+          transform(node.second)
+        end
+
+        def handle_array_append(node)
+          transform(node.first)
+        end
+
+        def handle_oo_array_lookup(node)          
+          [:call, [:call, transform(node.first), transform(node.third).to_sym], :[], [:array, transform(node.fifth)]]
+        end
+        
+        def handle_oo_expr(node)
+           transform(node)
+        end
+
+        def handle_oo_call(node)
+          debug "oo call node is #{node.inspect}"
+
+          if node.fifth == {:fun_args_within_call=>[{:no_args_within_call=>[]}]}
+            [:call, transform(node.first), transform(node.third).to_id]
+          else
+            [:call, transform(node.first), transform(node.third).to_id, transform(node.fifth)]
+          end
+        end
+
+        def handle_oo_regular_fun_call(node)
+          [transform(node.first).to_id, transform(node.third)]
+        end
+        
+        ################
+        ### literals ###
+        ################
+
+        def handle_true_value(node)
+          [:true]
+        end
+
+        def handle_false_value(node)
+          [:false]
+        end
+
+        def handle_single_quoted_string(node)
+          [:str, node]
+        end
+
+        def handle_double_quoted_string(node)
+          [:str, node]
+        end
+
+        ############
+        ### nils ###
+        ############
+
+        define_method "handle_;" do |node|
+          nil
+        end
+        
+        def handle_print(arg)
+          nil
+        end
+
+        define_method "handle_," do |node|
+          nil
+        end
+
+        ############
+        ### html ###
+        ############
+
+        def handle_html_text_with_php(node)
+          [:php] + transform(node)
+        end
+
+        def handle_html_string(node)
+          [:html, node]
+        end
+
+        def handle_php_start(node)
+          [:erb_start, "<%  "]
+        end
+
+        def handle_php_end(node)
+          [:erb_end, "  %>"]
+        end
+      end
+    end
+  end
+end