cucumber-messages 15.0.0 → 17.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b8c6493c848e7008eeb7b4cf47736aa0978839bf927cd295d171835fcf53fb
-  data.tar.gz: 759922ce9c517d4162a06bf4951301ff6f51cb3ddf7082d104646c24ee26b747
+  metadata.gz: 8d0c5f3b224e9a7990db0315f80048238598fb3e28ff751e1d3f28a2a59cb492
+  data.tar.gz: bc63d1daa752d4d68c59dbcac28b2e04f36e8477a91013090bdf85ecb6e9a81a
 SHA512:
-  metadata.gz: 6c066bd29e7454712813907faefa2ab76f912ea1f41c09a1b5c03f7391575419571fefe868c518dc073ea6ee0a0abe56782f3f5b9e6dac42e423bc10a0218669
-  data.tar.gz: 4ef1edcb8235665fc06fee708188be45cf0322271fc789cbfb48a1e464d2776908381c945df58f7de5d2fa32f333455cb846f4f2047ac4ac07ce2b00679d8294
+  metadata.gz: 0bbe6bc4aed1f7ee18136c80f3c417e623fe336b7d1c71458f1fe167ba11d202fa7493423309636fe4df8c58c7e82beecc99a345054a1b71df511ae97970cf75
+  data.tar.gz: f6f418b641a8c71e58000c180b438698e9b60f3e8bc64a111170a43fd122eb50aa7fb8b3448e18c3a7e310ce6f72affc6a83e976831e8414aba74d1a8a039644

data/README.md

@@ -1,2 +1,2 @@
-# Cucumber Messages for Ruby (Protocol Buffers)
+# Cucumber Messages for Ruby (JSON schema)
 

data/VERSION

@@ -1 +1 @@
-15.0.0
+17.0.1

data/lib/cucumber/messages.deserializers.rb

@@ -0,0 +1,1180 @@
+require 'cucumber/messages.dtos'
+require 'json'
+
+# The code was auto-generated by {this script}[https://github.com/cucumber/common/blob/main/messages/jsonschema/scripts/codegen.rb]
+#
+
+module Cucumber
+  module Messages
+
+    class Attachment
+
+      ##
+      # 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?
+
+        self.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
+
+    class Duration
+
+      ##
+      # 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?
+
+        self.new(
+          seconds: hash[:seconds],
+          nanos: hash[:nanos],
+        )
+      end
+    end
+
+    class Envelope
+
+      ##
+      # 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?
+
+        self.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
+
+    class GherkinDocument
+
+      ##
+      # 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) # => #<Cucumber::Messages::GherkinDocument:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          uri: hash[:uri],
+          feature: Feature.from_h(hash[:feature]),
+          comments: hash[:comments]&.map { |item| Comment.from_h(item) },
+        )
+      end
+    end
+
+    class Background
+
+      ##
+      # 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?
+
+        self.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
+
+    class Comment
+
+      ##
+      # 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?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          text: hash[:text],
+        )
+      end
+    end
+
+    class DataTable
+
+      ##
+      # 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?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          rows: hash[:rows]&.map { |item| TableRow.from_h(item) },
+        )
+      end
+    end
+
+    class DocString
+
+      ##
+      # 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?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          media_type: hash[:mediaType],
+          content: hash[:content],
+          delimiter: hash[:delimiter],
+        )
+      end
+    end
+
+    class Examples
+
+      ##
+      # 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?
+
+        self.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
+
+    class Feature
+
+      ##
+      # 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) # => #<Cucumber::Messages::Feature:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class FeatureChild
+
+      ##
+      # 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) # => #<Cucumber::Messages::FeatureChild:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          rule: Rule.from_h(hash[:rule]),
+          background: Background.from_h(hash[:background]),
+          scenario: Scenario.from_h(hash[:scenario]),
+        )
+      end
+    end
+
+    class Rule
+
+      ##
+      # 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) # => #<Cucumber::Messages::Rule:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class RuleChild
+
+      ##
+      # 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) # => #<Cucumber::Messages::RuleChild:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          background: Background.from_h(hash[:background]),
+          scenario: Scenario.from_h(hash[:scenario]),
+        )
+      end
+    end
+
+    class Scenario
+
+      ##
+      # 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) # => #<Cucumber::Messages::Scenario:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class Step
+
+      ##
+      # 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) # => #<Cucumber::Messages::Step:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          keyword: hash[:keyword],
+          text: hash[:text],
+          doc_string: DocString.from_h(hash[:docString]),
+          data_table: DataTable.from_h(hash[:dataTable]),
+          id: hash[:id],
+        )
+      end
+    end
+
+    class TableCell
+
+      ##
+      # 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) # => #<Cucumber::Messages::TableCell:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          value: hash[:value],
+        )
+      end
+    end
+
+    class TableRow
+
+      ##
+      # 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) # => #<Cucumber::Messages::TableRow:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          cells: hash[:cells]&.map { |item| TableCell.from_h(item) },
+          id: hash[:id],
+        )
+      end
+    end
+
+    class Tag
+
+      ##
+      # 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) # => #<Cucumber::Messages::Tag:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          location: Location.from_h(hash[:location]),
+          name: hash[:name],
+          id: hash[:id],
+        )
+      end
+    end
+
+    class Hook
+
+      ##
+      # 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) # => #<Cucumber::Messages::Hook:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          id: hash[:id],
+          source_reference: SourceReference.from_h(hash[:sourceReference]),
+          tag_expression: hash[:tagExpression],
+        )
+      end
+    end
+
+    class Location
+
+      ##
+      # 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) # => #<Cucumber::Messages::Location:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          line: hash[:line],
+          column: hash[:column],
+        )
+      end
+    end
+
+    class Meta
+
+      ##
+      # 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?
+
+        self.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
+
+    class Ci
+
+      ##
+      # 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?
+
+        self.new(
+          name: hash[:name],
+          url: hash[:url],
+          build_number: hash[:buildNumber],
+          git: Git.from_h(hash[:git]),
+        )
+      end
+    end
+
+    class Git
+
+      ##
+      # 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) # => #<Cucumber::Messages::Git:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          remote: hash[:remote],
+          revision: hash[:revision],
+          branch: hash[:branch],
+          tag: hash[:tag],
+        )
+      end
+    end
+
+    class Product
+
+      ##
+      # 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) # => #<Cucumber::Messages::Product:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          name: hash[:name],
+          version: hash[:version],
+        )
+      end
+    end
+
+    class ParameterType
+
+      ##
+      # 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?
+
+        self.new(
+          name: hash[:name],
+          regular_expressions: hash[:regularExpressions],
+          prefer_for_regular_expression_match: hash[:preferForRegularExpressionMatch],
+          use_for_snippets: hash[:useForSnippets],
+          id: hash[:id],
+        )
+      end
+    end
+
+    class ParseError
+
+      ##
+      # 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?
+
+        self.new(
+          source: SourceReference.from_h(hash[:source]),
+          message: hash[:message],
+        )
+      end
+    end
+
+    class Pickle
+
+      ##
+      # 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?
+
+        self.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
+
+    class PickleDocString
+
+      ##
+      # 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?
+
+        self.new(
+          media_type: hash[:mediaType],
+          content: hash[:content],
+        )
+      end
+    end
+
+    class PickleStep
+
+      ##
+      # 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?
+
+        self.new(
+          argument: PickleStepArgument.from_h(hash[:argument]),
+          ast_node_ids: hash[:astNodeIds],
+          id: hash[:id],
+          text: hash[:text],
+        )
+      end
+    end
+
+    class PickleStepArgument
+
+      ##
+      # 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?
+
+        self.new(
+          doc_string: PickleDocString.from_h(hash[:docString]),
+          data_table: PickleTable.from_h(hash[:dataTable]),
+        )
+      end
+    end
+
+    class PickleTable
+
+      ##
+      # 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?
+
+        self.new(
+          rows: hash[:rows]&.map { |item| PickleTableRow.from_h(item) },
+        )
+      end
+    end
+
+    class PickleTableCell
+
+      ##
+      # 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?
+
+        self.new(
+          value: hash[:value],
+        )
+      end
+    end
+
+    class PickleTableRow
+
+      ##
+      # 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?
+
+        self.new(
+          cells: hash[:cells]&.map { |item| PickleTableCell.from_h(item) },
+        )
+      end
+    end
+
+    class PickleTag
+
+      ##
+      # 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) # => #<Cucumber::Messages::PickleTag:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          name: hash[:name],
+          ast_node_id: hash[:astNodeId],
+        )
+      end
+    end
+
+    class Source
+
+      ##
+      # 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) # => #<Cucumber::Messages::Source:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          uri: hash[:uri],
+          data: hash[:data],
+          media_type: hash[:mediaType],
+        )
+      end
+    end
+
+    class SourceReference
+
+      ##
+      # 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) # => #<Cucumber::Messages::SourceReference:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class JavaMethod
+
+      ##
+      # 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) # => #<Cucumber::Messages::JavaMethod:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          class_name: hash[:className],
+          method_name: hash[:methodName],
+          method_parameter_types: hash[:methodParameterTypes],
+        )
+      end
+    end
+
+    class JavaStackTraceElement
+
+      ##
+      # 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) # => #<Cucumber::Messages::JavaStackTraceElement:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          class_name: hash[:className],
+          file_name: hash[:fileName],
+          method_name: hash[:methodName],
+        )
+      end
+    end
+
+    class StepDefinition
+
+      ##
+      # 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) # => #<Cucumber::Messages::StepDefinition:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          id: hash[:id],
+          pattern: StepDefinitionPattern.from_h(hash[:pattern]),
+          source_reference: SourceReference.from_h(hash[:sourceReference]),
+        )
+      end
+    end
+
+    class StepDefinitionPattern
+
+      ##
+      # 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) # => #<Cucumber::Messages::StepDefinitionPattern:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          source: hash[:source],
+          type: hash[:type],
+        )
+      end
+    end
+
+    class TestCase
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestCase:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          id: hash[:id],
+          pickle_id: hash[:pickleId],
+          test_steps: hash[:testSteps]&.map { |item| TestStep.from_h(item) },
+        )
+      end
+    end
+
+    class Group
+
+      ##
+      # 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) # => #<Cucumber::Messages::Group:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          children: hash[:children]&.map { |item| Group.from_h(item) },
+          start: hash[:start],
+          value: hash[:value],
+        )
+      end
+    end
+
+    class StepMatchArgument
+
+      ##
+      # 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) # => #<Cucumber::Messages::StepMatchArgument:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          group: Group.from_h(hash[:group]),
+          parameter_type_name: hash[:parameterTypeName],
+        )
+      end
+    end
+
+    class StepMatchArgumentsList
+
+      ##
+      # 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) # => #<Cucumber::Messages::StepMatchArgumentsList:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          step_match_arguments: hash[:stepMatchArguments]&.map { |item| StepMatchArgument.from_h(item) },
+        )
+      end
+    end
+
+    class TestStep
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestStep:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class TestCaseFinished
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestCaseFinished:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          test_case_started_id: hash[:testCaseStartedId],
+          timestamp: Timestamp.from_h(hash[:timestamp]),
+          will_be_retried: hash[:willBeRetried],
+        )
+      end
+    end
+
+    class TestCaseStarted
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestCaseStarted:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          attempt: hash[:attempt],
+          id: hash[:id],
+          test_case_id: hash[:testCaseId],
+          timestamp: Timestamp.from_h(hash[:timestamp]),
+        )
+      end
+    end
+
+    class TestRunFinished
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestRunFinished:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          message: hash[:message],
+          success: hash[:success],
+          timestamp: Timestamp.from_h(hash[:timestamp]),
+        )
+      end
+    end
+
+    class TestRunStarted
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestRunStarted:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          timestamp: Timestamp.from_h(hash[:timestamp]),
+        )
+      end
+    end
+
+    class TestStepFinished
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestStepFinished:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.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
+
+    class TestStepResult
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestStepResult:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          duration: Duration.from_h(hash[:duration]),
+          message: hash[:message],
+          status: hash[:status],
+        )
+      end
+    end
+
+    class TestStepStarted
+
+      ##
+      # 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) # => #<Cucumber::Messages::TestStepStarted:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          test_case_started_id: hash[:testCaseStartedId],
+          test_step_id: hash[:testStepId],
+          timestamp: Timestamp.from_h(hash[:timestamp]),
+        )
+      end
+    end
+
+    class Timestamp
+
+      ##
+      # 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) # => #<Cucumber::Messages::Timestamp:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          seconds: hash[:seconds],
+          nanos: hash[:nanos],
+        )
+      end
+    end
+
+    class UndefinedParameterType
+
+      ##
+      # 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) # => #<Cucumber::Messages::UndefinedParameterType:0x... ...>
+      #
+
+      def self.from_h(hash)
+        return nil if hash.nil?
+
+        self.new(
+          expression: hash[:expression],
+          name: hash[:name],
+        )
+      end
+    end
+  end
+end