mudguard 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e84d450c1adfd300b6be1e11244dd8eec43bc4ef2dffdd090974290591bce06f
-  data.tar.gz: c36b94a49c130dc29b6ce80befc227121348c53b977a88451337bc6987b5a0fa
+  metadata.gz: 3a7b56ba51f10b0d6d32fcb120599bc145b275076b30786b6955285f5da26668
+  data.tar.gz: ca75c47ff5f80584407bb0da9d56b64f7c9e1e65cc8f7fc8b377ea0e8d83fefa
 SHA512:
-  metadata.gz: 4db49720f6381c3c67a7e2e669235e070d8ed2cb650f48f41752dd95a243da43dc1bbc7bec7947828fd40c7abf3c7dc786c366cd04efb026d2c732cc5908d8d2
-  data.tar.gz: 84291c975dce9b7b893ae831dcfc54cafe16313d17b86f590d27a529b231fe4e1c2a4683455746c7a5143bbf880fe39f17ffb7be16954a63647eb98bda5a22ad
+  metadata.gz: e9bd40c81779ed70c331c0d445b735edb3e561967e65fce1dc228a62ad86fd9298dfaa990d3bded3faec6191b5821204466c9ed29cdf89d12e9eee1678884d81
+  data.tar.gz: 427d86d72d87f73d11dedfbb7a35d42ead0145919bf85e32dd5c9055bc977a2dadb9be668f76a081e61f54510a6ebb4aa66e7f4b11746da1a222efde3ad5b760

data/.gitignore

@@ -13,3 +13,11 @@
 # Ignore RSpec Working Dir
 /.rspec
 .rspec_status
+
+# 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.4)
+    mudguard (0.2.0)
       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

@@ -12,5 +12,5 @@ guard "rspec", rspec_options do
   watch(%r{^lib/mudguard/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch(%r{^lib/mudguard/(.+)\.rb$}) { |m| Dir.glob("spec/lib/#{m[1]}_*.rb") }
   watch("spec/spec_helper.rb") { "spec" }
-  watch(%r{^exe\/mudguard$}) { |_| "spec/bin/mudguard_spec.rb" }
+  watch(%r{^exe\/mudguard$}) { |_| "spec/exe/mudguard_spec.rb" }
 end

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/exe/mudguard

@@ -1,20 +1,13 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "mudguard"
-require "optparse"
+require "mudguard/infrastructure/cli/view"
+require "mudguard/infrastructure/cli/controller"
 
 # Checks the dependencies of a ruby project
 module Mudguard
-  parser = OptionParser.new do |opts|
-    opts.banner = "Usage: mudguard [options] [directory]"
-    opts.on("-h", "--help", "Prints this help") do
-      puts opts
-      exit
-    end
-  end
-
-  directories = parser.parse!
-  ok = directories.all?(&Mudguard.method(:check))
+  view = Mudguard::Infrastructure::Cli::View.new
+  parser = Mudguard::Infrastructure::Cli::Controller.new(view: view)
+  ok = parser.parse!(ARGV)
   exit(ok ? 0 : 1)
 end

data/lib/mudguard.rb

@@ -1,19 +1,4 @@
 # frozen_string_literal: true
 
-require "mudguard/version"
-require_relative "mudguard/policy_file"
-require_relative "mudguard/ruby_files"
-
-# Contains methods to check if your project is a bit muddy
-module Mudguard
-  class << self
-    def check(project_path)
-      policy_file_path = File.expand_path("MudguardFile", project_path)
-      policies = PolicyFile.read(policy_file_path)
-
-      files = RubyFiles.all(project_path).map { |f| File.read(f) }
-
-      policies.check(files)
-    end
-  end
-end
+require_relative "./mudguard/version"
+require_relative "./mudguard/application/application"

data/lib/mudguard/application/application.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../infrastructure/persistence/project_repository"
+require_relative "../domain/policies"
+
+# Contains methods to check if your project is a bit muddy
+module Mudguard
+  # API to mudguard
+  module Application
+    class << self
+      def check(project_path, notification)
+        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
+
+      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
+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