abstracta-contracts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec5dbea4ff031eb0fc61d786f5e5c443b0f9ecb6570e4f914531d4db4ae9e19d
+  data.tar.gz: 5c03262e0801b1be7cec8f63ef3d9a8338ef363888abbbc95d135d0ec5df4155
+SHA512:
+  metadata.gz: 78c6dd7e8fe309f40d7e58a6485b01c3852a921c95064a9bb452ae834f3d81365bfe92f8abc254a17eedcef62993be46417ca6db26cf5d2f7b18cf8ea23eb727
+  data.tar.gz: 0c2218ef59335cf982a665184427c103aba124d78a7ee8e14966ec50db413196273ac9c0712c42ad5db45636c3264c8d87b711545443084d3f47a81edff9083f

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to AbstractaContracts will be documented in this file.
+
+## [0.1.0] - Unreleased
+
+### Added
+
+- Declarative abstract classes with `AbstractaContracts.with_methods`.
+- Explicit abstract class, instance-method, and class-method contracts.
+- Reusable interfaces with `AbstractaContracts.interface` and `implements`.
+- Inherited and composable contracts across class and interface hierarchies.
+- Runtime instantiation validation and contract introspection.
+- Private implementation namespace under `AbstractaContracts::Internal`.
+- RSpec, RuboCop, branch-aware SimpleCov thresholds, CI matrix, Dependabot, and Trusted Publishing release verification.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juan Furattini
+
+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,203 @@
+# Abstracta Contracts
+
+## Public API
+
+AbstractaContracts exposes one supported entry point:
+
+```ruby
+require "abstracta_contracts"
+```
+
+The supported root API is intentionally small:
+
+- `AbstractaContracts.with_methods`
+- `AbstractaContracts.interface`
+- `AbstractaContracts::Error`
+- `AbstractaContracts::VERSION`
+- the class DSL installed by `include AbstractaContracts`: `abstract_class!`, `abstract_method`, `abstract_class_method`, and `implements`
+- the documented introspection methods installed by `include AbstractaContracts`
+
+Implementation modules, contract objects, guards, and specialized errors live behind `AbstractaContracts::Internal` and are not public API. No pre-release compatibility entry points are shipped.
+
+
+Declarative abstract classes and interfaces for Ruby.
+
+> **Gem:** `abstracta-contracts`  
+> **Namespace:** `AbstractaContracts`
+
+## Installation
+
+```ruby
+gem "abstracta-contracts", require: "abstracta_contracts"
+```
+
+```ruby
+require "abstracta_contracts"
+```
+
+## Abstract classes
+
+The compact API is the recommended form:
+
+```ruby
+class FeatureProvider
+  include AbstractaContracts.with_methods(:enabled?, :features)
+end
+```
+
+A class with an incomplete contract cannot be instantiated. A descendant becomes concrete when it implements every required method.
+
+```ruby
+class RedisProvider < FeatureProvider
+  def enabled?(feature)
+    features.include?(feature)
+  end
+
+  def features
+    [:search, :reports]
+  end
+end
+```
+
+Class-method contracts use `class_methods:`:
+
+```ruby
+class Provider
+  include AbstractaContracts.with_methods(:call, class_methods: [:provider_name])
+end
+```
+
+For dynamic or incremental declarations, use the explicit DSL:
+
+```ruby
+class Provider
+  include AbstractaContracts
+
+  abstract_class!
+  abstract_method :enabled?
+  abstract_method :features
+  abstract_class_method :provider_name
+end
+```
+
+`abstract_class!` marks only the declaring class as explicitly abstract. The marker is not inherited. Method requirements are inherited and can be extended or redeclared by descendants.
+
+## Reusable abstract contracts
+
+`with_methods` returns a reusable module-like contract:
+
+```ruby
+cache_contract = AbstractaContracts.with_methods(:read, :write, :delete)
+
+class RedisCache
+  include cache_contract
+
+  def read(key) = nil
+  def write(key, value) = value
+  def delete(key) = nil
+end
+```
+
+## Interfaces
+
+Interfaces are separate from abstract classes:
+
+```ruby
+module Cacheable
+  include AbstractaContracts.interface(
+    :read,
+    :write,
+    :delete,
+    class_methods: [:adapter_name]
+  )
+end
+```
+
+Classes opt into AbstractaContracts and explicitly declare interfaces:
+
+```ruby
+class RedisCache
+  include AbstractaContracts
+  implements Cacheable
+
+  def read(key) = nil
+  def write(key, value) = value
+  def delete(key) = nil
+  def self.adapter_name = :redis
+end
+```
+
+AbstractaContracts deliberately does not add `implements` to every Ruby class.
+
+### Interface inheritance and defaults
+
+An interface may include another AbstractaContracts interface. Interface modules may also provide default instance methods; those methods satisfy their requirements.
+
+```ruby
+module Readable
+  include AbstractaContracts.interface(:read)
+end
+
+module Cacheable
+  include Readable
+  include AbstractaContracts.interface(:write)
+
+  def read(key) = nil
+end
+```
+
+## Introspection
+
+Abstract classes expose:
+
+```ruby
+Provider.abstract?
+Provider.concrete?
+Provider.explicitly_abstract?
+Provider.abstract_methods
+Provider.abstract_class_methods
+Provider.missing_abstract_methods
+Provider.missing_abstract_class_methods
+Provider.valid_implementation?
+Provider.validate_implementation!
+```
+
+Classes implementing interfaces also expose:
+
+```ruby
+RedisCache.interfaces
+RedisCache.direct_interfaces
+RedisCache.implements?(Cacheable)
+RedisCache.interface_methods
+RedisCache.interface_class_methods
+RedisCache.missing_interface_methods
+RedisCache.missing_interface_class_methods
+```
+
+`missing_methods` and `missing_class_methods` return the combined unresolved abstract-class and interface requirements.
+
+## Contract rules
+
+- Abstract method contracts accumulate through inheritance.
+- Redeclaring a method as abstract requires a fresh implementation below that declaration.
+- Private and protected methods can satisfy contracts.
+- Modules included below an abstract declaration can satisfy instance-method contracts.
+- Interfaces remain distinct from abstract classes.
+- Interface requirements can be satisfied by the class, inherited implementations, or interface defaults.
+- AbstractaContracts has no runtime dependencies.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake
+bundle exec gem build abstracta-contracts.gemspec
+```
+
+## Release
+
+The repository includes CI and a RubyGems Trusted Publishing workflow. Repository synchronization, branches, commits, tags, and other version-control operations are intentionally outside the gem's responsibilities.
+
+## License
+
+MIT.

data/lib/abstracta_contracts/errors.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  # Public base exception for all AbstractaContracts errors.
+  class Error < StandardError; end
+
+  module Internal
+    class InvalidMethodNameError < Error; end
+    class InvalidInterfaceError < Error; end
+    class InterfaceAlreadyDefinedError < Error; end
+
+    class AbstractClassInstantiationError < Error
+      attr_reader :abstract_class
+
+      def initialize(abstract_class, message: nil)
+        @abstract_class = abstract_class
+        super(message || "#{AbstractaContracts.class_name(abstract_class)} is abstract and cannot be instantiated")
+      end
+    end
+
+    class UnimplementedMethodsError < AbstractClassInstantiationError
+      attr_reader :missing_instance_methods, :missing_class_methods
+
+      def initialize(abstract_class, instance_methods:, class_methods:)
+        @missing_instance_methods = instance_methods.freeze
+        @missing_class_methods = class_methods.freeze
+        super(abstract_class, message: unimplemented_message(abstract_class, instance_methods, class_methods))
+      end
+
+      private
+
+      def unimplemented_message(abstract_class, instance_methods, class_methods)
+        details = []
+        unless instance_methods.empty?
+          details << "instance methods: #{instance_methods.map { |name| "##{name}" }.join(', ')}"
+        end
+        details << "class methods: #{class_methods.map { |name| ".#{name}" }.join(', ')}" unless class_methods.empty?
+
+        "#{AbstractaContracts.class_name(abstract_class)} has unimplemented contract #{details.join('; ')}"
+      end
+    end
+  end
+end

data/lib/abstracta_contracts/internal/class_methods.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  module Internal
+    module ClassMethods
+      def abstract_class!
+        AbstractaContracts.synchronize(self) { @abstracta_contracts_explicitly_abstract = true }
+        self
+      end
+
+      def abstract_method(*names)
+        AbstractaContracts.register_instance_methods(self, AbstractaContracts.normalize_method_names(names))
+        self
+      end
+
+      def abstract_class_method(*names)
+        AbstractaContracts.register_class_methods(self, AbstractaContracts.normalize_method_names(names))
+        self
+      end
+
+      def implements(*interfaces)
+        normalized = AbstractaContracts.normalize_interfaces(interfaces)
+
+        AbstractaContracts.synchronize(self) do
+          direct = abstracta_contracts_direct_interfaces
+          normalized.each { |interface| direct << interface unless direct.include?(interface) }
+        end
+
+        normalized.each { |interface| include(interface) unless self < interface }
+        self
+      end
+
+      def explicitly_abstract?
+        @abstracta_contracts_explicitly_abstract == true
+      end
+
+      def abstract?
+        explicitly_abstract? || !missing_methods.empty? || !missing_class_methods.empty?
+      end
+
+      def concrete?
+        !abstract?
+      end
+
+      def abstract_methods
+        AbstractaContracts.required_instance_methods_for(self).keys.freeze
+      end
+
+      def abstract_class_methods
+        AbstractaContracts.required_class_methods_for(self).keys.freeze
+      end
+
+      def missing_abstract_methods
+        AbstractaContracts.missing_instance_methods_for(self).freeze
+      end
+
+      def missing_abstract_class_methods
+        AbstractaContracts.missing_class_methods_for(self).freeze
+      end
+
+      def direct_interfaces
+        abstracta_contracts_direct_interfaces.dup.freeze
+      end
+
+      def interfaces
+        AbstractaContracts.interfaces_for(self).freeze
+      end
+
+      def implements?(interface)
+        AbstractaContracts.validate_interface!(interface)
+        interfaces.include?(interface)
+      end
+
+      def interface_methods
+        AbstractaContracts.required_interface_instance_methods_for(self).freeze
+      end
+
+      def interface_class_methods
+        AbstractaContracts.required_interface_class_methods_for(self).freeze
+      end
+
+      def missing_interface_methods
+        AbstractaContracts.missing_interface_instance_methods_for(self).freeze
+      end
+
+      def missing_interface_class_methods
+        AbstractaContracts.missing_interface_class_methods_for(self).freeze
+      end
+
+      def missing_methods
+        (missing_abstract_methods + missing_interface_methods).uniq.freeze
+      end
+
+      def missing_class_methods
+        (missing_abstract_class_methods + missing_interface_class_methods).uniq.freeze
+      end
+
+      def valid_implementation?
+        concrete?
+      end
+
+      def validate_implementation!
+        return true if concrete?
+
+        missing = { instance_methods: missing_methods, class_methods: missing_class_methods }
+        raise Internal::UnimplementedMethodsError.new(self, **missing) unless missing.values.all?(&:empty?)
+
+        raise Internal::AbstractClassInstantiationError, self
+      end
+
+      private
+
+      def abstracta_contracts_declared_instance_methods
+        @abstracta_contracts_declared_instance_methods ||= []
+      end
+
+      def abstracta_contracts_declared_class_methods
+        @abstracta_contracts_declared_class_methods ||= []
+      end
+
+      def abstracta_contracts_direct_interfaces
+        @abstracta_contracts_direct_interfaces ||= []
+      end
+    end
+  end
+end

data/lib/abstracta_contracts/internal/constructor_guard.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  module Internal
+    module ConstructorGuard
+      def new(...)
+        validate_implementation! if respond_to?(:validate_implementation!)
+        super
+      end
+    end
+  end
+end

data/lib/abstracta_contracts/internal/contract.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  module Internal
+    class Contract < Module
+      attr_reader :instance_methods, :class_methods
+
+      def initialize(instance_methods:, class_methods:)
+        super()
+        @instance_methods = instance_methods.freeze
+        @class_methods = class_methods.freeze
+      end
+
+      def included(base)
+        AbstractaContracts.install(base)
+        base.abstract_method(*instance_methods) unless instance_methods.empty?
+        base.abstract_class_method(*class_methods) unless class_methods.empty?
+      end
+    end
+  end
+end

data/lib/abstracta_contracts/internal/interface.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  module Internal
+    module InterfaceDefinition
+      def interface?
+        true
+      end
+
+      def interface_methods
+        AbstractaContracts.interface_instance_methods_for(self)
+      end
+
+      def interface_class_methods
+        AbstractaContracts.interface_class_methods_for(self)
+      end
+    end
+
+    class Interface < Module
+      attr_reader :instance_methods, :class_methods
+
+      def initialize(instance_methods:, class_methods:)
+        super()
+        @instance_methods = instance_methods.freeze
+        @class_methods = class_methods.freeze
+      end
+
+      def included(base)
+        unless base.is_a?(Module) && !base.is_a?(Class)
+          raise TypeError, "AbstractaContracts.interface must be included in a module"
+        end
+
+        AbstractaContracts.define_interface(
+          base,
+          instance_methods: instance_methods,
+          class_methods: class_methods
+        )
+      end
+    end
+  end
+end

data/lib/abstracta_contracts/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AbstractaContracts
+  VERSION = "0.1.0"
+end

data/lib/abstracta_contracts.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "abstracta_contracts/version"
+require_relative "abstracta_contracts/errors"
+require_relative "abstracta_contracts/internal/class_methods"
+require_relative "abstracta_contracts/internal/constructor_guard"
+require_relative "abstracta_contracts/internal/contract"
+require_relative "abstracta_contracts/internal/interface"
+
+module AbstractaContracts
+  MUTEX_CREATION_LOCK = Mutex.new
+  private_constant :MUTEX_CREATION_LOCK
+
+  class << self
+    def included(base)
+      install(base)
+    end
+
+    def with_methods(*methods, class_methods: [])
+      instance_methods = normalize_method_names(methods)
+      singleton_methods = normalize_method_names(Array(class_methods))
+
+      if instance_methods.empty? && singleton_methods.empty?
+        raise ArgumentError, "at least one abstract instance or class method is required"
+      end
+
+      Internal::Contract.new(instance_methods: instance_methods, class_methods: singleton_methods)
+    end
+
+    def interface(*methods, class_methods: [])
+      instance_methods = normalize_method_names(methods)
+      singleton_methods = normalize_method_names(Array(class_methods))
+
+      if instance_methods.empty? && singleton_methods.empty?
+        raise ArgumentError, "at least one interface instance or class method is required"
+      end
+
+      Internal::Interface.new(instance_methods: instance_methods, class_methods: singleton_methods)
+    end
+
+    def install(base)
+      raise TypeError, "AbstractaContracts can only be included in classes" unless base.is_a?(Class)
+
+      base.extend(Internal::ClassMethods) unless base.singleton_class < Internal::ClassMethods
+      base.singleton_class.prepend(Internal::ConstructorGuard) unless base.singleton_class < Internal::ConstructorGuard
+      mutex_for(base)
+      base
+    end
+
+    def define_interface(base, instance_methods:, class_methods:)
+      if base.instance_variable_defined?(:@abstracta_contracts_interface_defined)
+        raise Internal::InterfaceAlreadyDefinedError,
+              "#{interface_name(base)} is already an AbstractaContracts interface"
+      end
+
+      base.instance_variable_set(:@abstracta_contracts_interface_defined, true)
+      base.instance_variable_set(:@abstracta_contracts_interface_instance_methods, instance_methods.freeze)
+      base.instance_variable_set(:@abstracta_contracts_interface_class_methods, class_methods.freeze)
+      base.extend(Internal::InterfaceDefinition) unless base.singleton_class < Internal::InterfaceDefinition
+      base
+    end
+
+    def interface?(object)
+      object.is_a?(Module) && object.respond_to?(:interface?) && object.interface?
+    end
+
+    def validate_interface!(interface)
+      return interface if interface?(interface)
+
+      raise Internal::InvalidInterfaceError, "#{interface.inspect} is not an AbstractaContracts interface"
+    end
+
+    def normalize_interfaces(interfaces)
+      interfaces.flatten.map { |interface| validate_interface!(interface) }.uniq.freeze
+    end
+
+    def normalize_method_names(names)
+      names.flatten.map do |name|
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          raise Internal::InvalidMethodNameError, "abstract method names must be Strings or Symbols, got #{name.class}"
+        end
+
+        normalized = name.to_s
+        if normalized.empty? || normalized.match?(/\s/)
+          raise Internal::InvalidMethodNameError, "invalid abstract method name: #{name.inspect}"
+        end
+
+        normalized.to_sym
+      end.uniq.freeze
+    end
+
+    def register_instance_methods(base, names)
+      install(base)
+      synchronize(base) do
+        declared = base.send(:abstracta_contracts_declared_instance_methods)
+        names.each { |name| declared << name unless declared.include?(name) }
+      end
+    end
+
+    def register_class_methods(base, names)
+      install(base)
+      synchronize(base) do
+        declared = base.send(:abstracta_contracts_declared_class_methods)
+        names.each { |name| declared << name unless declared.include?(name) }
+      end
+    end
+
+    def required_instance_methods_for(klass)
+      required_methods_for(klass, :abstracta_contracts_declared_instance_methods)
+    end
+
+    def required_class_methods_for(klass)
+      required_methods_for(klass, :abstracta_contracts_declared_class_methods)
+    end
+
+    def missing_instance_methods_for(klass)
+      required_instance_methods_for(klass).filter_map do |name, declaration_owner|
+        name unless implemented_after_declaration?(klass, name, declaration_owner, singleton: false)
+      end
+    end
+
+    def missing_class_methods_for(klass)
+      required_class_methods_for(klass).filter_map do |name, declaration_owner|
+        name unless implemented_after_declaration?(klass, name, declaration_owner, singleton: true)
+      end
+    end
+
+    def interfaces_for(klass)
+      result = []
+
+      klass.ancestors.reverse_each do |ancestor|
+        next unless ancestor.is_a?(Class)
+        next unless ancestor.respond_to?(:abstracta_contracts_direct_interfaces, true)
+
+        ancestor.send(:abstracta_contracts_direct_interfaces).each do |interface|
+          interface_hierarchy(interface).each { |candidate| result << candidate unless result.include?(candidate) }
+        end
+      end
+
+      result
+    end
+
+    def interface_instance_methods_for(interface)
+      validate_interface!(interface)
+      interface_hierarchy(interface).flat_map do |candidate|
+        candidate.instance_variable_get(:@abstracta_contracts_interface_instance_methods) || []
+      end.uniq.freeze
+    end
+
+    def interface_class_methods_for(interface)
+      validate_interface!(interface)
+      interface_hierarchy(interface).flat_map do |candidate|
+        candidate.instance_variable_get(:@abstracta_contracts_interface_class_methods) || []
+      end.uniq.freeze
+    end
+
+    def required_interface_instance_methods_for(klass)
+      interfaces_for(klass).flat_map { |interface| interface_instance_methods_for(interface) }.uniq
+    end
+
+    def required_interface_class_methods_for(klass)
+      interfaces_for(klass).flat_map { |interface| interface_class_methods_for(interface) }.uniq
+    end
+
+    def missing_interface_instance_methods_for(klass)
+      required_interface_instance_methods_for(klass).reject do |name|
+        method_available?(klass, name, singleton: false)
+      end
+    end
+
+    def missing_interface_class_methods_for(klass)
+      required_interface_class_methods_for(klass).reject do |name|
+        method_available?(klass, name, singleton: true)
+      end
+    end
+
+    def synchronize(base, &)
+      mutex_for(base).synchronize(&)
+    end
+
+    def class_name(klass)
+      klass.name || klass.inspect
+    end
+
+    def interface_name(interface)
+      interface.name || interface.inspect
+    end
+
+    private
+
+    def mutex_for(base)
+      if base.instance_variable_defined?(:@abstracta_contracts_mutex)
+        return base.instance_variable_get(:@abstracta_contracts_mutex)
+      end
+
+      MUTEX_CREATION_LOCK.synchronize do
+        base.instance_variable_get(:@abstracta_contracts_mutex) ||
+          base.instance_variable_set(:@abstracta_contracts_mutex, Mutex.new)
+      end
+    end
+
+    def required_methods_for(klass, reader)
+      declarations = {}
+
+      klass.ancestors.reverse_each do |ancestor|
+        next unless ancestor.is_a?(Class)
+        next unless ancestor.respond_to?(reader, true)
+
+        ancestor.send(reader).each { |name| declarations[name] = ancestor }
+      end
+
+      declarations.freeze
+    end
+
+    def implemented_after_declaration?(klass, name, declaration_owner, singleton:)
+      lookup_class = singleton ? klass.singleton_class : klass
+      declaration_lookup_owner = singleton ? declaration_owner.singleton_class : declaration_owner
+
+      implementation_owner = lookup_class.instance_method(name).owner
+      return true if implementation_owner == declaration_lookup_owner
+
+      ancestors = lookup_class.ancestors
+      implementation_index = ancestors.index(implementation_owner)
+      declaration_index = ancestors.index(declaration_lookup_owner)
+
+      implementation_index && declaration_index && implementation_index < declaration_index
+    rescue NameError
+      false
+    end
+
+    def method_available?(klass, name, singleton:)
+      lookup = singleton ? klass.singleton_class : klass
+      lookup.instance_method(name)
+      true
+    rescue NameError
+      false
+    end
+
+    def interface_hierarchy(interface)
+      validate_interface!(interface)
+
+      interface.ancestors.reverse_each.with_object([]) do |ancestor, result|
+        next unless interface?(ancestor)
+
+        result << ancestor unless result.include?(ancestor)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: abstracta-contracts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Furattini
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  AbstractaContracts provides lightweight, dependency-free abstract class contracts for Ruby,
+  including declarative instance/class methods, reusable interfaces, inherited contracts,
+  runtime validation, and introspection.
+email: []
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/abstracta_contracts.rb
+- lib/abstracta_contracts/errors.rb
+- lib/abstracta_contracts/internal/class_methods.rb
+- lib/abstracta_contracts/internal/constructor_guard.rb
+- lib/abstracta_contracts/internal/contract.rb
+- lib/abstracta_contracts/internal/interface.rb
+- lib/abstracta_contracts/version.rb
+homepage: https://github.com/Rubcraft/abstracta-contracts
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Rubcraft/abstracta-contracts
+  source_code_uri: https://github.com/Rubcraft/abstracta-contracts
+  changelog_uri: https://github.com/Rubcraft/abstracta-contracts/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Declarative abstract classes, interfaces, and method contracts for Ruby.
+test_files: []