varar 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b755d326581e7e691a70063e5fb1905193d49d10aa0330e3f6060e1edf35a99d
+  data.tar.gz: 9ca4b86b148592bf6ec59b91a56dd57c4ba23d1ebf31126f52a56bddbb552431
+SHA512:
+  metadata.gz: cafcb8f2d06411195cf648320ed6715df36108cfa18f8cf4694c0a0e466bc0ddf84f2d9dcbf0e60b242548ead3edc24ead4db74ee3d89db225fbf03f7c704bd1
+  data.tar.gz: 013c8f2eb13ac12fdf79ea7ee60aacfde0329920e22801c97befe7673bcf9d6f9cc98a7a4b773bdaf21aa8404abe55fca7335c2edddc2953d80dfbe650758b46

data/lib/varar/dsl.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'varar/internal'
+
+# `steps` as a top-level method, available in any step file after
+# `require "varar"` (idiomatic for BDD step DSLs, like Cucumber-Ruby's
+# Given/When/Then). It takes a block in which bare `stimulus`, `sensor` and
+# `param` register the file's steps:
+#
+#   steps(-> { { greeting: '' } }) do
+#     stimulus('I greet {string}') { |state, name| state.merge(greeting: "Hello, #{name}!") }
+#     sensor('the greeting is {string}') { |state, _expected| state[:greeting] }
+#   end
+#
+# The initial state is optional — omit it entirely for stateless step files —
+# but when given it MUST be a Proc/lambda, called fresh for every example. A
+# Hash was previously accepted and closed over a single object shared by every
+# example in the file; nested values `deep_freeze` does not recurse into (it
+# only descends Hash and Array) were then mutable and shared. Requiring a
+# factory makes freshness structural rather than something the deep-freeze has
+# to defend. The state is keyed by the calling file so contexts never bleed
+# across step files.
+module Kernel
+  private
+
+  def steps(factory = nil, &block)
+    unless factory.nil? || factory.is_a?(Proc)
+      raise ArgumentError,
+            'steps expects a Proc/lambda state factory, called fresh per example — ' \
+            "got #{factory.class}. Wrap it: steps(-> { { count: 0 } })"
+    end
+
+    builder = Varar::Internal.register(factory || -> { {} }, caller_locations(1, 1).first.path)
+    builder.instance_eval(&block) if block
+    nil
+  end
+end

data/lib/varar/internal.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'varar/core'
+
+module Varar
+  # The module-scope step-registration accumulator behind the block DSL
+  # `steps(...) do stimulus(...); sensor(...) end`. Mirrors @varar/varar's
+  # internal.ts. A step file, when loaded, calls steps() once; the Builder its
+  # block registers into these accumulators. The runner/harness then reads
+  # them via build_registry / context_factory.
+  module Internal
+    @steps = []
+    @context_factories_by_file = {}
+    @custom_types = []
+
+    class << self
+      # Register a file's state factory and return a Builder whose
+      # stimulus/sensor/param methods accumulate that file's steps. +factory+
+      # is a callable (or nil for empty state); +source_file+ keys the
+      # per-file context factory. Raises if called twice for one file.
+      def register(factory, source_file)
+        raise "steps() called more than once in #{source_file}" if @context_factories_by_file.key?(source_file)
+
+        @context_factories_by_file[source_file] = factory || -> { {} }
+        Builder.new
+      end
+
+      # Accumulate one step. The handler's source_location anchors it to the
+      # line the block is written on.
+      def add_step(expression, handler, kind)
+        file, line = handler.source_location
+        @steps << {
+          expression: expression, source_file: file, source_line: line,
+          handler: handler, kind: kind
+        }
+        nil
+      end
+
+      # Accumulate one custom parameter type.
+      def add_custom_type(name, regexp, parse, format)
+        @custom_types << { name: name, regexp: regexp, parse: parse, format: format }
+        nil
+      end
+
+      # (step_file) -> state: invoke the file's factory, or {} if none.
+      def context_factory
+        factories = @context_factories_by_file.dup
+        lambda do |step_file|
+          factory = factories[step_file]
+          factory ? factory.call : {}
+        end
+      end
+
+      # Build a Core::Registry: custom parameter types first (so expressions
+      # can reference them), then steps in registration order.
+      def build_registry
+        registry = Core::Registries.create_registry
+        @custom_types.each do |type|
+          registry = Core::Registries.define_parameter_type(
+            registry, name: type[:name], regexp: type[:regexp], parse: type[:parse], format: type[:format]
+          )
+        end
+        @steps.each do |step|
+          registry = Core::Registries.add_step(
+            registry,
+            expression: step[:expression],
+            expression_source_file: step[:source_file],
+            expression_source_line: step[:source_line],
+            handler: step[:handler],
+            kind: step[:kind]
+          )
+        end
+        registry
+      end
+
+      # Clear all accumulated state (between isolated runs / harness bundles).
+      def reset_builder
+        @steps = []
+        @context_factories_by_file = {}
+        @custom_types = []
+      end
+
+      # Conformance-harness accessor: custom parameter types projected to the
+      # {"name","regexp"} wire shape. `regexp` is the bare source (Regexp#source
+      # or the string as authored) — the cross-port convention.
+      def custom_parameter_types
+        @custom_types.map do |type|
+          regexp = type[:regexp]
+          regexp = regexp.source if regexp.is_a?(Regexp)
+          unless regexp.is_a?(String)
+            raise "parameter type #{type[:name].inspect}: regexp arrays are not supported " \
+                  'by the conformance projection yet'
+          end
+          { 'name' => type[:name], 'regexp' => regexp }
+        end
+      end
+    end
+
+    # The block-scoped authoring DSL. A Builder is `instance_eval`-ed with the
+    # `steps` block, so authors write bare `stimulus`/`sensor`/`param` calls;
+    # each delegates to the accumulator above.
+    class Builder
+      def stimulus(expression, &handler)
+        Internal.add_step(expression, handler, 'stimulus')
+      end
+
+      def sensor(expression, &handler)
+        Internal.add_step(expression, handler, 'sensor')
+      end
+
+      def param(name, regexp, parse: nil, format: nil)
+        Internal.add_custom_type(name, regexp, parse, format)
+      end
+    end
+  end
+end

data/lib/varar/registry.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'varar/internal'
+
+module Varar
+  # Adapter/harness glue — mirrors the `@varar/varar/registry` subpath.
+  # Authors import only `steps` (via varar); runners and the conformance
+  # harness reach the accumulator through here.
+  module RegistryGlue
+    module_function
+
+    def reset_builder
+      Internal.reset_builder
+    end
+
+    def build_registry
+      Internal.build_registry
+    end
+
+    def context_factory
+      Internal.context_factory
+    end
+
+    def custom_parameter_types
+      Internal.custom_parameter_types
+    end
+  end
+end

data/lib/varar.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'varar/core'
+require 'varar/internal'
+require 'varar/dsl'
+
+module Varar
+  # The author facade: `steps` (top-level DSL) → [param, stimulus, sensor],
+  # backed by the module-scope accumulator in Internal.
+  VERSION = '0.5.0'
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: varar
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Aslak Hellesøy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber-cucumber-expressions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 20.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 20.0.0
+- !ruby/object:Gem::Dependency
+  name: varar-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+description: 'The Vár author facade: define_state and the step-registration accumulator.'
+email:
+- aslak@oselvar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/varar.rb
+- lib/varar/dsl.rb
+- lib/varar/internal.rb
+- lib/varar/registry.rb
+homepage: https://varar.dev
+licenses:
+- MIT
+metadata:
+  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: Markdown-native BDD — author API (define_state)
+test_files: []