mudguard 0.1.4 → 0.2.0

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