archruby 0.1.0

data/lib/archruby/architecture/module_definition.rb

@@ -0,0 +1,218 @@
+module Archruby
+  module Architecture
+
+    class ModuleDefinition
+
+      ALLOWED_CONSTRAINTS = ['required', 'allowed', 'forbidden']
+
+      attr_reader :name, :allowed_modules, :required_modules, :forbidden_modules,
+      :dependencies, :classes_and_dependencies
+
+      attr_accessor :classes
+
+      def initialize config_definition, base_directory
+        @config_definition = config_definition
+        @name = @config_definition.module_name
+        @allowed_modules = @config_definition.allowed_modules
+        @required_modules = @config_definition.required_modules
+        @forbidden_modules = @config_definition.forbidden_modules
+        @base_directory = base_directory
+        @files_and_contents = []
+        @classes = []
+        @dependencies = []
+        @classes_and_dependencies = []
+        extract_content_of_files
+        extract_dependencies
+      end
+
+      def extract_content_of_files file_extractor = Archruby::Architecture::FileContent
+        return if !@classes.empty?
+        file_extractor = file_extractor.new(@base_directory)
+        @config_definition.files.each do |file|
+          file_content = file_extractor.all_content_from_directory file
+          @files_and_contents << file_content
+        end
+      end
+
+      def extract_dependencies ruby_parser = Archruby::Ruby::Parser
+        return if !@classes.empty?
+        @files_and_contents.each do |file_and_content|
+          file_and_content.each do |file_name, content|
+            parser = ruby_parser.new content
+            @classes << parser.classes
+            @dependencies << parser.dependencies
+            @classes_and_dependencies << parser.classes_and_dependencies
+          end
+        end
+        @classes << @config_definition.gems
+        @classes.flatten!
+        @dependencies.flatten!
+      end
+
+      def is_mine? class_name
+        splited_class_name = class_name.split('::')
+        first_class_name = splited_class_name.first
+        is_mine = false
+        if first_class_name.empty?
+          #pocurando por um match exato de dependencia
+          first_name = splited_class_name[1]
+          splited_class_name.shift # retirando o elemento ''
+          class_name = splited_class_name.join("::")
+          @classes.each do |klass|
+            #TODO Arrumar isso com uma expressao regular
+            if klass.include?(class_name) && klass.size == class_name.size
+              is_mine = true
+              break
+            end
+          end
+          if !is_mine && !@config_definition.gems.empty?
+            @classes.each do |klass|
+              #TODO Arrumar isso com uma expressao regular
+              if klass.include?(first_name) && klass.size == first_name.size
+                is_mine = true
+                break
+              end
+            end
+          end
+        end
+        if !is_mine
+          # procurando por acesso a classe que possa ser desse modulo
+          class_name = splited_class_name.join("::")
+          included_separator = class_name.include?("::")
+          @classes.each do |klass|
+            #TODO Arrumar isso com uma expressao regular
+            if included_separator
+              if klass.include?(class_name)
+                is_mine = true
+                break
+              end
+            else
+              if klass.include?(class_name) && klass.size == class_name.size
+                is_mine = true
+                break
+              end
+            end
+          end
+        end
+        if !is_mine
+          # procurando por GEM
+          @classes.each do |klass|
+            #TODO Arrumar isso com uma expressao regular
+            if klass.include?(first_class_name) && klass.size == first_class_name.size
+              is_mine = true
+              break
+            end
+          end
+        end
+
+        return is_mine
+      end
+
+      def is_external?
+        !@config_definition.gems.empty?
+      end
+
+      def is_empty?
+        @classes.empty?
+      end
+
+      def verify_constraints architecture
+        required_breaks = verify_required architecture
+        forbidden_breaks = verify_forbidden architecture
+        allowed_breaks = verify_allowed architecture
+        all_constraints_breaks = [required_breaks, forbidden_breaks, allowed_breaks].flatten
+        all_constraints_breaks.delete(nil)
+        all_constraints_breaks
+      end
+
+      # Verifica todas as classes do modulo
+      # Cada uma deve, de alguma forma, depender dos modulos que estao listados como required
+      def verify_required architecture
+        return if @config_definition.required_modules.empty?
+        breaks = []
+        @classes_and_dependencies.each_with_index do |class_and_depencies, index|
+          if class_and_depencies.empty?
+            breaks << Archruby::Architecture::ConstraintBreak.new(
+              :type => 'absence',
+              :module_origin => self.name,
+              :module_target => @config_definition.required_modules.first,
+              :class_origin => @classes[index],
+              :msg => "not implement a required module"
+            )
+            next
+          end
+          class_and_depencies.each do |class_name, dependencies|
+            dependency_module_names = []
+            dependencies.each do |dependency|
+              module_name = architecture.module_name(dependency.class_name)
+              dependency_module_names << module_name
+            end
+            @config_definition.required_modules.each do |required_module|
+              if !dependency_module_names.include?(required_module)
+                breaks << Archruby::Architecture::ConstraintBreak.new(
+                  :type => 'absence',
+                  :module_origin => self.name,
+                  :module_target => required_module,
+                  :class_origin => class_name,
+                  :msg => "not implement a required module"
+                )
+              end
+            end
+          end
+        end
+        breaks
+      end
+
+      def verify_forbidden architecture
+        return if @config_definition.forbidden_modules.empty?
+        breaks = []
+        @classes_and_dependencies.each do |class_and_depencies|
+          class_and_depencies.each do |class_name, dependencies|
+            dependencies.each do |dependency|
+              module_name = architecture.module_name(dependency.class_name)
+              next if architecture.is_ruby_internals? module_name
+              if @config_definition.forbidden_modules.include? module_name
+                next if /[A-Z]_+[A-Z]/.match(dependency.class_name)
+                breaks << Archruby::Architecture::ConstraintBreak.new(
+                  :type => 'divergence',
+                  :class_origin => class_name,
+                  :line_origin => dependency.line_number,
+                  :class_target => dependency.class_name,
+                  :module_origin => self.name,
+                  :module_target => module_name,
+                  :msg => "accessing a module which is forbidden")
+              end
+            end
+          end
+        end
+        breaks
+      end
+
+      def verify_allowed architecture
+        return if @config_definition.allowed_modules.empty?
+        breaks = []
+        @classes_and_dependencies.each do |class_and_depencies|
+          class_and_depencies.each do |class_name, dependencies|
+            dependencies.each do |dependency|
+              module_name = architecture.module_name(dependency.class_name)
+              next if architecture.is_ruby_internals? module_name
+              if module_name != self.name && !@config_definition.allowed_modules.include?(module_name)
+                next if /[A-Z]_+[A-Z]/.match(dependency.class_name)
+                breaks << Archruby::Architecture::ConstraintBreak.new(
+                  :type => 'divergence',
+                  :class_origin => class_name,
+                  :line_origin => dependency.line_number,
+                  :class_target => dependency.class_name,
+                  :module_origin => self.name,
+                  :module_target => module_name,
+                  :msg => "module #{self.name} is not allowed to depend on module #{module_name}")
+              end
+            end
+          end
+        end
+        breaks
+      end
+
+    end
+  end
+end

data/lib/archruby/architecture/parser.rb

@@ -0,0 +1,58 @@
+require 'yaml'
+
+module Archruby
+  module Architecture
+
+    class Parser
+      attr_reader :modules
+
+      def initialize config_file_path, base_path
+        @config_file = config_file_path
+        @base_path = base_path
+        @modules = []
+        parse
+        ruby_std_lib_module
+        ruby_core_module
+        unknow_module
+      end
+
+      def parse
+        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
+          rescue ArchChecker::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
+        end
+      end
+
+      def yaml_parser
+        YAML
+      end
+
+      def ruby_std_lib_module
+        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" => ""}
+        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" => ""}
+        @modules << Archruby::Architecture::ModuleDefinition.new(config_definition_unknow, @base_path)
+      end
+
+    end
+  end
+end

data/lib/archruby/presenters/graph.rb

@@ -0,0 +1,132 @@
+require 'graphviz'
+
+module Archruby
+  module Presenters
+
+    class Graph
+
+      def render architecture
+        modules = architecture.modules
+
+        g = GraphViz.new(:G)
+
+        g.edge[:color] = "black"
+        g.edge[:style] = "filled"
+        g.edge[:label] = ""
+
+        internal = g.subgraph("internal", "label" => "Internal", "color" => "black")
+
+        external = g.subgraph("external", "label" => "External", "color" => "black", "rank" => "same")
+
+        nodes = {}
+
+        internal_nodes = []
+        external_nodes = []
+        modules.each do |module_definiton|
+          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")
+            external_nodes << nodes[module_definiton.name]
+          else
+            if module_definiton.is_empty?
+              nodes[module_definiton.name] = internal.add_nodes("#{module_definiton.name}\n [empty]", "color" => "gray74", "shape" => "rectangle")
+            else
+              nodes[module_definiton.name] = internal.add_nodes(module_definiton.name, "color" => "gray92", "style" => "filled", "shape" => "rectangle")
+            end
+            internal_nodes << nodes[module_definiton.name]
+          end
+        end
+
+        edges = {}
+        edges_objs = []
+
+        modules.each do |module_definiton|
+          module_name = module_definiton.name
+          node_origin = nodes[module_name]
+          edges[module_name] ||= {}
+          edges[module_name][:edges] ||= []
+
+          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
+            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
+              node_dest = nodes[module_dest]
+              edges_objs << internal.add_edges(node_origin, node_dest, :headlabel => how_many_access, :minlen => 2)
+            end
+          end
+        end
+
+        constraints_breaks = architecture.constraints_breaks
+        constraints_breaks.each_with_index do |constraint_break, index|
+          module_origin = constraint_break.module_origin
+          module_target = constraint_break.module_target
+          contraint_type = constraint_break.type
+          node_origin = nodes[module_origin]
+          node_dest = nodes[module_target]
+          node_found = false
+          edges_objs.each do |edge|
+            if edge.node_one == module_origin && edge.node_two == module_target
+              if contraint_type == Archruby::Architecture::ConstraintBreak::ABSENSE
+                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.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.minlen = 2
+                end
+              end
+              node_found = true
+              break
+            end
+          end
+
+          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)
+            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)
+            end
+          end
+        end
+
+        modules.each do |module_definiton|
+          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
+          module_definiton.allowed_modules.each do |allowed_module_name|
+            module_target = allowed_module_name
+            node_dest = nodes[allowed_module_name]
+            edge_found = false
+            edges_objs.each do |edge|
+              if edge.node_one == module_origin && edge.node_two == module_target
+                edge_found = true
+                break
+              end
+            end
+            if !edge_found
+              internal.add_edges(node_origin, node_dest, :color => 'gray74', :label => "[none]", :minlen => 2)
+            end
+          end
+        end
+
+        g.output( :png => "architecture.png" )
+      end
+
+    end
+  end
+end

data/lib/archruby/presenters/text.rb

@@ -0,0 +1,14 @@
+module ArchChecker
+  module Presenters
+    class Text
+      def render constraint_breaks
+        file = File.new('violations.txt', 'w')
+        constraint_breaks.each do |constraint_break|
+          constraint_break.each do |violations|
+            file.puts "#{violations.keys.first} #{violations[violations.keys.first]}"
+          end
+        end        
+      end
+    end
+  end
+end

data/lib/archruby/presenters/yaml.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+
+module Archruby
+  module Presenters
+
+    class Yaml
+      def render architecture
+        constraints_breaks = architecture.constraints_breaks
+        file = File.new('constraints_breaks.yml', 'w')
+        contraints = []
+        constraints_breaks.each do |constraint_break|
+          constraint = {}
+          constraint[constraint_break.type] = {}
+          constraint[constraint_break.type]['class_origin'] = constraint_break.class_origin
+          constraint[constraint_break.type]['line_origin'] = constraint_break.line_origin
+          constraint[constraint_break.type]['class_target'] = constraint_break.class_target
+          constraint[constraint_break.type]['module_origin'] = constraint_break.module_origin
+          constraint[constraint_break.type]['module_target'] = constraint_break.module_target
+          constraint[constraint_break.type]['message'] = constraint_break.msg
+          contraints << constraint
+        end
+        file.write contraints.to_yaml
+        file.close
+      end
+    end
+
+  end
+end