executable-stories-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca5f49335f6bb83179d6c6d3710fa24fc7bc03250dfe0af5722a301e439485ff
+  data.tar.gz: 5e2fee0c6f9ab67787d7f89af3fec3a5e9074a805fbbc577884eba6fc805404a
+SHA512:
+  metadata.gz: 4df5210a06292fe29466f57fb91887450249c6562b239489d90d0ff2259d5581c922782b75d9e66ac0882c9360fb61cb3e4f0ea56940fd7658967b5954a25c27
+  data.tar.gz: ca7e21e81ae8999d8b1117b5fc91706bb85ee9706ff52a6410e878b651d2052fcb32b30c1e1a473c894bd333c57a06ea35f49ca7a614acb555c6ec409595ba02

data/lib/executable_stories/collector.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+module ExecutableStories
+  @mutex = Mutex.new
+  @collected = []
+  @order_seq = 0
+
+  module Collector
+    module_function
+
+    def record(test_case)
+      @mutex ||= Mutex.new
+      @collected ||= []
+      @mutex.synchronize do
+        @collected << test_case
+      end
+    end
+
+    def all
+      @mutex ||= Mutex.new
+      @collected ||= []
+      @mutex.synchronize do
+        @collected.dup
+      end
+    end
+
+    def next_order
+      @mutex ||= Mutex.new
+      @order_seq ||= 0
+      @mutex.synchronize do
+        n = @order_seq
+        @order_seq += 1
+        n
+      end
+    end
+
+    def reset
+      @mutex ||= Mutex.new
+      @mutex.synchronize do
+        @collected = []
+        @order_seq = 0
+      end
+    end
+  end
+end

data/lib/executable_stories/doc_entry.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ExecutableStories
+  module DocEntry
+    module_function
+
+    def note(text, children: nil)
+      entry = { "kind" => "note", "text" => text, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def tag(*names, children: nil)
+      entry = { "kind" => "tag", "names" => names.flatten, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def kv(label, value, children: nil)
+      entry = { "kind" => "kv", "label" => label, "value" => value, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def json_doc(label, value, children: nil)
+      require "json"
+      content = JSON.pretty_generate(value)
+      entry = { "kind" => "code", "label" => label, "content" => content, "lang" => "json", "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def code(label, content, lang: nil, children: nil)
+      entry = { "kind" => "code", "label" => label, "content" => content, "phase" => "runtime" }
+      entry["lang"] = lang if lang
+      apply_children(entry, children)
+    end
+
+    def table(label, columns, rows, children: nil)
+      entry = { "kind" => "table", "label" => label, "columns" => columns, "rows" => rows, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def link(label, url, children: nil)
+      entry = { "kind" => "link", "label" => label, "url" => url, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def section(title, markdown, children: nil)
+      entry = { "kind" => "section", "title" => title, "markdown" => markdown, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def mermaid(code, title: nil, children: nil)
+      entry = { "kind" => "mermaid", "code" => code, "phase" => "runtime" }
+      entry["title"] = title if title
+      apply_children(entry, children)
+    end
+
+    def screenshot(path, alt: nil, children: nil)
+      entry = { "kind" => "screenshot", "path" => path, "phase" => "runtime" }
+      entry["alt"] = alt if alt
+      apply_children(entry, children)
+    end
+
+    def custom(type, data, children: nil)
+      entry = { "kind" => "custom", "type" => type, "data" => data, "phase" => "runtime" }
+      apply_children(entry, children)
+    end
+
+    def apply_children(entry, children)
+      return entry unless children && !children.empty?
+
+      entry["children"] = children.map { |c| c.is_a?(Hash) ? c : c.to_h }
+      entry
+    end
+  end
+end

data/lib/executable_stories/json_writer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "types"
+
+module ExecutableStories
+  module JsonWriter
+    module_function
+
+    def write_raw_run(run, output_path)
+      dir = File.dirname(output_path)
+      FileUtils.mkdir_p(dir)
+
+      json = "#{JSON.pretty_generate(ExecutableStories.run_to_h(run))}\n"
+      File.write(output_path, json)
+    end
+  end
+end

data/lib/executable_stories/minitest.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "minitest"
+require_relative "story"
+require_relative "collector"
+require_relative "json_writer"
+require_relative "types"
+
+module ExecutableStories
+  module MinitestPlugin
+    module_function
+
+    def install!
+      return if @installed
+
+      Minitest.after_run do
+        write_results
+      end
+
+      @installed = true
+    end
+
+    def write_results(output_path: nil)
+      cases = Collector.all
+      return if cases.empty?
+
+      output_path ||= ENV.fetch("EXECUTABLE_STORIES_OUTPUT", ".executable-stories/raw-run.json")
+
+      started = cases.map(&:start_time).compact.min
+      finished = cases.map(&:end_time).compact.max
+
+      run = RawRun.new(
+        schema_version: 1,
+        test_cases: cases,
+        project_root: Dir.pwd,
+        started_at_ms: started,
+        finished_at_ms: finished,
+        package_version: nil,
+        git_sha: nil,
+        ci: detect_ci
+      )
+
+      JsonWriter.write_raw_run(run, output_path)
+    end
+
+    def detect_ci
+      if ENV["GITHUB_ACTIONS"] == "true"
+        url = nil
+        server = ENV["GITHUB_SERVER_URL"]
+        repo = ENV["GITHUB_REPOSITORY"]
+        run_id = ENV["GITHUB_RUN_ID"]
+        url = "#{server}/#{repo}/actions/runs/#{run_id}" if server && repo && run_id
+        RawCIInfo.new(name: "github", url: url, build_number: ENV["GITHUB_RUN_NUMBER"])
+      elsif ENV["CIRCLECI"] == "true"
+        RawCIInfo.new(name: "circleci", url: ENV["CIRCLE_BUILD_URL"], build_number: ENV["CIRCLE_BUILD_NUM"])
+      elsif !ENV["JENKINS_URL"].nil?
+        RawCIInfo.new(name: "jenkins", url: ENV["BUILD_URL"], build_number: ENV["BUILD_NUMBER"])
+      elsif ENV["TRAVIS"] == "true"
+        RawCIInfo.new(name: "travis", url: ENV["TRAVIS_BUILD_WEB_URL"], build_number: ENV["TRAVIS_BUILD_NUMBER"])
+      elsif ENV["GITLAB_CI"] == "true"
+        RawCIInfo.new(name: "gitlab", url: ENV["CI_PIPELINE_URL"], build_number: ENV["CI_PIPELINE_IID"])
+      elsif ENV["CI"] == "true"
+        RawCIInfo.new(name: "ci")
+      end
+    end
+  end
+end
+
+ExecutableStories::MinitestPlugin.install!

data/lib/executable_stories/story.rb

@@ -0,0 +1,414 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "types"
+require_relative "doc_entry"
+require_relative "collector"
+
+module ExecutableStories
+  class Story
+    attr_accessor :scenario, :steps, :tags, :tickets, :meta, :docs,
+                  :current_step, :seen_primary, :start_time, :end_time,
+                  :source_order, :step_counter, :attachments, :active_timers,
+                  :timer_counter, :otel_spans, :trace_url_template
+
+    def initialize(scenario, tags: nil, ticket: nil, meta: nil, trace_url_template: nil)
+      @scenario = scenario
+      @steps = []
+      @tags = tags
+      @tickets = normalize_tickets(ticket)
+      @meta = meta&.dup
+      @docs = []
+      @current_step = nil
+      @seen_primary = {}
+      @start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0
+      @source_order = Collector.next_order
+      @step_counter = 0
+      @attachments = []
+      @active_timers = {}
+      @timer_counter = 0
+      @otel_spans = nil
+      @trace_url_template = trace_url_template
+
+      bridge_otel
+    end
+
+    def given(text)
+      add_step("Given", text)
+      self
+    end
+
+    def when(text)
+      add_step("When", text)
+      self
+    end
+
+    def then(text)
+      add_step("Then", text)
+      self
+    end
+
+    def and(text)
+      add_explicit_step("And", text)
+      self
+    end
+
+    def but(text)
+      add_explicit_step("But", text)
+      self
+    end
+
+    def arrange(text)
+      add_step("Given", text)
+      self
+    end
+
+    def act(text)
+      add_step("When", text)
+      self
+    end
+
+    def assert_that(text)
+      add_step("Then", text)
+      self
+    end
+
+    def setup(text)
+      add_step("Given", text)
+      self
+    end
+
+    def context(text)
+      add_step("Given", text)
+      self
+    end
+
+    def execute(text)
+      add_step("When", text)
+      self
+    end
+
+    def action(text)
+      add_step("When", text)
+      self
+    end
+
+    def verify(text)
+      add_step("Then", text)
+      self
+    end
+
+    def fn(keyword, text, &body)
+      add_step(keyword, text)
+      @current_step.wrapped = true
+
+      start_ms = Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0
+      begin
+        result = body.call
+        @current_step.duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0) - start_ms
+        result
+      rescue StandardError => e
+        @current_step.duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0) - start_ms
+        raise e
+      end
+    end
+
+    def expect(text, &)
+      fn("Then", text, &)
+    end
+
+    def start_timer
+      token = @timer_counter
+      @timer_counter += 1
+
+      step_index = @current_step ? @steps.index(@current_step) : nil
+      entry = {
+        start: Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0,
+        step_index: step_index,
+        step_id: @current_step&.id,
+        consumed: false
+      }
+      @active_timers[token] = entry
+      token
+    end
+
+    def end_timer(token)
+      entry = @active_timers[token]
+      return unless entry && !entry[:consumed]
+
+      entry[:consumed] = true
+      duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0) - entry[:start]
+
+      step = nil
+      step = @steps.find { |s| s.id == entry[:step_id] } if entry[:step_id]
+      step = @steps[entry[:step_index]] if !step && entry[:step_index] && entry[:step_index] < @steps.length
+
+      step.duration_ms = duration_ms if step
+    end
+
+    def note(text, children: nil)
+      entry = DocEntry.note(text, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def tag(*names, children: nil)
+      entry = DocEntry.tag(*names, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def kv(label, value, children: nil)
+      entry = DocEntry.kv(label, value, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def json(label, value, children: nil)
+      entry = DocEntry.json_doc(label, value, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def code(label, content, lang: nil, children: nil)
+      entry = DocEntry.code(label, content, lang: lang, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def table(label, columns, rows, children: nil)
+      entry = DocEntry.table(label, columns, rows, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def link(label, url, children: nil)
+      entry = DocEntry.link(label, url, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def section(title, markdown, children: nil)
+      entry = DocEntry.section(title, markdown, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def mermaid(code, title: nil, children: nil)
+      entry = DocEntry.mermaid(code, title: title, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def screenshot(path, alt: nil, children: nil)
+      entry = DocEntry.screenshot(path, alt: alt, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def custom(type, data, children: nil)
+      entry = DocEntry.custom(type, data, children: children)
+      attach_doc(entry)
+      entry
+    end
+
+    def attach(name, media_type, path: nil, body: nil, encoding: nil, charset: nil, file_name: nil)
+      att = RawAttachment.new(
+        name: name,
+        media_type: media_type,
+        path: path,
+        body: body,
+        encoding: encoding,
+        charset: charset,
+        file_name: file_name
+      )
+      if @current_step
+        idx = @steps.index(@current_step)
+        att.step_index = idx if idx
+        att.step_id = @current_step.id
+      end
+      @attachments << att
+      self
+    end
+
+    def attach_inline(name, media_type, body, encoding: "IDENTITY")
+      att = RawAttachment.new(
+        name: name,
+        media_type: media_type,
+        body: body,
+        encoding: encoding
+      )
+      if @current_step
+        idx = @steps.index(@current_step)
+        att.step_index = idx if idx
+        att.step_id = @current_step.id
+      end
+      @attachments << att
+      self
+    end
+
+    def attach_spans(spans)
+      @otel_spans = spans
+      self
+    end
+
+    def get_meta
+      StoryMeta.new(
+        scenario: @scenario,
+        steps: @steps,
+        tags: @tags,
+        tickets: @tickets,
+        meta: @meta,
+        docs: @docs.empty? ? nil : @docs,
+        source_order: @source_order,
+        otel_spans: @otel_spans
+      )
+    end
+
+    def record(status:, title: nil, suite_path: nil, source_file: nil, duration_ms: nil, error: nil)
+      @end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000.0
+      duration = duration_ms || (@end_time - @start_time)
+
+      step_events = @steps.each_with_index.map do |s, i|
+        s.duration_ms ? RawStepEvent.new(index: i, title: s.text, duration_ms: s.duration_ms) : nil
+      end.compact
+
+      tc = RawTestCase.new(
+        status: status,
+        title: title || @scenario,
+        title_path: suite_path ? suite_path + [@scenario] : [@scenario],
+        story: get_meta,
+        source_file: source_file,
+        duration_ms: duration,
+        error: error,
+        retry: 0,
+        retries: 0,
+        attachments: @attachments.empty? ? nil : @attachments,
+        step_events: step_events.empty? ? nil : step_events,
+        start_time: @start_time,
+        end_time: @end_time
+      )
+      Collector.record(tc)
+      tc
+    end
+
+    private
+
+    def add_step(keyword, text)
+      effective = keyword
+      if %w[Given When Then].include?(keyword)
+        if @seen_primary[keyword]
+          effective = "And"
+        else
+          @seen_primary[keyword] = true
+        end
+      end
+
+      step = StoryStep.new(
+        id: "step-#{@step_counter}",
+        keyword: effective,
+        text: text,
+        mode: nil,
+        wrapped: nil,
+        duration_ms: nil,
+        docs: nil
+      )
+      @step_counter += 1
+      @steps << step
+      @current_step = step
+      nil
+    end
+
+    def add_explicit_step(keyword, text)
+      step = StoryStep.new(
+        id: "step-#{@step_counter}",
+        keyword: keyword,
+        text: text,
+        mode: nil,
+        wrapped: nil,
+        duration_ms: nil,
+        docs: nil
+      )
+      @step_counter += 1
+      @steps << step
+      @current_step = step
+      nil
+    end
+
+    def attach_doc(entry)
+      if entry["children"] && !entry["children"].empty?
+        child_set = entry["children"].to_set(&:object_id)
+        filter_docs = ->(docs) { docs.reject { |d| child_set.include?(d.object_id) } }
+        @docs = filter_docs.call(@docs)
+        @steps.each { |s| s.docs = filter_docs.call(s.docs) if s.docs }
+      end
+
+      if @current_step
+        @current_step.docs ||= []
+        @current_step.docs << entry
+      else
+        @docs << entry
+      end
+    end
+
+    def normalize_tickets(ticket)
+      return nil unless ticket
+
+      tickets = Array(ticket)
+      tickets.map do |t|
+        if t.is_a?(String)
+          Ticket.new(id: t)
+        else
+          Ticket.new(id: t[:id] || t["id"], url: t[:url] || t["url"])
+        end
+      end
+    end
+
+    def bridge_otel
+      require "opentelemetry-api"
+      context = OpenTelemetry::Trace.current_span_context
+      return unless context&.valid?
+
+      inject_otel_meta(context)
+      inject_otel_docs(context)
+      tag_otel_span
+    rescue LoadError
+      # opentelemetry-api not available
+    rescue StandardError
+      # OTel not configured, ignore
+    end
+
+    def inject_otel_meta(context)
+      @meta ||= {}
+      @meta["otel"] = { "traceId" => context.trace_id, "spanId" => context.span_id }
+    end
+
+    def inject_otel_docs(context)
+      @docs << DocEntry.kv("Trace ID", context.trace_id)
+
+      template = @trace_url_template || ENV["OTEL_TRACE_URL_TEMPLATE"]
+      return unless template && !template.empty?
+
+      url = template.gsub("{traceId}", context.trace_id)
+      @docs << DocEntry.link("View Trace", url)
+    end
+
+    def tag_otel_span
+      span = OpenTelemetry::Trace.current_span
+      return unless span && !span.recording?
+
+      span.set_attribute("story.scenario", @scenario)
+      span.set_attribute("story.tags", @tags.join(",")) if @tags && !@tags.empty?
+      return unless @tickets
+
+      span.set_attribute("story.tickets", @tickets.map(&:id).join(","))
+    end
+  end
+
+  module_function
+
+  def init(scenario, **opts)
+    Story.new(scenario, **opts)
+  end
+end

data/lib/executable_stories/types.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ExecutableStories
+  Ticket = Struct.new(:id, :url, keyword_init: true)
+
+  RawError = Struct.new(:message, :stack, keyword_init: true)
+
+  RawCIInfo = Struct.new(:name, :url, :build_number, keyword_init: true)
+
+  RawAttachment = Struct.new(
+    :name, :media_type, :path, :body, :encoding,
+    :charset, :file_name, :byte_length, :step_index, :step_id,
+    keyword_init: true
+  )
+
+  RawStepEvent = Struct.new(:index, :title, :status, :duration_ms, keyword_init: true)
+
+  StoryStep = Struct.new(
+    :id, :keyword, :text, :mode, :wrapped, :duration_ms, :docs,
+    keyword_init: true
+  )
+
+  StoryMeta = Struct.new(
+    :scenario, :steps, :tags, :tickets, :meta, :suite_path, :docs,
+    :source_order, :otel_spans,
+    keyword_init: true
+  )
+
+  RawTestCase = Struct.new(
+    :status, :external_id, :title, :title_path, :story, :source_file,
+    :source_line, :duration_ms, :error, :meta, :retry, :retries,
+    :attachments, :step_events, :start_time, :end_time,
+    keyword_init: true
+  )
+
+  RawRun = Struct.new(
+    :schema_version, :test_cases, :project_root, :started_at_ms,
+    :finished_at_ms, :package_version, :git_sha, :ci, :meta,
+    keyword_init: true
+  )
+
+  module_function
+
+  def step_to_h(step)
+    h = {
+      "keyword" => step.keyword,
+      "text" => step.text
+    }
+    h["id"] = step.id if step.id
+    h["mode"] = step.mode if step.mode
+    h["wrapped"] = step.wrapped if step.wrapped
+    h["durationMs"] = step.duration_ms if step.duration_ms
+    h["docs"] = step.docs.map { |d| d.is_a?(Hash) ? d : d.to_h } if step.docs && !step.docs.empty?
+    h
+  end
+
+  def meta_to_h(meta)
+    h = {
+      "scenario" => meta.scenario,
+      "steps" => meta.steps.map { |s| s.is_a?(StoryStep) ? step_to_h(s) : s }
+    }
+    h["tags"] = meta.tags if meta.tags && !meta.tags.empty?
+    h["tickets"] = meta.tickets.map { |t| t.is_a?(Ticket) ? ticket_to_h(t) : t } if meta.tickets && !meta.tickets.empty?
+    h["meta"] = meta.meta if meta.meta
+    h["suitePath"] = meta.suite_path if meta.suite_path
+    h["docs"] = meta.docs if meta.docs && !meta.docs.empty?
+    h["sourceOrder"] = meta.source_order unless meta.source_order.nil?
+    h["otelSpans"] = meta.otel_spans if meta.otel_spans
+    h
+  end
+
+  def ticket_to_h(ticket)
+    h = { "id" => ticket.id }
+    h["url"] = ticket.url if ticket.url
+    h
+  end
+
+  def error_to_h(error)
+    h = {}
+    h["message"] = error.message if error.message
+    h["stack"] = error.stack if error.stack
+    h
+  end
+
+  def attachment_to_h(att)
+    h = {
+      "name" => att.name,
+      "mediaType" => att.media_type
+    }
+    h["path"] = att.path if att.path
+    h["body"] = att.body if att.body
+    h["encoding"] = att.encoding if att.encoding
+    h["charset"] = att.charset if att.charset
+    h["fileName"] = att.file_name if att.file_name
+    h["byteLength"] = att.byte_length if att.byte_length
+    h["stepIndex"] = att.step_index unless att.step_index.nil?
+    h["stepId"] = att.step_id if att.step_id
+    h
+  end
+
+  def step_event_to_h(event)
+    h = {}
+    h["index"] = event.index unless event.index.nil?
+    h["title"] = event.title if event.title
+    h["status"] = event.status if event.status
+    h["durationMs"] = event.duration_ms if event.duration_ms
+    h
+  end
+
+  def test_case_to_h(tc)
+    h = { "status" => tc.status }
+    h["externalId"] = tc.external_id if tc.external_id
+    h["title"] = tc.title if tc.title
+    h["titlePath"] = tc.title_path if tc.title_path
+    h["story"] = meta_to_h(tc.story) if tc.story
+    h["sourceFile"] = tc.source_file if tc.source_file
+    h["sourceLine"] = tc.source_line if tc.source_line
+    h["durationMs"] = tc.duration_ms if tc.duration_ms
+    h["error"] = error_to_h(tc.error) if tc.error
+    h["meta"] = tc.meta if tc.meta
+    h["retry"] = tc.retry unless tc.retry.nil?
+    h["retries"] = tc.retries unless tc.retries.nil?
+    h["attachments"] = tc.attachments.map { |a| attachment_to_h(a) } if tc.attachments && !tc.attachments.empty?
+    h["stepEvents"] = tc.step_events.map { |e| step_event_to_h(e) } if tc.step_events && !tc.step_events.empty?
+    h
+  end
+
+  def ci_info_to_h(ci)
+    h = { "name" => ci.name }
+    h["url"] = ci.url if ci.url
+    h["buildNumber"] = ci.build_number if ci.build_number
+    h
+  end
+
+  def run_to_h(run)
+    h = {
+      "schemaVersion" => run.schema_version,
+      "testCases" => run.test_cases.map { |tc| test_case_to_h(tc) },
+      "projectRoot" => run.project_root
+    }
+    h["startedAtMs"] = run.started_at_ms unless run.started_at_ms.nil?
+    h["finishedAtMs"] = run.finished_at_ms unless run.finished_at_ms.nil?
+    h["packageVersion"] = run.package_version if run.package_version
+    h["gitSha"] = run.git_sha if run.git_sha
+    h["ci"] = ci_info_to_h(run.ci) if run.ci
+    h["meta"] = run.meta if run.meta
+    h
+  end
+end

data/lib/executable_stories.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "executable_stories/story"
+require_relative "executable_stories/doc_entry"
+require_relative "executable_stories/types"
+require_relative "executable_stories/collector"
+require_relative "executable_stories/json_writer"
+
+module ExecutableStories
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: executable-stories-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jag Reehal
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description: BDD story testing library for Ruby. Tests and documentation from the
+  same code.
+email:
+- jag@jagreehal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/executable_stories.rb
+- lib/executable_stories/collector.rb
+- lib/executable_stories/doc_entry.rb
+- lib/executable_stories/json_writer.rb
+- lib/executable_stories/minitest.rb
+- lib/executable_stories/story.rb
+- lib/executable_stories/types.rb
+homepage: https://github.com/jagreehal/executable-stories
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jagreehal/executable-stories
+  source_code_uri: https://github.com/jagreehal/executable-stories/tree/main/packages/executable-stories-ruby
+  changelog_uri: https://github.com/jagreehal/executable-stories/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Ruby-first story/given/when/then helpers for Minitest with doc generation.
+test_files: []