mudguard 0.1.3 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '076099989a94de468e2c43e3abe2ee8cfc1c1ab5a0f7b25291f609e597f1e04c'
-  data.tar.gz: dff2e30cf95d50679ec2f03a65944dfc84c96f7daa2bf26557a790ba325d6a4d
+  metadata.gz: 6db3d7377ad8b0b1d13e59c306bd937bcb39a2b68bee5d0539a4dff17d460243
+  data.tar.gz: b46919284fea9ad09e6db895025c50eeff3577fc0fe32bbc3b5ad7aec0e4833f
 SHA512:
-  metadata.gz: 66ca1a68eb9b7f12864da3c83ef74df51afb305cb1fb4ccbdccb267e9189ba2adfdc9c756b69637fab29ae8a28e5c5d246a1cdfc4d3beab1697f82d7fc3de704
-  data.tar.gz: 54b2984f6c619c21e59c2056b1237dd05ff4d8915eb45570d69a119f4b676fd30046b215106c7142ebfc40ac4a4b5cbc681b7b7be7bc828c704c0a0022707185
+  metadata.gz: 68ed243c036a7bdbe9a5e3e5e5996c76006cbc7057f4f5aad78d43c011038a6de16496c61ce5bd9c88a63c678f6d501f53af17e18e931abb20d0bce351ce0585
+  data.tar.gz: 050fdc731cc7297f986f10ed1b39e95aa6e82bf2f36959d7fe6e322c9681b5322a8a0390b177ced26ecc5c09bea737e86b26645966e4d1b2612eee25d370a735

data/.gitignore

@@ -13,3 +13,10 @@
 # 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

data/.rubocop.yml

@@ -1,7 +1,9 @@
 AllCops:
+  NewCops: enable
   Exclude:
     - 'bin/*'
-    - 'spec/lib/test_projects/**/*.rb'
+    - '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.3)
+    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/Guardfile

@@ -8,7 +8,9 @@ rspec_options = {
 
 guard "rspec", rspec_options do
   watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
   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/exe/mudguard_spec.rb" }
 end

data/exe/mudguard

@@ -1,5 +1,13 @@
 #!/usr/bin/env ruby
-require "mudguard"
+# frozen_string_literal: true
 
-Mudguard.check("")
-puts "OK"
+require "mudguard/infrastructure/cli/view"
+require "mudguard/infrastructure/cli/controller"
+
+# Checks the dependencies of a ruby project
+module Mudguard
+  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

data/lib/mudguard/domain/dependency.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Domain
+    # A Dependency between Modules
+    class Dependency
+      attr_reader :location, :dependency
+
+      def initialize(location: nil, dependency:)
+        @location = location
+        @dependency = dependency
+      end
+
+      def inspect
+        "{#{@location}, #{@dependency}}"
+      end
+
+      def match(policy)
+        @dependency.match(policy)
+      end
+
+      def ==(other)
+        @location == other.instance_eval { @location } &&
+          @dependency == other.instance_eval { @dependency }
+      end
+    end
+  end
+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/{error.rb → domain/error.rb}

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Mudguard
-  class Error < StandardError
+  module Domain
+    class Error < StandardError
+    end
   end
 end

data/lib/mudguard/domain/policies.rb

@@ -0,0 +1,49 @@
+# 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
+      include Texts
+
+      def initialize(source_policies: [])
+        @source_policies = source_policies
+      end
+
+      def check(notification)
+        result = analyse(:check, notification)
+
+        count = result[:sources_count]
+        violations = result[:analyser_count]
+
+        notification.add(nil, summary(count, violations))
+        violations.zero?
+      end
+
+      def print_allowed_dependencies(notification)
+        result = analyse(:print_allowed, notification)
+
+        count = result[:sources_count]
+        violations = result[:analyser_count]
+
+        notification.add(nil, dependency_summary(count, violations))
+      end
+
+      private
+
+      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
+end

data/lib/mudguard/domain/source.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "parser/current"
+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:, code_loader: -> { "" })
+        @code_loader = code_loader
+        @location = location
+      end
+
+      def ==(other)
+        @location == other.instance_eval { @location }
+      end
+
+      def hash
+        @location.hash
+      end
+
+      def eql?(other)
+        @location.eql?(other.instance_eval { @location })
+      end
+
+      def inspect
+        @location
+      end
+
+      def find_mod_dependencies(consts)
+        visitor = DependencyVisitor.new(consts: consts)
+        visit_ast(visitor)
+        visitor.dependencies
+      end
+
+      def find_consts
+        visitor = ConstVisitor.new
+        visit_ast(visitor)
+        visitor.consts
+      end
+
+      def location?(glob)
+        @location == glob
+      end
+
+      private
+
+      SYNTAX_ERROR = "error"
+
+      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 code
+        @code ||= @code_loader.call
+      end
+
+      def visit_ast(visitor)
+        return if ast == SYNTAX_ERROR
+
+        SourceProcessor.new(location: @location).process(ast, visitor)
+      end
+    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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "mudguard/application/application"
+require_relative "notification_adapter"
+
+module Mudguard
+  module Infrastructure
+    module Cli
+      # Parses the cli arguments
+      class Controller
+        def initialize(view:) # rubocop:disable Metrics/MethodLength
+          @cmd = :analyse
+          @view = view
+          @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
+              @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) # rubocop:disable Metrics/MethodLength
+          directories = @parser.parse!(argv)
+
+          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
+
+        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? do |directory|
+            yield directory, notification
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Infrastructure
+    module Cli
+      # Forwards Notification to the view for printing
+      class NotificationAdapter
+        def initialize(view:, compressed: false)
+          @view = view
+          @compressed = compressed
+          @printed_texts = Set.new
+        end
+
+        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
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Mudguard
+  module Infrastructure
+    module Cli
+      # Handles user input
+      class View
+        def print(text)
+          puts text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../../domain/policies"
+require_relative "../../domain/error"
+
+module Mudguard
+  module Infrastructure
+    module Persistence
+      # A file containing the Mudguard-Policies
+      class PolicyFile
+        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"
+            end
+
+            read_yml(policy_file)
+          end
+
+          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
+  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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "mudguard/domain/source"
+
+module Mudguard
+  module Infrastructure
+    module Persistence
+      # Provides access to all ruby-files of a project
+      class RubyFiles
+        class << self
+          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
+
+            patterns = [File.join("**", "*.rb")] if patterns.nil?
+            enumerate_files(project_path, patterns)
+          end
+
+          private
+
+          def enumerate_files(project_path, patterns)
+            project_path_name = Pathname.new(project_path)
+            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_loader: -> { File.read(f) })
+            end
+          end
+        end
+      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.3"
+  VERSION = "0.1.8"
 end

data/mudguard.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "mudguard helps your ruby project not becoming a "\
                        "'Big ball of mud'"
-  spec.homepage      = "https://gibhub.com/Enceradeira/mudguard"
+  spec.homepage      = "https://github.com/Enceradeira/mudguard"
   spec.license       = "MIT"
 
   spec.metadata["homepage_uri"] = spec.homepage
@@ -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.3
+  version: 0.1.8
 platform: ruby
 authors:
 - Jorg Jenni
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-15 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
@@ -171,23 +185,36 @@ files:
 - Rakefile
 - exe/mudguard
 - lib/mudguard.rb
-- lib/mudguard/error.rb
-- lib/mudguard/policies.rb
-- lib/mudguard/policy_file.rb
-- lib/mudguard/ruby_analyser.rb
-- lib/mudguard/ruby_files.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/gem.rake
 - lib/tasks/rubocop.rake
 - lib/tasks/test.rake
 - mudguard.gemspec
 - pkg/mudguard-0.1.0.gem
-homepage: https://gibhub.com/Enceradeira/mudguard
+homepage: https://github.com/Enceradeira/mudguard
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://gibhub.com/Enceradeira/mudguard
-  source_code_uri: https://gibhub.com/Enceradeira/mudguard
+  homepage_uri: https://github.com/Enceradeira/mudguard
+  source_code_uri: https://github.com/Enceradeira/mudguard
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/mudguard/policies.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "ruby_analyser"
-
-module Mudguard
-  # Contains the policies to be enforced
-  class Policies
-    def initialize(policies: [])
-      @policies = policies.map { |l| l.gsub(/\s/, "") }.map { |p| /^#{p}/ }
-    end
-
-    def check(sources)
-      sources.all? do |source|
-        dependencies = RubyAnalyser.find_mod_dependencies(source)
-        dependencies.all? do |d|
-          @policies.any? do |p|
-            d.match?(p)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mudguard/policy_file.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "policies"
-require_relative "error"
-
-module Mudguard
-  # A file containing the Mudguard-Policies
-  class PolicyFile
-    def self.read(policy_file)
-      policy_exists = File.exist?(policy_file)
-
-      raise Error, "expected policy file #{policy_file} doesn't exists" unless policy_exists
-
-      Policies.new(policies: File.readlines(policy_file))
-    end
-  end
-end

data/lib/mudguard/ruby_analyser.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "parser/current"
-
-module Mudguard
-  # Analyses Ruby-Source and returns extracted information
-  class RubyAnalyser
-    class << self
-      def find_mod_dependencies(source)
-        begin
-          root = Parser::CurrentRuby.parse(source)
-        rescue Parser::SyntaxError
-          return []
-        end
-        return [] if root.nil?
-
-        process(root)
-      end
-
-      private
-
-      def process(node, module_name = "")
-        case node
-        when type?(:module)
-          process_module(node.children)
-        when type?(:class)
-          process_class(node.children, module_name)
-        when type?(:const)
-          ["#{module_name}->#{find_const_name(node.children)}"]
-        else
-          ignore_and_continue(node, module_name)
-        end
-      end
-
-      def ignore_and_continue(node, module_name)
-        case node
-        when children?
-          node.children.flat_map { |c| process(c, module_name) }
-        else
-          []
-        end
-      end
-
-      def process_module(children)
-        module_name = find_const_name(children[0].children)
-        process(children[1], module_name)
-      end
-
-      def process_class(children, module_name)
-        process(children[1], module_name)
-      end
-
-      def find_const_name(children)
-        return nil if children.nil?
-
-        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}"
-        end
-      end
-
-      def children?
-        ->(n) { n.respond_to?(:children) }
-      end
-
-      def type?(type)
-        ->(n) { n.respond_to?(:type) && n.type == type }
-      end
-    end
-  end
-end

data/lib/mudguard/ruby_files.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Mudguard
-  # Provides access to all ruby-files of a project
-  class RubyFiles
-    class << self
-      def all(project_path)
-        project_exists = Dir.exist?(project_path)
-
-        raise Error, "expected project #{project_path} doesn't exists" unless project_exists
-
-        ruby_files = File.join(project_path, "**", "*.rb")
-        Dir.glob(ruby_files).lazy
-      end
-    end
-  end
-end

data/lib/tasks/gem.rake

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "rspec/core/rake_task"
-require "mudguard/version"
-
-namespace :gem do
-  desc "Publishes the gem on rubygems.org"
-  task publish: "gem:build" do
-    exec("gem push mudguard-#{Mudguard::VERSION}.gem")
-  end
-  desc "Builds the gem"
-  task :build do
-    exec("gem build mudguard.gemspec")
-  end
-end