cucumber-messages 24.1.0 → 25.0.0

data/lib/cucumber/messages/message.rb

@@ -1,11 +1,99 @@
-require 'cucumber/messages/message/deserialization'
-require 'cucumber/messages/message/serialization'
+# frozen_string_literal: true
+
+require 'json'
 
 module Cucumber
   module Messages
     class Message
-      include Cucumber::Messages::Message::Deserialization
-      include Cucumber::Messages::Message::Serialization
+      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::Duration:0x00007efda134c290 @seconds=1, @nanos=42>
+      #   Cucumber::Messages::PickleTag.from_json('{"name":"foo","astNodeId":"abc-def"}')
+      #     # => #<Cucumber::Messages::PickleTag:0x00007efda138cdb8 @name="foo", @ast_node_id="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)
+      #     # => #<Cucumber::Messages::Comment:0x00007efda6abf888 @location=#<Cucumber::Messages::Location:0x00007efda6abf978 @line=2, @column=nil>, @text="comment">
+      #
+      #   json_string = { uri: 'file:///...', comments: [{text: 'text comment'}, {text: 'another comment'}]}.to_json
+      #   Cucumber::Messages::GherkinDocument.from_json(json_string)
+      #     # => #<Cucumber::Messages::GherkinDocument:0x00007efda11e6a90 ... @comments=[#<Cucumber::Messages::Comment:0x00007efda11e6e50 ...]>
+      ##
+      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

data/lib/cucumber/messages/meta.rb

@@ -0,0 +1,81 @@
+# 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 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) # => #<Cucumber::Messages::Meta:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/parameter_type.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 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) # => #<Cucumber::Messages::ParameterType:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/parse_error.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 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) # => #<Cucumber::Messages::ParseError:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          source: SourceReference.from_h(hash[:source]),
+          message: hash[:message]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/pickle.rb

@@ -0,0 +1,107 @@
+# 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 Pickle message in Cucumber's {message protocol}[https://github.com/cucumber/messages].
+    ##
+    #
+    # //// Pickles
+    #
+    # *
+    #  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 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: '',
+        name: '',
+        language: '',
+        steps: [],
+        tags: [],
+        ast_node_ids: []
+      )
+        @id = id
+        @uri = uri
+        @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) # => #<Cucumber::Messages::Pickle:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          id: hash[:id],
+          uri: hash[:uri],
+          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

data/lib/cucumber/messages/pickle_doc_string.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 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) # => #<Cucumber::Messages::PickleDocString:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          media_type: hash[:mediaType],
+          content: hash[:content]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/pickle_step.rb

@@ -0,0 +1,71 @@
+# 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 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) # => #<Cucumber::Messages::PickleStep:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/pickle_step_argument.rb

@@ -0,0 +1,43 @@
+# 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 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) # => #<Cucumber::Messages::PickleStepArgument:0x... ...>
+      ##
+      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

data/lib/cucumber/messages/pickle_step_type.rb

@@ -0,0 +1,13 @@
+# 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 PickleStepType
+      UNKNOWN = 'Unknown'
+      CONTEXT = 'Context'
+      ACTION = 'Action'
+      OUTCOME = 'Outcome'
+    end
+  end
+end

data/lib/cucumber/messages/pickle_table.rb

@@ -0,0 +1,36 @@
+# 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 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) # => #<Cucumber::Messages::PickleTable:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          rows: hash[:rows]&.map { |item| PickleTableRow.from_h(item) }
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/pickle_table_cell.rb

@@ -0,0 +1,36 @@
+# 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 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) # => #<Cucumber::Messages::PickleTableCell:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          value: hash[:value]
+        )
+      end
+    end
+  end
+end

data/lib/cucumber/messages/pickle_table_row.rb

@@ -0,0 +1,36 @@
+# 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 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) # => #<Cucumber::Messages::PickleTableRow:0x... ...>
+      ##
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        new(
+          cells: hash[:cells]&.map { |item| PickleTableCell.from_h(item) }
+        )
+      end
+    end
+  end
+end