archruby 0.2.0 → 0.3.0

data/lib/archruby/architecture/parser.rb

@@ -6,11 +6,12 @@ module Archruby
     class Parser
       attr_reader :modules
 
-      def initialize config_file_path, base_path
+      def initialize(config_file_path, base_path)
         @config_file = config_file_path
         @base_path = base_path
         @modules = []
         @type_inference_checker = TypeInferenceChecker.new
+        @type_inferece_dependency_organizer = Archruby::Ruby::TypeInference::DependencyOrganizer.new
         parse
         ruby_std_lib_module
         ruby_core_module
@@ -18,21 +19,34 @@ module Archruby
       end
 
       def parse
-        parsed_yaml = yaml_parser.load_file @config_file
+        parsed_yaml = yaml_parser.load_file(@config_file)
         parsed_yaml.each do |module_name, definitions|
           begin
-            config_definition = Archruby::Architecture::ConfigDefinition.new module_name, definitions
-            module_definition = Archruby::Architecture::ModuleDefinition.new config_definition, @base_path
-            @type_inference_checker.add_method_deps module_definition.class_methods_and_deps
-            @type_inference_checker.add_method_calls module_definition.class_methods_calls
+            config_definition = Archruby::Architecture::ConfigDefinition.new(module_name, definitions)
+            module_definition = Archruby::Architecture::ModuleDefinition.new(config_definition, @base_path)
+            # @type_inference_checker.add_method_deps(module_definition.class_methods_and_deps)
+            # @type_inference_checker.add_method_calls(module_definition.class_methods_calls)
+
+            @type_inferece_dependency_organizer.add_dependencies(module_definition.type_inference_dependencies)
+            @type_inferece_dependency_organizer.add_method_calls(module_definition.type_inference_methods_calls)
           rescue Archruby::MultipleConstraints => e
             STDOUT.puts "The config file is not right: #{e.msg} | err_code: #{e.status_code} | module_definition: #{module_name}"
             exit(e.status_code)
           end
           @modules << module_definition
-          @type_inference_checker.verify_types
-          @type_inference_checker.add_new_deps @modules
+          #binding.pry
+          # @type_inference_checker.verify_types
+          # @type_inference_checker.add_new_deps(@modules)
         end
+        type_inferece_verifier = Archruby::Ruby::TypeInference::TypeInferenceChecker.new(
+                                  @type_inferece_dependency_organizer.dependencies,
+                                  @type_inferece_dependency_organizer.method_definitions
+                                )
+        type_inferece_verifier.add_dependency_based_on_calls
+        type_inferece_verifier.add_dependency_based_on_internal_calls
+        @type_inference_checker.populate_dependencies(type_inferece_verifier.dependencies)
+        @type_inference_checker.add_new_deps(@modules)
+        #binding.pry
       end
 
       def yaml_parser
@@ -40,21 +54,21 @@ module Archruby
       end
 
       def ruby_std_lib_module
-        config_definition_std_lib = Archruby::Architecture::ConfigDefinition.new Archruby::Ruby::STD_LIB_NAME, {"gems"=>"", "files"=>"", "allowed"=>"", "forbidden" => ""}
+        config_definition_std_lib = Archruby::Architecture::ConfigDefinition.new(Archruby::Ruby::STD_LIB_NAME, {"gems"=>"", "files"=>"", "allowed"=>"", "forbidden" => ""})
         module_definiton_std_lib = Archruby::Architecture::ModuleDefinition.new(config_definition_std_lib, @base_path)
         module_definiton_std_lib.classes = Archruby::Ruby::STD_LIBRARY_CLASSES
         @modules << module_definiton_std_lib
       end
 
       def ruby_core_module
-        config_definition_core = Archruby::Architecture::ConfigDefinition.new Archruby::Ruby::CORE_LIB_NAME, {"gems"=>"", "files"=>"", "allowed"=>"", "forbidden" => ""}
+        config_definition_core = Archruby::Architecture::ConfigDefinition.new(Archruby::Ruby::CORE_LIB_NAME, {"gems"=>"", "files"=>"", "allowed"=>"", "forbidden" => ""})
         module_definiton_core = Archruby::Architecture::ModuleDefinition.new(config_definition_core, @base_path)
         module_definiton_core.classes = Archruby::Ruby::CORE_LIBRARY_CLASSES
         @modules << module_definiton_core
       end
 
       def unknow_module
-        config_definition_unknow = Archruby::Architecture::ConfigDefinition.new "unknown", {"gems"=>"unknown", "files"=>"", "allowed"=>"", "forbidden" => ""}
+        config_definition_unknow = Archruby::Architecture::ConfigDefinition.new("unknown", {"gems"=>"unknown", "files"=>"", "allowed"=>"", "forbidden" => ""})
         @modules << Archruby::Architecture::ModuleDefinition.new(config_definition_unknow, @base_path)
       end
 

data/lib/archruby/architecture/type_inference_checker.rb

@@ -2,35 +2,51 @@ module Archruby
   module Architecture
 
     class TypeInferenceChecker
-      attr_reader :method_and_deps, :method_calls
+      #attr_reader :method_and_deps, :method_calls
+      attr_reader :dependencies
 
-      def initialize method_and_deps = nil, method_calls = nil
-        @method_and_deps = []
-        @method_calls = []
-        @method_and_deps = method_and_deps unless method_and_deps.nil?
-        @method_calls = method_calls unless method_calls.nil?
+      def initialize(dependencies=nil)
+        @dependencies = dependencies
+        # @method_and_deps = []
+        # @method_calls = []
+        # @method_and_deps = method_and_deps unless method_and_deps.nil?
+        # @method_calls = method_calls unless method_calls.nil?
       end
 
-      def add_method_deps method_deps
+      def populate_dependencies(dependencies)
+        @dependencies = dependencies
+      end
+
+      def add_method_deps(method_deps)
         @method_and_deps << method_deps
         @method_and_deps.flatten!
       end
 
-      def add_method_calls method_calls
+      def add_method_calls(method_calls)
         @method_calls << method_calls
         @method_calls.flatten!
       end
 
-      def add_new_deps modules
-        @method_and_deps.each do |dep|
+      def add_new_deps(modules)
+        @dependencies.each do |klass, dependencies|
           modules.each do |modl|
-            if !dep[:class_name].nil? && modl.is_mine?(dep[:class_name])
-              dep[:dep].each do |class_dep|
-                modl.add_new_dep dep[:class_name], class_dep
+            if !klass.nil? && modl.is_mine?(klass)
+              dependencies.each do |class_dep_name|
+                modl.add_new_dep(klass, class_dep_name)
               end
             end
           end
         end
+        # @method_and_deps.each do |dep|
+        #   modules.each do |modl|
+        #     if !dep[:class_name].nil? && modl.is_mine?(dep[:class_name])
+        #       dep[:dep].each do |class_dep|
+        #         modl.add_new_dep(dep[:class_name], class_dep)
+        #         binding.pry
+        #       end
+        #     end
+        #   end
+        # end
       end
 
       def verify_types

data/lib/archruby/presenters/dsm.rb

@@ -0,0 +1,163 @@
+require 'imgkit'
+require_relative 'dsm/cell_dsm'
+
+module Archruby
+  module Presenters
+
+    class DSM
+
+      def render(architecture)
+        matrix = create_DSM(architecture)
+        html = create_HTML(getModules(architecture), matrix)
+        save_img(html)
+      end
+
+      def save_img(html)
+        path_css = File.expand_path('../dsm/dsm_css.css', __FILE__)
+        path_img = File.absolute_path("architecture_dsm.png")
+        kit = IMGKit.new(html, :quality => 100)
+        kit.stylesheets << path_css
+        kit.to_file(path_img)
+      end
+
+      def create_DSM(architecture)
+        modules = getModules(architecture)
+        index = create_hash_index(modules)
+        matrix = Array.new(modules.size) { Array.new(modules.size) }
+
+
+        #adiciona na matriz todas as dependências permitidas
+        modules.each do |module_definiton|
+          module_name = module_definiton.name
+          dependencies = []
+          module_definiton.dependencies.each do |class_name|
+            module_dest = architecture.module_name(class_name)
+            dependencies << module_dest
+            next if module_dest == Archruby::Ruby::STD_LIB_NAME || module_dest == Archruby::Ruby::CORE_LIB_NAME
+            next if module_dest == 'unknown'
+            how_many_access = architecture.how_many_access_to(module_name, module_dest)
+            if module_dest != module_name
+              matrix[index[module_dest]][index[module_name]] = CellDSM.new(how_many_access, "allowed")
+            end
+          end
+          module_definiton.allowed_modules.each do |allowed_module_name|
+            if !dependencies.include? allowed_module_name
+              matrix[index[allowed_module_name]][index[module_name]] = CellDSM.new("?","warning")
+            end
+          end
+        end
+
+        #adiciona na matriz todas as violações
+        constraints_breaks = architecture.constraints_breaks
+        constraints_breaks.each do |constraint_break|
+          module_origin = constraint_break.module_origin
+          module_target = constraint_break.module_target
+          contraint_type = constraint_break.type
+          how_many_access =
+            if contraint_type == Archruby::Architecture::ConstraintBreak::ABSENSE
+              architecture.how_many_break(module_origin, module_target, Archruby::Architecture::ConstraintBreak::ABSENSE)
+            else
+              architecture.how_many_break(module_origin, module_target, Archruby::Architecture::ConstraintBreak::DIVERGENCE)
+            end
+          begin
+            matrix[index[module_target]][index[module_origin]] = CellDSM.new(how_many_access,contraint_type)
+          rescue
+          end
+
+        end
+        matrix
+      end
+
+      def font(number)
+        font =
+          if number >= 1000
+            "<font size = '1'>#{number}<font>"
+          elsif number >= 100
+            "<font size = '2'>#{number}<font>"
+          else
+            "#{number}"
+          end
+        font
+      end
+
+      def create_HTML(modules, matrix)
+        show_unknown = show_unknown?(matrix, modules)
+        text = "\n<center><table>\n"
+        text = "#{text}    <tr>\n"
+        text = "#{text}      <th>Modules</th>\n"
+        for i in 0..modules.size - 1
+          next if modules[i].name == 'unknown' && !show_unknown
+          module_type = modules[i].is_external? ? "external" : "internal"
+          text = "#{text}      <td class='#{module_type}'><div style='width: 25px'><center>#{font(i+1)}</center></div></td>\n"
+        end
+        text = "#{text}    </tr>\n"
+        for line in 0..matrix.size - 1
+            next if modules[line].name == 'unknown' && !show_unknown
+            text = "#{text}  <tr>\n"
+            module_type = modules[line].is_external? ? "external" : "internal"
+            text = "#{text}    <td class='#{module_type}'><div class='module'>#{modules[line].name}</div><div class='number'>#{line+1}</div></td>\n"
+          for column in 0..matrix.size - 1
+            next if modules[column].name == 'unknown' && !show_unknown
+            text =
+              if line == column
+                "#{text}    <td class='diagonal'></td>\n"
+              elsif matrix[line][column].nil?
+                "#{text}    <td class='default'></td>\n"
+              elsif matrix[line][column].type == "absence"
+                "#{text}    <td class='absence'><center>#{font(matrix[line][column].how_many_access)}</center></td>\n"
+              elsif matrix[line][column].type == "divergence"
+                "#{text}    <td class='divergence'><center>#{font(matrix[line][column].how_many_access)}</center></td>\n"
+              elsif matrix[line][column].type == "warning"
+                "#{text}    <td class='warning'><center>#{matrix[line][column].how_many_access}</center></td>\n"
+              else
+                "#{text}    <td class='default'><center>#{font(matrix[line][column].how_many_access)}</center></td>\n"
+              end
+          end
+          text = "#{text}  </tr>\n"
+        end
+        text = "#{text}</table> </center>"
+        text
+      end
+
+      def getModules(architecture)
+        modules = []
+        architecture.modules.each do |module_definiton|
+          #next if module_definiton.name == 'unknown'
+          next if module_definiton.name == Archruby::Ruby::STD_LIB_NAME || module_definiton.name == Archruby::Ruby::CORE_LIB_NAME
+          modules << module_definiton
+        end
+        modules
+      end
+
+      def create_hash_index(modules)
+        index = {}
+        for i in 0..modules.size - 1
+          index[modules[i].name] = i
+        end
+        index
+      end
+
+      def show_unknown?(matrix, modules)
+        #column = column of module unknown
+        column = -1
+        show_unknown = false
+        for i in 0 .. modules.size - 1
+          if modules[i].name == 'unknown'
+            column = i
+            break
+          end
+        end
+        if column != -1
+          for i in 0 .. matrix.size - 1
+            if !matrix[i][column].nil? || !matrix[column][i].nil?
+              show_unknown = true
+              break
+            end
+          end
+        end
+        show_unknown
+      end
+
+    end
+  end
+end

data/lib/archruby/presenters/dsm/cell_dsm.rb

@@ -0,0 +1,17 @@
+module Archruby
+  module Presenters
+
+    class CellDSM
+
+      attr_reader :type
+      attr_reader :how_many_access
+
+      def initialize(how_many_access, type)
+        @how_many_access = how_many_access
+        @type = type
+      end
+
+    end
+
+  end
+end

data/lib/archruby/presenters/dsm/dsm_css.css

@@ -0,0 +1,77 @@
+table td, tr, th {
+  margin:0;
+  padding:0;
+  font-weight:normal;
+}
+
+table td,th {
+  padding:5px;
+  border:1px solid #fff;
+  border-width:0 1px 1px 0;
+}
+
+table {
+  white-space: nowrap;
+  border-collapse:collapse;
+  margin-bottom:15px;
+}
+
+td,th {
+  text-align:center;
+}
+
+th {
+  background:#F9F9F9;
+}
+
+.absence{
+  width:25px;
+  background:rgba(255,0,0,0.4);
+  border: 2px double #ff0000;
+  padding: 2px;
+  border-style:dotted;
+}
+
+.divergence{
+  width:25px;
+  background:rgba(255,162,0,0.4);
+  border: 2px double #ffa200;
+  padding: 2px;
+  border-style:dashed;
+}
+
+.diagonal{
+  width:25px;
+  background:#F3F3F3;
+}
+
+.external{
+  background:#999999;
+}
+
+.internal{
+  background:#ebebeb;
+}
+
+.default{
+  width:25px;
+  background:#F9F9F9;
+}
+
+.module{
+  float: left;
+  padding-right: 5px;
+}
+
+.number{
+  float: right;
+}
+
+.warning{
+  border: 1px double gray;
+  width:25px;
+  background:#F9F9F9;
+  font-size: 12;
+  color: gray;
+  text-align: center;
+}

data/lib/archruby/presenters/graph.rb

@@ -23,6 +23,7 @@ module Archruby
         internal_nodes = []
         external_nodes = []
         modules.each do |module_definiton|
+          next if module_definiton.name == 'unknown'
           next if module_definiton.name == Archruby::Ruby::STD_LIB_NAME || module_definiton.name == Archruby::Ruby::CORE_LIB_NAME
           if module_definiton.is_external?
             nodes[module_definiton.name] = external.add_nodes(module_definiton.name, "shape" => "parallelogram", "color" => "gray60", "style" => "filled")
@@ -49,6 +50,7 @@ module Archruby
           module_definiton.dependencies.each do |class_name|
             module_dest = architecture.module_name class_name
             next if module_dest == Archruby::Ruby::STD_LIB_NAME || module_dest == Archruby::Ruby::CORE_LIB_NAME
+            next if module_dest == 'unknown'
             how_many_access = architecture.how_many_access_to module_name, module_dest
             if !edges[module_name][:edges].include?(module_dest) && module_dest != module_name
               edges[module_name][:edges] << module_dest
@@ -62,6 +64,7 @@ module Archruby
         constraints_breaks.each_with_index do |constraint_break, index|
           module_origin = constraint_break.module_origin
           module_target = constraint_break.module_target
+          next if module_target == 'unknown'
           contraint_type = constraint_break.type
           node_origin = nodes[module_origin]
           node_dest = nodes[module_target]
@@ -72,14 +75,14 @@ module Archruby
                 edge.set do |e|
                   e.headlabel = "X (##{architecture.how_many_break(module_origin, module_target,  Archruby::Architecture::ConstraintBreak::ABSENSE)})"
                   e.color = "red"
-                  e.style = "bold"
+                  e.style = "dotted"
                   e.minlen = 2
                 end
               else
                 edge.set do |e|
                   e.headlabel = "! (##{architecture.how_many_break(module_origin, module_target, Archruby::Architecture::ConstraintBreak::DIVERGENCE)})"
                   e.color = "orange"
-                  e.style = "bold"
+                  e.style = "dashed"
                   e.minlen = 2
                 end
               end
@@ -91,10 +94,10 @@ module Archruby
           if !node_found
             if contraint_type == Archruby::Architecture::ConstraintBreak::ABSENSE
               break_count = architecture.how_many_break(module_origin, module_target, Archruby::Architecture::ConstraintBreak::ABSENSE)
-              edges_objs << g.add_edges(node_origin, node_dest, :color => 'red', :headlabel => "X (##{break_count})", 'style' => 'bold', :minlen => 2)
+              edges_objs << g.add_edges(node_origin, node_dest, :color => 'red', :headlabel => "X (##{break_count})", 'style' => 'dotted', :minlen => 2)
             else
               break_count = architecture.how_many_break(module_origin, module_target, Archruby::Architecture::ConstraintBreak::DIVERGENCE)
-              edges_objs << g.add_edges(node_origin, node_dest, :color => 'red', :headlabel => "! (##{break_count})", 'style' => 'bold', :minlen => 2)
+              edges_objs << g.add_edges(node_origin, node_dest, :color => 'orange', :headlabel => "! (##{break_count})", 'style' => 'dashed', :minlen => 2)
             end
           end
         end
@@ -103,11 +106,11 @@ module Archruby
           next if module_definiton.name == Archruby::Ruby::STD_LIB_NAME || module_definiton.name == Archruby::Ruby::CORE_LIB_NAME
           module_origin = module_definiton.is_empty? ? "#{module_definiton.name}\n [empty]" : module_definiton.name
           node_origin = nodes[module_origin]
-           puts module_definiton.name.inspect
-           puts module_definiton.classes.inspect
-           puts module_definiton.dependencies.inspect
-           puts module_definiton.classes_and_dependencies.inspect
-           puts
+          #  puts module_definiton.name.inspect
+          #  puts module_definiton.classes.inspect
+          #  puts module_definiton.dependencies.inspect
+          #  puts module_definiton.classes_and_dependencies.inspect
+          #  puts
           module_definiton.allowed_modules.each do |allowed_module_name|
             module_target = allowed_module_name
             node_dest = nodes[allowed_module_name]