cucumber-messages-32.2.0/0000755000004100000410000000000015152054552015244 5ustar www-datawww-datacucumber-messages-32.2.0/lib/0000755000004100000410000000000015152054552016012 5ustar www-datawww-datacucumber-messages-32.2.0/lib/cucumber/0000755000004100000410000000000015152054552017617 5ustar www-datawww-datacucumber-messages-32.2.0/lib/cucumber/messages.rb0000644000004100000410000000075615152054552021763 0ustar www-datawww-data# frozen_string_literal: true require 'cucumber/messages/helpers/id_generator' require 'cucumber/messages/helpers/ndjson_to_message_enumerator' require 'cucumber/messages/helpers/test_step_result_comparator' require 'cucumber/messages/helpers/time_conversion' require 'cucumber/messages/message' Dir["#{File.dirname(__FILE__)}/messages/*.rb"].each { |file| require file } module Cucumber module Messages VERSION = File.read(File.expand_path('../../VERSION', __dir__)).strip end end cucumber-messages-32.2.0/lib/cucumber/messages/0000755000004100000410000000000015152054552021426 5ustar www-datawww-datacucumber-messages-32.2.0/lib/cucumber/messages/attachment_content_encoding.rb0000644000004100000410000000043515152054552027505 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class AttachmentContentEncoding IDENTITY = 'IDENTITY' BASE64 = 'BASE64' end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_run_hook_finished.rb0000644000004100000410000000264715152054552026520 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestRunHookFinished message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestRunHookFinished < Message ## # Identifier for the hook execution that has finished ## attr_reader :test_run_hook_started_id attr_reader :result attr_reader :timestamp def initialize( test_run_hook_started_id: '', result: TestStepResult.new, timestamp: Timestamp.new ) @test_run_hook_started_id = test_run_hook_started_id @result = result @timestamp = timestamp super() end ## # Returns a new TestRunHookFinished from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestRunHookFinished.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( test_run_hook_started_id: hash[:testRunHookStartedId], result: TestStepResult.from_h(hash[:result]), timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/group.rb0000644000004100000410000000237115152054552023112 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Group message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Group < Message ## # The nested capture groups of an argument. # Absent if the group has no nested capture groups. ## attr_reader :children attr_reader :start attr_reader :value def initialize( children: nil, start: nil, value: nil ) @children = children @start = start @value = value super() end ## # Returns a new Group from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Group.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( children: hash[:children]&.map { |item| Group.from_h(item) }, start: hash[:start], value: hash[:value] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_doc_string.rb0000644000004100000410000000207415152054552025440 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleDocString message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class PickleDocString < Message attr_reader :media_type attr_reader :content def initialize( media_type: nil, content: '' ) @media_type = media_type @content = content super() end ## # Returns a new PickleDocString from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleDocString.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( media_type: hash[:mediaType], content: hash[:content] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/source_reference.rb0000644000004100000410000000312215152054552025267 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the SourceReference message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Points to a [Source](#io.cucumber.messages.Source) identified by `uri` and a # [Location](#io.cucumber.messages.Location) within that file. ## class SourceReference < Message attr_reader :uri attr_reader :java_method attr_reader :java_stack_trace_element attr_reader :location def initialize( uri: nil, java_method: nil, java_stack_trace_element: nil, location: nil ) @uri = uri @java_method = java_method @java_stack_trace_element = java_stack_trace_element @location = location super() end ## # Returns a new SourceReference from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::SourceReference.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( uri: hash[:uri], java_method: JavaMethod.from_h(hash[:javaMethod]), java_stack_trace_element: JavaStackTraceElement.from_h(hash[:javaStackTraceElement]), location: Location.from_h(hash[:location]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_match_argument.rb0000644000004100000410000000335415152054552026011 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the StepMatchArgument message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Represents a single argument extracted from a step match and passed to a step definition. # This is used for the following purposes: # - Construct an argument to pass to a step definition (possibly through a parameter type transform) # - Highlight the matched parameter in rich formatters such as the HTML formatter # # This message closely matches the `Argument` class in the `cucumber-expressions` library. ## class StepMatchArgument < Message ## # Represents the outermost capture group of an argument. This message closely matches the # `Group` class in the `cucumber-expressions` library. ## attr_reader :group attr_reader :parameter_type_name def initialize( group: Group.new, parameter_type_name: nil ) @group = group @parameter_type_name = parameter_type_name super() end ## # Returns a new StepMatchArgument from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::StepMatchArgument.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( group: Group.from_h(hash[:group]), parameter_type_name: hash[:parameterTypeName] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/tag.rb0000644000004100000410000000245315152054552022532 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Tag message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A tag ## class Tag < Message ## # Location of the tag ## attr_reader :location ## # The name of the tag (including the leading `@`) ## attr_reader :name ## # Unique ID to be able to reference the Tag from PickleTag ## attr_reader :id def initialize( location: Location.new, name: '', id: '' ) @location = location @name = name @id = id super() end ## # Returns a new Tag from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Tag.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), name: hash[:name], id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/rule.rb0000644000004100000410000000334715152054552022731 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Rule message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Rule < Message ## # The location of the `Rule` keyword ## attr_reader :location ## # All the tags placed above the `Rule` keyword ## attr_reader :tags attr_reader :keyword attr_reader :name attr_reader :description attr_reader :children attr_reader :id def initialize( location: Location.new, tags: [], keyword: '', name: '', description: '', children: [], id: '' ) @location = location @tags = tags @keyword = keyword @name = name @description = description @children = children @id = id super() end ## # Returns a new Rule from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Rule.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), tags: hash[:tags]&.map { |item| Tag.from_h(item) }, keyword: hash[:keyword], name: hash[:name], description: hash[:description], children: hash[:children]&.map { |item| RuleChild.from_h(item) }, id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_step_started.rb0000644000004100000410000000245115152054552025515 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestStepStarted message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestStepStarted < Message attr_reader :test_case_started_id attr_reader :test_step_id attr_reader :timestamp def initialize( test_case_started_id: '', test_step_id: '', timestamp: Timestamp.new ) @test_case_started_id = test_case_started_id @test_step_id = test_step_id @timestamp = timestamp super() end ## # Returns a new TestStepStarted from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestStepStarted.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( test_case_started_id: hash[:testCaseStartedId], test_step_id: hash[:testStepId], timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/duration.rb0000644000004100000410000000256215152054552023605 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Duration message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # The structure is pretty close of the Timestamp one. For clarity, a second type # of message is used. ## class Duration < Message attr_reader :seconds ## # Non-negative fractions of a second at nanosecond resolution. Negative # second values with fractions must still have non-negative nanos values # that count forward in time. Must be from 0 to 999,999,999 # inclusive. ## attr_reader :nanos def initialize( seconds: 0, nanos: 0 ) @seconds = seconds @nanos = nanos super() end ## # Returns a new Duration from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Duration.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( seconds: hash[:seconds], nanos: hash[:nanos] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_run_started.rb0000644000004100000410000000206115152054552025343 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestRunStarted message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestRunStarted < Message attr_reader :timestamp attr_reader :id def initialize( timestamp: Timestamp.new, id: nil ) @timestamp = timestamp @id = id super() end ## # Returns a new TestRunStarted from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestRunStarted.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( timestamp: Timestamp.from_h(hash[:timestamp]), id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/java_stack_trace_element.rb0000644000004100000410000000235215152054552026752 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the JavaStackTraceElement message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class JavaStackTraceElement < Message attr_reader :class_name attr_reader :file_name attr_reader :method_name def initialize( class_name: '', file_name: '', method_name: '' ) @class_name = class_name @file_name = file_name @method_name = method_name super() end ## # Returns a new JavaStackTraceElement from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::JavaStackTraceElement.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( class_name: hash[:className], file_name: hash[:fileName], method_name: hash[:methodName] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_step_result_status.rb0000644000004100000410000000063615152054552026773 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class TestStepResultStatus UNKNOWN = 'UNKNOWN' PASSED = 'PASSED' SKIPPED = 'SKIPPED' PENDING = 'PENDING' UNDEFINED = 'UNDEFINED' AMBIGUOUS = 'AMBIGUOUS' FAILED = 'FAILED' end end end cucumber-messages-32.2.0/lib/cucumber/messages/table_row.rb0000644000004100000410000000244015152054552023731 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TableRow message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A row in a table ## class TableRow < Message ## # The location of the first cell in the row ## attr_reader :location ## # Cells in the row ## attr_reader :cells attr_reader :id def initialize( location: Location.new, cells: [], id: '' ) @location = location @cells = cells @id = id super() end ## # Returns a new TableRow from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TableRow.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), cells: hash[:cells]&.map { |item| TableCell.from_h(item) }, id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/parse_error.rb0000644000004100000410000000206415152054552024300 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the ParseError message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class ParseError < Message attr_reader :source attr_reader :message def initialize( source: SourceReference.new, message: '' ) @source = source @message = message super() end ## # Returns a new ParseError from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::ParseError.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( source: SourceReference.from_h(hash[:source]), message: hash[:message] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/snippet.rb0000644000004100000410000000271715152054552023444 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Snippet message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Snippet < Message ## # The programming language of the code. # # This must be formatted as an all lowercase identifier such that syntax highlighters like [Prism](https://prismjs.com/#supported-languages) or [Highlight.js](https://github.com/highlightjs/highlight.js/blob/main/SUPPORTED_LANGUAGES.md) can recognize it. # For example: `cpp`, `cs`, `go`, `java`, `javascript`, `php`, `python`, `ruby`, `scala`. ## attr_reader :language ## # A snippet of code ## attr_reader :code def initialize( language: '', code: '' ) @language = language @code = code super() end ## # Returns a new Snippet from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Snippet.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( language: hash[:language], code: hash[:code] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_run_hook_started.rb0000644000004100000410000000376415152054552026376 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestRunHookStarted message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestRunHookStarted < Message ## # Unique identifier for this hook execution ## attr_reader :id ## # Identifier for the test run that this hook execution belongs to ## attr_reader :test_run_started_id ## # Identifier for the hook that will be executed ## attr_reader :hook_id ## # An identifier for the worker process running this hook, if parallel workers are in use. The identifier will be unique per worker, but no particular format is defined - it could be an index, uuid, machine name etc - and as such should be assumed that it's not human readable. ## attr_reader :worker_id attr_reader :timestamp def initialize( id: '', test_run_started_id: '', hook_id: '', worker_id: nil, timestamp: Timestamp.new ) @id = id @test_run_started_id = test_run_started_id @hook_id = hook_id @worker_id = worker_id @timestamp = timestamp super() end ## # Returns a new TestRunHookStarted from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestRunHookStarted.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], test_run_started_id: hash[:testRunStartedId], hook_id: hash[:hookId], worker_id: hash[:workerId], timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/envelope.rb0000644000004100000410000001057215152054552023575 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Envelope message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Envelope < Message attr_reader :attachment attr_reader :external_attachment attr_reader :gherkin_document attr_reader :hook attr_reader :meta attr_reader :parameter_type attr_reader :parse_error attr_reader :pickle attr_reader :suggestion attr_reader :source attr_reader :step_definition attr_reader :test_case attr_reader :test_case_finished attr_reader :test_case_started attr_reader :test_run_finished attr_reader :test_run_started attr_reader :test_step_finished attr_reader :test_step_started attr_reader :test_run_hook_started attr_reader :test_run_hook_finished attr_reader :undefined_parameter_type def initialize( attachment: nil, external_attachment: nil, gherkin_document: nil, hook: nil, meta: nil, parameter_type: nil, parse_error: nil, pickle: nil, suggestion: nil, source: nil, step_definition: nil, test_case: nil, test_case_finished: nil, test_case_started: nil, test_run_finished: nil, test_run_started: nil, test_step_finished: nil, test_step_started: nil, test_run_hook_started: nil, test_run_hook_finished: nil, undefined_parameter_type: nil ) @attachment = attachment @external_attachment = external_attachment @gherkin_document = gherkin_document @hook = hook @meta = meta @parameter_type = parameter_type @parse_error = parse_error @pickle = pickle @suggestion = suggestion @source = source @step_definition = step_definition @test_case = test_case @test_case_finished = test_case_finished @test_case_started = test_case_started @test_run_finished = test_run_finished @test_run_started = test_run_started @test_step_finished = test_step_finished @test_step_started = test_step_started @test_run_hook_started = test_run_hook_started @test_run_hook_finished = test_run_hook_finished @undefined_parameter_type = undefined_parameter_type super() end ## # Returns a new Envelope from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Envelope.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( attachment: Attachment.from_h(hash[:attachment]), external_attachment: ExternalAttachment.from_h(hash[:externalAttachment]), gherkin_document: GherkinDocument.from_h(hash[:gherkinDocument]), hook: Hook.from_h(hash[:hook]), meta: Meta.from_h(hash[:meta]), parameter_type: ParameterType.from_h(hash[:parameterType]), parse_error: ParseError.from_h(hash[:parseError]), pickle: Pickle.from_h(hash[:pickle]), suggestion: Suggestion.from_h(hash[:suggestion]), source: Source.from_h(hash[:source]), step_definition: StepDefinition.from_h(hash[:stepDefinition]), test_case: TestCase.from_h(hash[:testCase]), test_case_finished: TestCaseFinished.from_h(hash[:testCaseFinished]), test_case_started: TestCaseStarted.from_h(hash[:testCaseStarted]), test_run_finished: TestRunFinished.from_h(hash[:testRunFinished]), test_run_started: TestRunStarted.from_h(hash[:testRunStarted]), test_step_finished: TestStepFinished.from_h(hash[:testStepFinished]), test_step_started: TestStepStarted.from_h(hash[:testStepStarted]), test_run_hook_started: TestRunHookStarted.from_h(hash[:testRunHookStarted]), test_run_hook_finished: TestRunHookFinished.from_h(hash[:testRunHookFinished]), undefined_parameter_type: UndefinedParameterType.from_h(hash[:undefinedParameterType]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_step.rb0000644000004100000410000000513215152054552023766 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestStep message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A `TestStep` is derived from either a `PickleStep` combined with a `StepDefinition`, or from a `Hook`. # # When derived from a PickleStep: # * For `UNDEFINED` steps `stepDefinitionIds` and `stepMatchArgumentsLists` will be empty. # * For `AMBIGUOUS` steps, there will be multiple entries in `stepDefinitionIds` and `stepMatchArgumentsLists`. The first entry in the stepMatchArgumentsLists holds the list of arguments for the first matching step definition, the second entry for the second, etc ## class TestStep < Message ## # Pointer to the `Hook` (if derived from a Hook) ## attr_reader :hook_id attr_reader :id ## # Pointer to the `PickleStep` (if derived from a `PickleStep`) ## attr_reader :pickle_step_id ## # Pointer to all the matching `StepDefinition`s (if derived from a `PickleStep`). # # Each element represents a matching step definition. ## attr_reader :step_definition_ids ## # A list of list of StepMatchArgument (if derived from a `PickleStep`). # # Each element represents the arguments for a matching step definition. ## attr_reader :step_match_arguments_lists def initialize( hook_id: nil, id: '', pickle_step_id: nil, step_definition_ids: nil, step_match_arguments_lists: nil ) @hook_id = hook_id @id = id @pickle_step_id = pickle_step_id @step_definition_ids = step_definition_ids @step_match_arguments_lists = step_match_arguments_lists super() end ## # Returns a new TestStep from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestStep.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( hook_id: hash[:hookId], id: hash[:id], pickle_step_id: hash[:pickleStepId], step_definition_ids: hash[:stepDefinitionIds], step_match_arguments_lists: hash[:stepMatchArgumentsLists]&.map { |item| StepMatchArgumentsList.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/java_method.rb0000644000004100000410000000240015152054552024230 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the JavaMethod message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class JavaMethod < Message attr_reader :class_name attr_reader :method_name attr_reader :method_parameter_types def initialize( class_name: '', method_name: '', method_parameter_types: [] ) @class_name = class_name @method_name = method_name @method_parameter_types = method_parameter_types super() end ## # Returns a new JavaMethod from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::JavaMethod.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( class_name: hash[:className], method_name: hash[:methodName], method_parameter_types: hash[:methodParameterTypes] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step.rb0000644000004100000410000000431415152054552022730 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Step message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A step ## class Step < Message ## # The location of the steps' `keyword` ## attr_reader :location ## # The actual keyword as it appeared in the source. ## attr_reader :keyword ## # The test phase signalled by the keyword: Context definition (Given), Action performance (When), Outcome assertion (Then). Other keywords signal Continuation (And and But) from a prior keyword. Please note that all translations which a dialect maps to multiple keywords (`*` is in this category for all dialects), map to 'Unknown'. ## attr_reader :keyword_type attr_reader :text attr_reader :doc_string attr_reader :data_table ## # Unique ID to be able to reference the Step from PickleStep ## attr_reader :id def initialize( location: Location.new, keyword: '', keyword_type: nil, text: '', doc_string: nil, data_table: nil, id: '' ) @location = location @keyword = keyword @keyword_type = keyword_type @text = text @doc_string = doc_string @data_table = data_table @id = id super() end ## # Returns a new Step from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Step.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), keyword: hash[:keyword], keyword_type: hash[:keywordType], text: hash[:text], doc_string: DocString.from_h(hash[:docString]), data_table: DataTable.from_h(hash[:dataTable]), id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_definition.rb0000644000004100000410000000241115152054552025134 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the StepDefinition message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class StepDefinition < Message attr_reader :id attr_reader :pattern attr_reader :source_reference def initialize( id: '', pattern: StepDefinitionPattern.new, source_reference: SourceReference.new ) @id = id @pattern = pattern @source_reference = source_reference super() end ## # Returns a new StepDefinition from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::StepDefinition.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], pattern: StepDefinitionPattern.from_h(hash[:pattern]), source_reference: SourceReference.from_h(hash[:sourceReference]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/feature.rb0000644000004100000410000000436115152054552023412 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Feature message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Feature < Message ## # The location of the `Feature` keyword ## attr_reader :location ## # All the tags placed above the `Feature` keyword ## attr_reader :tags ## # The [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) language code of the Gherkin document ## attr_reader :language ## # The text of the `Feature` keyword (in the language specified by `language`) ## attr_reader :keyword ## # The name of the feature (the text following the `keyword`) ## attr_reader :name ## # The line(s) underneath the line with the `keyword` that are used as description ## attr_reader :description ## # Zero or more children ## attr_reader :children def initialize( location: Location.new, tags: [], language: '', keyword: '', name: '', description: '', children: [] ) @location = location @tags = tags @language = language @keyword = keyword @name = name @description = description @children = children super() end ## # Returns a new Feature from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Feature.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), tags: hash[:tags]&.map { |item| Tag.from_h(item) }, language: hash[:language], keyword: hash[:keyword], name: hash[:name], description: hash[:description], children: hash[:children]&.map { |item| FeatureChild.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/examples.rb0000644000004100000410000000354015152054552023573 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Examples message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Examples < Message ## # The location of the `Examples` keyword ## attr_reader :location attr_reader :tags attr_reader :keyword attr_reader :name attr_reader :description attr_reader :table_header attr_reader :table_body attr_reader :id def initialize( location: Location.new, tags: [], keyword: '', name: '', description: '', table_header: nil, table_body: [], id: '' ) @location = location @tags = tags @keyword = keyword @name = name @description = description @table_header = table_header @table_body = table_body @id = id super() end ## # Returns a new Examples from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Examples.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), tags: hash[:tags]&.map { |item| Tag.from_h(item) }, keyword: hash[:keyword], name: hash[:name], description: hash[:description], table_header: TableRow.from_h(hash[:tableHeader]), table_body: hash[:tableBody]&.map { |item| TableRow.from_h(item) }, id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_case_finished.rb0000644000004100000410000000250315152054552025576 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestCaseFinished message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestCaseFinished < Message attr_reader :test_case_started_id attr_reader :timestamp attr_reader :will_be_retried def initialize( test_case_started_id: '', timestamp: Timestamp.new, will_be_retried: false ) @test_case_started_id = test_case_started_id @timestamp = timestamp @will_be_retried = will_be_retried super() end ## # Returns a new TestCaseFinished from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestCaseFinished.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( test_case_started_id: hash[:testCaseStartedId], timestamp: Timestamp.from_h(hash[:timestamp]), will_be_retried: hash[:willBeRetried] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/ci.rb0000644000004100000410000000270315152054552022350 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Ci message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # CI environment ## class Ci < Message ## # Name of the CI product, e.g. "Jenkins", "CircleCI" etc. ## attr_reader :name ## # Link to the build ## attr_reader :url ## # The build number. Some CI servers use non-numeric build numbers, which is why this is a string ## attr_reader :build_number attr_reader :git def initialize( name: '', url: nil, build_number: nil, git: nil ) @name = name @url = url @build_number = build_number @git = git super() end ## # Returns a new Ci from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Ci.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( name: hash[:name], url: hash[:url], build_number: hash[:buildNumber], git: Git.from_h(hash[:git]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_table.rb0000644000004100000410000000170115152054552024370 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleTable message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class PickleTable < Message attr_reader :rows def initialize( rows: [] ) @rows = rows super() end ## # Returns a new PickleTable from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleTable.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( rows: hash[:rows]&.map { |item| PickleTableRow.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/suggestion.rb0000644000004100000410000000275715152054552024155 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Suggestion message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A suggested fragment of code to implement an undefined step ## class Suggestion < Message ## # A unique id for this suggestion ## attr_reader :id ## # The ID of the `PickleStep` this `Suggestion` was created for. ## attr_reader :pickle_step_id ## # A collection of code snippets that could implement the undefined step ## attr_reader :snippets def initialize( id: '', pickle_step_id: '', snippets: [] ) @id = id @pickle_step_id = pickle_step_id @snippets = snippets super() end ## # Returns a new Suggestion from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Suggestion.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], pickle_step_id: hash[:pickleStepId], snippets: hash[:snippets]&.map { |item| Snippet.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/undefined_parameter_type.rb0000644000004100000410000000211515152054552027014 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the UndefinedParameterType message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class UndefinedParameterType < Message attr_reader :expression attr_reader :name def initialize( expression: '', name: '' ) @expression = expression @name = name super() end ## # Returns a new UndefinedParameterType from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::UndefinedParameterType.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( expression: hash[:expression], name: hash[:name] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_definition_pattern_type.rb0000644000004100000410000000051315152054552027733 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class StepDefinitionPatternType CUCUMBER_EXPRESSION = 'CUCUMBER_EXPRESSION' REGULAR_EXPRESSION = 'REGULAR_EXPRESSION' end end end cucumber-messages-32.2.0/lib/cucumber/messages/external_attachment.rb0000644000004100000410000000613215152054552026007 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the ExternalAttachment message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Represents an attachment that is stored externally rather than embedded in the message stream. # # This message type is used for large attachments (e.g., video files) that are already # on the filesystem and should not be loaded into memory. Instead of embedding the content, # only a URL reference is stored. # # A formatter or other consumer of messages may replace an Attachment with an ExternalAttachment if it makes sense to do so. ## class ExternalAttachment < Message ## # A URL where the attachment can be retrieved. This could be a file:// URL for # local filesystem paths, or an http(s):// URL for remote resources. ## attr_reader :url ## # The media type of the data. This can be any valid # [IANA Media Type](https://www.iana.org/assignments/media-types/media-types.xhtml) # as well as Cucumber-specific media types such as `text/x.cucumber.gherkin+plain` # and `text/x.cucumber.stacktrace+plain` ## attr_reader :media_type ## # The identifier of the test case attempt if the attachment was created during the execution of a test step ## attr_reader :test_case_started_id ## # The identifier of the test step if the attachment was created during the execution of a test step ## attr_reader :test_step_id ## # The identifier of the test run hook execution if the attachment was created during the execution of a test run hook ## attr_reader :test_run_hook_started_id ## # When the attachment was created ## attr_reader :timestamp def initialize( url: '', media_type: '', test_case_started_id: nil, test_step_id: nil, test_run_hook_started_id: nil, timestamp: nil ) @url = url @media_type = media_type @test_case_started_id = test_case_started_id @test_step_id = test_step_id @test_run_hook_started_id = test_run_hook_started_id @timestamp = timestamp super() end ## # Returns a new ExternalAttachment from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::ExternalAttachment.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( url: hash[:url], media_type: hash[:mediaType], test_case_started_id: hash[:testCaseStartedId], test_step_id: hash[:testStepId], test_run_hook_started_id: hash[:testRunHookStartedId], timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/source_media_type.rb0000644000004100000410000000056115152054552025455 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class SourceMediaType TEXT_X_CUCUMBER_GHERKIN_PLAIN = 'text/x.cucumber.gherkin+plain' TEXT_X_CUCUMBER_GHERKIN_MARKDOWN = 'text/x.cucumber.gherkin+markdown' end end end cucumber-messages-32.2.0/lib/cucumber/messages/location.rb0000644000004100000410000000205015152054552023560 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Location message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Points to a line and a column in a text file ## class Location < Message attr_reader :line attr_reader :column def initialize( line: 0, column: nil ) @line = line @column = column super() end ## # Returns a new Location from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Location.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( line: hash[:line], column: hash[:column] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_step_result.rb0000644000004100000410000000324015152054552025362 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestStepResult message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestStepResult < Message attr_reader :duration ## # An arbitrary bit of information that explains this result. If there was an exception, this should include a stringified representation of it including type, message and stack trace (the exact format will vary by platform). ## attr_reader :message attr_reader :status ## # Exception thrown while executing this step, if any. ## attr_reader :exception def initialize( duration: Duration.new, message: nil, status: TestStepResultStatus::UNKNOWN, exception: nil ) @duration = duration @message = message @status = status @exception = exception super() end ## # Returns a new TestStepResult from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestStepResult.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( duration: Duration.from_h(hash[:duration]), message: hash[:message], status: hash[:status], exception: Exception.from_h(hash[:exception]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_case_started.rb0000644000004100000410000000401115152054552025447 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestCaseStarted message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestCaseStarted < Message ## # The first attempt should have value 0, and for each retry the value # should increase by 1. ## attr_reader :attempt ## # Because a `TestCase` can be run multiple times (in case of a retry), # we use this field to group messages relating to the same attempt. ## attr_reader :id attr_reader :test_case_id ## # An identifier for the worker process running this test case, if test cases are being run in parallel. The identifier will be unique per worker, but no particular format is defined - it could be an index, uuid, machine name etc - and as such should be assumed that it's not human readable. ## attr_reader :worker_id attr_reader :timestamp def initialize( attempt: 0, id: '', test_case_id: '', worker_id: nil, timestamp: Timestamp.new ) @attempt = attempt @id = id @test_case_id = test_case_id @worker_id = worker_id @timestamp = timestamp super() end ## # Returns a new TestCaseStarted from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestCaseStarted.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( attempt: hash[:attempt], id: hash[:id], test_case_id: hash[:testCaseId], worker_id: hash[:workerId], timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_case.rb0000644000004100000410000000306315152054552023727 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestCase message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A `TestCase` contains a sequence of `TestStep`s. ## class TestCase < Message attr_reader :id ## # The ID of the `Pickle` this `TestCase` is derived from. ## attr_reader :pickle_id attr_reader :test_steps ## # Identifier for the test run that this test case belongs to ## attr_reader :test_run_started_id def initialize( id: '', pickle_id: '', test_steps: [], test_run_started_id: nil ) @id = id @pickle_id = pickle_id @test_steps = test_steps @test_run_started_id = test_run_started_id super() end ## # Returns a new TestCase from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestCase.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], pickle_id: hash[:pickleId], test_steps: hash[:testSteps]&.map { |item| TestStep.from_h(item) }, test_run_started_id: hash[:testRunStartedId] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/parameter_type.rb0000644000004100000410000000354515152054552025003 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the ParameterType message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class ParameterType < Message ## # The name is unique, so we don't need an id. ## attr_reader :name attr_reader :regular_expressions attr_reader :prefer_for_regular_expression_match attr_reader :use_for_snippets attr_reader :id attr_reader :source_reference def initialize( name: '', regular_expressions: [], prefer_for_regular_expression_match: false, use_for_snippets: false, id: '', source_reference: nil ) @name = name @regular_expressions = regular_expressions @prefer_for_regular_expression_match = prefer_for_regular_expression_match @use_for_snippets = use_for_snippets @id = id @source_reference = source_reference super() end ## # Returns a new ParameterType from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::ParameterType.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( name: hash[:name], regular_expressions: hash[:regularExpressions], prefer_for_regular_expression_match: hash[:preferForRegularExpressionMatch], use_for_snippets: hash[:useForSnippets], id: hash[:id], source_reference: SourceReference.from_h(hash[:sourceReference]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle.rb0000644000004100000410000000622215152054552023224 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Pickle message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A `Pickle` represents a template for a `TestCase`. It is typically derived # from another format, such as [GherkinDocument](#io.cucumber.messages.GherkinDocument). # In the future a `Pickle` may be derived from other formats such as Markdown or # Excel files. # # By making `Pickle` the main data structure Cucumber uses for execution, the # implementation of Cucumber itself becomes simpler, as it doesn't have to deal # with the complex structure of a [GherkinDocument](#io.cucumber.messages.GherkinDocument). # # Each `PickleStep` of a `Pickle` is matched with a `StepDefinition` to create a `TestCase` ## class Pickle < Message ## # A unique id for the pickle ## attr_reader :id ## # The uri of the source file ## attr_reader :uri ## # The location of this pickle in source file. A pickle constructed from `Examples` will point to the example row. ## attr_reader :location ## # The name of the pickle ## attr_reader :name ## # The language of the pickle ## attr_reader :language ## # One or more steps ## attr_reader :steps ## # One or more tags. If this pickle is constructed from a Gherkin document, # It includes inherited tags from the `Feature` as well. ## attr_reader :tags ## # Points to the AST node locations of the pickle. The last one represents the unique # id of the pickle. A pickle constructed from `Examples` will have the first # id originating from the `Scenario` AST node, and the second from the `TableRow` AST node. ## attr_reader :ast_node_ids def initialize( id: '', uri: '', location: nil, name: '', language: '', steps: [], tags: [], ast_node_ids: [] ) @id = id @uri = uri @location = location @name = name @language = language @steps = steps @tags = tags @ast_node_ids = ast_node_ids super() end ## # Returns a new Pickle from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Pickle.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], uri: hash[:uri], location: Location.from_h(hash[:location]), name: hash[:name], language: hash[:language], steps: hash[:steps]&.map { |item| PickleStep.from_h(item) }, tags: hash[:tags]&.map { |item| PickleTag.from_h(item) }, ast_node_ids: hash[:astNodeIds] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/helpers/0000755000004100000410000000000015152054552023070 5ustar www-datawww-datacucumber-messages-32.2.0/lib/cucumber/messages/helpers/test_step_result_comparator.rb0000644000004100000410000000106115152054552031252 0ustar www-datawww-data# frozen_string_literal: true module Cucumber module Messages module Helpers module TestStepResultComparator def test_step_result_rankings { TestStepResultStatus::UNKNOWN => 0, TestStepResultStatus::PASSED => 1, TestStepResultStatus::SKIPPED => 2, TestStepResultStatus::PENDING => 3, TestStepResultStatus::UNDEFINED => 4, TestStepResultStatus::AMBIGUOUS => 5, TestStepResultStatus::FAILED => 6 } end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/helpers/id_generator.rb0000644000004100000410000000016115152054552026055 0ustar www-datawww-data# frozen_string_literal: true require_relative 'id_generator/uuid' require_relative 'id_generator/incrementing' cucumber-messages-32.2.0/lib/cucumber/messages/helpers/time_conversion.rb0000644000004100000410000000066715152054552026631 0ustar www-datawww-data# frozen_string_literal: true module Cucumber module Messages module Helpers module TimeConversion NANOSECONDS_PER_SECOND = 1_000_000_000 def time_to_timestamp(time) Cucumber::Messages::Timestamp.new(seconds: time.to_i, nanos: time.nsec) end def timestamp_to_time(timestamp) Time.at(timestamp.seconds, timestamp.nanos, :nanosecond) end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/helpers/ndjson_to_message_enumerator.rb0000644000004100000410000000117415152054552031362 0ustar www-datawww-data# frozen_string_literal: true require 'cucumber/messages' module Cucumber module Messages module Helpers class NdjsonToMessageEnumerator < Enumerator def initialize(io) super() do |yielder| io.each_line do |line| next if line.strip.empty? message = extract_message(line) yielder.yield(message) end end end private def extract_message(json_line) Envelope.from_json(json_line) rescue StandardError raise "Not JSON: #{json_line.strip}" end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/helpers/id_generator/0000755000004100000410000000000015152054552025532 5ustar www-datawww-datacucumber-messages-32.2.0/lib/cucumber/messages/helpers/id_generator/uuid.rb0000644000004100000410000000040115152054552027020 0ustar www-datawww-data# frozen_string_literal: true require 'securerandom' module Cucumber module Messages module Helpers module IdGenerator class UUID def new_id SecureRandom.uuid end end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/helpers/id_generator/incrementing.rb0000644000004100000410000000050315152054552030537 0ustar www-datawww-data# frozen_string_literal: true module Cucumber module Messages module Helpers module IdGenerator class Incrementing def initialize @index = -1 end def new_id @index += 1 @index.to_s end end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_definition_pattern.rb0000644000004100000410000000213415152054552026673 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the StepDefinitionPattern message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class StepDefinitionPattern < Message attr_reader :source attr_reader :type def initialize( source: '', type: StepDefinitionPatternType::CUCUMBER_EXPRESSION ) @source = source @type = type super() end ## # Returns a new StepDefinitionPattern from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::StepDefinitionPattern.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( source: hash[:source], type: hash[:type] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_run_finished.rb0000644000004100000410000000377415152054552025502 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestRunFinished message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestRunFinished < Message ## # An informative message about the test run. Typically additional information about failure, but not necessarily. ## attr_reader :message ## # A test run is successful if all steps are either passed or skipped, all before/after hooks passed and no other exceptions where thrown. ## attr_reader :success ## # Timestamp when the TestRun is finished ## attr_reader :timestamp ## # Any exception thrown during the test run, if any. Does not include exceptions thrown while executing steps. ## attr_reader :exception attr_reader :test_run_started_id def initialize( message: nil, success: false, timestamp: Timestamp.new, exception: nil, test_run_started_id: nil ) @message = message @success = success @timestamp = timestamp @exception = exception @test_run_started_id = test_run_started_id super() end ## # Returns a new TestRunFinished from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestRunFinished.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( message: hash[:message], success: hash[:success], timestamp: Timestamp.from_h(hash[:timestamp]), exception: Exception.from_h(hash[:exception]), test_run_started_id: hash[:testRunStartedId] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/source.rb0000644000004100000410000000310215152054552023247 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Source message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A source file, typically a Gherkin document or Java/Ruby/JavaScript source code ## class Source < Message ## # The [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) # of the source, typically a file path relative to the root directory ## attr_reader :uri ## # The contents of the file ## attr_reader :data ## # The media type of the file. Can be used to specify custom types, such as # text/x.cucumber.gherkin+plain ## attr_reader :media_type def initialize( uri: '', data: '', media_type: SourceMediaType::TEXT_X_CUCUMBER_GHERKIN_PLAIN ) @uri = uri @data = data @media_type = media_type super() end ## # Returns a new Source from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Source.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( uri: hash[:uri], data: hash[:data], media_type: hash[:mediaType] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/meta.rb0000644000004100000410000000375715152054552022715 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Meta message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # This message contains meta information about the environment. Consumers can use # this for various purposes. ## class Meta < Message ## # The [SEMVER](https://semver.org/) version number of the protocol ## attr_reader :protocol_version ## # SpecFlow, Cucumber-JVM, Cucumber.js, Cucumber-Ruby, Behat etc. ## attr_reader :implementation ## # Java, Ruby, Node.js etc ## attr_reader :runtime ## # Windows, Linux, MacOS etc ## attr_reader :os ## # 386, arm, amd64 etc ## attr_reader :cpu attr_reader :ci def initialize( protocol_version: '', implementation: Product.new, runtime: Product.new, os: Product.new, cpu: Product.new, ci: nil ) @protocol_version = protocol_version @implementation = implementation @runtime = runtime @os = os @cpu = cpu @ci = ci super() end ## # Returns a new Meta from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Meta.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( protocol_version: hash[:protocolVersion], implementation: Product.from_h(hash[:implementation]), runtime: Product.from_h(hash[:runtime]), os: Product.from_h(hash[:os]), cpu: Product.from_h(hash[:cpu]), ci: Ci.from_h(hash[:ci]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/attachment.rb0000644000004100000410000001222415152054552024104 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Attachment message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Attachments (parse errors, execution errors, screenshots, links...) # # An attachment represents any kind of data associated with a line in a # [Source](#io.cucumber.messages.Source) file. It can be used for: # # * Syntax errors during parse time # * Screenshots captured and attached during execution # * Logs captured and attached during execution # # It is not to be used for runtime errors raised/thrown during execution. This # is captured in `TestResult`. ## class Attachment < Message ## # The body of the attachment. If `contentEncoding` is `IDENTITY`, the attachment # is simply the string. If it's `BASE64`, the string should be Base64 decoded to # obtain the attachment. ## attr_reader :body ## # Whether to interpret `body` "as-is" (IDENTITY) or if it needs to be Base64-decoded (BASE64). # # Content encoding is *not* determined by the media type, but rather by the type # of the object being attached: # # - string: IDENTITY # - byte array: BASE64 # - stream: BASE64 ## attr_reader :content_encoding ## # Suggested file name of the attachment. (Provided by the user as an argument to `attach`) ## attr_reader :file_name ## # The media type of the data. This can be any valid # [IANA Media Type](https://www.iana.org/assignments/media-types/media-types.xhtml) # as well as Cucumber-specific media types such as `text/x.cucumber.gherkin+plain` # and `text/x.cucumber.stacktrace+plain` ## attr_reader :media_type attr_reader :source ## # The identifier of the test case attempt if the attachment was created during the execution of a test step ## attr_reader :test_case_started_id ## # The identifier of the test step if the attachment was created during the execution of a test step ## attr_reader :test_step_id ## # A URL where the attachment can be retrieved. This field should not be set by Cucumber. # It should be set by a program that reads a message stream and does the following for # each Attachment message: # # - Writes the body (after base64 decoding if necessary) to a new file. # - Sets `body` and `contentEncoding` to `null` # - Writes out the new attachment message # # This will result in a smaller message stream, which can improve performance and # reduce bandwidth of message consumers. It also makes it easier to process and download attachments # separately from reports. # # Deprecated; use ExternalAttachment instead. ## attr_reader :url ## # Not used; implementers should instead populate `testRunHookStartedId` if an attachment was created during the execution of a test run hook ## attr_reader :test_run_started_id ## # The identifier of the test run hook execution if the attachment was created during the execution of a test run hook ## attr_reader :test_run_hook_started_id ## # When the attachment was created ## attr_reader :timestamp def initialize( body: '', content_encoding: AttachmentContentEncoding::IDENTITY, file_name: nil, media_type: '', source: nil, test_case_started_id: nil, test_step_id: nil, url: nil, test_run_started_id: nil, test_run_hook_started_id: nil, timestamp: nil ) @body = body @content_encoding = content_encoding @file_name = file_name @media_type = media_type @source = source @test_case_started_id = test_case_started_id @test_step_id = test_step_id @url = url @test_run_started_id = test_run_started_id @test_run_hook_started_id = test_run_hook_started_id @timestamp = timestamp super() end ## # Returns a new Attachment from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Attachment.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( body: hash[:body], content_encoding: hash[:contentEncoding], file_name: hash[:fileName], media_type: hash[:mediaType], source: Source.from_h(hash[:source]), test_case_started_id: hash[:testCaseStartedId], test_step_id: hash[:testStepId], url: hash[:url], test_run_started_id: hash[:testRunStartedId], test_run_hook_started_id: hash[:testRunHookStartedId], timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/feature_child.rb0000644000004100000410000000236115152054552024553 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the FeatureChild message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A child node of a `Feature` node ## class FeatureChild < Message attr_reader :rule attr_reader :background attr_reader :scenario def initialize( rule: nil, background: nil, scenario: nil ) @rule = rule @background = background @scenario = scenario super() end ## # Returns a new FeatureChild from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::FeatureChild.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( rule: Rule.from_h(hash[:rule]), background: Background.from_h(hash[:background]), scenario: Scenario.from_h(hash[:scenario]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_match_arguments_list.rb0000644000004100000410000000213115152054552027217 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the StepMatchArgumentsList message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class StepMatchArgumentsList < Message attr_reader :step_match_arguments def initialize( step_match_arguments: [] ) @step_match_arguments = step_match_arguments super() end ## # Returns a new StepMatchArgumentsList from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::StepMatchArgumentsList.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( step_match_arguments: hash[:stepMatchArguments]&.map { |item| StepMatchArgument.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/git.rb0000644000004100000410000000242315152054552022537 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Git message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Information about Git, provided by the Build/CI server as environment # variables. ## class Git < Message attr_reader :remote attr_reader :revision attr_reader :branch attr_reader :tag def initialize( remote: '', revision: '', branch: nil, tag: nil ) @remote = remote @revision = revision @branch = branch @tag = tag super() end ## # Returns a new Git from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Git.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( remote: hash[:remote], revision: hash[:revision], branch: hash[:branch], tag: hash[:tag] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_step_type.rb0000644000004100000410000000050415152054552025315 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class PickleStepType UNKNOWN = 'Unknown' CONTEXT = 'Context' ACTION = 'Action' OUTCOME = 'Outcome' end end end cucumber-messages-32.2.0/lib/cucumber/messages/hook_type.rb0000644000004100000410000000072615152054552023761 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class HookType BEFORE_TEST_RUN = 'BEFORE_TEST_RUN' AFTER_TEST_RUN = 'AFTER_TEST_RUN' BEFORE_TEST_CASE = 'BEFORE_TEST_CASE' AFTER_TEST_CASE = 'AFTER_TEST_CASE' BEFORE_TEST_STEP = 'BEFORE_TEST_STEP' AFTER_TEST_STEP = 'AFTER_TEST_STEP' end end end cucumber-messages-32.2.0/lib/cucumber/messages/doc_string.rb0000644000004100000410000000245115152054552024110 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the DocString message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class DocString < Message attr_reader :location attr_reader :media_type attr_reader :content attr_reader :delimiter def initialize( location: Location.new, media_type: nil, content: '', delimiter: '' ) @location = location @media_type = media_type @content = content @delimiter = delimiter super() end ## # Returns a new DocString from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::DocString.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), media_type: hash[:mediaType], content: hash[:content], delimiter: hash[:delimiter] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/test_step_finished.rb0000644000004100000410000000277015152054552025644 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TestStepFinished message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class TestStepFinished < Message attr_reader :test_case_started_id attr_reader :test_step_id attr_reader :test_step_result attr_reader :timestamp def initialize( test_case_started_id: '', test_step_id: '', test_step_result: TestStepResult.new, timestamp: Timestamp.new ) @test_case_started_id = test_case_started_id @test_step_id = test_step_id @test_step_result = test_step_result @timestamp = timestamp super() end ## # Returns a new TestStepFinished from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TestStepFinished.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( test_case_started_id: hash[:testCaseStartedId], test_step_id: hash[:testStepId], test_step_result: TestStepResult.from_h(hash[:testStepResult]), timestamp: Timestamp.from_h(hash[:timestamp]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_table_row.rb0000644000004100000410000000172715152054552025267 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleTableRow message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class PickleTableRow < Message attr_reader :cells def initialize( cells: [] ) @cells = cells super() end ## # Returns a new PickleTableRow from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleTableRow.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( cells: hash[:cells]&.map { |item| PickleTableCell.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/timestamp.rb0000644000004100000410000000266715152054552023771 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Timestamp message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Timestamp < Message ## # Represents seconds of UTC time since Unix epoch # 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to # 9999-12-31T23:59:59Z inclusive. ## attr_reader :seconds ## # Non-negative fractions of a second at nanosecond resolution. Negative # second values with fractions must still have non-negative nanos values # that count forward in time. Must be from 0 to 999,999,999 # inclusive. ## attr_reader :nanos def initialize( seconds: 0, nanos: 0 ) @seconds = seconds @nanos = nanos super() end ## # Returns a new Timestamp from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Timestamp.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( seconds: hash[:seconds], nanos: hash[:nanos] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/table_cell.rb0000644000004100000410000000224715152054552024046 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the TableCell message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A cell in a `TableRow` ## class TableCell < Message ## # The location of the cell ## attr_reader :location ## # The value of the cell ## attr_reader :value def initialize( location: Location.new, value: '' ) @location = location @value = value super() end ## # Returns a new TableCell from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::TableCell.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), value: hash[:value] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_step_argument.rb0000644000004100000410000000225215152054552026160 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleStepArgument message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # An optional argument ## class PickleStepArgument < Message attr_reader :doc_string attr_reader :data_table def initialize( doc_string: nil, data_table: nil ) @doc_string = doc_string @data_table = data_table super() end ## # Returns a new PickleStepArgument from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleStepArgument.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( doc_string: PickleDocString.from_h(hash[:docString]), data_table: PickleTable.from_h(hash[:dataTable]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/scenario.rb0000644000004100000410000000347415152054552023566 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Scenario message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Scenario < Message ## # The location of the `Scenario` keyword ## attr_reader :location attr_reader :tags attr_reader :keyword attr_reader :name attr_reader :description attr_reader :steps attr_reader :examples attr_reader :id def initialize( location: Location.new, tags: [], keyword: '', name: '', description: '', steps: [], examples: [], id: '' ) @location = location @tags = tags @keyword = keyword @name = name @description = description @steps = steps @examples = examples @id = id super() end ## # Returns a new Scenario from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Scenario.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), tags: hash[:tags]&.map { |item| Tag.from_h(item) }, keyword: hash[:keyword], name: hash[:name], description: hash[:description], steps: hash[:steps]&.map { |item| Step.from_h(item) }, examples: hash[:examples]&.map { |item| Examples.from_h(item) }, id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/data_table.rb0000644000004100000410000000210115152054552024025 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the DataTable message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class DataTable < Message attr_reader :location attr_reader :rows def initialize( location: Location.new, rows: [] ) @location = location @rows = rows super() end ## # Returns a new DataTable from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::DataTable.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), rows: hash[:rows]&.map { |item| TableRow.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_table_cell.rb0000644000004100000410000000165715152054552025401 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleTableCell message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class PickleTableCell < Message attr_reader :value def initialize( value: '' ) @value = value super() end ## # Returns a new PickleTableCell from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleTableCell.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( value: hash[:value] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/exception.rb0000644000004100000410000000301015152054552023743 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Exception message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A simplified representation of an exception ## class Exception < Message ## # The type of the exception that caused this result. E.g. "Error" or "org.opentest4j.AssertionFailedError" ## attr_reader :type ## # The message of exception that caused this result. E.g. expected: "a" but was: "b" ## attr_reader :message ## # The stringified stack trace of the exception that caused this result ## attr_reader :stack_trace def initialize( type: '', message: nil, stack_trace: nil ) @type = type @message = message @stack_trace = stack_trace super() end ## # Returns a new Exception from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Exception.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( type: hash[:type], message: hash[:message], stack_trace: hash[:stackTrace] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_step.rb0000644000004100000410000000356015152054552024261 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleStep message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # An executable step ## class PickleStep < Message attr_reader :argument ## # References the IDs of the source of the step. For Gherkin, this can be # the ID of a Step, and possibly also the ID of a TableRow ## attr_reader :ast_node_ids ## # A unique ID for the PickleStep ## attr_reader :id ## # The context in which the step was specified: context (Given), action (When) or outcome (Then). # # Note that the keywords `But` and `And` inherit their meaning from prior steps and the `*` 'keyword' doesn't have specific meaning (hence Unknown) ## attr_reader :type attr_reader :text def initialize( argument: nil, ast_node_ids: [], id: '', type: nil, text: '' ) @argument = argument @ast_node_ids = ast_node_ids @id = id @type = type @text = text super() end ## # Returns a new PickleStep from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleStep.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( argument: PickleStepArgument.from_h(hash[:argument]), ast_node_ids: hash[:astNodeIds], id: hash[:id], type: hash[:type], text: hash[:text] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/gherkin_document.rb0000644000004100000410000000352015152054552025300 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the GherkinDocument message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document. # Cucumber implementations should *not* depend on `GherkinDocument` or any of its # children for execution - use [Pickle](#io.cucumber.messages.Pickle) instead. # # The only consumers of `GherkinDocument` should only be formatters that produce # "rich" output, resembling the original Gherkin document. ## class GherkinDocument < Message ## # The [URI](https://en.wikipedia.org/wiki/Uniform_Resource_Identifier) # of the source, typically a file path relative to the root directory ## attr_reader :uri attr_reader :feature ## # All the comments in the Gherkin document ## attr_reader :comments def initialize( uri: nil, feature: nil, comments: [] ) @uri = uri @feature = feature @comments = comments super() end ## # Returns a new GherkinDocument from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::GherkinDocument.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( uri: hash[:uri], feature: Feature.from_h(hash[:feature]), comments: hash[:comments]&.map { |item| Comment.from_h(item) } ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/pickle_tag.rb0000644000004100000410000000215115152054552024054 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the PickleTag message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A tag ## class PickleTag < Message attr_reader :name ## # Points to the AST node this was created from ## attr_reader :ast_node_id def initialize( name: '', ast_node_id: '' ) @name = name @ast_node_id = ast_node_id super() end ## # Returns a new PickleTag from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::PickleTag.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( name: hash[:name], ast_node_id: hash[:astNodeId] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/product.rb0000644000004100000410000000220215152054552023427 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Product message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # Used to describe various properties of Meta ## class Product < Message ## # The product name ## attr_reader :name ## # The product version ## attr_reader :version def initialize( name: '', version: nil ) @name = name @version = version super() end ## # Returns a new Product from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Product.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( name: hash[:name], version: hash[:version] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/message.rb0000644000004100000410000001070415152054552023401 0ustar www-datawww-data# frozen_string_literal: true require 'json' module Cucumber module Messages class Message def self.camelize(term) camelized = term.to_s camelized.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" } end ## # Returns a new Message - or messages into an array - deserialized from the given json document. # CamelCased keys are properly converted to snake_cased attributes in the process # # Cucumber::Messages::Duration.from_json('{"seconds":1,"nanos":42}') # # => # # Cucumber::Messages::PickleTag.from_json('{"name":"foo","astNodeId":"abc-def"}') # # => # # # It is recursive so embedded messages are also processed. # # json_string = { location: { line: 2 }, text: "comment" }.to_json # Cucumber::Messages::Comment.from_json(json_string) # # => #, @text="comment"> # # json_string = { uri: 'file:///...', comments: [{text: 'text comment'}, {text: 'another comment'}]}.to_json # Cucumber::Messages::GherkinDocument.from_json(json_string) # # => # ## def self.from_json(json_string) from_h(JSON.parse(json_string, { symbolize_names: true })) end ## # Returns a new Hash formed from the message attributes # If +camelize:+ keyword parameter is set to true, then keys will be camelized # If +reject_nil_values:+ keyword parameter is set to true, resulting hash won't include nil values # # Cucumber::Messages::Duration.new(seconds: 1, nanos: 42).to_h # # => { seconds: 1, nanos: 42 } # Cucumber::Messages::PickleTag.new(name: 'foo', ast_node_id: 'abc-def').to_h(camelize: true) # # => { name: 'foo', astNodeId: 'abc-def' } # Cucumber::Messages::PickleTag.new(name: 'foo', ast_node_id: nil).to_h(reject_nil_values: true) # # => { name: 'foo' } # # It is recursive so embedded messages are also processed # # location = Cucumber::Messages::Location.new(line: 2) # Cucumber::Messages::Comment.new(location: location, text: 'comment').to_h # # => { location: { line: 2, :column: nil }, text: "comment" } ## def to_h(camelize: false, reject_nil_values: false) resulting_hash = instance_variables.to_h do |variable_name| h_key = variable_name[1..] h_key = Cucumber::Messages::Message.camelize(h_key) if camelize h_value = prepare_value(instance_variable_get(variable_name), camelize: camelize, reject_nil_values: reject_nil_values) [h_key.to_sym, h_value] end resulting_hash.tap { |hash| hash.compact! if reject_nil_values } end ## # Generates a JSON document from the message. # Keys are camelized during the process. Null values are not part of the json document. # # Cucumber::Messages::Duration.new(seconds: 1, nanos: 42).to_json # # => '{"seconds":1,"nanos":42}' # Cucumber::Messages::PickleTag.new(name: 'foo', ast_node_id: 'abc-def').to_json # # => '{"name":"foo","astNodeId":"abc-def"}' # Cucumber::Messages::PickleTag.new(name: 'foo', ast_node_id: nil).to_json # # => '{"name":"foo"}' # # As with #to_h, the method is recursive # # location = Cucumber::Messages::Location.new(line: 2) # Cucumber::Messages::Comment.new(location: location, text: 'comment').to_json # # => '{"location":{"line":2,"column":null},"text":"comment"}' ## def to_json(*_args) to_h(camelize: true, reject_nil_values: true).to_json end private def prepare_value(value, camelize:, reject_nil_values:) if value.is_a?(Cucumber::Messages::Message) value.to_h(camelize: camelize, reject_nil_values: reject_nil_values) elsif value.is_a?(Array) value.map { |element| prepare_value(element, camelize: camelize, reject_nil_values: reject_nil_values) } else value end end end end end cucumber-messages-32.2.0/lib/cucumber/messages/background.rb0000644000004100000410000000305715152054552024077 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Background message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Background < Message ## # The location of the `Background` keyword ## attr_reader :location attr_reader :keyword attr_reader :name attr_reader :description attr_reader :steps attr_reader :id def initialize( location: Location.new, keyword: '', name: '', description: '', steps: [], id: '' ) @location = location @keyword = keyword @name = name @description = description @steps = steps @id = id super() end ## # Returns a new Background from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Background.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), keyword: hash[:keyword], name: hash[:name], description: hash[:description], steps: hash[:steps]&.map { |item| Step.from_h(item) }, id: hash[:id] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/step_keyword_type.rb0000644000004100000410000000054715152054552025541 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages class StepKeywordType UNKNOWN = 'Unknown' CONTEXT = 'Context' ACTION = 'Action' OUTCOME = 'Outcome' CONJUNCTION = 'Conjunction' end end end cucumber-messages-32.2.0/lib/cucumber/messages/comment.rb0000644000004100000410000000224515152054552023420 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Comment message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A comment in a Gherkin document ## class Comment < Message ## # The location of the comment ## attr_reader :location ## # The text of the comment ## attr_reader :text def initialize( location: Location.new, text: '' ) @location = location @text = text super() end ## # Returns a new Comment from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Comment.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( location: Location.from_h(hash[:location]), text: hash[:text] ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/rule_child.rb0000644000004100000410000000216415152054552024070 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the RuleChild message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## # # A child node of a `Rule` node ## class RuleChild < Message attr_reader :background attr_reader :scenario def initialize( background: nil, scenario: nil ) @background = background @scenario = scenario super() end ## # Returns a new RuleChild from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::RuleChild.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( background: Background.from_h(hash[:background]), scenario: Scenario.from_h(hash[:scenario]) ) end end end end cucumber-messages-32.2.0/lib/cucumber/messages/hook.rb0000644000004100000410000000261015152054552022712 0ustar www-datawww-data# frozen_string_literal: true # The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/codegen/codegen.rb] module Cucumber module Messages ## # Represents the Hook message in Cucumber's {message protocol}[https://github.com/cucumber/messages]. ## ## class Hook < Message attr_reader :id attr_reader :name attr_reader :source_reference attr_reader :tag_expression attr_reader :type def initialize( id: '', name: nil, source_reference: SourceReference.new, tag_expression: nil, type: nil ) @id = id @name = name @source_reference = source_reference @tag_expression = tag_expression @type = type super() end ## # Returns a new Hook from the given hash. # If the hash keys are camelCased, they are properly assigned to the # corresponding snake_cased attributes. # # Cucumber::Messages::Hook.from_h(some_hash) # => # ## def self.from_h(hash) return nil if hash.nil? new( id: hash[:id], name: hash[:name], source_reference: SourceReference.from_h(hash[:sourceReference]), tag_expression: hash[:tagExpression], type: hash[:type] ) end end end end cucumber-messages-32.2.0/cucumber-messages.gemspec0000644000004100000410000001307515152054552022231 0ustar www-datawww-data######################################################### # This file has been automatically generated by gem2tgz # ######################################################### # -*- encoding: utf-8 -*- # stub: cucumber-messages 32.2.0 ruby lib Gem::Specification.new do |s| s.name = "cucumber-messages".freeze s.version = "32.2.0".freeze s.required_rubygems_version = Gem::Requirement.new(">= 3.2.8".freeze) if s.respond_to? :required_rubygems_version= s.metadata = { "bug_tracker_uri" => "https://github.com/cucumber/messages/issues", "changelog_uri" => "https://github.com/cucumber/messages/blob/main/CHANGELOG.md", "documentation_uri" => "https://www.rubydoc.info/github/cucumber/messages", "mailing_list_uri" => "https://groups.google.com/forum/#!forum/cukes", "source_code_uri" => "https://github.com/cucumber/messages" } if s.respond_to? :metadata= s.require_paths = ["lib".freeze] s.authors = ["Aslak Helles\u00F8y".freeze] s.date = "1980-01-02" s.description = "JSON schema-based messages for Cucumber's inter-process communication".freeze s.email = "cukes@googlegroups.com".freeze s.files = ["LICENSE".freeze, "README.md".freeze, "VERSION".freeze, "lib/cucumber/messages.rb".freeze, "lib/cucumber/messages/attachment.rb".freeze, "lib/cucumber/messages/attachment_content_encoding.rb".freeze, "lib/cucumber/messages/background.rb".freeze, "lib/cucumber/messages/ci.rb".freeze, "lib/cucumber/messages/comment.rb".freeze, "lib/cucumber/messages/data_table.rb".freeze, "lib/cucumber/messages/doc_string.rb".freeze, "lib/cucumber/messages/duration.rb".freeze, "lib/cucumber/messages/envelope.rb".freeze, "lib/cucumber/messages/examples.rb".freeze, "lib/cucumber/messages/exception.rb".freeze, "lib/cucumber/messages/external_attachment.rb".freeze, "lib/cucumber/messages/feature.rb".freeze, "lib/cucumber/messages/feature_child.rb".freeze, "lib/cucumber/messages/gherkin_document.rb".freeze, "lib/cucumber/messages/git.rb".freeze, "lib/cucumber/messages/group.rb".freeze, "lib/cucumber/messages/helpers/id_generator.rb".freeze, "lib/cucumber/messages/helpers/id_generator/incrementing.rb".freeze, "lib/cucumber/messages/helpers/id_generator/uuid.rb".freeze, "lib/cucumber/messages/helpers/ndjson_to_message_enumerator.rb".freeze, "lib/cucumber/messages/helpers/test_step_result_comparator.rb".freeze, "lib/cucumber/messages/helpers/time_conversion.rb".freeze, "lib/cucumber/messages/hook.rb".freeze, "lib/cucumber/messages/hook_type.rb".freeze, "lib/cucumber/messages/java_method.rb".freeze, "lib/cucumber/messages/java_stack_trace_element.rb".freeze, "lib/cucumber/messages/location.rb".freeze, "lib/cucumber/messages/message.rb".freeze, "lib/cucumber/messages/meta.rb".freeze, "lib/cucumber/messages/parameter_type.rb".freeze, "lib/cucumber/messages/parse_error.rb".freeze, "lib/cucumber/messages/pickle.rb".freeze, "lib/cucumber/messages/pickle_doc_string.rb".freeze, "lib/cucumber/messages/pickle_step.rb".freeze, "lib/cucumber/messages/pickle_step_argument.rb".freeze, "lib/cucumber/messages/pickle_step_type.rb".freeze, "lib/cucumber/messages/pickle_table.rb".freeze, "lib/cucumber/messages/pickle_table_cell.rb".freeze, "lib/cucumber/messages/pickle_table_row.rb".freeze, "lib/cucumber/messages/pickle_tag.rb".freeze, "lib/cucumber/messages/product.rb".freeze, "lib/cucumber/messages/rule.rb".freeze, "lib/cucumber/messages/rule_child.rb".freeze, "lib/cucumber/messages/scenario.rb".freeze, "lib/cucumber/messages/snippet.rb".freeze, "lib/cucumber/messages/source.rb".freeze, "lib/cucumber/messages/source_media_type.rb".freeze, "lib/cucumber/messages/source_reference.rb".freeze, "lib/cucumber/messages/step.rb".freeze, "lib/cucumber/messages/step_definition.rb".freeze, "lib/cucumber/messages/step_definition_pattern.rb".freeze, "lib/cucumber/messages/step_definition_pattern_type.rb".freeze, "lib/cucumber/messages/step_keyword_type.rb".freeze, "lib/cucumber/messages/step_match_argument.rb".freeze, "lib/cucumber/messages/step_match_arguments_list.rb".freeze, "lib/cucumber/messages/suggestion.rb".freeze, "lib/cucumber/messages/table_cell.rb".freeze, "lib/cucumber/messages/table_row.rb".freeze, "lib/cucumber/messages/tag.rb".freeze, "lib/cucumber/messages/test_case.rb".freeze, "lib/cucumber/messages/test_case_finished.rb".freeze, "lib/cucumber/messages/test_case_started.rb".freeze, "lib/cucumber/messages/test_run_finished.rb".freeze, "lib/cucumber/messages/test_run_hook_finished.rb".freeze, "lib/cucumber/messages/test_run_hook_started.rb".freeze, "lib/cucumber/messages/test_run_started.rb".freeze, "lib/cucumber/messages/test_step.rb".freeze, "lib/cucumber/messages/test_step_finished.rb".freeze, "lib/cucumber/messages/test_step_result.rb".freeze, "lib/cucumber/messages/test_step_result_status.rb".freeze, "lib/cucumber/messages/test_step_started.rb".freeze, "lib/cucumber/messages/timestamp.rb".freeze, "lib/cucumber/messages/undefined_parameter_type.rb".freeze] s.homepage = "https://github.com/cucumber/messages#readme".freeze s.licenses = ["MIT".freeze] s.rdoc_options = ["--charset=UTF-8".freeze] s.required_ruby_version = Gem::Requirement.new(">= 3.2".freeze) s.rubygems_version = "3.6.9".freeze s.summary = "cucumber-messages-32.2.0".freeze s.specification_version = 4 s.add_development_dependency(%q.freeze, ["~> 13.1".freeze]) s.add_development_dependency(%q.freeze, ["~> 3.13".freeze]) s.add_development_dependency(%q.freeze, ["~> 1.80.0".freeze]) s.add_development_dependency(%q.freeze, ["~> 1.24.0".freeze]) s.add_development_dependency(%q.freeze, ["~> 0.6.0".freeze]) s.add_development_dependency(%q.freeze, ["~> 3.7.0".freeze]) end cucumber-messages-32.2.0/LICENSE0000644000004100000410000000207615152054552016256 0ustar www-datawww-dataMIT License Copyright (c) 2018 Cucumber Ltd and contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. cucumber-messages-32.2.0/VERSION0000644000004100000410000000000715152054552016311 0ustar www-datawww-data32.2.0 cucumber-messages-32.2.0/README.md0000644000004100000410000000011415152054552016517 0ustar www-datawww-data# Cucumber Messages for Ruby (JSON schema) See main [README](../README.md)