cucumber-messages 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fae43985a14dd510cdad40de4e15f44d41a25d2cc5872eb8ce95b486995ddf9e
+  data.tar.gz: 3bd925db18e60f98b718ebd017e328dcc2938c8022b526bf4d3e057ae1ecb39a
+SHA512:
+  metadata.gz: 120be88738c8374cd69723b9e4b2a33664f8f802cf72af92a46b6dfef12c9520b85c0e853861102bad57948f5f019d7cff50e5565833e91b2a136e7f3ae7a30d
+  data.tar.gz: ba5ccba6194a142270aadb05e5db76728a1dc57f1fe1617fd25d593f069761b4da0c95b06030da83051b7e932d2bd2e1d3050a144c44dbae5fef5ada0a4fae4d

data/README.md

@@ -0,0 +1,3 @@
+# Cucumber Messages for Ruby (JSON schema)
+
+See main [README](../README.md)

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/cucumber/messages/id_generator.rb

@@ -0,0 +1,24 @@
+require 'securerandom'
+
+module Cucumber
+  module Messages
+    module IdGenerator
+      class Incrementing
+        def initialize
+          @index = -1
+        end
+
+        def new_id
+          @index += 1
+          @index.to_s
+        end
+      end
+
+      class UUID
+        def new_id
+          SecureRandom.uuid
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/messages/message/deserialization.rb

@@ -0,0 +1,37 @@
+require 'cucumber/messages/message/utils'
+require 'json'
+
+module Cucumber
+  module Messages
+    class Message
+      include Cucumber::Messages::Message::Utils
+
+      module Deserialization
+        def self.included(other)
+          other.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          ##
+          # 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 ..., #<Cucumber::Messages::Comment:0x00007efda11e6b58 ...>]>
+          ##
+          def from_json(json_string)
+            from_h(JSON.parse(json_string, { symbolize_names: true }))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/messages/message/serialization.rb

@@ -0,0 +1,70 @@
+require 'cucumber/messages/message/utils'
+require 'json'
+
+module Cucumber
+  module Messages
+    class Message
+      include Cucumber::Messages::Message::Utils
+
+      module Serialization
+        ##
+        # 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 = self.instance_variables.map do |variable_name|
+            h_key = variable_name[1..-1]
+            h_key = Cucumber::Messages::Message.camelize(h_key) if camelize
+
+            h_value = prepare_value(
+              self.instance_variable_get(variable_name),
+              camelize: camelize,
+              reject_nil_values: reject_nil_values
+            )
+
+            [ h_key.to_sym, h_value ]
+          end.to_h
+
+          resulting_hash.reject! { |_, value| value.nil? } if reject_nil_values
+          resulting_hash
+        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 #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
+          to_h(camelize: true, reject_nil_values: true).to_json
+        end
+
+        private
+
+        def prepare_value(value, camelize:, reject_nil_values:)
+          return value.to_h(camelize: camelize, reject_nil_values: reject_nil_values) if value.is_a?(Cucumber::Messages::Message)
+          return value.map { |v| prepare_value(v, camelize: camelize, reject_nil_values: reject_nil_values) } if value.is_a?(Array)
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/messages/message/utils.rb

@@ -0,0 +1,45 @@
+module Cucumber
+  module Messages
+    class Message
+      module Utils
+        def self.included(other)
+          other.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          ##
+          # Makes an underscored, lowercase form from the expression in the string.
+          #
+          #   underscore('GherkinDocument')         # => "gherkin_document"
+          #
+          # This is a simplified version of the Ruby on Rails implementation
+          # https://github.com/rails/rails/blob/v6.1.3.2/activesupport/lib/active_support/inflector/methods.rb#L92
+          ##
+          def underscore(term)
+            return term unless /[A-Z-]/.match?(term)
+
+            word = term.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+            word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+            word.tr!("-", "_")
+            word.downcase!
+            word
+          end
+
+          ##
+          # Converts strings to UpperCamelCase.
+          #
+          #   camelize('gherkin_document')                # => "GherkinDocument"
+          #
+          # This is a simplified version of the Ruby on Rails implementation
+          # https://github.com/rails/rails/blob/v6.1.3.2/activesupport/lib/active_support/inflector/methods.rb#L69
+          ##
+          def camelize(term)
+            camelized = term.to_s
+            camelized.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+            camelized
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/messages/message.rb

@@ -0,0 +1,11 @@
+require 'cucumber/messages/message/deserialization'
+require 'cucumber/messages/message/serialization'
+
+module Cucumber
+  module Messages
+    class Message
+      include Cucumber::Messages::Message::Deserialization
+      include Cucumber::Messages::Message::Serialization
+    end
+  end
+end

data/lib/cucumber/messages/ndjson_to_message_enumerator.rb

@@ -0,0 +1,21 @@
+require 'cucumber/messages.deserializers'
+
+module Cucumber
+  module Messages
+    class NdjsonToMessageEnumerator < Enumerator
+      def initialize(io)
+        super() do |yielder|
+          io.each_line do |line|
+            next if line.strip.empty?
+            begin
+              m = Envelope.from_json(line)
+            rescue => e
+              raise "Not JSON: #{line.strip}"
+            end
+            yielder.yield(m)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/messages/time_conversion.rb

@@ -0,0 +1,33 @@
+module Cucumber
+  module Messages
+    module TimeConversion
+      NANOSECONDS_PER_SECOND = 1000000000
+
+      def time_to_timestamp(time)
+        {
+          'seconds' => time.to_i,
+          'nanos' => time.nsec
+        }
+      end
+
+      def timestamp_to_time(timestamp)
+        Time.at(timestamp['seconds'] + timestamp['nanos'].to_f / NANOSECONDS_PER_SECOND)
+      end
+
+      def seconds_to_duration(seconds_float)
+        seconds, second_modulus = seconds_float.divmod(1)
+        nanos = second_modulus * NANOSECONDS_PER_SECOND
+        {
+          'seconds' => seconds,
+          'nanos' => nanos.to_i
+        }
+      end
+
+      def duration_to_seconds(duration)
+        seconds_part = duration['seconds']
+        nanos_part = duration['nanos'].to_f / NANOSECONDS_PER_SECOND
+        seconds_part + nanos_part
+      end
+    end
+  end
+end