cucumber-messages 24.1.0 → 25.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6755e75e067d8b0f25a9923894792eae5f2cfed2fe7c190c31f7f613806c3e0c
-  data.tar.gz: 710073dda292664e50cbc47b07eb43595a94733895d0f97f525f885964787ab4
+  metadata.gz: 5503bb8b808557151373a4c743bb3c2505045ee76eb90ecb89024910a6716fa3
+  data.tar.gz: 85161d88c9aed19bb5079b65c19c64b0e095dd498d5c165f07f459e9a530bf5c
 SHA512:
-  metadata.gz: 79185a41d5bb609f905bcd5d82deda311655e700b5d4abc45e8bd3a301bd15d4e62dfb9ea88ef55adf8e962a90930238b34844cccff287f4581ee49eda3427bd
-  data.tar.gz: b0da332b0a5793e20509b51072ca81e4b12abfa901a8c1c2876e592f537db603c28194d422520b1a0c40c360d68ac7dd2f74e04b5534060bd1b2de20da56d7a8
+  metadata.gz: 3d44796653824c23b69f9b492a78991c265335ac245e4f919f89fa80bd30a9c3d695ab7b2c23a187378310c21497cbaad642c5678c8df5d2309afcd339a4794d
+  data.tar.gz: 5b5bfa76bec9f68083a8027ecd3124bf31604d8e1cb13c468fca8a334cd3466dc7793c97a23d4f34360ed3b367da5269cc179207fa610f43728606f19df6b3ec

data/VERSION

@@ -1 +1 @@
-24.1.0
+25.0.0

data/lib/cucumber/messages/attachment.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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
+
+      attr_reader :test_case_started_id
+
+      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.
+      ##
+      attr_reader :url
+
+      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
+      )
+        @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
+        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) # => #<Cucumber::Messages::Attachment:0x... ...>
+      ##
+      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]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/attachment_content_encoding.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/codegen.rb]
+module Cucumber
+  module Messages
+    class AttachmentContentEncoding
+      IDENTITY = 'IDENTITY'
+      BASE64 = 'BASE64'
+    end
+  end
+end

data/lib/cucumber/messages/background.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::Background:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/ci.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::Ci:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/comment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::Comment:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          location: Location.from_h(hash[:location]),
+          text: hash[:text]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/data_table.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::DataTable:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/doc_string.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::DocString:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/duration.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::Duration:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          seconds: hash[:seconds],
+          nanos: hash[:nanos]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/envelope.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/codegen.rb]
+module Cucumber
+  module Messages
+    ##
+    # Represents the Envelope message in Cucumber's {message protocol}[https://github.com/cucumber/messages].
+    ##
+    #
+    # When removing a field, replace it with reserved, rather than deleting the line.
+    #  When adding a field, add it to the end and increment the number by one.
+    #  See https://developers.google.com/protocol-buffers/docs/proto#updating for details
+    #
+    # *
+    #  All the messages that are passed between different components/processes are Envelope
+    #  messages.
+    ##
+    class Envelope < Message
+      attr_reader :attachment
+
+      attr_reader :gherkin_document
+
+      attr_reader :hook
+
+      attr_reader :meta
+
+      attr_reader :parameter_type
+
+      attr_reader :parse_error
+
+      attr_reader :pickle
+
+      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 :undefined_parameter_type
+
+      def initialize(
+        attachment: nil,
+        gherkin_document: nil,
+        hook: nil,
+        meta: nil,
+        parameter_type: nil,
+        parse_error: nil,
+        pickle: 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,
+        undefined_parameter_type: nil
+      )
+        @attachment = attachment
+        @gherkin_document = gherkin_document
+        @hook = hook
+        @meta = meta
+        @parameter_type = parameter_type
+        @parse_error = parse_error
+        @pickle = pickle
+        @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
+        @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) # => #<Cucumber::Messages::Envelope:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          attachment: Attachment.from_h(hash[:attachment]),
+          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]),
+          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]),
+          undefined_parameter_type: UndefinedParameterType.from_h(hash[:undefinedParameterType])
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/examples.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/messages/blob/main/jsonschema/scripts/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) # => #<Cucumber::Messages::Examples:0x... ...>
+      ##
+      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