strict 1.4.0 → 2.0.0

data/benchmark/baseline.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "strict"
+
+module StrictBenchmark
+  BenchmarkCase = Data.define(:name, :operation)
+
+  ITERATIONS = Integer(ENV.fetch("ITERATIONS", "100000"), 10)
+  WARMUP_ITERATIONS = Integer(ENV.fetch("WARMUP_ITERATIONS", "20000"), 10)
+  SAMPLES = Integer(ENV.fetch("SAMPLES", "5"), 10)
+  FORMAT = ENV.fetch("FORMAT", "text")
+  FORMATS = %w[markdown text].freeze
+
+  class Value
+    include Strict::Value
+
+    attributes do
+      id Integer
+      name String
+      active Boolean()
+    end
+  end
+
+  class Mutable
+    include Strict::Object
+
+    attributes do
+      value Integer
+    end
+  end
+
+  class VerifiedMethod
+    include Strict::Method
+
+    sig do
+      value Integer
+      returns Integer
+    end
+    def call(value:) = value
+  end
+
+  class Interface
+    include Strict::Interface
+
+    expose(:call) do
+      value Integer
+      returns Integer
+    end
+  end
+
+  class Implementation
+    def call(value:) = value
+  end
+
+  class Formatter
+    def initialize(output_format)
+      @output_format = output_format
+    end
+
+    def print_header
+      puts markdown? ? markdown_header : text_header
+    end
+
+    def print_result(name:, nanoseconds:, allocations:)
+      result = if markdown?
+                 markdown_result(name:, nanoseconds:, allocations:)
+               else
+                 text_result(name:, nanoseconds:, allocations:)
+               end
+      puts result
+    end
+
+    private
+
+    attr_reader :output_format
+
+    def markdown? = output_format == "markdown"
+
+    def markdown_header
+      <<~MARKDOWN.chomp
+        ### Strict benchmark
+
+        `Ruby #{RUBY_VERSION} (#{RUBY_ENGINE})`
+
+        Iterations: #{ITERATIONS}; warmup: #{WARMUP_ITERATIONS}; samples: #{SAMPLES}
+
+        | Operation | Median ns/op | Allocations/op |
+        | --- | ---: | ---: |
+      MARKDOWN
+    end
+
+    def text_header
+      <<~TEXT.chomp
+        Ruby #{RUBY_VERSION} (#{RUBY_ENGINE})
+        Iterations: #{ITERATIONS}; warmup: #{WARMUP_ITERATIONS}; samples: #{SAMPLES}
+        Operation                      median ns/op     allocations/op
+      TEXT
+    end
+
+    def markdown_result(name:, nanoseconds:, allocations:)
+      format("| %<name>s | %<nanoseconds>.1f | %<allocations>.3f |", name:, nanoseconds:, allocations:)
+    end
+
+    def text_result(name:, nanoseconds:, allocations:)
+      format("%<name>-24s %<nanoseconds>18.1f %<allocations>18.3f", name:, nanoseconds:, allocations:)
+    end
+  end
+
+  class << self
+    def run
+      validate_settings!
+      benchmark_cases = build_cases
+      warm_up(benchmark_cases)
+      formatter = Formatter.new(FORMAT)
+
+      formatter.print_header
+      benchmark_cases.each { |benchmark_case| print_result(formatter, benchmark_case) }
+    end
+
+    private
+
+    def print_result(formatter, benchmark_case)
+      nanoseconds = median(measure_times(benchmark_case.operation)) * 1_000_000_000 / ITERATIONS
+      allocations = measure_allocations(benchmark_case.operation).fdiv(ITERATIONS)
+      formatter.print_result(name: benchmark_case.name, nanoseconds:, allocations:)
+    end
+
+    def validate_settings!
+      {
+        "ITERATIONS" => ITERATIONS,
+        "WARMUP_ITERATIONS" => WARMUP_ITERATIONS,
+        "SAMPLES" => SAMPLES
+      }.each do |name, value|
+        raise ArgumentError, "#{name} must be greater than zero, got #{value}" unless value.positive?
+      end
+      return if FORMATS.include?(FORMAT)
+
+      raise ArgumentError, "FORMAT must be one of #{FORMATS.join(', ')}, got #{FORMAT.inspect}"
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def build_cases
+      value = Value.new(id: 1, name: "Strict", active: true)
+      equal_value = Value.new(id: 1, name: "Strict", active: true)
+      mutable = Mutable.new(value: 1)
+      verified_method = VerifiedMethod.new
+      implementation = Implementation.new
+      interface = Interface.new(implementation)
+
+      [
+        BenchmarkCase.new("value initialization", -> { Value.new(id: 1, name: "Strict", active: true) }),
+        BenchmarkCase.new("mutable assignment", -> { mutable.value = 1 }),
+        BenchmarkCase.new("verified method call", -> { verified_method.call(value: 1) }),
+        BenchmarkCase.new("interface construction", -> { Interface.new(implementation) }),
+        BenchmarkCase.new("interface call", -> { interface.call(value: 1) }),
+        BenchmarkCase.new("to_h", -> { value.to_h }),
+        BenchmarkCase.new("equality", -> { value == equal_value }),
+        BenchmarkCase.new("hashing", -> { value.hash })
+      ]
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def warm_up(benchmark_cases)
+      benchmark_cases.each do |benchmark_case|
+        repeat(WARMUP_ITERATIONS, benchmark_case.operation)
+      end
+    end
+
+    def measure_times(operation)
+      Array.new(SAMPLES) do
+        GC.start
+        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        repeat(ITERATIONS, operation)
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+      end
+    end
+
+    def measure_allocations(operation)
+      GC.start
+      gc_was_disabled = GC.disable
+      before = GC.stat(:total_allocated_objects)
+      repeat(ITERATIONS, operation)
+      GC.stat(:total_allocated_objects) - before
+    ensure
+      GC.enable unless gc_was_disabled
+    end
+
+    def repeat(iterations, operation)
+      result = nil
+      iterations.times { result = operation.call }
+      result
+    end
+
+    def median(values)
+      sorted = values.sort
+      middle = sorted.length / 2
+      return sorted.fetch(middle) if sorted.length.odd?
+
+      (sorted.fetch(middle - 1) + sorted.fetch(middle)) / 2
+    end
+  end
+end
+
+StrictBenchmark.run

data/lib/strict/assignment_error.rb

@@ -4,8 +4,11 @@ module Strict
   class AssignmentError < Error
     attr_reader :invalid_attribute, :value
 
-    def initialize(assignable_class:, invalid_attribute:, value:)
-      super(message_from(assignable_class: assignable_class, invalid_attribute: invalid_attribute, value: value))
+    def initialize(assignable_class:, invalid_attribute:, value:, violations: Validation::NONE)
+      super(
+        message_from(assignable_class: assignable_class, invalid_attribute: invalid_attribute, value: value),
+        violations: violations
+      )
 
       @invalid_attribute = invalid_attribute
       @value = value

data/lib/strict/attribute.rb

@@ -1,63 +1,24 @@
 # frozen_string_literal: true
 
 module Strict
-  class Attribute
-    NOT_PROVIDED = ::Object.new.freeze
-
+  class Attribute < Declaration
     class << self
-      def make(name, validator = Validators::Anything.instance, coerce: false, **defaults)
-        unless valid_defaults?(**defaults)
-          raise ArgumentError, "Only one of 'default', 'default_value', or 'default_generator' can be provided"
-        end
-
-        new(
-          name: name.to_sym,
-          validator: validator,
-          default_generator: make_default_generator(**defaults),
-          coercer: coerce
-        )
+      def instance_variable_for(name)
+        "@#{name.to_s.delete_suffix('?').delete_suffix('!')}"
       end
 
       private
 
-      def valid_defaults?(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
-        defaults_provided = [default, default_value, default_generator].count do |default_option|
-          !default_option.equal?(NOT_PROVIDED)
-        end
-
-        defaults_provided <= 1
-      end
-
-      def make_default_generator(default: NOT_PROVIDED, default_value: NOT_PROVIDED, default_generator: NOT_PROVIDED)
-        if !default.equal?(NOT_PROVIDED)
-          default.respond_to?(:call) ? default : -> { default }
-        elsif !default_value.equal?(NOT_PROVIDED)
-          -> { default_value }
-        elsif !default_generator.equal?(NOT_PROVIDED)
-          default_generator
-        else
-          NOT_PROVIDED
-        end
+      def coercer_supported?(coercer)
+        super || coercer.equal?(true) || coercer.is_a?(Symbol) || coercer.respond_to?(:call)
       end
     end
 
-    attr_reader :name, :validator, :default_generator, :coercer, :instance_variable
+    attr_reader :instance_variable
 
     def initialize(name:, validator:, default_generator:, coercer:)
-      @name = name.to_sym
-      @validator = validator
-      @default_generator = default_generator
-      @coercer = coercer
-      @optional = !default_generator.equal?(NOT_PROVIDED)
-      @instance_variable = "@#{name.to_s.chomp('!').chomp('?')}"
-    end
-
-    def optional?
-      @optional
-    end
-
-    def valid?(value)
-      validator === value
+      super
+      @instance_variable = self.class.instance_variable_for(self.name)
     end
 
     def coerce(value, for_class:)

data/lib/strict/attributes/class.rb

@@ -3,12 +3,6 @@
 module Strict
   module Attributes
     module Class
-      CONSTANT = :STRICT_INTERNAL_ATTRIBUTES_CONFIGURATION__
-
-      def strict_attributes
-        self::STRICT_INTERNAL_ATTRIBUTES_CONFIGURATION__
-      end
-
       def coercer
         Coercer.new(self)
       end

data/lib/strict/attributes/coercer.rb

@@ -3,6 +3,8 @@
 module Strict
   module Attributes
     class Coercer
+      NOT_PROVIDED = ::Object.new.freeze
+
       attr_reader :attributes_class
 
       def initialize(attributes_class)
@@ -10,15 +12,14 @@ module Strict
       end
 
       def call(value)
-        return value if value.nil? || !value.respond_to?(:to_h)
+        return value if value.nil? || value.instance_of?(attributes_class)
+        return value unless value.respond_to?(:to_h)
 
         coerce(value.to_h)
       end
 
       private
 
-      NOT_PROVIDED = ::Object.new.freeze
-
       def coerce(hash)
         attributes_class.new(
           **attributes_class.strict_attributes.each_with_object({}) do |attribute, attributes|

data/lib/strict/attributes/configuration.rb

@@ -30,6 +30,7 @@ module Strict
       attr_reader :attributes
 
       def initialize(attributes:)
+        validate_instance_variables!(attributes)
         @attributes = attributes
         @attributes_index = attributes.to_h { |a| [a.name, a] }
       end
@@ -41,6 +42,20 @@ module Strict
       private
 
       attr_reader :attributes_index
+
+      def validate_instance_variables!(attributes)
+        attributes_by_instance_variable = {}
+        attributes.each do |attribute|
+          conflicting_attribute = attributes_by_instance_variable[attribute.instance_variable]
+          if conflicting_attribute
+            raise ArgumentError,
+                  "Attribute #{attribute.name.inspect} conflicts with #{conflicting_attribute.name.inspect} " \
+                  "because both use #{attribute.instance_variable}"
+          end
+
+          attributes_by_instance_variable[attribute.instance_variable] = attribute
+        end
+      end
     end
   end
 end

data/lib/strict/attributes/dsl.rb

@@ -4,9 +4,9 @@ module Strict
   module Attributes
     class Dsl < BasicObject
       class << self
-        def run(&block)
-          dsl = new
-          dsl.instance_eval(&block)
+        def run(attributes: [], &)
+          dsl = new(attributes: attributes)
+          dsl.instance_eval(&)
           ::Strict::Attributes::Configuration.new(attributes: dsl.__strict_dsl_internal_attributes.values)
         end
       end
@@ -16,19 +16,27 @@ module Strict
 
       attr_reader :__strict_dsl_internal_attributes
 
-      def initialize
-        @__strict_dsl_internal_attributes = {}
+      def initialize(attributes:)
+        @__strict_dsl_internal_attributes = attributes.to_h { |attribute| [attribute.name, attribute] }
+        @__strict_dsl_internal_inherited_attributes = @__strict_dsl_internal_attributes.dup
       end
 
-      def strict_attribute(*args, **kwargs)
-        attribute = ::Strict::Attribute.make(*args, **kwargs)
-        __strict_dsl_internal_attributes[attribute.name] = attribute
+      def strict_attribute(*, **)
+        attribute = ::Strict::Attribute.make(*, **)
+        name = attribute.name
+        existing_attribute = __strict_dsl_internal_attributes[name]
+        inherited_attribute = @__strict_dsl_internal_inherited_attributes[name]
+        if existing_attribute && !existing_attribute.equal?(inherited_attribute)
+          ::Kernel.raise ::ArgumentError, "Attribute #{attribute.name.inspect} is already declared"
+        end
+
+        __strict_dsl_internal_attributes[name] = attribute
         nil
       end
 
-      def method_missing(name, *args, **kwargs)
+      def method_missing(name, *, **)
         if respond_to_missing?(name)
-          strict_attribute(name, *args, **kwargs)
+          strict_attribute(name, *, **)
         else
           super
         end

data/lib/strict/attributes/generated_methods.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Strict
+  module Attributes
+    class GeneratedMethods < ::Module
+      DECLARATION_MARKER = :@__strict_attributes_declared
+      RESERVED_METHODS = %i[class eql? hash instance_variable_set public_send raise].freeze
+      private_constant :DECLARATION_MARKER, :RESERVED_METHODS
+
+      class << self
+        def install_on(target, writable:)
+          installation = ->(receiver, &definition) { install_attributes_on(receiver, writable, &definition) }
+          target.define_singleton_method(:attributes) do |&definition|
+            installation.call(self, &definition)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def install_attributes_on(target, writable, &definition)
+          if target.instance_variable_defined?(DECLARATION_MARKER)
+            raise ArgumentError, "Attributes are already declared for #{target}"
+          end
+
+          definition ||= -> {}
+          inherited_attributes = target.respond_to?(:strict_attributes) ? target.strict_attributes.to_a : []
+          configuration = Strict::Attributes::Dsl.run(attributes: inherited_attributes, &definition)
+          declared_attributes = configuration.to_a - inherited_attributes
+          generated_methods = new(
+            configuration,
+            writable: writable,
+            target: target,
+            declared_attributes: declared_attributes
+          )
+          target.instance_variable_set(DECLARATION_MARKER, true)
+          target.include(Strict::Attributes::Instance, generated_methods)
+          target.define_singleton_method(:strict_attributes) { configuration }
+          target.extend(Strict::Attributes::Class)
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      def initialize(configuration, writable:, target:, declared_attributes:)
+        super()
+
+        validate_collisions!(target, declared_attributes, writable: writable)
+        configuration.each do |attribute|
+          define_reader(attribute)
+          define_writer(attribute) if writable
+        end
+      end
+
+      private
+
+      def validate_collisions!(target, attributes, writable:)
+        attributes.each do |attribute|
+          validate_method_available!(target, attribute.name, writable: writable)
+          validate_method_available!(target, :"#{attribute.name}=", writable: writable) if writable
+        end
+      end
+
+      def validate_method_available!(target, name, writable:)
+        return unless method_reserved?(target, name, writable: writable)
+
+        raise ArgumentError, "Generated attribute method #{name.inspect} already exists for #{target}"
+      end
+
+      def method_reserved?(target, name, writable:)
+        method_defined_directly?(target, name) ||
+          method_defined_directly?(Strict::Attributes::Instance, name) ||
+          (!writable && method_defined_directly?(Strict::Value, name)) ||
+          method_defined_directly?(BasicObject, name) ||
+          RESERVED_METHODS.include?(name)
+      end
+
+      def method_defined_directly?(owner, name)
+        owner.public_method_defined?(name, false) ||
+          owner.protected_method_defined?(name, false) ||
+          owner.private_method_defined?(name, false)
+      end
+
+      def define_reader(attribute)
+        storage_name = attribute.instance_variable.to_s.delete_prefix("@").to_sym
+        reader_module = ::Module.new { attr_reader(storage_name) }
+        define_method(attribute.name, reader_module.instance_method(storage_name))
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def define_writer(attribute)
+        instance_variable = attribute.instance_variable
+        define_method(:"#{attribute.name}=") do |value|
+          assignable_class = self.class
+          value = attribute.coerce(value, for_class: assignable_class)
+          configuration = Strict.configuration
+          violations = attribute.violations(value, configuration)
+
+          if violations.empty?
+            instance_variable_set(instance_variable, value)
+          else
+            raise Strict::AssignmentError.new(
+              assignable_class: assignable_class,
+              invalid_attribute: attribute,
+              value: value,
+              violations: Strict::Validation.prepend_path(violations, attribute.name)
+            )
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/strict/attributes/instance.rb

@@ -3,52 +3,69 @@
 module Strict
   module Attributes
     module Instance
+      def self.attribute_values(instance)
+        instance.class.strict_attributes.to_h do |attribute|
+          [attribute.name, instance.public_send(attribute.name)]
+        end
+      end
+
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def initialize(**attributes)
-        remaining_attributes = Set.new(attributes.keys)
+        initializable_class = self.class
+        configuration = Strict.configuration
         invalid_attributes = nil
         missing_attributes = nil
+        violations = nil
 
-        self.class.strict_attributes.each do |attribute|
-          if remaining_attributes.delete?(attribute.name)
-            value = attributes.fetch(attribute.name)
+        initializable_class.strict_attributes.each do |attribute|
+          if attributes.key?(attribute.name)
+            value = attributes.delete(attribute.name)
           elsif attribute.optional?
             value = attribute.default_generator.call
           else
             missing_attributes ||= []
             missing_attributes << attribute.name
+            violations ||= []
+            violations << Validation.missing(attribute.validator, path: [attribute.name])
             next
           end
 
-          value = attribute.coerce(value, for_class: self.class)
-          if attribute.valid?(value)
+          value = attribute.coerce(value, for_class: initializable_class)
+          attribute_violations = attribute.violations(value, configuration)
+          if attribute_violations.empty?
             instance_variable_set(attribute.instance_variable, value)
           else
             invalid_attributes ||= {}
             invalid_attributes[attribute] = value
+            violations ||= []
+            violations.concat(Validation.prepend_path(attribute_violations, attribute.name))
           end
         end
 
-        return if remaining_attributes.none? && invalid_attributes.nil? && missing_attributes.nil?
+        return if attributes.empty? && invalid_attributes.nil? && missing_attributes.nil?
 
+        violations ||= []
+        attributes.each do |name, value|
+          violations << Validation.unexpected(value, path: [name])
+        end
         raise InitializationError.new(
-          initializable_class: self.class,
-          remaining_attributes: remaining_attributes,
+          initializable_class: initializable_class,
+          remaining_attributes: Set.new(attributes.keys),
           invalid_attributes: invalid_attributes,
-          missing_attributes: missing_attributes
+          missing_attributes: missing_attributes,
+          violations: violations
         )
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       def to_h
-        self.class.strict_attributes.to_h do |attribute|
-          [attribute.name, public_send(attribute.name)]
-        end
+        Instance.attribute_values(self)
       end
 
       def inspect
         if self.class.strict_attributes.any?
-          "#<#{self.class} #{to_h.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')}>"
+          attributes = Instance.attribute_values(self)
+          "#<#{self.class} #{attributes.map { |key, value| "#{key}=#{value.inspect}" }.join(' ')}>"
         else
           "#<#{self.class}>"
         end
@@ -56,7 +73,7 @@ module Strict
 
       def pretty_print(pp)
         pp.object_group(self) do
-          to_h.each do |key, value|
+          Instance.attribute_values(self).each do |key, value|
             pp.breakable
             pp.text("#{key}=")
             pp.pp(value)

data/lib/strict/configuration.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Strict
+  class Configuration
+    attr_reader :random, :sample_rate
+
+    def initialize(random: nil, sample_rate: nil)
+      self.random = random || Random.new
+      self.sample_rate = sample_rate || 1
+    end
+
+    def random=(random)
+      case random
+      when Random::Formatter
+        @random = random
+      else
+        raise Strict::Error, "Expected a Random::Formatter, got: #{random.inspect}."
+      end
+    end
+
+    def sample_rate=(rate)
+      case rate
+      when 0..1
+        @sample_rate = rate
+      else
+        raise Strict::Error, "Expected a sample rate between 0 and 1 (inclusive), got: #{rate.inspect}. " \
+                             "A rate of 0 will disable strict validation. " \
+                             "A rate of 1 will validate 100% of the time. " \
+                             "A rate of 0.25 will validate roughly 25% of the time."
+      end
+    end
+
+    def validate?
+      sample_rate >= 1 || (sample_rate > 0 && random.rand < sample_rate) # rubocop:disable Style/NumericPredicate
+    end
+
+    def to_h
+      {
+        random: random,
+        sample_rate: sample_rate
+      }
+    end
+  end
+end