mudguard 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52da6086ca5ad7d9cc7882c0be051e35d1a1672930d616f3929d44909b23717f
-  data.tar.gz: 84ba1b85b2d6cdec19ccbd80ffe6f39745054f3e8617a250c7dc613cd40dc00e
+  metadata.gz: 6db3d7377ad8b0b1d13e59c306bd937bcb39a2b68bee5d0539a4dff17d460243
+  data.tar.gz: b46919284fea9ad09e6db895025c50eeff3577fc0fe32bbc3b5ad7aec0e4833f
 SHA512:
-  metadata.gz: d41681429a450ad75420b5cbe6bf78a261bc2d6d90be6547e080557d09b66c7a937c6798cd2f4603e20c7154d1540638f3861830ea4add5c5bce513d78a6dfbb
-  data.tar.gz: e4f6a3925f3a65496c646cf2c1d0f5143b7e9f0c103a327961479b3dd01e4307bc743934ef8152ac73d15661bd04a842906876d595414814efdc6be285ba5efb
+  metadata.gz: 68ed243c036a7bdbe9a5e3e5e5996c76006cbc7057f4f5aad78d43c011038a6de16496c61ce5bd9c88a63c678f6d501f53af17e18e931abb20d0bce351ce0585
+  data.tar.gz: 050fdc731cc7297f986f10ed1b39e95aa6e82bf2f36959d7fe6e322c9681b5322a8a0390b177ced26ecc5c09bea737e86b26645966e4d1b2612eee25d370a735

data/.gitignore

@@ -16,3 +16,7 @@
 
 # Ignore pkg (gem dir)
 /pkg
+/tmp
+
+# Following file is dynamically created while running tests
+/spec/lib/infrastructure/persistence/policy_file_project/.mudguard.yml

data/.rubocop.yml

@@ -1,7 +1,9 @@
 AllCops:
+  NewCops: enable
   Exclude:
     - 'bin/*'
     - 'spec/test_projects/**/*.rb'
+    - 'spec/lib/domain/source_examples/*.rb'
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/Gemfile.lock

@@ -1,19 +1,20 @@
 PATH
   remote: .
   specs:
-    mudguard (0.1.7)
+    mudguard (0.1.8)
       parser (~> 2.7)
+      rake (~> 13.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.0)
-    byebug (11.0.1)
+    byebug (11.1.3)
     coderay (1.1.2)
     diff-lcs (1.3)
     ffi (1.12.2)
     formatador (0.2.5)
-    guard (2.16.1)
+    guard (2.16.2)
       formatador (>= 0.2.4)
       listen (>= 2.7, < 4.0)
       lumberjack (>= 1.0.12, < 2.0)
@@ -27,31 +28,30 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
-    jaro_winkler (1.5.4)
     listen (3.2.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    lumberjack (1.2.4)
-    method_source (0.9.2)
+    lumberjack (1.2.5)
+    method_source (1.0.0)
     nenv (0.3.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
     parallel (1.19.1)
-    parser (2.7.0.4)
+    parser (2.7.1.3)
       ast (~> 2.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
       byebug (~> 11.0)
-      pry (~> 0.10)
-    pry-doc (1.0.0)
+      pry (~> 0.13.0)
+    pry-doc (1.1.0)
       pry (~> 0.11)
       yard (~> 0.9.11)
     rainbow (3.0.0)
     rake (13.0.1)
-    rb-fsevent (0.10.3)
+    rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     rexml (3.2.4)
@@ -59,28 +59,30 @@ GEM
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
-    rspec-support (3.9.2)
-    rubocop (0.80.1)
-      jaro_winkler (~> 1.5.1)
+    rspec-support (3.9.3)
+    rubocop (0.84.0)
       parallel (~> 1.10)
       parser (>= 2.7.0.1)
       rainbow (>= 2.2.2, < 4.0)
       rexml
+      rubocop-ast (>= 0.0.3)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.0.3)
+      parser (>= 2.7.0.1)
     ruby-progressbar (1.10.1)
     shellany (0.0.1)
     thor (1.0.1)
-    unicode-display_width (1.6.1)
-    yard (0.9.24)
+    unicode-display_width (1.7.0)
+    yard (0.9.25)
 
 PLATFORMS
   ruby

data/lib/mudguard/application/application.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "../infrastructure/persistence/policy_file"
-require_relative "../infrastructure/persistence/ruby_files"
+require_relative "../infrastructure/persistence/project_repository"
+require_relative "../domain/policies"
 
 # Contains methods to check if your project is a bit muddy
 module Mudguard
@@ -9,10 +9,24 @@ module Mudguard
   module Application
     class << self
       def check(project_path, notification)
-        policy_file_path = File.expand_path("MudguardFile", project_path)
-        policies = Infrastructure::Persistence::PolicyFile.read(policy_file_path)
+        create_policies(project_path) do |policies|
+          policies.check(notification)
+        end
+      end
+
+      def print_allowed_dependencies(project_path, notification)
+        create_policies(project_path) do |policies|
+          policies.print_allowed_dependencies(notification)
+        end
+      end
+
+      private
 
-        policies.check(Infrastructure::Persistence::RubyFiles.all(project_path), notification)
+      def create_policies(project_path)
+        repo = Infrastructure::Persistence::ProjectRepository
+        source_policies = repo.load_source_policies(project_path)
+        policies = Domain::Policies.new(source_policies: source_policies)
+        yield policies
       end
     end
   end

data/lib/mudguard/domain/const_visitor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # Transforms AST-Nodes into Strings denoting consts
+    class ConstVisitor
+      def initialize
+        @consts = []
+      end
+
+      attr_reader :consts
+
+      def visit_dependency(_, __, ___); end # rubocop:disable Naming/MethodParameterName
+
+      def visit_const_declaration(_location, const_name, module_name)
+        @consts << "#{module_name}#{const_name}"
+      end
+    end
+  end
+end

data/lib/mudguard/domain/consts.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module Mudguard
+  module Domain
+    # Knows all constants of the project
+    class Consts
+      def initialize(sources:)
+        @consts = sources
+                  .flat_map(&:find_consts)
+                  .each_with_object(Hash.new { |h, k| h[k] = {} }) do |c, a|
+          path = split_hierarchy(c)
+          const_name = path.last
+          module_names = path.take(path.count - 1)
+          sub_module = module_names.reduce(a) { |h, m| h[m] }
+          sub_module[const_name] = {} unless sub_module.key?(const_name)
+        end
+      end
+
+      def resolve(module_name, const_name)
+        raise Error, "const_name is undefined" if const_name.empty?
+
+        path = split_hierarchy(module_name)
+        if module_name.empty?
+          # not in a module therefor const can only be defined in the root module (::)
+          qualified_path(const_name)
+        else
+          # analyse module hierarchy to find fully qualified const name
+          # resolve_in_modules(const_name, path)
+          const_path = const_name.split(SEPARATOR).drop(1)
+          find_const_deeper("", path, @consts, const_path) || qualified_path(const_name)
+        end
+      end
+
+      private
+
+      SEPARATOR = "::"
+
+      def find_const_deeper(current_module, remaining_modules, consts, const_path)
+        return if consts.nil?
+
+        if remaining_modules.any?
+          # Move deeper toward target module
+          next_module = remaining_modules.first
+          next_remaining = remaining_modules.drop(1)
+          next_consts = consts[next_module]
+          found_const = find_const_deeper(next_module, next_remaining, next_consts, const_path)
+          return join_path(current_module, found_const) if found_const
+        end
+
+        find_const(current_module, consts, const_path)
+      end
+
+      def find_const(current_module, consts, const_path)
+        const_name = const_path.first
+        if const_path.length == 1 && consts.key?(const_name)
+          # const defined in current_module
+          return join_path(current_module, const_name)
+        end
+
+        # backward search (along const_path only)
+        next_path = const_path.drop(1)
+        found_const = find_const_deeper(const_name, next_path, consts[const_name], next_path)
+        found_const ? join_path(current_module, found_const) : nil
+      end
+
+      def join_path(module_name, const_name)
+        "#{module_name}#{SEPARATOR}#{const_name}"
+      end
+
+      def qualified_path(const_name)
+        const_name =~ /^#{SEPARATOR}/ ? const_name : "#{SEPARATOR}#{const_name}"
+      end
+
+      def split_hierarchy(module_name)
+        module_name.split(SEPARATOR).drop(1)
+      end
+    end
+  end
+end

data/lib/mudguard/domain/dependencies.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "texts"
+
+module Mudguard
+  module Domain
+    # Executes operation on a set of dependencies
+    class Dependencies
+      include Texts
+
+      def initialize(policies:, notification:)
+        @policies = policies.map { |p| /^#{p}/x }
+        @notification = notification
+      end
+
+      def check(dependencies)
+        select_dependencies(dependencies) do |dependency, is_allowed|
+          add_message(dependency, dependency_not_allowed(dependency.dependency)) unless is_allowed
+          !is_allowed
+        end
+      end
+
+      def print_allowed(dependencies)
+        select_dependencies(dependencies) do |dependency, is_allowed|
+          add_message(dependency, dependency_allowed(dependency.dependency)) if is_allowed
+          is_allowed
+        end
+      end
+
+      private
+
+      def add_message(dependency, message)
+        @notification.add(dependency.location, message)
+      end
+
+      def select_dependencies(dependencies)
+        dependencies.select do |dependency|
+          yield dependency, dependency_allowed?(dependency)
+        end.count
+      end
+
+      def dependency_allowed?(dependency)
+        @policies.any? { |p| dependency.match(p) }
+      end
+    end
+  end
+end

data/lib/mudguard/domain/dependency.rb

@@ -4,6 +4,8 @@ module Mudguard
   module Domain
     # A Dependency between Modules
     class Dependency
+      attr_reader :location, :dependency
+
       def initialize(location: nil, dependency:)
         @location = location
         @dependency = dependency
@@ -13,10 +15,6 @@ module Mudguard
         "{#{@location}, #{@dependency}}"
       end
 
-      def to_s
-        "#{@location} #{@dependency}"
-      end
-
       def match(policy)
         @dependency.match(policy)
       end

data/lib/mudguard/domain/dependency_visitor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # Transforms AST-Nodes into Dependencies
+    class DependencyVisitor
+      def initialize(consts:)
+        @consts = consts
+        @dependencies = []
+      end
+
+      attr_reader :dependencies
+
+      def visit_dependency(location, const_name, module_name)
+        qualified_const_name = @consts.resolve(module_name, const_name)
+        return [] unless qualified_const_name&.include?("::")
+
+        dependency = if module_name.empty?
+                       "->#{qualified_const_name}"
+                     else
+                       "#{module_name}->#{qualified_const_name}"
+                     end
+
+        @dependencies << Dependency.new(location: location, dependency: dependency)
+      end
+
+      # rubocop:disable Naming/MethodParameterName
+      def visit_const_declaration(_, __, ___); end
+      # rubocop:enable Naming/MethodParameterName
+    end
+  end
+end

data/lib/mudguard/domain/policies.rb

@@ -1,47 +1,48 @@
 # frozen_string_literal: true
 
+require_relative "dependencies"
+require_relative "texts"
+require_relative "consts"
+
 module Mudguard
   module Domain
     # Contains the policies to be enforced
     class Policies
-      def initialize(policies: [])
-        @policies = policies.map { |l| l.gsub(/\s/, "") }.map { |p| /^#{p}/ }
+      include Texts
+
+      def initialize(source_policies: [])
+        @source_policies = source_policies
       end
 
-      def check(sources, notification)
-        result = check_sources(sources, notification)
+      def check(notification)
+        result = analyse(:check, notification)
 
-        count = result[:count]
-        violations = result[:violations]
+        count = result[:sources_count]
+        violations = result[:analyser_count]
 
-        files = pluralize("file", count)
-        problems = pluralize("problem", violations)
-        notification.add("#{count} #{files} inspected, #{violations} #{problems} detected")
+        notification.add(nil, summary(count, violations))
         violations.zero?
       end
 
-      private
+      def print_allowed_dependencies(notification)
+        result = analyse(:print_allowed, notification)
 
-      def pluralize(word, count)
-        count == 1 ? word : "#{word}s"
-      end
+        count = result[:sources_count]
+        violations = result[:analyser_count]
 
-      def check_sources(sources, notification)
-        sources.each_with_object(count: 0, violations: 0) do |source, result|
-          result[:count] += 1
-          dependencies = source.find_mod_dependencies
-          result[:violations] += check_dependencies(dependencies, notification)
-        end
+        notification.add(nil, dependency_summary(count, violations))
       end
 
-      def check_dependencies(dependencies, notification)
-        dependencies.reject { |d| check_dependency(d, notification) }.count
-      end
+      private
 
-      def check_dependency(dependency, notification)
-        is_allowed = @policies.any? { |p| dependency.match(p) }
-        notification.add("#{dependency} not allowed") unless is_allowed
-        is_allowed
+      def analyse(method, notification)
+        consts = Consts.new(sources: @source_policies.map(&:source))
+        @source_policies.each_with_object(sources_count: 0, analyser_count: 0) do |sp, result|
+          analyser = Dependencies.new(policies: sp.policies, notification: notification)
+          dependencies = sp.source.find_mod_dependencies(consts)
+          result[:sources_count] += 1
+          result[:analyser_count] += analyser.send(method, dependencies)
+        end
       end
     end
   end

data/lib/mudguard/domain/source.rb

@@ -1,105 +1,78 @@
 # frozen_string_literal: true
 
 require "parser/current"
-require "mudguard/domain/dependency"
+require_relative "dependency"
+require_relative "dependency_visitor"
+require_relative "const_visitor"
+require_relative "error"
+require_relative "source_processor"
 
 module Mudguard
   module Domain
     # Represents a Ruby source file
     class Source
-      def initialize(location: nil, code:)
-        @code = code
+      def initialize(location:, code_loader: -> { "" })
+        @code_loader = code_loader
         @location = location
       end
 
       def ==(other)
-        @code == other.instance_eval { @code } && @location == other.instance_eval { @location }
+        @location == other.instance_eval { @location }
       end
 
-      def inspect
-        @location
+      def hash
+        @location.hash
       end
 
-      def find_mod_dependencies
-        begin
-          root = Parser::CurrentRuby.parse(@code)
-        rescue Parser::SyntaxError
-          return []
-        end
-        return [] if root.nil?
-
-        process(root)
+      def eql?(other)
+        @location.eql?(other.instance_eval { @location })
       end
 
-      private
-
-      def process(node, module_name = "")
-        case node
-        when type?(:module)
-          process_module(node.children, module_name)
-        when type?(:class)
-          process_class(node.children, module_name)
-        when type?(:const)
-          create_dependency(module_name, node)
-        else
-          ignore_and_continue(node, module_name)
-        end
+      def inspect
+        @location
       end
 
-      def create_dependency(module_name, node)
-        const_name = find_const_name(node.children)
-        return [] unless const_name&.include?("::")
-
-        dependency = if module_name.empty?
-                       const_name
-                     else
-                       "#{module_name}->#{const_name}"
-                     end
-        location = "#{@location}:#{node.location.line}"
-        [Dependency.new(location: location, dependency: dependency)]
+      def find_mod_dependencies(consts)
+        visitor = DependencyVisitor.new(consts: consts)
+        visit_ast(visitor)
+        visitor.dependencies
       end
 
-      def ignore_and_continue(node, module_name)
-        case node
-        when children?
-          node.children.flat_map { |c| process(c, module_name) }
-        else
-          []
-        end
+      def find_consts
+        visitor = ConstVisitor.new
+        visit_ast(visitor)
+        visitor.consts
       end
 
-      def process_module(children, module_name)
-        const_name = find_const_name(children[0].children)
-        module_name = if module_name.empty?
-                        const_name
-                      else
-                        "#{module_name}::#{const_name}"
-                      end
-        process(children[1], module_name)
+      def location?(glob)
+        @location == glob
       end
 
-      def process_class(children, module_name)
-        process(children[1], module_name)
-      end
+      private
 
-      def find_const_name(children)
-        return nil if children.nil?
+      SYNTAX_ERROR = "error"
 
-        module_name = find_const_name(children[0]&.children)
-        const_name = children[1].to_s
-        if module_name.nil?
-          const_name
-        else
-          "#{module_name}::#{const_name}"
+      def ast
+        @ast ||= create_ast
+      end
+
+      def create_ast
+        begin
+          root = Parser::CurrentRuby.parse(code)
+        rescue Parser::SyntaxError
+          return SYNTAX_ERROR
         end
+        root.nil? ? SYNTAX_ERROR : root
       end
 
-      def children?
-        ->(n) { n.respond_to?(:children) }
+      def code
+        @code ||= @code_loader.call
       end
 
-      def type?(type)
-        ->(n) { n.respond_to?(:type) && n.type == type }
+      def visit_ast(visitor)
+        return if ast == SYNTAX_ERROR
+
+        SourceProcessor.new(location: @location).process(ast, visitor)
       end
     end
   end

data/lib/mudguard/domain/source_policies.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # Associates a source with it's policies
+    SourcePolicies = Struct.new(:source, :policies, keyword_init: true)
+  end
+end

data/lib/mudguard/domain/source_processor.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # Processes the interesting parts of the Ast and forwards selected nodes to the visitors
+    class SourceProcessor
+      def initialize(location:)
+        @location = location
+      end
+
+      def process(node, visitor)
+        process_node(node, visitor, "")
+      end
+
+      private
+
+      def process_node(node, visitor, module_name) # rubocop:disable Metrics/MethodLength
+        case node
+        when type?(:module)
+          process_module(node, visitor, module_name)
+        when type?(:class)
+          process_module(node, visitor, module_name)
+        when type?(:const)
+          process_const(node, visitor, module_name)
+        when type?(:casgn)
+          process_const_assignment(node, visitor, module_name)
+        else
+          ignore_and_continue(node, visitor, module_name)
+        end
+      end
+
+      def process_const_assignment(node, visitor, module_name)
+        is_explicit, is_static, const_name = find_const_name(node.children)
+        return unless is_static
+
+        visitor.visit_const_declaration(describe_location(node), const_name,
+                                        is_explicit ? "" : module_name)
+      end
+
+      def process_const(node, visitor, module_name)
+        is_explicit, is_static, const_name = find_const_name(node.children)
+        return unless is_static
+
+        visitor.visit_dependency(describe_location(node), const_name,
+                                 is_explicit ? "" : module_name)
+      end
+
+      def describe_location(node)
+        "#{@location}:#{node.location.line}"
+      end
+
+      def ignore_and_continue(node, visitor, module_name)
+        return unless node.respond_to?(:children)
+
+        node.children.flat_map { |c| process_node(c, visitor, module_name) }
+      end
+
+      def process_module(node, visitor, module_name)
+        is_explicit, is_static, const_name = find_const_name(node.children[0].children)
+        return unless is_static
+
+        visitor.visit_const_declaration(describe_location(node), const_name, module_name)
+
+        module_name = "#{is_explicit ? '' : module_name}#{const_name}"
+        node.children.drop(1).reject(&:nil?).each do |child_node|
+          process_node(child_node, visitor, module_name)
+        end
+      end
+
+      def find_const_name(children)
+        return [false, nil] if children.nil? || children.empty?
+
+        first_child = children[0]
+        is_explicit, is_static = find_const_type(first_child)
+        first_child_children = first_child.respond_to?(:children) ? first_child.children : nil
+        _, __, module_name = find_const_name(first_child_children)
+        const_name = children[1].to_s
+        [is_explicit, is_static, "#{module_name}::#{const_name}"]
+      end
+
+      def find_const_type(first_child)
+        is_explicit = type?(:cbase).call(first_child)
+        is_static = is_explicit || first_child.nil? || type?(:const).call(first_child)
+        [is_explicit, is_static]
+      end
+
+      def type?(type)
+        ->(n) { n.respond_to?(:type) && n.type == type }
+      end
+    end
+  end
+end

data/lib/mudguard/domain/texts.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # Builds texts to be displayed to a user
+    module Texts
+      def summary(file_count, violation_count)
+        files = pluralize("file", file_count)
+        "#{file_count} #{files} inspected, #{count(violation_count)}\
+ bad #{dependency(violation_count)} detected"
+      end
+
+      def dependency_not_allowed(dependency)
+        "#{dependency} not allowed"
+      end
+
+      def dependency_summary(file_count, dependency_count)
+        files = pluralize("file", file_count)
+        "#{file_count} #{files} inspected, #{count(dependency_count)}\
+ good #{dependency(dependency_count)} detected"
+      end
+
+      def dependency_allowed(dependency)
+        dependency.to_s
+      end
+
+      private
+
+      def dependency(count)
+        count <= 1 ? "dependency" : "dependencies"
+      end
+
+      def count(count)
+        count.zero? ? "no" : count.to_s
+      end
+
+      def pluralize(word, count)
+        count == 1 ? word : "#{word}s"
+      end
+    end
+  end
+end

data/lib/mudguard/infrastructure/cli/controller.rb

@@ -9,26 +9,68 @@ module Mudguard
     module Cli
       # Parses the cli arguments
       class Controller
-        def initialize(view:)
+        def initialize(view:) # rubocop:disable Metrics/MethodLength
+          @cmd = :analyse
           @view = view
-          @done = false
+          @display_opts = {
+            view: view,
+            compressed: false
+          }
           @parser = ::OptionParser.new do |opts|
             opts.banner = "Usage: mudguard [options] [directory]"
             opts.on("-h", "--help", "Prints this help") do
-              view.print(opts.to_s)
-              @done = true
+              @cmd = :help
+            end
+            opts.on("-p", "--print", "Prints all allowed dependencies") do
+              @cmd = :print_allowed
+            end
+            opts.on("-c", "--compressed", "Omits printing the same dependency more than once") do
+              @display_opts[:compressed] = true
             end
           end
         end
 
-        def parse!(argv)
+        def parse!(argv) # rubocop:disable Metrics/MethodLength
           directories = @parser.parse!(argv)
 
-          return true if @done
+          case @cmd
+          when :print_allowed
+            print_allowed_dependencies(directories)
+          when :help
+            help
+          when :analyse
+            check_dependencies(directories)
+          else
+            raise StandardError, "unknown command #{@cmd}"
+          end
+        end
+
+        private
+
+        def help
+          @view.print(@parser.to_s)
+          true
+        end
+
+        def check_dependencies(directories)
+          yield_directories(directories) do |directory, notification|
+            Mudguard::Application.check(directory, notification)
+          end
+        end
 
-          notification = NotificationAdapter.new(view: @view)
+        def print_allowed_dependencies(directories)
+          yield_directories(directories) do |directory, notification|
+            Mudguard::Application.print_allowed_dependencies(directory, notification)
+            true
+          end
+        end
+
+        def yield_directories(directories)
+          notification = NotificationAdapter.new(**@display_opts)
           directories = [Dir.pwd] if directories.empty?
-          directories.all? { |d| Mudguard::Application.check(d, notification) }
+          directories.all? do |directory|
+            yield directory, notification
+          end
         end
       end
     end

data/lib/mudguard/infrastructure/cli/notification_adapter.rb

@@ -5,12 +5,20 @@ module Mudguard
     module Cli
       # Forwards Notification to the view for printing
       class NotificationAdapter
-        def initialize(view:)
+        def initialize(view:, compressed: false)
           @view = view
+          @compressed = compressed
+          @printed_texts = Set.new
         end
 
-        def add(text)
-          @view.print(text)
+        def add(location, text)
+          text = if location.nil? || @compressed
+                   text
+                 else
+                   "#{location} #{text}"
+                 end
+          @view.print(text) unless @printed_texts.include?(text)
+          @printed_texts << text
         end
       end
     end

data/lib/mudguard/infrastructure/persistence/policy_file.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "yaml"
 require_relative "../../domain/policies"
 require_relative "../../domain/error"
 
@@ -8,14 +9,35 @@ module Mudguard
     module Persistence
       # A file containing the Mudguard-Policies
       class PolicyFile
-        def self.read(policy_file)
-          policy_exists = File.exist?(policy_file)
+        class << self
+          def read(project_path)
+            policy_file = File.join(project_path, ".mudguard.yml")
+            policy_exists = File.exist?(policy_file)
 
-          unless policy_exists
-            raise Mudguard::Domain::Error, "expected policy file #{policy_file} doesn't exists"
+            unless policy_exists
+              raise Mudguard::Domain::Error, "expected policy file #{policy_file} doesn't exists"
+            end
+
+            read_yml(policy_file)
           end
 
-          Mudguard::Domain::Policies.new(policies: File.readlines(policy_file))
+          private
+
+          def read_yml(policy_file)
+            yaml_file = File.read(policy_file)
+            yaml = YAML.safe_load(yaml_file, [Symbol], [], policy_file) || {}
+            yaml.transform_values { |value| (value || []).map(&method(:unsymbolize)) }
+          rescue Psych::SyntaxError => e
+            raise Mudguard::Domain::Error, "#{policy_file} is invalid (#{e.message})"
+          end
+
+          def unsymbolize(dependency)
+            if dependency.is_a?(Symbol)
+              ":#{dependency}"
+            else
+              dependency
+            end
+          end
         end
       end
     end

data/lib/mudguard/infrastructure/persistence/project_repository.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "policy_file"
+require_relative "ruby_files"
+require_relative "../../domain/source_policies"
+
+module Mudguard
+  module Infrastructure
+    module Persistence
+      # Provides access to the persisted source and policies
+      class ProjectRepository
+        class << self
+          def load_source_policies(project_path)
+            file = PolicyFile.read(project_path)
+            scopes = file.flat_map do |patterns, policies|
+              sources = RubyFiles.select(project_path, patterns: [patterns])
+              sources.flat_map { |s| { source: s, policies: policies } }
+            end
+
+            sources = scopes.group_by { |e| e[:source] }
+
+            sources.map do |source, group|
+              policies = group.flat_map { |r| r[:policies] }.uniq
+              Domain::SourcePolicies.new(source: source, policies: policies)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mudguard/infrastructure/persistence/ruby_files.rb

@@ -9,26 +9,28 @@ module Mudguard
       # Provides access to all ruby-files of a project
       class RubyFiles
         class << self
-          def all(project_path)
+          def select(project_path, patterns: nil)
             project_exists = Dir.exist?(project_path)
 
             unless project_exists
               raise Mudguard::Domain::Error, "expected project #{project_path} doesn't exists"
             end
 
-            enumerate_files(project_path)
+            patterns = [File.join("**", "*.rb")] if patterns.nil?
+            enumerate_files(project_path, patterns)
           end
 
           private
 
-          def enumerate_files(project_path)
+          def enumerate_files(project_path, patterns)
             project_path_name = Pathname.new(project_path)
-            ruby_files = File.join(project_path, "**", "*.rb")
+            ruby_files = patterns.map { |p| File.join(project_path, p) }
             Dir.glob(ruby_files).map do |f|
               file_path_name = Pathname.new(f)
               diff_path = file_path_name.relative_path_from(project_path_name).to_s
-              Mudguard::Domain::Source.new(location: File.join("./", diff_path), code: File.read(f))
-            end.lazy
+              Mudguard::Domain::Source.new(location: File.join("./", diff_path),
+                                           code_loader: -> { File.read(f) })
+            end
           end
         end
       end

data/lib/mudguard/infrastructure/rake/task.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+require_relative "../../application/application"
+require_relative "../../infrastructure/cli/notification_adapter"
+require_relative "../../infrastructure/cli/view"
+
+module Mudguard
+  module Infrastructure
+    module Rake
+      # Provides Mudguard Rake Tasks
+      class Task < ::Rake::TaskLib
+        def initialize(project_dir: Dir.pwd)
+          @project_dir = project_dir
+
+          desc "Run Mudguard"
+          task(:mudguard) do
+            view = Mudguard::Infrastructure::Cli::View.new
+            notification = Mudguard::Infrastructure::Cli::NotificationAdapter.new(view: view)
+            ok = Application.check(@project_dir, notification)
+            abort unless ok
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mudguard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mudguard
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/mudguard.gemspec

@@ -40,4 +40,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "~>0.80"
 
   spec.add_dependency "parser", "~>2.7"
+  spec.add_dependency "rake", "~> 13.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mudguard
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Jorg Jenni
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-28 00:00:00.000000000 Z
+date: 2020-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
 description: 
 email:
 - jorg.jenni@jennius.co.uk
@@ -172,15 +186,24 @@ files:
 - exe/mudguard
 - lib/mudguard.rb
 - lib/mudguard/application/application.rb
+- lib/mudguard/domain/const_visitor.rb
+- lib/mudguard/domain/consts.rb
+- lib/mudguard/domain/dependencies.rb
 - lib/mudguard/domain/dependency.rb
+- lib/mudguard/domain/dependency_visitor.rb
 - lib/mudguard/domain/error.rb
 - lib/mudguard/domain/policies.rb
 - lib/mudguard/domain/source.rb
+- lib/mudguard/domain/source_policies.rb
+- lib/mudguard/domain/source_processor.rb
+- lib/mudguard/domain/texts.rb
 - lib/mudguard/infrastructure/cli/controller.rb
 - lib/mudguard/infrastructure/cli/notification_adapter.rb
 - lib/mudguard/infrastructure/cli/view.rb
 - lib/mudguard/infrastructure/persistence/policy_file.rb
+- lib/mudguard/infrastructure/persistence/project_repository.rb
 - lib/mudguard/infrastructure/persistence/ruby_files.rb
+- lib/mudguard/infrastructure/rake/task.rb
 - lib/mudguard/version.rb
 - lib/tasks/rubocop.rake
 - lib/tasks/test.rake