archruby 0.2.0 → 0.3.0

data/lib/archruby/ruby/type_inference/ruby/process_method_params.rb

@@ -0,0 +1,276 @@
+module Archruby
+  module Ruby
+    module TypeInference
+      module Ruby
+
+        class ProcessMethodParams < SexpInterpreter
+          def initialize(ast, local_scope)
+            super()
+            @ast = ast
+            @current_dependency_class = []
+            @current_dependency_class_name = nil
+            @local_scope = local_scope
+            @params = []
+          end
+
+          def parse
+            @ast.map! {|sub_tree| process(sub_tree)}
+            @params
+          end
+
+          def process_defn(exp)
+            #estudar esse caso
+          end
+
+          def process_dregx_once(exp)
+            _, start, *args = exp
+            args.map! {|sub_tree| process(sub_tree) if sub_tree.class == Sexp}
+          end
+
+          def process_block(exp)
+            _, *args = exp
+            args.map! { |subtree| process(subtree) }
+          end
+
+          def process_kwsplat(exp)
+            _, *args = exp
+            args.map! { |subtree| process(subtree) }
+          end
+
+          def process_dot3(exp)
+            _, left, right = exp
+            process(left)
+            process(right)
+          end
+
+          def process_lasgn(exp)
+          end
+
+          def process_lvar(exp)
+            _, lvar_name = exp
+            type = @local_scope.var_type(lvar_name)
+            if type
+              add_to_params(type)
+            else
+              add_to_params(lvar_name)
+            end
+            #chamado para pegar o valor
+          end
+
+          def process_const(exp)
+            _, const_name = exp
+            if !@current_dependency_class.empty?
+              @current_dependency_class_name = build_full_name(const_name)
+              add_to_params(@current_dependency_class_name)
+              @current_dependency_class_name = nil
+            else
+              add_to_params(const_name)
+            end
+          end
+
+          def process_call(exp)
+            _, receiver, method_name, *params = exp
+            process(receiver)
+          end
+
+          def process_block_pass(exp)
+            _, *args = exp
+            args.map! { |subtree| process(subtree) }
+          end
+
+          def add_to_params(name)
+            @params << name
+          end
+
+          def process_colon2(exp)
+            _, first_part, last_part = exp
+            @current_dependency_class.unshift(last_part)
+            process(first_part)
+          end
+
+          def process_colon3(exp)
+            _, constant_name = exp
+            @current_dependency_class_name = build_full_name("::#{constant_name}")
+          end
+
+          def build_full_name(const_name)
+            @current_dependency_class.unshift(const_name)
+            full_class_path = @current_dependency_class.join('::')
+            @current_dependency_class = []
+            full_class_path
+          end
+
+          def process_hash(exp)
+            _, key, value = exp
+            process(key)
+            process(value)
+          end
+
+          def process_splat(exp)
+            _, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_iasgn(exp)
+            _, instance_varialbe_name, *value = exp
+            value.map! { |subtree| process(subtree) }
+          end
+
+          def process_if(exp)
+            _, condition, true_body, else_body = exp
+            process(condition)
+            process(true_body)
+            process(else_body)
+          end
+
+          def process_iter(exp)
+            _, first_part, second_part, *body = exp
+            process(first_part)
+            body.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_dstr(exp)
+            _, init, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_evstr(exp)
+            _, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_xstr(exp)
+          end
+
+          def process_array(exp)
+            _, *elements = exp
+            elements.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_match2(exp)
+            _, rec, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_defined(exp)
+            _, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_dxstr(exp)
+            _, str, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_dregx(exp)
+            _, str, *args = exp
+            args.map! {|sub_tree| process(sub_tree) if sub_tree.class == Sexp }
+          end
+
+          def process_dot2(exp)
+            _, left, right = exp
+            process(left)
+            process(right)
+          end
+
+          def process_dsym(exp)
+            _, str, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_or(exp)
+            _, left_side, right_side = exp
+            process(left_side)
+            process(right_side)
+          end
+
+          def process_and(exp)
+            _, left_side, right_side = exp
+            process(left_side)
+            process(right_side)
+          end
+
+          def process_case(exp)
+            _, condition, when_part, ensure_part = exp
+            process(condition)
+            process(when_part)
+            process(ensure_part)
+          end
+
+          def process_when(exp)
+            _, condition, body = exp
+            process(condition)
+            process(body)
+          end
+
+          def process_rescue(exp)
+            _, body, rescbody = exp
+            process(body)
+            process(rescbody)
+          end
+
+          def process_attrasgn(exp)
+            _, receiver, method, arg, value = exp
+            process(receiver)
+            process(value)
+          end
+
+          def process_yield(exp)
+            _, *args = exp
+            args.map! {|sub_tree| process(sub_tree)}
+          end
+
+          def process_match3(exp)
+            _, first, second = exp
+            process(first)
+            process(second)
+          end
+
+          def process_nth_ref(exp)
+          end
+
+          def process_gvar(exp)
+          end
+
+          def process_back_ref(exp)
+          end
+
+          def process_lit(exp)
+            _, value = exp
+          end
+
+          def process_cvar(exp)
+            # class variable
+          end
+
+          def process_super(exp)
+          end
+
+          def process_nil(exp)
+          end
+
+          def process_self(exp)
+          end
+
+          def process_str(exp)
+          end
+
+          def process_false(exp)
+          end
+
+          def process_true(exp)
+          end
+
+          def process_ivar(exp)
+          end
+
+          def process_zsuper(exp)
+          end
+
+
+        end
+
+      end
+    end
+  end
+end

data/lib/archruby/ruby/type_inference/type_inference_checker.rb

@@ -0,0 +1,126 @@
+module Archruby
+  module Ruby
+    module TypeInference
+
+      class TypeInferenceChecker
+        attr_reader :dependencies, :method_definitions
+
+        def initialize(dependencies, method_definitions)
+          @dependencies = dependencies
+          @method_definitions = method_definitions
+        end
+
+        def total_deps
+          total_dep = 0
+          @dependencies.each do |class_name, deps|
+            total_dep += deps.size
+          end
+          total_dep
+        end
+
+        def add_dependency_based_on_calls
+          @method_definitions.each do |class_name, method_definitions|
+            method_definitions.each do |method_definition|
+              method_definition.method_calls.each do |method_call|
+                receiver_class = method_call.class_name
+                method_name = method_call.method_name
+                dependencies = extract_param_classes(method_definition.args, method_call.params)
+                add_new_dependencies(receiver_class, dependencies, method_name)
+              end
+            end
+          end
+        end
+
+        def add_dependency_based_on_internal_calls
+          3.times do
+            @method_definitions.each do |class_name, method_definitions|
+              method_definitions.each do |method_definition|
+                method_definition.method_calls.each do |method_call|
+                  receiver_class = method_call.class_name
+                  method_name = method_call.method_name
+                  formal_params = extract_formal_parameter(method_call.params)
+                  dependencies = extract_param_classes(method_definition.args, formal_params)
+                  add_new_dependencies(receiver_class, dependencies, method_name)
+                end
+              end
+            end
+          end
+        end
+
+        def extract_param_classes(method_args, params)
+          dependencies = []
+          params.each do |param|
+            if param.class == Symbol
+              type = method_args[param]
+              type = type.to_a
+              dependencies << type
+            elsif param.class == String
+              type = [param]
+              dependencies << type
+            end
+          end
+          dependencies
+        end
+
+        def extract_formal_parameter(params)
+          formal_params = []
+          params.each do |param|
+            if param.class == Symbol
+              formal_params << param
+            end
+          end
+          formal_params
+        end
+
+        def add_new_dependencies(receiver_class, dependencies, method_name)
+          add_to_dependencies(receiver_class, dependencies)
+          add_to_method_definitions(receiver_class, dependencies, method_name)
+        end
+
+        def add_to_dependencies(receiver_class, dependencies)
+          dep_class = @dependencies[receiver_class]
+          if dep_class.nil?
+            @dependencies[receiver_class] = Set.new
+            dep_class = @dependencies[receiver_class]
+          end
+          # utilizamos o flatten pois aqui não importa a posição
+          # do parametro formal
+          dependencies.flatten.each do |dependency|
+            dep_class.add(dependency)
+          end
+        end
+
+        def add_to_method_definitions(receiver_class, dependencies, method_name)
+          method_definitions = @method_definitions[receiver_class]
+          if method_definitions
+            method_definitions.each do |method_definition|
+              if method_definition.method_name == method_name
+                add_new_params_dependency(method_definition, dependencies)
+                break
+              end
+            end
+          end
+        end
+
+        def add_new_params_dependency(method_definition, dependencies)
+          args = method_definition.args.keys
+          dependencies.each_with_index do |deps, i|
+            # aqui mantemos a ordem dos parametros formais
+            formal_parameter_name = method_definition.args[args[i]]
+            if formal_parameter_name
+              deps.each do |dep|
+                begin
+                  formal_parameter_name.add(dep)
+                rescue
+                  binding.pry
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/archruby/version.rb

@@ -1,3 +1,3 @@
 module Archruby
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/spec/architecture/file_content_spec.rb

@@ -3,7 +3,8 @@ require 'spec_helper'
 describe Archruby::Architecture::FileContent do
 
   it 'get the content from the right files' do
-    file_reader = Archruby::Architecture::FileContent.new("/Users/sergiomiranda/Labs/ruby_arch_checker/arch_checker/spec/dummy_app/app/")
+    fake_app_path = File.expand_path('../../dummy_app/app', __FILE__)
+    file_reader = Archruby::Architecture::FileContent.new(fake_app_path)
     content = file_reader.all_content_from_directory "controllers/**/*.rb"
     content.keys.should include('application_controller')
     content['application_controller'].should_not be_nil

data/spec/architecture/module_definition_spec.rb

@@ -21,8 +21,8 @@ describe Archruby::Architecture::ModuleDefinition do
     base_directory = File.expand_path('../../dummy_app/', __FILE__)
     config_definition = Archruby::Architecture::ConfigDefinition.new 'model', parsed_yaml['model']
     module_definition = Archruby::Architecture::ModuleDefinition.new(config_definition, base_directory)
-    module_definition.already_has_dependency?("User", "ActiveRecord::Base").should be_true
-    module_definition.already_has_dependency?("User", "ClassQualquer").should be_false
+    expect(module_definition.already_has_dependency?("User", "ActiveRecord::Base")).to be_true
+    expect(module_definition.already_has_dependency?("User", "ClassQualquer")).to be_false
   end
 
   it 'build the dependencies correctly' do
@@ -38,13 +38,13 @@ describe Archruby::Architecture::ModuleDefinition do
     base_directory = File.expand_path('../../dummy_app/', __FILE__)
     config_definition = Archruby::Architecture::ConfigDefinition.new 'model', parsed_yaml['model']
     module_definition = Archruby::Architecture::ModuleDefinition.new(config_definition, base_directory)
-    module_definition.is_mine?("Teste").should be_true
-    module_definition.is_mine?("User").should be_true
-    module_definition.is_mine?("ActiveRecord").should be_false
-    module_definition.is_mine?("QualquerCoisa").should be_false
-    module_definition.is_mine?("::User").should be_true
-    module_definition.is_mine?("::User::Nao::Sei").should be_false
-    module_definition.is_mine?("Testando::VaiAcessar").should be_true
+    expect(module_definition.is_mine?("Teste")).to be_true
+    expect(module_definition.is_mine?("User")).to be_true
+    expect(module_definition.is_mine?("ActiveRecord")).to be_false
+    expect(module_definition.is_mine?("QualquerCoisa")).to be_false
+    expect(module_definition.is_mine?("::User")).to be_true
+    expect(module_definition.is_mine?("::User::Nao::Sei")).to be_false
+    expect(module_definition.is_mine?("Testando::VaiAcessar")).to be_true
 
     config_definition = Archruby::Architecture::ConfigDefinition.new 'actioncontroller', parsed_yaml['actioncontroller']
     module_definition = Archruby::Architecture::ModuleDefinition.new(config_definition, base_directory)