mudguard 0.1.7 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52da6086ca5ad7d9cc7882c0be051e35d1a1672930d616f3929d44909b23717f
-  data.tar.gz: 84ba1b85b2d6cdec19ccbd80ffe6f39745054f3e8617a250c7dc613cd40dc00e
+  metadata.gz: 44d7f2ff1e9b179d3d64e1263ab13cb217497fce8dd174f5b0ee5ef4cdf1c67f
+  data.tar.gz: 6597fed3f89fa210951650bec390b8c6a5196db0806b3e5b2daaba9406693d21
 SHA512:
-  metadata.gz: d41681429a450ad75420b5cbe6bf78a261bc2d6d90be6547e080557d09b66c7a937c6798cd2f4603e20c7154d1540638f3861830ea4add5c5bce513d78a6dfbb
-  data.tar.gz: e4f6a3925f3a65496c646cf2c1d0f5143b7e9f0c103a327961479b3dd01e4307bc743934ef8152ac73d15661bd04a842906876d595414814efdc6be285ba5efb
+  metadata.gz: 0eecb391426607e7650a7da55c2f470acf06b44da2327c7853c1215dc2a46fcdb592cedf3a7f383d57772b16017eb5f2b0c9edb0b87c4dc1d9d3821749a7a1a1
+  data.tar.gz: d69e2ec7b320c04a6e01475f7973992204f08653d84316865f903363b72e51928c15f98601c1b0e2a9009f712612556e0fc33811bf271c707d6cbcc92def2eba

data/.gitignore

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

data/.mudguard.yml

@@ -0,0 +1,6 @@
+'./**/*.rb':
+  # uncomment following lines to allow all dependencies
+  # - .*
+
+  # all code can depend on modules or constants defined in same module
+  - ^(::.+)(::[^:]+)* -> \1(::[^:]+)*$

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.2.3)
       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/Guardfile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 rspec_options = {
-  cmd: "rspec",
+  cmd: "bundle exec rspec",
   notification: false,
   failed_mode: :focus
 }

data/README.md

@@ -1,10 +1,16 @@
 # Mudguard
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mudguard`. To experiment with that code, run `bin/console` for an interactive prompt.
+**Mudguard** is a Ruby static code analyzer that investigates the coupling of modules in your source code. Mudguard
+prevents your code from becoming a [Big ball of mud](http://www.laputan.org/mud/) and helps implementing and
+maintaining an intended design.
 
-TODO: Delete this and the text above, and describe your gem
+Mudguard is inspired by
+* [Rubocop](https://github.com/rubocop-hq/rubocop)
+* Clean Architecture by Robert C. Martin (ISBN-13: 978-0-13-449416-6)
+* having seen many larger code bases in a sorrow state
+* my inability to efficiently break up application code into gems or rails engines
 
-## Installation
+# Installation
 
 Add this line to your application's Gemfile:
 
@@ -20,19 +26,66 @@ Or install it yourself as:
 
     $ gem install mudguard
 
-## Usage
+## Quickstart
+```
+$ cd my/cool/ruby/project
+$ mudguard
+```
+
+Mudguard creates on it's first run a file called **.mudguard.yml** which is used to configure **design policies** 
+governing your code. A .mudguard.yml could look like:
+```
+'./**/*.rb': # all code
+  # all code can depend on siblings in same module or class
+  - ^(::.+)(::[^:]+)* -> \1(::[^:]+)*$
+  # all code can depend on certain types
+  - .* -> ::(String|SecureRandom|Container|Time|Date|JSON|Object|Hash)$
+
+  # in all code module Application can depend on module Domain
+  - ^::Application(::[^:]+)* -> ::(Domain)(::[^:]+)*$
+  # in all code module Infrastructure can depend on module Application
+  - ^::Infrastructure(::[^:]+)* -> ::(Application)(::[^:]+)*$
+
+'spec/**/*.rb': # spec code
+  # Only in test code can we use RSpec, Timecop and Exception
+  - .* -> ::(RSpec|Timecop|Exception)$
+``` 
+
+## The .mudguard.yml
+The .mudguard.yml defines scopes and policies. A policy defines which dependencies are inside that scope permissible:
+```
+scope1:
+    - policy 1
+    - policy 2
+scope2:
+    - policy 3
+```
+The **scope** is a [glob-pattern](https://en.wikipedia.org/wiki/Glob_(programming)) and defines to which files a set
+of policies apply. For example a value `lib/docker/**/*.rb` defines a scope containing all Ruby files inside 
+folder lib/docker. 
 
-TODO: Write usage instructions here
+A **policy** is a [regular expression](https://ruby-doc.org/core-2.5.1/Regexp.html) matching one or a set of 
+dependencies that are permissible inside that scope. Mudguard represents a **dependency** as a symbol in form 
+of `X -> Y` meaning "X depends on Y". See following examples:
 
-## Development
+| Policy | matched Dependency|  Explanation |
+| --- | --- | --- |
+| `^::A -> ::B$` | `::A -> ::B` |Module A can depend on module or constant B |
+| `^::Infrastructure -> ::Rails$` | `::Infrastructure -> ::Rails` |Module Infrastructure can depend on Rails |
+| `^::Infrastructure(::[^:]+)* -> ::ActiveRecord$` | `::Infrastructure::Logger -> ::ActiveRecord` or `::Infrastructure::Persistence -> ::ActiveRecord`|Module Infrastructure and its submodules can depend on ActiveRecord |
+| `.*   -> ::Exception$` | `::Api::Gateway -> ::Exception` or `::Logger -> ::Gateway` |Any module can depend on class Exception | 
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Any dependency for which Mudguard doesn't find a matching policy is reported as an impermissible dependency.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+## Outlook
+Using regular expressions as policies is very flexible but difficult to use. Furthermore certain patterns used in 
+the regular expressions do repeat. It might be useful to replace regular expressions in future with a specific language
+to describe permissible dependencies. Any thoughts on that?
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mudguard. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Enceradeira/mudguard.
+ This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

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,84 @@
+# 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(create_hash_of_hash) 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 create_hash_of_hash
+        Hash.new { |h, k| h[k] = create_hash_of_hash }
+      end
+
+      def find_const_deeper(current_module, remaining_modules, consts, const_path)
+        return if consts.nil? || consts.empty?
+
+        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,85 @@
 # frozen_string_literal: true
 
-require "parser/current"
-require "mudguard/domain/dependency"
+orig = $VERBOSE
+begin
+  $VERBOSE = nil # silence warning when ruby versions are not exactly matching
+  require "parser/current"
+ensure
+  $VERBOSE = orig
+end
+
+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/.mudguard.template.yml

@@ -0,0 +1,6 @@
+'./**/*.rb':
+  # uncomment following lines to allow all dependencies
+  # - .*
+
+  # all code can depend on modules or constants defined in same module
+  - ^(::.+)(::[^:]+)* -> \1(::[^:]+)*$

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,36 @@ 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
+              template_file = File.join(__dir__, ".mudguard.template.yml")
+              FileUtils.cp(template_file, policy_file)
+            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")
-            Dir.glob(ruby_files).map do |f|
+            ruby_files = patterns.map { |p| File.join(project_path, p) }
+            Dir.glob(ruby_files).select { |f| File.file?(f) }.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.2.3"
 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.2.3
 platform: ruby
 authors:
 - Jorg Jenni
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-28 00:00:00.000000000 Z
+date: 2021-01-09 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
@@ -160,6 +174,7 @@ extra_rdoc_files: []
 files:
 - ".envrc"
 - ".gitignore"
+- ".mudguard.yml"
 - ".rubocop.yml"
 - ".ruby-version"
 - CODE_OF_CONDUCT.md
@@ -172,15 +187,25 @@ 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/.mudguard.template.yml
 - 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