oselvar-var 0.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb0852755c7a3a3b12c48ba5a068b697d0ae7e56e9fab0119adb7edfe1f4ff87
+  data.tar.gz: 308eb73b130b267ecc468f32ca0cd22e02b443c5a27170616749f0f822007d3a
+SHA512:
+  metadata.gz: cd02c874113a84d2ff1b53239ec567dd463c429a34f6f13de5bce235706c3f645140c6741d11461a4e9746ab325134de5dd1cc78be9bb73549855553ca27f03c
+  data.tar.gz: 9a394baac86793e5efa3b3926b9d80766cb7e6003e0436ebe430094ed31cf2be76c5ce1b87fdcbc7126b5ca5213bc27de81a56e589434fe8f7e03ae50aeeeef9

data/lib/oselvar/var/dsl.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'oselvar/var/internal'
+
+# `steps` as a top-level method, available in any step file after
+# `require "oselvar/var"` (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| { greeting: "Hello, #{name}!" } }
+#     sensor('the greeting is {string}') { |state, _expected| state[:greeting] }
+#   end
+#
+# The initial state is optional and may be given as keyword arguments, a Hash,
+# or a Proc factory (called fresh per example); omit it entirely for stateless
+# step files. The state is keyed by the calling file so contexts never bleed
+# across step files.
+module Kernel
+  private
+
+  def steps(state = nil, **kwstate, &block)
+    initial =
+      if state.is_a?(Proc)
+        state
+      elsif !kwstate.empty?
+        kwstate
+      else
+        state || {}
+      end
+    factory = initial.is_a?(Proc) ? initial : -> { initial }
+    builder = Oselvar::Var::Internal.register(factory, caller_locations(1, 1).first.path)
+    builder.instance_eval(&block) if block
+    nil
+  end
+end

data/lib/oselvar/var/internal.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'oselvar/var/core'
+
+module Oselvar
+  module Var
+    # The module-scope step-registration accumulator behind the block DSL
+    # `steps(...) do stimulus(...); sensor(...) end`. Mirrors @oselvar/var'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
+end

data/lib/oselvar/var/registry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'oselvar/var/internal'
+
+module Oselvar
+  module Var
+    # Adapter/harness glue — mirrors the `@oselvar/var/registry` subpath.
+    # Authors import only `steps` (via oselvar/var); 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
+end

data/lib/oselvar/var.rb

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

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: oselvar-var
+version: !ruby/object:Gem::Version
+  version: 0.3.2
+platform: ruby
+authors:
+- Aslak Hellesøy
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-07 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: oselvar-var-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+description: 'The Vár author facade: define_state and the step-registration accumulator.'
+email:
+- aslak@oselvar.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/oselvar/var.rb
+- lib/oselvar/var/dsl.rb
+- lib/oselvar/var/internal.rb
+- lib/oselvar/var/registry.rb
+homepage: https://var.oselvar.com
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+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: 3.4.10
+signing_key:
+specification_version: 4
+summary: Markdown-native BDD — author API (define_state)
+test_files: []