calificador 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f7600ea7641198f91585844a8701550ba999fb7b2e91c49a4d0c4e1728429d7
+  data.tar.gz: 9b81427ec6996cb065868cac1d0406f0af6262163c442f33b193709d838498a9
+SHA512:
+  metadata.gz: 27229e0b80d7da65f9c9c039070b2aa42981a9d64408e2c687ec7ee1af24a82ec70eb678d03ff8e3c1d57272cc8ce45734236991b4b325ea824a2597afb356b2
+  data.tar.gz: 2d0ef75a9ed7549a0deaeb5d5b62c8d277db62b8dc2c3a7ac3f1f5c8e33e9b325f3a56a7c426eff5a469dd491cdf2839c5007170f92321f3d26e94ff2484507b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jochen Seeber
+
+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,97 @@
+## What is it?
+
+A small Gem that lets you write concise and readable unit tests. It is heavily inspired by [Minitest], [Factory Bot], and [Assertive Expressive] but tries to boil everything down to be as concise as possible:
+
+```ruby
+    module ReadMe
+      require "calificador"
+
+      # Define a test class
+      class HighTea
+        attr_accessor :scones, :posh
+
+        def eat_scone
+          raise "Out of scones" if scones == 0
+
+          @scones -= 1
+        end
+
+        def tea
+          @posh ? "Darjeeling First Flush" : "Earl Grey"
+        end
+      end
+
+      # Unit test
+      class HighTeaTest < Calificador::Test
+        examines HighTea
+
+        # Define a factory for the test subject
+        factory HighTea do
+          scones { 2 }
+          posh { false }
+
+          # Use raits to define variants of your test subject
+          trait :style do
+            posh { true }
+          end
+        end
+
+        # Define test method
+        must "have tea and scones" do
+          # Write assertions using plain Ruby methods instead of spec DSL methods
+          refute { subject.tea }.nil?
+          assert { subject.scones } > 0
+        end
+
+        # Get nice test names. This one will be called "HighTea must have me let a scone"
+        must "let me have a scone" do
+          count = subject.scones
+          subject.eat_scone
+          assert { subject.scones } == count - 1
+        end
+
+        # Adjust test subject using traits or properties for minor variations
+        must "complain if out of scones", scones: 0 do
+          assert { subject.eat_scone }.raises?(StandardError)
+        end
+
+        # Create subcontexts for variations of the test subject using traits and properties
+        with :style do
+          # Still nice test names. This one is "HighTea with style should have expensive tea"
+          must "have expensive tea" do
+            assert { subject.tea }.include?("First Flush")
+          end
+        end
+      end
+    end
+
+    ReadMe::HighTeaTest.run_all_tests
+```
+
+[Minitest]: https://github.com/seattlerb/minitest
+[Factory Bot]: https://github.com/thoughtbot/factory_bot
+[Shoulda Context]: https://github.com/thoughtbot/shoulda-context
+[Assertive Expressive]: https://github.com/rubyworks/ae
+
+## Why?
+
+Calificador is an experiment in getting rid of as much mental load, boilerplate and distractions as possible. It tries to create a simple, easy to learn and easy to understand DSL for unit tests.
+
+Only a handful of DSL methods are required:
+
+* Test structure: examine, must, where/with/without
+* Factory methods: factory, traits
+* Assertions: assert, refute and raises?
+
+It also tries to keep things simple by avoiding all the special assertion and expectation methods you need to learn for other test frameworks. Instead of having to learn that `include` is the RSpec matcher for `include?`, or Minitest's `assert_match` is used to assert regular expression matches, you can write `refute { something }.include? "value"` or `assert { something }.match %r{pattern}` using Ruby's normal `String#match` method.
+
+
+## Frequently asked questions
+
+Q: What's with the name?
+
+A: In the [Spanish Inquisition](https://en.wikipedia.org/wiki/Spanish_Inquisition), a defendant was examined by calificadores, who determined if there was heresy involved.
+
+Q: The Spanish Inquisition? I did not expect that.
+
+A: Well, [nobody expects the Spanish Inquisition](https://www.youtube.com/watch?v=sAn7baRbhx4).

data/lib/calificador.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "minitest"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+# Main module
+module Calificador
+  using Calificador::Util::CoreExtensions
+
+  MISSING = Util::Missing.instance
+
+  class << self
+    attr_writer :call_formatter
+
+    def call_formatter
+      @call_formatter ||= Calificador::Util::CallFormatter.new
+    end
+  end
+
+  def self.test(subject_type, trait: Key::INHERITED_TRAIT, &block)
+    raise "Subject type must be a #{Module}" unless subject_type.is_a?(Module)
+
+    test_class = Class.new(Calificador::Test)
+    test_class_name = "#{subject_type.base_name}Test"
+    test_module = subject_type.parent_module
+
+    if test_module
+      test_module.const_set(test_class_name, test_class)
+    else
+      Kernel.const_set(test_class_name, test_class)
+    end
+
+    test_class.examines(subject_type, trait)
+    test_class.class_eval(&block)
+
+    test_class
+  end
+end
+
+Minitest::Assertion.prepend(Calificador::Minitest::MinitestPatches::AssertionMethods)
+Class.include(Calificador::Util::ClassMixin)

data/lib/calificador/assertor.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "minitest"
+
+module Calificador
+  class Assertor < BasicObject
+    def initialize(test:, negated: false, block: nil)
+      @test = test
+      @negated = negated ? true : false
+      @block = block
+      @value = MISSING
+      @triggered = false
+    end
+
+    def respond_to?(method, include_all = false)
+      __value.respond_to?(method, include_all) || super
+    end
+
+    def method_missing(method, *arguments, **options, &block) # rubocop:disable Style/MissingRespondToMissing
+      if __value.respond_to?(method)
+        __check(method: method, arguments: arguments, options: options, &block)
+      else
+        super
+      end
+    end
+
+    def ==(other)
+      message = ::Kernel.proc do
+        actual = ::Calificador.call_formatter.value(value: __value)
+        expected = ::Calificador.call_formatter.value(value: other)
+
+        "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} be equal to #{expected} (#{other.class})"
+      end
+
+      __check(method: :"==", message: message, arguments: [other])
+    end
+
+    def !=(other)
+      message = ::Kernel.proc do
+        actual = ::Calificador.call_formatter.value(value: __value)
+        expected = ::Calificador.call_formatter.value(value: other)
+
+        "Expected #{actual} (#{__value.class})  to#{@negated ? "" : " not"} be equal to #{expected} (#{other.class})"
+      end
+
+      __check(method: :"!=", message: message, arguments: [other])
+    end
+
+    def identical?(other)
+      message = ::Kernel.proc do
+        actual = ::Calificador.call_formatter.value(value: __value)
+        expected = ::Calificador.call_formatter.value(value: other)
+
+        "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} be identical to #{expected} (#{other.class})"
+      end
+
+      __check(method: :"equal?", message: message, arguments: [other])
+    end
+
+    def not
+      Assertor.new(test: @test, negated: !@negated, block: @block)
+    end
+
+    def raises?(*exception_classes, &block)
+      @triggered = true
+
+      block ||= @block
+
+      ::Kernel.raise ::ArgumentError, "Exception classes must not be empty" if exception_classes.empty?
+      ::Kernel.raise ::ArgumentError, "Exception assert must have a block" if block.nil?
+
+      message = ::Kernel.proc do
+        actual = ::Calificador.call_formatter.value(value: @block)
+        "Expected #{actual} (#{@block}) to#{@negated ? " not" : ""} raise #{exception_classes.join(", ")}"
+      end
+
+      begin
+        result = block.call
+
+        @test.assert(@negated, message)
+
+        result
+      rescue *exception_classes => e
+        @test.refute(@negated, @test.exception_details(e, message.call))
+        e
+      rescue ::Minitest::Assertion, ::SignalException, ::SystemExit
+        ::Kernel.raise
+      rescue ::Exception => e # rubocop:disable Lint/RescueException
+        @test.assert(@negated, @test.exception_details(e, message.call))
+      end
+    end
+
+    def __check_triggered
+      unless @triggered
+        ::Kernel.raise ::StandardError, <<~MESSAGE.gsub("\n", " ")
+          Assertor (#{@block.source_location.join(":")}) was not triggered. You probably need to call a method to
+          check for something, our your check must be changed to use a method not defined on BasicObject.
+        MESSAGE
+      end
+    end
+
+    protected
+
+    def __value
+      if @value.equal?(MISSING)
+        ::Kernel.raise ::StandardError, "No block set for assertion" if @block.nil?
+
+        @value = @block.call
+      end
+
+      @value
+    end
+
+    def __check(method:, message: nil, arguments: [], options: {}, &block)
+      @triggered = true
+
+      result = __value.send(method, *arguments, **options, &block)
+
+      message ||= ::Kernel.proc do
+        actual = ::Calificador.call_formatter.value(value: __value)
+        call = ::Calificador.call_formatter.method(method: method, arguments: arguments, options: options)
+        "Expected #{actual} (#{__value.class}) to#{@negated ? " not" : ""} #{call}"
+      end
+
+      if @negated
+        @test.refute(result, message)
+      else
+        @test.assert(result, message)
+      end
+
+      result
+    end
+  end
+end

data/lib/calificador/build/attribute.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Calificador
+  module Build
+    # Attribute description
+    class Attribute
+      TYPES = %i[property transient init].freeze
+
+      attr_reader :name, :type, :config
+
+      def initialize(name:, type:, config:)
+        raise "Illegal property type #{type}. Valid types are #{TYPES.join(", ")}" unless TYPES.include?(type.to_sym)
+
+        @name = name.to_sym
+        @type = type.to_sym
+        @config = config
+      end
+    end
+  end
+end

data/lib/calificador/build/attribute_container.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Build
+    # Factory calss
+    class AttributeContainer
+      class Dsl
+        def initialize(delegate:)
+          @delegate = delegate
+          @property_type = nil
+        end
+
+        def add_attribute(name, type: nil, &config)
+          type ||= @delegate.parent&.attribute(name: name)&.type || @property_type || :property
+          @delegate.add_attribute(Attribute.new(name: name, type: type, config: config))
+        end
+
+        def transient(&block)
+          raise ArgumentError, "Transient requires a block" if block.nil?
+
+          old_property_type = @property_type
+          @property_type = :transient
+
+          begin
+            instance_exec(self, &block)
+          ensure
+            @property_type = old_property_type
+          end
+        end
+
+        def init_with(&block)
+          raise "Initializer requires a block to create the object" if block.nil?
+
+          @delegate.init_with = block
+        end
+
+        def before_create(&block)
+          raise "Before requires a block to call" if block.nil?
+
+          @delegate.before_create = block
+        end
+
+        def after_create(&block)
+          raise "After requires a block to call" if block.nil?
+
+          @delegate.after_create = block
+        end
+
+        def respond_to_missing?(method, include_all = false)
+          if method.start_with?("__")
+            super
+          else
+            true
+          end
+        end
+
+        def method_missing(method, *arguments, &block)
+          if method.start_with?("__")
+            super
+          else
+            unless arguments.empty?
+              raise ::ArgumentError, <<~ERROR
+                Attribute #{method} cannot have arguments. Please use a block to configure the value
+              ERROR
+            end
+
+            raise ::ArgumentError, "Attribute #{method} must have a block to provide the value" if block.nil?
+
+            add_attribute(method, &block)
+          end
+        end
+      end
+
+      attr_reader :parent, :description
+      attr_accessor :init_with, :before_create, :after_create
+
+      def initialize(parent:, description:)
+        @parent = parent
+        @description = description.dup.freeze
+        @attributes = {}
+        @init_with = nil
+        @before_create = nil
+        @after_create = nil
+      end
+
+      def attributes
+        @attributes.dup.freeze
+      end
+
+      def attribute(name:)
+        @attributes[name]
+      end
+
+      def add_attribute(attribute)
+        raise KeyError, "Duplicate attribute name #{name}" if @attributes.key?(attribute.name)
+
+        @attributes[attribute.name] = attribute
+      end
+    end
+  end
+end

data/lib/calificador/build/attribute_evaluator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+using Calificador::Util::CoreExtensions
+
+module Calificador
+  module Build
+    class AttributeEvaluator
+      EVALUATING = Object.new.freeze
+
+      class Proxy
+        def initialize(delegate:)
+          @delegate = delegate
+        end
+
+        def create(type, trait = nil)
+          key = Key[type, trait]
+          @delegate.create_object(key: key)
+        end
+
+        def respond_to_missing?(method, include_all)
+          @delegate.attribute?(name: method) ? true : super
+        end
+
+        def method_missing(method, *arguments, &block)
+          if @delegate.attribute?(name: method)
+            raise ArgumentError, "Getter must not be called with arguments" unless arguments.empty?
+
+            @delegate.value(name: method)
+          else
+            super
+          end
+        end
+      end
+
+      attr_reader :attributes, :values
+
+      def initialize(context:)
+        @context = context
+        @attributes = {}
+        @values = {}
+        @proxy = Proxy.new(delegate: self)
+      end
+
+      def create_object(key:)
+        @context.create_object(key: key)
+      end
+
+      def add_values(values)
+        @values.merge!(values)
+      end
+
+      def add_attributes(attributes)
+        attributes.each do |attribute|
+          @attributes[attribute.name] = attribute
+        end
+      end
+
+      def value(name:)
+        result = @values.fetch(name) do
+          @values[name] = EVALUATING
+
+          begin
+            config = @attributes.fetch(name).config
+            @values[name] = evaluate(&config)
+          rescue StandardError
+            @values.delete(name)
+            raise
+          end
+        end
+
+        raise StandardError, "Endless recursion while evaluating attribute #{name}" if result == EVALUATING
+
+        result
+      end
+
+      def evaluate(*arguments, **options, &block)
+        block.invoke_with_target(@proxy, *arguments, **options)
+      end
+
+      def attribute?(name:)
+        @attributes.key?(name)
+      end
+    end
+  end
+end