varar-runner 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35de6da02e737f392c23569377f72becdc449aaa20f63475c23792be9e6b2b38
+  data.tar.gz: d9df6fb1290276b4e6d767de37e0593d0701f159b61d65cb5a0b49a3a066c1c5
+SHA512:
+  metadata.gz: cd4113e5eb8cbd2541575c469a316cda2c95ed5bdf6b6acc53b6d60954ee3ca89eedb45b33edbdecea12e3a00b66f8dec75eb51e8af49fd96f4b07db7108c012
+  data.tar.gz: eb88c79d204b4e65b5dc202907eeb99f8d5e683176be7b4c731a3b81fe40c5ab856889ccb088af121974ff5fcda4ecea28ea74a63d38a195b9c59655344bcb19

data/exe/varar

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'varar/runner/cli'
+
+exit Varar::Runner::CLI.main(ARGV)

data/lib/varar/runner/baseline_store.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Varar
+  module Runner
+    # The filesystem BaselineStore: the committed drift baseline lives at the
+    # project root as varar.lock.json. The core owns the format; this adapter
+    # only moves raw text. Port of baseline_store.py.
+    class FileBaselineStore
+      def initialize(root)
+        @path = File.join(root.to_s, 'varar.lock.json')
+      end
+
+      def read
+        File.exist?(@path) ? File.read(@path, encoding: 'UTF-8') : nil
+      end
+
+      def write(contents)
+        File.write(@path, contents)
+      end
+    end
+
+    module_function
+
+    def create_file_baseline_store(root)
+      FileBaselineStore.new(root)
+    end
+  end
+end

data/lib/varar/runner/cli.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Varar
+  module Runner
+    # The `var` command-line entry point (exposed by the `exe/var`
+    # executable). Today it offers a single sub-command, `varar init`, which
+    # scaffolds a new project: a `varar.config.json`, one Markdown spec, its
+    # step definitions, and a framework bridge that turns the specs into
+    # RSpec examples or Minitest tests.
+    #
+    # The config, spec and steps mirror the TypeScript CLI (`@varar/cli`)
+    # so a project started with `varar init` looks the same in every language;
+    # only the bridge is Ruby-specific, because RSpec/Minitest — unlike
+    # pytest — need an explicit generator call to discover the specs.
+    module CLI
+      CONFIG = <<~JSON
+        {
+          "docs": { "include": ["varar-examples/**/*.md"], "exclude": [] },
+          "steps": ["varar-examples/**/*.steps.rb"]
+        }
+      JSON
+
+      EXAMPLE_MD = <<~MARKDOWN
+        # Hello, BDD
+
+        Given I greet "world"
+        Then the greeting is "Hello, world!"
+      MARKDOWN
+
+      EXAMPLE_STEPS = <<~RUBY
+        # frozen_string_literal: true
+
+        require 'varar'
+
+        steps(-> { { greeting: '' } }) do
+          stimulus('I greet {string}') { |_state, name| { greeting: "Hello, \#{name}!" } }
+          sensor('the greeting is {string}') { |state, _expected| state[:greeting] }
+        end
+      RUBY
+
+      RSPEC_BRIDGE = <<~RUBY
+        # frozen_string_literal: true
+
+        # Turn every Markdown spec matched by varar.config.json into RSpec examples —
+        # one `it` per Markdown example, discovered when this file loads.
+        require 'varar/rspec'
+
+        # varar.config.json lives at the project root (the parent of spec/).
+        Varar::RSpec.generate(root: File.expand_path('..', __dir__))
+      RUBY
+
+      MINITEST_BRIDGE = <<~RUBY
+        # frozen_string_literal: true
+
+        require 'minitest/autorun'
+        require 'varar/minitest'
+
+        # Turn every Markdown spec matched by varar.config.json into Minitest tests —
+        # varar.config.json lives at the project root (the parent of test/).
+        Varar::Minitest.generate_tests(Object, root: File.expand_path('..', __dir__))
+      RUBY
+
+      USAGE = <<~TEXT
+        varar — scaffold and run Markdown specs
+
+        Usage:
+          varar init               scaffold a new project
+      TEXT
+
+      def self.main(argv, cwd: Dir.pwd, out: $stdout)
+        case argv.first
+        when 'init'
+          run_init(cwd, out)
+        else
+          out.print(USAGE)
+          argv.empty? || %w[help -h --help].include?(argv.first) ? 0 : 1
+        end
+      end
+
+      # Write the scaffold into +cwd+, skipping any file that already exists.
+      # The framework bridge matches whichever adapter gem is installed
+      # (RSpec by default).
+      def self.run_init(cwd, out, framework: detect_framework)
+        files = [
+          ['varar.config.json', CONFIG],
+          ['varar-examples/01-hello.md', EXAMPLE_MD],
+          ['varar-examples/steps/01-hello.steps.rb', EXAMPLE_STEPS]
+        ]
+        files << if framework == :minitest
+                   ['test/var_test.rb', MINITEST_BRIDGE]
+                 else
+                   ['spec/var_spec.rb', RSPEC_BRIDGE]
+                 end
+
+        files.each do |rel, content|
+          target = File.join(cwd, rel)
+          if File.exist?(target)
+            out.puts "skipped #{rel} (already exists)"
+            next
+          end
+          FileUtils.mkdir_p(File.dirname(target))
+          File.write(target, content)
+          out.puts "created #{rel}"
+        end
+        0
+      end
+
+      # RSpec when its adapter is installed, Minitest when only that one is,
+      # RSpec as the fallback (matching the tutorial's default track).
+      def self.detect_framework
+        return :rspec if gem_present?('varar-rspec')
+        return :minitest if gem_present?('varar-minitest')
+
+        :rspec
+      end
+
+      def self.gem_present?(name)
+        Gem::Specification.find_all_by_name(name).any?
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/varar/runner/discovery.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Varar
+  module Runner
+    module_function
+
+    # Translate a glob with **, *, ? to an anchored regex (PEP 428 / pathlib
+    # full_match semantics), matching the other ports' hand-rolled compiler
+    # rather than Ruby's Dir glob. Port of _glob_to_regex.
+    def glob_to_regex(pattern)
+      result = +''
+      i = 0
+      n = pattern.length
+      while i < n
+        c = pattern[i]
+        if c == '/' && pattern[i, 4] == '/**/'
+          result << '/(?:.+/)?'
+          i += 4
+        elsif c == '/' && pattern[i, 3] == '/**' && i + 3 == n
+          result << '(?:/.*)?'
+          i += 3
+        elsif c == '*' && pattern[i, 3] == '**/'
+          result << '(?:.*/)?'
+          i += 3
+        elsif c == '*' && pattern[i, 2] == '**'
+          result << '.*'
+          i += 2
+        elsif c == '*'
+          result << '[^/]*'
+          i += 1
+        elsif c == '?'
+          result << '[^/]'
+          i += 1
+        else
+          result << Regexp.escape(c)
+          i += 1
+        end
+      end
+      /\A#{result}\z/
+    end
+
+    # Relative POSIX path of +path+ within +root+, without dereferencing
+    # symlinks; yields a ../ prefix when +path+ is outside +root+.
+    def rel_posix(path, root)
+      Pathname.new(File.expand_path(path))
+              .relative_path_from(Pathname.new(File.expand_path(root))).to_s
+    end
+
+    def matches_any?(rel, globs)
+      globs.any? { |g| glob_to_regex(g).match?(rel) }
+    end
+
+    # True iff +path+ matches an include glob and no exclude glob.
+    def match_spec?(path, include, exclude, root)
+      rel = rel_posix(path, root)
+      matches_any?(rel, include) && !matches_any?(rel, exclude)
+    end
+
+    # Existing files under +root+ matching any include glob, minus excludes; sorted.
+    def find_specs(include, exclude, root)
+      out = []
+      include.each do |g|
+        out.concat(Dir.glob(g, base: root).map { |rel| File.join(root, rel) })
+      end
+      out = out.select { |p| File.file?(p) }.uniq
+      out.reject { |p| matches_any?(rel_posix(p, root), exclude) }.sort
+    end
+  end
+end

data/lib/varar/runner/render.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'varar/core'
+
+module Varar
+  module Runner
+    module_function
+
+    # Render a step failure as a human-readable, markdown-anchored string,
+    # dispatching on the concrete error type. Port of render.py.
+    def render_failure(error, _source, path)
+      case error
+      when Core::CellMismatchError
+        lines = ["Cell mismatch in #{path}:"]
+        failing = error.cells.reject(&:ok)
+        lines << '  (no failing cells)' if failing.empty?
+        failing.each do |cell|
+          lines << "  line #{cell.span.start_line} | column '#{cell.column}' — " \
+                   "expected: #{cell.expected.inspect}, actual: #{cell.actual.inspect}"
+        end
+        lines.join("\n")
+      when Core::DocStringMismatchError
+        diff = error.diff
+        "Doc string mismatch at line #{diff.span.start_line}:\n  " \
+          "expected: #{diff.expected.inspect}\n  actual:   #{diff.actual.inspect}"
+      when Core::ReturnShapeError
+        error.message
+      else
+        "#{error.class}: #{error.message}"
+      end
+    end
+  end
+end

data/lib/varar/runner/run.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'varar/core'
+
+module Varar
+  module Runner
+    # Collects diagnostics emitted during planning/execution.
+    class RecordingReporter
+      attr_reader :diagnostics
+
+      def initialize
+        @diagnostics = []
+      end
+
+      def diagnostic(diagnostic)
+        @diagnostics << diagnostic
+      end
+    end
+
+    module_function
+
+    def plan_spec(path, source, registry)
+      Core::Plan.plan(Core::Parse.parse(path, source), registry)
+    end
+
+    # Pair each PlannedExample with its lazy run closure, in plan order.
+    def examples_with_runs(execution_plan, create_context, reporter)
+      reporter_cb = ->(d) { reporter.diagnostic(d) }
+      queue = Core::Execute.collect_examples(execution_plan, create_context: create_context, reporter: reporter_cb)
+      execution_plan.examples.zip(queue).map { |example, queued| [example, queued.run] }
+    end
+  end
+end

data/lib/varar/runner/steps.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'varar'
+require 'varar/registry'
+
+module Varar
+  module Runner
+    # The registry + per-file context factory built from loaded step files.
+    LoadedSteps = Data.define(:registry, :create_context)
+
+    module_function
+
+    # Reset the accumulator, load (execute) every step file matching
+    # +step_globs+ under +root+, and build the registry + context factory.
+    def load_steps(step_globs, root)
+      RegistryGlue.reset_builder
+      files = []
+      step_globs.each do |g|
+        files.concat(Dir.glob(g, base: root).map { |rel| File.join(root, rel) })
+      end
+      files.select { |p| File.file?(p) }.uniq.sort.each { |path| load path }
+      LoadedSteps.new(registry: RegistryGlue.build_registry, create_context: RegistryGlue.context_factory)
+    end
+  end
+end

data/lib/varar/runner.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'varar'
+require 'varar/config'
+require 'varar/core'
+
+module Varar
+  # The imperative shell: discovery, step loading, planning, failure
+  # rendering, and the filesystem drift baseline store. Depends on the facade
+  # and config; never on a test framework. Port of var-runner.
+  module Runner
+    VERSION = '0.5.0'
+  end
+end
+
+require 'varar/runner/discovery'
+require 'varar/runner/steps'
+require 'varar/runner/run'
+require 'varar/runner/render'
+require 'varar/runner/baseline_store'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: varar-runner
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Aslak Hellesøy
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: varar
+  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
+- !ruby/object:Gem::Dependency
+  name: varar-config
+  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: Spec/step discovery, step loading, planning, failure rendering, and the
+  drift baseline store.
+email:
+- aslak@oselvar.com
+executables:
+- varar
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/varar
+- lib/varar/runner.rb
+- lib/varar/runner/baseline_store.rb
+- lib/varar/runner/cli.rb
+- lib/varar/runner/discovery.rb
+- lib/varar/runner/render.rb
+- lib/varar/runner/run.rb
+- lib/varar/runner/steps.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 — imperative shell (discovery, loading, drift)
+test_files: []