layer_checker 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78b371df5e5e5da7832fe55c7c73118533e5ed0f58a81c210893b798c3e79cb5
+  data.tar.gz: 6c8061758737e375c24ac30f96a6bb266b5f03d2fbf75d22e72eb3d8540d21c0
+SHA512:
+  metadata.gz: 594f7ef3c58a15ae5cfaa153fa3f75141f8bf1411efacfd233751319782f81a591a97dd6252c1af23cb67f02f8f9f40c7019b9499f6b67709da2d2c1f434b082
+  data.tar.gz: 79d98cff723311e13d9239e5d7fbe50c5b6f85379f717212d5954d4c120ce1c99b700c8e2fb3a45a5c9ad0dab453dcc44ea7282a142410b50142409f39f1a336

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victor Manuel Chaves Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,313 @@
+# Layer Checker
+> This project was made with a little help of vibe-coding.
+
+A Ruby gem to validate architectural layer dependencies in your projects based on YAML configuration files.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'layer-checker'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install layer-checker
+```
+
+## Usage
+
+### 1. Create a Configuration File
+
+Create a `project_layers.yml` file in your project root:
+
+```yaml
+version: 1
+
+modules:
+  controller:
+    paths:
+      - app/controllers/**
+    depends_on:
+      - service
+      - presenter
+
+  service:
+    paths:
+      - app/services/**
+    depends_on:
+      - model
+
+  model:
+    paths:
+      - app/models/**
+    depends_on: []
+
+  presenter:
+    paths:
+      - app/presenters/**
+    depends_on: []
+
+options:
+  fail_on_violation: true
+  unassigned_behavior: warn
+  allow_external_constants:
+    - ActiveRecord::Base
+    - ApplicationController
+```
+
+### 2. Run the Checker
+
+#### Command Line
+
+```bash
+layer_checker
+```
+
+With options:
+
+```bash
+layer_checker --config custom_config.yml --format json
+```
+
+#### In Rails (Rake Task)
+
+```bash
+rake layer_checker:check
+```
+
+With environment variables:
+
+```bash
+CONFIG=custom_config.yml FORMAT=json rake layer_checker:check
+```
+
+#### Programmatically
+
+```ruby
+require 'layer_checker'
+
+checker = LayerChecker::Checker.new(
+  config_path: 'project_layers.yml',
+  project_root: Dir.pwd
+)
+
+result = checker.check
+checker.report(format: :console)
+
+if result[:success]
+  puts "All good!"
+else
+  puts "Found #{result[:violations].size} violations"
+end
+```
+
+## Configuration
+
+### Module Structure
+
+#### Simple Modules
+
+```yaml
+modules:
+  controller:
+    paths:
+      - app/controllers/**
+    depends_on:
+      - service
+```
+
+#### Nested Modules (DDD Style)
+
+```yaml
+modules:
+  billing:
+    modules:
+      domain:
+        paths:
+          - app/billing/domain/**
+        depends_on: []
+      
+      application:
+        paths:
+          - app/billing/application/**
+        depends_on:
+          - domain
+      
+      infrastructure:
+        paths:
+          - app/billing/infrastructure/**
+        depends_on:
+          - application
+          - domain
+```
+
+#### Feature-Based Modules
+
+```yaml
+modules:
+  authentication:
+    modules:
+      controller:
+        paths:
+          - app/authentication/controllers/**
+        depends_on:
+          - service
+      
+      service:
+        paths:
+          - app/authentication/services/**
+        depends_on:
+          - model
+      
+      model:
+        paths:
+          - app/authentication/models/**
+        depends_on: []
+```
+
+### Options
+
+- **`fail_on_violation`** (boolean, default: `false`): Exit with error code 1 if violations are found
+- **`unassigned_behavior`** (string, default: `warn`): How to handle files that don't belong to any module
+  - `warn`: Just warn about unassigned files
+  - `fail`: Treat unassigned files as violations
+  - `ignore`: Ignore unassigned files
+- **`allow_external_constants`** (array, default: `[]`): List of external constants that are allowed (e.g., Rails framework classes)
+
+## Examples
+
+See the `examples/` directory for complete configuration examples:
+
+- **[conventional-layer.yml](examples/conventional-layer.yml)**: Traditional MVC layered architecture
+- **[ddd-layer.yml](examples/ddd-layer.yml)**: Domain-Driven Design with nested modules
+- **[featured-layer.yml](examples/featured-layer.yml)**: Feature-based architecture
+
+## How It Works
+
+1. **Load Configuration**: Parses the YAML file to understand your architecture
+2. **Scan Code**: Finds all Ruby files in your project
+3. **Extract Dependencies**: Uses AST parsing to detect:
+   - Constant references (e.g., `UserService`, `User::Profile`)
+   - Method calls (e.g., `UserService.new`)
+   - Class inheritance (e.g., `class Controller < ApplicationController`)
+4. **Validate**: Checks if each dependency is allowed according to your configuration
+5. **Report**: Shows violations with file locations and line numbers
+
+## Output Formats
+
+### Console (Default)
+
+```
+================================================================================
+Layer Checker Results
+================================================================================
+✗ Found 2 violation(s)
+
+Violations found:
+
+  controller:
+    app/controllers/users_controller.rb:15
+      → controller cannot depend on model
+      → Referenced: User
+
+  service:
+    app/services/billing_service.rb:23
+      → service cannot depend on presenter
+      → Referenced: InvoicePresenter
+
+================================================================================
+Summary:
+  Total violations: 2
+  Modules affected: 2
+================================================================================
+```
+
+### JSON
+
+```json
+{
+  "success": false,
+  "message": "Found 2 violation(s)",
+  "violations": [
+    {
+      "source_file": "app/controllers/users_controller.rb",
+      "source_module": "controller",
+      "target_constant": "User",
+      "target_module": "model",
+      "line_number": 15,
+      "violation_type": "forbidden_dependency"
+    }
+  ],
+  "summary": {
+    "total_violations": 2,
+    "modules_affected": 2
+  }
+}
+```
+
+## CLI Options
+
+```
+Usage: layer_checker [options]
+    -c, --config PATH                Path to config file (default: project_layers.yml)
+    -p, --project PATH               Project root directory (default: current directory)
+    -f, --format FORMAT              Output format: console or json (default: console)
+    -h, --help                       Show this help message
+    -v, --version                    Show version
+```
+
+## Integration with CI/CD
+
+Add to your CI pipeline:
+
+```yaml
+# .github/workflows/ci.yml
+- name: Check Layer Architecture
+  run: bundle exec layer_checker
+```
+
+Or with Rake:
+
+```yaml
+- name: Check Layer Architecture
+  run: bundle exec rake layer_checker:check
+```
+
+Set `fail_on_violation: true` in your config to fail the build on violations.
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+```
+
+To build the gem:
+
+```bash
+gem build layer_checker.gemspec
+```
+
+To install locally:
+
+```bash
+gem install ./layer-checker-0.1.0.gem
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).

data/bin/layer_checker

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative '../lib/layer_checker'
+
+options = {
+  config_path: 'project_layers.yml',
+  project_root: Dir.pwd,
+  format: :console
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: layer_checker [options]"
+
+  opts.on("-c", "--config PATH", "Path to config file (default: project_layers.yml)") do |path|
+    options[:config_path] = path
+  end
+
+  opts.on("-p", "--project PATH", "Project root directory (default: current directory)") do |path|
+    options[:project_root] = path
+  end
+
+  opts.on("-f", "--format FORMAT", "Output format: console or json (default: console)") do |format|
+    options[:format] = format.to_sym
+  end
+
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+
+  opts.on("-v", "--version", "Show version") do
+    puts "LayerChecker version #{LayerChecker::VERSION}"
+    exit
+  end
+end.parse!
+
+begin
+  checker = LayerChecker::Checker.new(
+    config_path: options[:config_path],
+    project_root: options[:project_root]
+  )
+  
+  result = checker.check
+  checker.report(format: options[:format])
+  
+  # Exit with error code if violations found and fail_on_violation is true
+  if !result[:success] && checker.config.option('fail_on_violation', false)
+    exit 1
+  end
+rescue LayerChecker::ConfigError => e
+  puts "Configuration Error: #{e.message}"
+  exit 1
+rescue => e
+  puts "Error: #{e.message}"
+  puts e.backtrace if ENV['DEBUG']
+  exit 1
+end

data/examples/conventional-layer.yml

@@ -0,0 +1,25 @@
+version: 1
+
+modules:
+  controller:
+    paths:
+      - app/controllers/**
+    depends_on:
+      - service
+      - presenter
+
+  service:
+    paths:
+      - app/services/**
+    depends_on:
+      - model
+
+  model:
+    paths:
+      - app/models/**
+    depends_on: []
+
+  presenter:
+    paths:
+      - app/presenters/**
+    depends_on: []

data/examples/ddd-layer.yml

@@ -0,0 +1,42 @@
+version: 1
+
+modules:
+  billing:
+    modules:
+      domain:
+        paths:
+          - app/billing/domain/**
+        depends_on: []
+
+      application:
+        paths:
+          - app/billing/application/**
+        depends_on:
+          - domain
+
+      infrastructure:
+        paths:
+          - app/billing/infrastructure/**
+        depends_on:
+          - application
+          - domain
+
+  users:
+    modules:
+      domain:
+        paths:
+          - app/users/domain/**
+        depends_on: []
+
+      application:
+        paths:
+          - app/users/application/**
+        depends_on:
+          - domain
+
+      infrastructure:
+        paths:
+          - app/users/infrastructure/**
+        depends_on:
+          - application
+          - domain

data/examples/featured-layer.yml

@@ -0,0 +1,29 @@
+version: 1
+
+modules:
+  authentication:
+    modules:
+      controller:
+        paths:
+          - app/authentication/controllers/**
+        depends_on:
+          - service
+
+      service:
+        paths:
+          - app/authentication/services/**
+        depends_on:
+          - model
+
+      model:
+        paths:
+          - app/authentication/models/**
+        depends_on: []
+
+
+options:
+  fail_on_violation: true
+  unassigned_behavior: fail
+  allow_external_constants:
+    - ActiveRecord::Base
+    - ApplicationController

data/lib/layer_checker/code_analyzer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'dependency_extractor'
+
+module LayerChecker
+  class CodeAnalyzer
+    attr_reader :config, :project_root, :file_dependencies
+
+    def initialize(config, project_root: Dir.pwd)
+      @config = config
+      @project_root = project_root
+      @file_dependencies = {}
+    end
+
+    # Scan all Ruby files in the project
+    def analyze
+      ruby_files = find_ruby_files
+      
+      ruby_files.each do |file_path|
+        relative_path = file_path.sub("#{@project_root}/", '')
+        dependencies = DependencyExtractor.extract(file_path)
+        
+        @file_dependencies[relative_path] = {
+          absolute_path: file_path,
+          module: @config.module_for_file(relative_path),
+          dependencies: dependencies
+        }
+      end
+
+      @file_dependencies
+    end
+
+    # Get all files that belong to a specific module
+    def files_for_module(mod)
+      @file_dependencies.select { |_, info| info[:module] == mod }
+    end
+
+    # Get files that don't belong to any module
+    def unassigned_files
+      @file_dependencies.select { |_, info| info[:module].nil? }
+    end
+
+    private
+
+    def find_ruby_files
+      # Find all .rb files, excluding common directories to ignore
+      exclude_patterns = %w[
+        **/vendor/**
+        **/node_modules/**
+        **/tmp/**
+        **/log/**
+        **/coverage/**
+        **/.git/**
+      ]
+
+      all_files = Dir.glob("#{@project_root}/**/*.rb")
+      
+      all_files.reject do |file|
+        exclude_patterns.any? { |pattern| File.fnmatch?(pattern, file, File::FNM_PATHNAME) }
+      end
+    end
+  end
+end

data/lib/layer_checker/config.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'module'
+
+module LayerChecker
+  class Config 
+    attr_reader :modules, :options, :all_modules
+
+    def initialize(config_path)
+      config = load_config(config_path)
+          
+      @modules = parse_modules(config['modules'] || {})
+      @options = parse_options(config['options'] || {})
+      @all_modules = build_all_modules_map
+    end
+
+    # Find which module a file belongs to
+    def module_for_file(file_path)
+      @all_modules.values.find { |mod| mod.matches_file?(file_path) }
+    end
+
+    # Get option value with default
+    def option(key, default = nil)
+      @options.fetch(key, default)
+    end
+
+    private
+
+    def load_config(path)
+      raise "Config file not found: #{path}" unless File.exist?(path)
+
+      YAML.load_file(path)
+    end
+
+    def parse_modules(modules_config)
+      modules = {}
+
+      modules_config.each do |mod_name, mod_config|
+        modules[mod_name] = LayerChecker::Module.new(mod_name, mod_config)
+      end
+
+      modules
+    end
+
+    def parse_options(options_config)
+      {
+        'fail_on_violation' => options_config['fail_on_violation'] || false,
+        'unassigned_behavior' => options_config['unassigned_behavior'] || 'warn',
+        'allow_external_constants' => Array(options_config['allow_external_constants'] || [])
+      }
+    end
+
+    # Build a flat map of all modules (including nested ones)
+    def build_all_modules_map
+      result = {}
+      @modules.each_value do |mod|
+        result.merge!(mod.all_modules)
+      end
+      result
+    end
+  end
+end

data/lib/layer_checker/dependency_extractor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module LayerChecker
+  class DependencyExtractor
+    # Extract dependencies from a Ruby file
+    def self.extract(file_path)
+      return [] unless File.exist?(file_path)
+
+      source = File.read(file_path)
+      dependencies = []
+
+      begin
+        buffer = Parser::Source::Buffer.new(file_path)
+        buffer.source = source
+        
+        parser = Parser::CurrentRuby.new
+        ast = parser.parse(buffer)
+        
+        dependencies = extract_from_ast(ast) if ast
+      rescue Parser::SyntaxError => e
+        # Skip files with syntax errors
+        warn "Syntax error in #{file_path}: #{e.message}" if ENV['DEBUG']
+      end
+
+      dependencies.uniq
+    end
+
+    private
+
+    def self.extract_from_ast(node, dependencies = [])
+      return dependencies unless node.is_a?(Parser::AST::Node)
+
+      case node.type
+      when :const
+        # Extract constant references (e.g., UserService, User::Profile)
+        const_name = extract_const_name(node)
+        dependencies << { type: :constant, name: const_name, node: node } if const_name
+      
+      when :send
+        # Extract method calls that might reference other modules
+        # e.g., UserService.new, User.find(1)
+        if node.children[0].is_a?(Parser::AST::Node) && node.children[0].type == :const
+          const_name = extract_const_name(node.children[0])
+          dependencies << { type: :method_call, name: const_name, node: node } if const_name
+        end
+      
+      when :class, :module
+        # Extract class/module inheritance and includes
+        if node.children[1] # superclass
+          if node.children[1].is_a?(Parser::AST::Node) && node.children[1].type == :const
+            const_name = extract_const_name(node.children[1])
+            dependencies << { type: :inheritance, name: const_name, node: node.children[1] } if const_name
+          end
+        end
+      end
+
+      # Recursively process child nodes
+      node.children.each do |child|
+        extract_from_ast(child, dependencies) if child.is_a?(Parser::AST::Node)
+      end
+
+      dependencies
+    end
+
+    def self.extract_const_name(node)
+      return nil unless node.is_a?(Parser::AST::Node) && node.type == :const
+
+      parts = []
+      current = node
+
+      while current && current.is_a?(Parser::AST::Node)
+        if current.type == :const
+          parts.unshift(current.children[1].to_s)
+          current = current.children[0]
+        elsif current.type == :cbase
+          # Absolute constant (::Something)
+          break
+        else
+          break
+        end
+      end
+
+      parts.join('::')
+    end
+  end
+end

data/lib/layer_checker/dependency_validator.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative 'violation'
+
+module LayerChecker
+  class DependencyValidator
+    attr_reader :config, :analyzer, :violations
+
+    def initialize(config, analyzer)
+      @config = config
+      @analyzer = analyzer
+      @violations = []
+    end
+
+    def validate
+      @violations = []
+
+      @analyzer.file_dependencies.each do |file_path, file_info|
+        source_module = file_info[:module]
+        
+        # Handle unassigned files
+        if source_module.nil?
+          handle_unassigned_file(file_path, file_info)
+          next
+        end
+
+        # Check each dependency
+        file_info[:dependencies].each do |dependency|
+          check_dependency(file_path, source_module, dependency)
+        end
+      end
+
+      # Deduplicate violations (same file, line, source and target)
+      @violations.uniq! do |v|
+        [v.source_file, v.line_number, v.source_module&.full_name, v.target_module&.full_name]
+      end
+
+      @violations
+    end
+
+    private
+
+    def handle_unassigned_file(file_path, file_info)
+      behavior = @config.option('unassigned_behavior', 'warn')
+      
+      if behavior == 'fail' && file_info[:dependencies].any?
+        @violations << Violation.new(
+          source_file: file_path,
+          source_module: nil,
+          target_constant: 'N/A',
+          target_module: nil,
+          violation_type: :unassigned_file
+        )
+      end
+    end
+
+    def check_dependency(file_path, source_module, dependency)
+      const_name = dependency[:name]
+      
+      # Skip if it's an allowed external constant
+      return if allowed_external_constant?(const_name)
+
+      # Find which module this constant belongs to
+      target_module = find_module_for_constant(const_name)
+      
+      # If we can't find the module, it might be external (gem, Rails, etc.)
+      return unless target_module
+
+      # Skip if it's the same module
+      return if target_module == source_module
+
+      # Check if this dependency is allowed
+      unless dependency_allowed?(source_module, target_module)
+        @violations << Violation.new(
+          source_file: file_path,
+          source_module: source_module,
+          target_constant: const_name,
+          target_module: target_module,
+          line_number: extract_line_number(dependency[:node]),
+          violation_type: :forbidden_dependency
+        )
+      end
+    end
+
+    def allowed_external_constant?(const_name)
+      allowed = @config.option('allow_external_constants', [])
+      allowed.any? { |pattern| const_name.start_with?(pattern) }
+    end
+
+    def find_module_for_constant(const_name)
+      # Try to find a file that defines this constant
+      # Convert constant name to possible file paths
+      # e.g., UserService -> user_service.rb, User::Profile -> user/profile.rb
+      possible_file_names = constant_to_file_names(const_name)
+      
+      # Look for files that match the constant name
+      matching_files = []
+      
+      @analyzer.file_dependencies.each do |file_path, file_info|
+        next unless file_info[:module]
+        
+        # Check if this file likely defines the constant
+        file_basename = File.basename(file_path, '.rb')
+        
+        if possible_file_names.include?(file_basename)
+          matching_files << file_info
+        end
+      end
+      
+      # Return the module of the first matching file
+      # (in most cases there should only be one)
+      matching_files.first&.dig(:module)
+    end
+
+    def constant_to_file_names(const_name)
+      # Convert CamelCase to snake_case
+      parts = const_name.split('::')
+      snake_parts = parts.map { |part| camel_to_snake(part) }
+      
+      # Return possible file names
+      [
+        snake_parts.last,  # Just the class name
+        snake_parts.join('_')  # Full namespaced name
+      ].uniq
+    end
+
+    def camel_to_snake(str)
+      str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .downcase
+    end
+
+    def dependency_allowed?(source_module, target_module)
+      allowed_deps = source_module.allowed_dependencies
+      target_name = target_module.full_name
+      
+      # Check direct match
+      return true if allowed_deps.include?(target_name)
+      
+      # Check if target is in the allowed list (by simple name)
+      return true if allowed_deps.include?(target_module.name)
+      
+      # Check parent module dependencies for nested modules
+      if source_module.parent
+        parent_allowed = source_module.parent.allowed_dependencies
+        return true if parent_allowed.include?(target_name) || parent_allowed.include?(target_module.name)
+      end
+
+      false
+    end
+
+    def extract_line_number(node)
+      return nil unless node.respond_to?(:loc) && node.loc.respond_to?(:line)
+      node.loc.line
+    end
+  end
+end

data/lib/layer_checker/module.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LayerChecker
+  class Module
+    attr_reader :name, :paths, :depends_on, :submodules, :parent
+
+    def initialize(name, config = {}, parent: nil)
+      @name = name
+      @parent = parent
+      @paths = Array(config['paths'] || [])
+      @depends_on = Array(config['depends_on'] || [])
+      @submodules = {}
+
+      # Parse nested modules if they exist
+      if config['modules']
+        config['modules'].each do |submodule_name, submodule_config|
+          @submodules[submodule_name] = Module.new(submodule_name, submodule_config, parent: self)
+        end
+      end
+    end
+
+    # Check if a file path belongs to this module
+    def matches_file?(file_path)
+      @paths.any? { |pattern| File.fnmatch?(pattern, file_path, File::FNM_PATHNAME) }
+    end
+
+    # Get the full qualified name (e.g., "billing.domain")
+    def full_name
+      parent ? "#{parent.full_name}.#{name}" : name
+    end
+
+    # Get all modules (including nested ones) as a flat hash
+    def all_modules
+      result = { full_name => self }
+      @submodules.each_value do |submodule|
+        result.merge!(submodule.all_modules)
+      end
+      result
+    end
+
+    # Check if this module can depend on another module
+    def can_depend_on?(other_module_name)
+      # Direct dependency check
+      return true if @depends_on.include?(other_module_name)
+
+      # Check if it's a sibling module (same parent)
+      if parent
+        sibling_names = parent.submodules.keys
+        return @depends_on.any? { |dep| sibling_names.include?(dep) && dep == other_module_name }
+      end
+
+      false
+    end
+
+    # Get all allowed dependencies (resolving relative names)
+    def allowed_dependencies
+      return @depends_on unless parent
+
+      # For nested modules, resolve dependencies relative to parent
+      @depends_on.map do |dep|
+        # If it's a simple name, it refers to a sibling
+        if parent.submodules.key?(dep)
+          "#{parent.full_name}.#{dep}"
+        else
+          dep
+        end
+      end
+    end
+
+    def to_s
+      full_name
+    end
+  end
+end

data/lib/layer_checker/railtie.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module LayerChecker
+  class Railtie < Rails::Railtie
+    railtie_name :layer_checker
+
+    rake_tasks do
+      namespace :layer_checker do
+        desc "Check layer architecture compliance"
+        task check: :environment do
+          config_path = ENV['CONFIG'] || 'project_layers.yml'
+          format = ENV['FORMAT'] || 'console'
+          
+          checker = LayerChecker::Checker.new(
+            config_path: config_path,
+            project_root: Rails.root.to_s
+          )
+          
+          result = checker.check
+          checker.report(format: format.to_sym)
+          
+          if !result[:success] && checker.config.option('fail_on_violation', false)
+            abort "Layer violations found!"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/layer_checker/reporter.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module LayerChecker
+  class Reporter
+    COLORS = {
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      blue: "\e[34m",
+      reset: "\e[0m"
+    }.freeze
+
+    def self.report(result, format: :console)
+      case format
+      when :console
+        console_report(result)
+      when :json
+        json_report(result)
+      else
+        console_report(result)
+      end
+    end
+
+    def self.console_report(result)
+      puts "\n" + "=" * 80
+      puts colorize("Layer Checker Results", :blue)
+      puts "=" * 80 + "\n"
+
+      if result[:success]
+        puts colorize("✓ #{result[:message]}", :green)
+      else
+        puts colorize("✗ #{result[:message]}", :red)
+        puts
+
+        if result[:violations].any?
+          puts colorize("Violations found:", :yellow)
+          puts
+
+          # Group violations by source module
+          grouped = result[:violations].group_by { |v| v.to_h[:source_module] }
+          
+          grouped.each do |source_module, violations|
+            module_name = source_module || "Unassigned files"
+            puts colorize("  #{module_name}:", :yellow)
+            
+            violations.each do |violation|
+              puts "    #{format_violation(violation)}"
+            end
+            puts
+          end
+
+          # Summary
+          puts "=" * 80
+          puts colorize("Summary:", :blue)
+          puts "  Total violations: #{colorize(result[:violations].size.to_s, :red)}"
+          puts "  Modules affected: #{colorize(grouped.keys.size.to_s, :yellow)}"
+        end
+      end
+
+      puts "=" * 80 + "\n"
+    end
+
+    def self.json_report(result)
+      require 'json'
+      
+      output = {
+        success: result[:success],
+        message: result[:message],
+        violations: result[:violations].map(&:to_h),
+        summary: {
+          total_violations: result[:violations].size,
+          modules_affected: result[:violations].map { |v| v.to_h[:source_module] }.uniq.size
+        }
+      }
+
+      puts JSON.pretty_generate(output)
+    end
+
+    private
+
+    def self.format_violation(violation)
+      v = violation.to_h
+      location = v[:line_number] ? "#{v[:source_file]}:#{v[:line_number]}" : v[:source_file]
+      
+      "#{location}\n" \
+      "      → #{v[:source_module]} cannot depend on #{v[:target_module]}\n" \
+      "      → Referenced: #{colorize(v[:target_constant], :red)}"
+    end
+
+    def self.colorize(text, color)
+      return text unless $stdout.tty?
+      "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+    end
+  end
+end

data/lib/layer_checker/version.rb

@@ -0,0 +1,3 @@
+module LayerChecker
+  VERSION = "0.1.1"
+end

data/lib/layer_checker/violation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LayerChecker
+  class Violation
+    attr_reader :source_file, :source_module, :target_constant, 
+                :target_module, :line_number, :violation_type
+
+    def initialize(source_file:, source_module:, target_constant:, 
+                   target_module:, line_number: nil, violation_type: :dependency)
+      @source_file = source_file
+      @source_module = source_module
+      @target_constant = target_constant
+      @target_module = target_module
+      @line_number = line_number
+      @violation_type = violation_type
+    end
+
+    def to_s
+      location = @line_number ? "#{@source_file}:#{@line_number}" : @source_file
+      "#{location}: #{@source_module} cannot depend on #{@target_module} (#{@target_constant})"
+    end
+
+    def to_h
+      {
+        source_file: @source_file,
+        source_module: @source_module&.to_s,
+        target_constant: @target_constant,
+        target_module: @target_module&.to_s,
+        line_number: @line_number,
+        violation_type: @violation_type
+      }
+    end
+  end
+end

data/lib/layer_checker.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'layer_checker/version'
+require 'layer_checker/config'
+require 'layer_checker/module'
+require 'layer_checker/code_analyzer'
+require 'layer_checker/dependency_validator'
+require 'layer_checker/violation'
+require 'layer_checker/reporter'
+
+module LayerChecker
+  class Error < StandardError; end
+  class ConfigError < Error; end
+  class ValidationError < Error; end
+
+  class Checker
+    attr_reader :config, :analyzer, :validator, :violations
+
+    def initialize(config_path: 'project_layers.yml', project_root: Dir.pwd)
+      @config_path = config_path
+      @project_root = project_root
+      @config = nil
+      @analyzer = nil
+      @validator = nil
+      @violations = []
+    end
+
+    def check
+      load_configuration
+      analyze_code
+      validate_dependencies
+      
+      build_result
+    end
+
+    def report(format: :console)
+      result = build_result
+      Reporter.report(result, format: format)
+      result
+    end
+
+    private
+
+    def load_configuration
+      config_file = File.join(@project_root, @config_path)
+      @config = Config.new(config_file)
+    rescue => e
+      raise ConfigError, "Failed to load configuration: #{e.message}"
+    end
+
+    def analyze_code
+      @analyzer = CodeAnalyzer.new(@config, project_root: @project_root)
+      @analyzer.analyze
+    end
+
+    def validate_dependencies
+      @validator = DependencyValidator.new(@config, @analyzer)
+      @violations = @validator.validate
+    end
+
+    def build_result
+      if @violations.empty?
+        { success: true, message: "All layers are respected!", violations: [] }
+      else
+        { 
+          success: false, 
+          message: "Found #{@violations.size} violation(s)", 
+          violations: @violations 
+        }
+      end
+    end
+  end
+
+  # Convenience method for quick checks
+  def self.check(config_path: 'project_layers.yml', project_root: Dir.pwd)
+    checker = Checker.new(config_path: config_path, project_root: project_root)
+    checker.check
+  end
+end
+
+# Load Railtie if Rails is available
+require 'layer_checker/railtie' if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: layer_checker
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Víctor Manuel Chaves García
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A Ruby gem to validate architectural layer dependencies based on YAML
+  configuration
+email: victormcg96@gmail.com
+executables:
+- layer_checker
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/layer_checker
+- examples/conventional-layer.yml
+- examples/ddd-layer.yml
+- examples/featured-layer.yml
+- lib/layer_checker.rb
+- lib/layer_checker/code_analyzer.rb
+- lib/layer_checker/config.rb
+- lib/layer_checker/dependency_extractor.rb
+- lib/layer_checker/dependency_validator.rb
+- lib/layer_checker/module.rb
+- lib/layer_checker/parser.rb
+- lib/layer_checker/railtie.rb
+- lib/layer_checker/reporter.rb
+- lib/layer_checker/version.rb
+- lib/layer_checker/violation.rb
+homepage: https://rubygems.org/gems/layer-checker
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.19
+signing_key:
+specification_version: 4
+summary: Check project layer architecture compliance
+test_files: []