archruby 0.2.0 → 0.3.0

data/lib/archruby/ruby/parser.rb

@@ -6,10 +6,11 @@ module Archruby
 
     class Parser < SexpInterpreter
       attr_reader :dependencies, :classes, :classes_and_dependencies,
-                  :type_inference, :method_calls
+                  :type_inference, :method_calls, :type_propagation_parser
 
-      def initialize content
+      def initialize(content)
         super()
+        #a = Archruby::Presenters::Graph.new
         @content = content
         @dependencies = []
         @classes = []
@@ -18,21 +19,23 @@ module Archruby
         @module_names = []
         @complete_class_name = []
         @var_propagation = Archruby::Ruby::VarPropagation.new
+        @type_propagation_parser = Archruby::Ruby::TypeInference::Ruby::ParserForTypeinference.new
         @type_inference = []
         @method_calls = []
         parse
       end
 
       def parse
-        process ruby_parser.parse @content
+        process ruby_parser.parse(@content)
+        @type_propagation_parser.parse(@content)
       end
 
-      def process_block exp
+      def process_block(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_class exp
+      def process_class(exp)
         _, class_name, *args = exp
         if class_name.class == Symbol
           if !@module_names.empty?
@@ -42,17 +45,17 @@ module Archruby
           end
         else
           # cai aqui quando a definicao é algo do tipo: class Teste::De end
-          get_complete_class_name class_name
+          get_complete_class_name(class_name)
           @classes << @complete_class_name.join("::")
           @complete_class_name = []
         end
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def get_complete_class_name exp
+      def get_complete_class_name(exp)
         if exp[0] == :const
           _, const_name = exp
-          @complete_class_name.unshift const_name
+          @complete_class_name.unshift(const_name)
           return
         else
           _, first_part, last_constant_part = exp
@@ -61,53 +64,57 @@ module Archruby
         end
       end
 
-      def process_const exp
+      def process_const(exp)
         _, const_name = exp
         if !@full_class_path.empty?
           const_name = build_full_name(const_name)
         end
-        add_dependency const_name
-        build_class_dependency const_name, exp.line
+        add_dependency(const_name)
+        build_class_dependency(const_name, exp.line)
       end
 
-      def build_full_name const_name
-        @full_class_path.unshift const_name
+      def build_full_name(const_name)
+        @full_class_path.unshift(const_name)
         full_class_path = @full_class_path.join('::')
         @full_class_path = []
         full_class_path
       end
 
-      def build_class_dependency const_name, line_number
+      def build_class_dependency(const_name, line_number)
         return if @classes.empty?
         class_name = @classes.last
         @classes_and_dependencies[class_name] = [] if @classes_and_dependencies[class_name].nil?
         @classes_and_dependencies[class_name] << Archruby::Architecture::Dependency.new(const_name, line_number)
       end
 
-      def add_dependency const_name
+      def process_for(exp)
+        
+      end
+
+      def add_dependency(const_name)
         @dependencies << const_name.to_s if !@dependencies.include?(const_name.to_s)
       end
 
-      def process_colon3 exp
+      def process_colon3(exp)
         _, constant_name = exp
         const_name = build_full_name("::#{constant_name}")
-        add_dependency const_name
-        build_class_dependency const_name, exp.line
+        add_dependency(const_name)
+        build_class_dependency(const_name, exp.line)
       end
 
-      def process_call exp
+      def process_call(exp)
         _, receiver, method_name, *args = exp
-        process receiver
+        process(receiver)
         if receiver && (receiver[0] == :const || receiver[0] == :colon2)
           if @variables
-            @var_propagation.push @variables.last, exp.line, @dependencies.last
+            @var_propagation.push(@variables.last, exp.line, @dependencies.last)
           end
         end
         build_type_inference(receiver, method_name, args, exp.line)
         args.map! {|sub_tree| process sub_tree}
       end
 
-      def build_call_history receiver, method_name, params_name
+      def build_call_history(receiver, method_name, params_name)
         @method_calls << {
           :class => @classes.last,
           :method => @current_method_name,
@@ -115,10 +122,10 @@ module Archruby
           :class_call => receiver,
           :method_call => method_name,
           :method_call_params => params_name
-          }
+        }
       end
 
-      def build_type_inference receiver, method_name, params, line_num
+      def build_type_inference(receiver, method_name, params, line_num)
         if !@local_types.nil? && receiver && receiver[0] == :lvar
           receiver = @local_types[receiver[1]]
           params_name = []
@@ -151,28 +158,27 @@ module Archruby
         end
       end
 
-      def extract_arguments arguments
+      def extract_arguments(arguments)
         _, *arg_vars = arguments
         if arg_vars[0].class == Symbol
           @current_arguments = arg_vars
         end
       end
 
-      def process_defn exp
+      def process_defn(exp)
         @variables = []
         @local_types = {}
         _, method_name, method_arguments, *args = exp
         @current_method_name = method_name
         extract_arguments(method_arguments)
-        process method_arguments
+        process(method_arguments)
         args.map! {|sub_tree| process sub_tree}
         @var_propagation.vars.each do |var|
           var = var[var.keys.first]
           if var[:type]
             var[:lines].shift
             var[:lines].each do |line_number|
-
-              build_class_dependency var[:type], line_number
+              build_class_dependency(var[:type], line_number)
             end
           end
         end
@@ -182,185 +188,185 @@ module Archruby
         @current_arguments = nil
       end
 
-      def process_lasgn exp
+      def process_lasgn(exp)
         _, variable_name, *args = exp
         const_access = args[0][0] == :call unless args[0].nil?
         @variables.push(variable_name) if @variables
-        args.map! {|sub_tree| process sub_tree}
+        args.map!{ |sub_tree| process(sub_tree) }
         if @local_types.class == Hash && const_access
           @local_types[variable_name] = @dependencies.last
         end
       end
 
-      def process_lit exp
+      def process_lit(exp)
         _, value = exp
       end
 
-      def process_lvar exp
+      def process_lvar(exp)
         _, variable_name = exp
-        @var_propagation.push variable_name, exp.line
+        @var_propagation.push(variable_name, exp.line)
       end
 
-      def process_iter exp
+      def process_iter(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| next if sub_tree.class == Fixnum; process(sub_tree)}
       end
 
-      def process_args exp
+      def process_args(exp)
         _, *args = exp
         args.map! do |sub_tree|
           process sub_tree if sub_tree.class != Symbol
         end
       end
 
-      def process_nil exp
+      def process_nil(exp)
         _ = exp
       end
 
-      def process_str exp
+      def process_str(exp)
         _, string = exp
       end
 
-      def process_return exp
+      def process_return(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree) }
       end
 
-      def process_colon2 exp
+      def process_colon2(exp)
         _, first_part, last_part = exp
         @full_class_path.unshift(last_part)
-        process first_part
+        process(first_part)
       end
 
-      def process_hash exp
+      def process_hash(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
       def process_iasgn exp
         _, variable_name, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_defs exp
+      def process_defs(exp)
         _, receiver, method_name, arguments, *args = exp
-        process arguments
-        args.map! {|sub_tree| process sub_tree}
+        process(arguments)
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_attrasgn exp
+      def process_attrasgn(exp)
         _, object, method_call, *args = exp
-        process object
-        args.map! {|sub_tree| process sub_tree}
+        process(object)
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_ivar exp
+      def process_ivar(exp)
         _, instance_variable_name = exp
       end
 
-      def process_dstr exp
+      def process_dstr(exp)
         _, string, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_evstr exp
+      def process_evstr(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_self exp
+      def process_self(exp)
         _ = exp
       end
 
-      def process_masgn exp
+      def process_masgn(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_array exp
+      def process_array(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_cdecl exp
+      def process_cdecl(exp)
         _, constant_name = exp
       end
 
-      def process_and exp
+      def process_and(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_rescue exp
+      def process_rescue(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_resbody exp
+      def process_resbody(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_gvar exp
+      def process_gvar(exp)
         _, ruby_global_var_name = exp
       end
 
-      def process_if exp
+      def process_if(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_true exp
+      def process_true(exp)
         _ = exp
       end
 
-      def process_false exp
+      def process_false(exp)
         _ = exp
       end
 
-      def process_case exp
+      def process_case(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_when exp
+      def process_when(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_op_asgn1 exp
+      def process_op_asgn1(exp)
         _, variabe_rec, position_to_access, operator, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_arglist exp
+      def process_arglist(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_block_pass exp
+      def process_block_pass(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_or exp
+      def process_or(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_sclass exp
+      def process_sclass(exp)
         _, *args = exp
         args.map! {|sub_tree| process sub_tree}
       end
 
-      def process_next exp
+      def process_next(exp)
         _ = exp
       end
 
-      def process_module exp
+      def process_module(exp)
         _, module_name, *args = exp
         if module_name.class == Symbol
-          @module_names.push module_name.to_s
+          @module_names.push(module_name.to_s)
           @classes << @module_names.join('::')
         else
           get_complete_class_name(module_name)
@@ -368,98 +374,98 @@ module Archruby
           @module_names.push @complete_class_name.join('::')
           @complete_class_name = []
         end
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
         @module_names.pop
       end
 
-      def process_to_ary exp
+      def process_to_ary(exp)
         _, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_while exp
+      def process_while(exp)
         _, condition, *args = exp
         true_clause = args.pop
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_cvdecl exp
+      def process_cvdecl(exp)
         _, variable_name, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_cvar exp
+      def process_cvar(exp)
         _, variable_name = exp
       end
 
-      def process_until exp
+      def process_until(exp)
         _, condition, *args = exp
         true_clause = args.pop
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_yield exp
+      def process_yield(exp)
         _, *body = exp
         if !body.empty?
-          body.map! {|sub_tree| process sub_tree}
+          body.map! {|sub_tree| process(sub_tree)}
         end
       end
 
-      def process_dot2 exp
+      def process_dot2(exp)
         _, first, second = exp
       end
 
-      def process_zsuper exp
+      def process_zsuper(exp)
         _ = exp
       end
 
-      def process_op_asgn_or exp
+      def process_op_asgn_or(exp)
         _, first, second = exp
-        process first
-        process second
+        process(first)
+        process(second)
       end
 
-      def process_match3 exp
+      def process_match3(exp)
         _, regular_expression, *args = exp
-        args.map! {|sub_tree| process sub_tree}
+        args.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_break exp
+      def process_break(exp)
         _ = exp
       end
 
-      def process_dregx exp
+      def process_dregx(exp)
         _, regex = exp
       end
 
-      def process_super exp
+      def process_super(exp)
         _, args = exp
-        process args
+        process(args)
       end
 
-      def process_ensure exp
+      def process_ensure(exp)
         _, rescue_clause, *ensure_clause = exp
-        process rescue_clause
-        ensure_clause.map! {|sub_tree| process sub_tree}
+        process(rescue_clause)
+        ensure_clause.map! {|sub_tree| process(sub_tree)}
       end
 
-      def process_op_asgn2 exp
+      def process_op_asgn2(exp)
         _, left_assign, variable, method, args = exp
-        process left_assign
-        process args
+        process(left_assign)
+        process(args)
       end
 
-      def process_splat exp
+      def process_splat(exp)
         _, left_assign = exp
-        process left_assign
+        process(left_assign)
       end
 
-      def process_dxstr exp
+      def process_dxstr(exp)
         # shelling out
         _ = exp
       end
 
-      def process_dot3 exp
+      def process_dot3(exp)
         _ = exp
       end