yet-another-cucumber-tcl 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7702ff40bce2ca9b6d7b46f3295037a97a91af61b39d82091021b6bb67d49f78
+  data.tar.gz: 507b0fd3aff1588875256620fdffbee7ffffcdc12992a92fd81d53b0b16ce9d4
+SHA512:
+  metadata.gz: 8847973edb86c68d6a7f0339bfe738c424d4c58322ef962d20f2d602dfc21fab77c28a1025e937b7c775b233791f45e88adf2a033a2e1d55529cf62d715cebba
+  data.tar.gz: 69e9638942adc193fe00993023df4e631793b668c12cc16379b74095b13377b1803ca053e3fe10be4eee157c2d97f6caa0ff6be4520ea7be4d1e91485b288eb8

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rubocop.yml

@@ -0,0 +1,13 @@
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  NewCops: enable
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# to be removed if/when done
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# CHANGELOG
+
+All notable changes to this project will be documented in this file.
+
+This project adheres to [Semantic Versioning](http://semver.org).
+
+This document is formatted according to the principles of [Keep A CHANGELOG](http://keepachangelog.com).
+
+Please visit [cucumber/CONTRIBUTING.md](CONTRIBUTING.md) for more info on how to contribute to Cucumber.
+
+----
+## [0.0.9] - 2026-07-17
+
+### Added
+
+- Rubocop Linting
+- Rake tasks (clean, spec, cucumber, rubocop, build, install)

data/CONTRIBUTING.md

@@ -0,0 +1,6 @@
+## Running tests
+
+    bundle install
+    bundle exec rake
+
+This runs tests on both the Ruby and Tcl code.

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'aruba'
+  gem 'irb'
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop'
+  gem 'rubocop-rake'
+  gem 'rubocop-rspec'
+  gem 'yard'
+end

data/README.md

@@ -0,0 +1,120 @@
+# Cucumber Tcl
+
+Drive your Tcl code with Cucumber.
+
+## Dependencies
+
+You'll need the following:
+
+* tcl8.5 and dev libraries
+* ruby > 3.0.0 along with its dev libraries
+
+## How to use
+
+First, add the `cucumber-tcl` plugin to your Gemfile:
+
+    gem 'cucumber-tcl'
+
+Install it:
+
+    bundle install
+
+In a file in Cucumber's load path, like `features/support/env.rb`, add the following line:
+
+    require 'cucumber/tcl'
+
+You should now be able to start writing features, and implementing the step definitions in Tcl. These should be placed in `.tcl` files below the features directory. To create the step definitions, you're provided with `Given`, `When`, `Then` and `And` procs for you to call, for example:
+
+    Given {^I am a logged in user$} {
+      puts "I'm a logged in user
+    }
+
+    When {^I purchase a ticket$} {
+      puts "Purchase a ticket"
+    }
+
+    Then {^I receive confirmation of the purchase$} {
+      puts "Purchase confirmation"
+    }
+
+If your regular expression captures any matches, you should provide a list of variable names as the second parameter to any of these procedure calls. These will then be available to your script, for example:
+
+    Given {^I am logged in with username (\w+)$} {username} {
+      puts "Username is $username"
+    }
+
+    Given {^I buy (\d+) cucumbers for $(\d+)$} {quantity price} {
+      puts "$quantity cucumbers bought. Price was $price"
+    }
+
+You can use basic tables in your scenarios. The data from the table s made available to your step definition, via the last variable name you pass into the capture list. For example, if you had the following step in your feature:
+
+    Given I have added the following products to my shopping cart:
+      | apple  | £2.00 |
+      | orange | £3.00 |
+      | banana | £1.50 |
+
+I could write the step definition for the Given step as:
+
+    Given {^I have added the following products to my shopping cart:$} {table_data} {
+      puts "$table_data"
+    }
+
+The data in the table is provided as a list of lists, so in the above example, table data would look like:
+
+    {"apple" "£2.00"} {"orange" "£3.00"} {"banana" "£1.50"}
+
+meaning you can access each element using `lindex`, e.g.
+
+    puts [lindex [lindex $table_data 0] 0]
+    apple
+
+If your step definition captures a match in the step definition as well as has a table, the table variable will always be last, e.g.
+
+    When I buy the following items from Tesco:
+      | cabbage |
+      | potato  |
+      | onion   |
+
+and in your step definition, you might have
+
+    Given {^I buy the following items from (\w+):$} {store items} {
+      puts "I've been shopping at $store"
+      puts "The first item I bought was [lindex $items 0]"
+    }
+
+## Resetting state between scenarios
+
+Depending on how your test and/or application code is structured, there may be a chance of data persisting between scenarios, which could result in tests that pass or fail unexpectedly.  To eliminate the risk of this, Cucumber TCL will start a new TCL interpreter between every scenario by creating a new instance of the 'framework' object, meaning that the env.tcl file is loaded each time.  Whilst this will remove the data leakage risk, it may also cause your scenarios to run slowly if there is a lot of setup required for a scenario to run (eg, setting up fixture data, building a database or loading large amounts of data into memory).  To override the default behaviour of starting up a new interpreter, an environment variable can be passed into the 'cucumber' command enabling the sharing of the TCL interpreter via the 'framework' object:
+
+    cucumber SHARE_FRAMEWORK=1
+
+It's also possible to make the default behaviour of starting up a new interpreter explicit:
+
+    cucumber SHARE_FRAMEWORK=0
+
+When wrapping Cucumber around legacy Tcl code, you can speed up local development by sharing the framework object to avoid starting a new Tcl interpreter for every test. However, you should keep the default behavior in your CI build to prevent potential data leakage between tests.
+
+## Returning Test Step Results
+
+Cucumber knows different types of results defined in:
+
+    lib/cucumber/core/test/result.rb
+
+Passed, Failed are the most common test results, while Skipped, Pending and Undefined are "exceptions that can be raised in a step definition causing the step to have that result."
+
+To make a test step "Passed", use:
+
+    return -code ok
+
+in your tcl implementation. (tcl automatically returns that at the end of each step)
+
+To make a test step "Failed", raise an error:
+
+    error "The shopping cart is empty"
+
+To trigger the exceptions "Skipped", "Pending" or "Undefined", use these keywords as error message.
+
+    error "skipped"; # this test step shall appeared as "Skipped" (=blue in reports)
+    error "pending; # this test step shall appeared as "Pending" (= unimplemented)
+    error "undefined"; # this test step shall appeared as "Undefined"

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler'
+
+require 'bundler/gem_tasks'
+
+task default: %i[clean spec cucumber tcltest rubocop build install]
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:cucumber) do |t|
+  t.cucumber_opts = %w[--format pretty --publish-quiet]
+end
+
+desc 'runs tcl test'
+task :tcltest do
+  sh({ 'TEST' => '1' }, 'tclsh lib/cucumber/tcl/test/test_framework.tcl')
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new do |task|
+  task.fail_on_error = false
+end
+
+CLEAN.include %w[pkg/ tmp/]

data/cucumber-tcl.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/cucumber/tcl/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'yet-another-cucumber-tcl'
+  s.version     = Cucumber::Tcl::VERSION
+  s.authors     = ['Matt Wynne', 'Jon Owers', 'Barney Fisher']
+  s.description = 'TCL plugin for Cucumber'
+  s.summary     = "cucumber-tcl-#{s.version}"
+  s.email       = 'pedro.miranda@gmail.com'
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/p3t3ru5/yet-another-cucumber-ruby-tcl#'
+  s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 3.0.0'
+
+  s.add_dependency 'cucumber'
+  s.add_dependency 'yet-another-ruby-tcl', '~> 0.1.2'
+
+  # s.rubygems_version = ">= 1.6.1"
+  s.files            = `git ls-files`.split("\n").grep_v(/\.gitignore$/)
+  s.rdoc_options     = ['--charset=UTF-8']
+  s.require_path     = 'lib'
+  s.metadata['rubygems_mfa_required'] = 'true'
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --publish-quiet

data/features/data_tables.feature

@@ -0,0 +1,26 @@
+Feature: DataTables
+
+  Scenario: Match a step with a DataTable
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+        Given passing with a DataTable:
+          | a | b |
+          | c | d |
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^passing with a DataTable:$} {content} {
+        puts $content
+      }
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      {{a} {b}} {{c} {d}}
+      """

data/features/define_a_step.feature

@@ -0,0 +1,155 @@
+Feature: Define a step
+
+  Scenario: Define a passing step
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given passing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^passing$} {
+        puts "Hello world"
+      }
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Hello world
+      """
+
+  Scenario: Define a step with a parameter
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given passing 123
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^passing (\d+)$} {num} {
+        puts "Hello $num"
+      }
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Hello 123
+      """
+
+  Scenario: Define a feature with no steps file
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given undefined
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Feature: 
+
+        Scenario:         # features/test.feature:2
+          Given undefined # features/test.feature:3
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+
+  Scenario: Define a failing step
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given failing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^failing$} {
+        error "Failing Step"
+      }
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      Feature: 
+      
+        Scenario:       # features/test.feature:2
+          Given failing # features/test.feature:3
+            Failing Step
+                while executing
+            "error "Failing Step""
+                ("eval" body line 2)
+                invoked from within
+            "eval $existing_step_body" (Tcl::Error)
+            features/test.feature:3:in `failing'
+      
+      Failing Scenarios:
+      cucumber features/test.feature:2 # Scenario: 
+      
+      1 scenario (1 failed)
+      1 step (1 failed)
+      """
+
+  Scenario: Define a step that calls a failing proc
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given failing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^failing$} {
+        failing_proc
+      }
+      proc failing_proc {} {
+        error "Failing Step"
+      }
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      Feature: 
+      
+        Scenario:       # features/test.feature:2
+          Given failing # features/test.feature:3
+            Failing Step
+                while executing
+            "error "Failing Step""
+                (procedure "failing_proc" line 2)
+                invoked from within
+            "failing_proc"
+                ("eval" body line 2)
+                invoked from within
+            "eval $existing_step_body" (Tcl::Error)
+            features/test.feature:3:in `failing'
+      
+      Failing Scenarios:
+      cucumber features/test.feature:2 # Scenario: 
+      
+      1 scenario (1 failed)
+      1 step (1 failed)
+      """
+

data/features/doc_strings.feature

@@ -0,0 +1,27 @@
+Feature: DocStrings
+
+  Scenario: Match a step with a DocString
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+        Given passing with a DocString:
+          \"\"\"
+          DocString content
+          \"\"\"
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^passing with a DocString:$} {content} {
+        puts "Hello $content"
+      }
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Hello DocString content
+      """

data/features/file_sourcing.feature

@@ -0,0 +1,137 @@
+Feature: Sourcing tcl files
+
+  Scenario: Source files in the appropriate order (no command line options)
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given testing file sourcing
+      """
+    And a file named "features/step_definitions/steps_a.tcl" with:
+      """
+      puts "Sourced step_definitions/steps_a.tcl"
+      """
+    And a file named "features/step_definitions/steps_b.tcl" with:
+      """
+      puts "Sourced step_definitions/steps_b.tcl"
+      """
+    And a file named "features/support/db.tcl" with:
+      """
+      puts "Sourced support/db.tcl"
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/support/env.tcl" with:
+      """
+      puts "Sourced support/env.tcl"
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Sourced support/env.tcl
+      Sourced support/db.tcl
+      Sourced step_definitions/steps_a.tcl
+      Sourced step_definitions/steps_b.tcl
+      """
+
+  Scenario: Source files in the appropriate order (with command line options)
+    Given a file named "myfeatures/group one/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given testing file sourcing
+      """
+    And a file named "myfeatures/step definitions/steps.tcl" with:
+      """
+      puts "Sourced step definitions/steps.tcl"
+      """
+    And a file named "myfeatures/support/db.tcl" with:
+      """
+      puts "Sourced support/db.tcl"
+      """
+    And a file named "myfeatures/support/debug.tcl" with:
+      """
+      puts "Sourced support/debug.tcl"
+      """
+    And a file named "myfeatures/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "myfeatures/support/env.tcl" with:
+      """
+      puts "Sourced support/env.tcl"
+      """
+    When I run `cucumber 'myfeatures/group one/test.feature' --require myfeatures --exclude 'debug.*'`
+    Then it should pass with:
+      """
+      Sourced support/env.tcl
+      Sourced support/db.tcl
+      Sourced step definitions/steps.tcl
+      """
+
+  Scenario: Display stack trace when there is an error in a sourced file
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given testing file sourcing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/support/helper.tcl" with:
+      """
+      error "Fail sourcing"
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      Fail sourcing
+          while executing
+      "error "Fail sourcing""
+          (file "features/support/helper.tcl" line 1)
+          invoked from within
+      "source features/support/helper.tcl"
+          ("uplevel" body line 1)
+          invoked from within
+      "uplevel #0 [list source $file]" (Tcl::Error)
+      """
+
+  Scenario: Display stack trace with multiple levels
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given testing file sourcing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/support/helper.tcl" with:
+      """
+      proc test_proc args {
+        proc_doesnt_exist
+      }
+
+      test_proc
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      invalid command name "proc_doesnt_exist"
+          while executing
+      "proc_doesnt_exist"
+          (procedure "test_proc" line 2)
+          invoked from within
+      "test_proc"
+          (file "features/support/helper.tcl" line 5)
+          invoked from within
+      "source features/support/helper.tcl"
+          ("uplevel" body line 1)
+          invoked from within
+      "uplevel #0 [list source $file]" (Tcl::Error)
+      """

data/features/pending_step.feature

@@ -0,0 +1,39 @@
+Feature: A step that is still pending implementation
+
+  Calling `pending` from a Tcl step definition will fail that scenario as
+  pending.
+
+  Still to do:
+
+  - [pass a message back about why the step is pending](https://github.com/cucumber/cucumber-ruby-tcl/issues/24)
+  - [display the file:line where `pending` was called in backtrace](https://github.com/cucumber/cucumber-ruby-tcl/issues/25)
+
+  Scenario: A un-implemented step returns pending
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given pending
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      Given {^pending$} {
+        pending
+      }
+      """
+    When I run `cucumber -q`
+    Then it should pass with:
+      """
+      Feature: 
+
+        Scenario: 
+          Given pending
+
+      1 scenario (1 pending)
+      1 step (1 pending)
+      """
+