cucumber-messages 15.0.0 → 17.0.1

data/lib/cucumber/messages.rb

@@ -1,17 +1,10 @@
-require 'cucumber/messages.pb'
-require 'cucumber/messages/binary_to_message_enumerator'
 require 'cucumber/messages/ndjson_to_message_enumerator'
-require 'cucumber/messages/protobuf_delimited'
-require 'cucumber/messages/protobuf_ndjson'
 require 'cucumber/messages/time_conversion'
 require 'cucumber/messages/id_generator'
-
-Cucumber::Messages::Envelope.include(Cucumber::Messages::WriteNdjson)
-Cucumber::Messages::Envelope.include(Cucumber::Messages::WriteDelimited)
-Cucumber::Messages::Envelope.extend(Cucumber::Messages::ParseDelimited)
+require 'cucumber/messages.deserializers'
 
 module Cucumber
   module Messages
     VERSION = File.read(File.expand_path("../../VERSION", __dir__)).strip
   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/message/deserialization.rb

@@ -0,0 +1,39 @@
+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,73 @@
+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,46 @@
+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/ndjson_to_message_enumerator.rb

@@ -1,4 +1,4 @@
-require 'cucumber/messages/varint'
+require 'cucumber/messages.deserializers'
 
 module Cucumber
   module Messages
@@ -8,7 +8,7 @@ module Cucumber
           io.each_line do |line|
             next if line.strip.empty?
             begin
-              m = Cucumber::Messages::Envelope.from_json(line)
+              m = Envelope.from_json(line)
             rescue => e
               raise "Not JSON: #{line.strip}"
             end

data/lib/cucumber/messages/time_conversion.rb

@@ -4,25 +4,28 @@ module Cucumber
       NANOSECONDS_PER_SECOND = 1000000000
 
       def time_to_timestamp(time)
-        Timestamp.new(
-          seconds: time.to_i,
-          nanos: time.nsec
-        )
+        {
+          'seconds' => time.to_i,
+          'nanos' => time.nsec
+        }
       end
 
       def timestamp_to_time(timestamp)
-        Time.at(timestamp.seconds + timestamp.nanos.to_f / NANOSECONDS_PER_SECOND)
+        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
-        Duration.new(seconds: seconds, nanos: nanos)
+        {
+          '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 = duration['seconds']
+        nanos_part = duration['nanos'].to_f / NANOSECONDS_PER_SECOND
         seconds_part + nanos_part
       end
     end

data/spec/cucumber/messages/acceptance_spec.rb

@@ -0,0 +1,27 @@
+require 'json'
+require 'cucumber/messages'
+
+module Cucumber
+  module Messages
+    describe 'messages acdeptance tests' do
+      # TODO: Remove '/minimal' from the glob
+      Dir["#{File.dirname(__FILE__)}/../../../../../compatibility-kit/javascript/features/**/*.ndjson"].each do |ndjson_file|
+        it "deserialises and serialises messages in #{ndjson_file}" do
+          File.open(ndjson_file, 'r:utf-8') do |io|
+            io.each_line do |json|
+              check(json)
+            end
+          end
+        end
+      end
+
+      def check(json)
+        hash = JSON.parse(json)
+        envelope = Envelope.from_json(json)
+        new_json = envelope.to_json
+        new_hash = JSON.parse(new_json)
+        expect(new_hash).to eq(hash)
+      end
+    end
+  end
+end

data/spec/cucumber/messages/message/deserialization_spec.rb

@@ -0,0 +1,30 @@
+require 'rspec'
+require 'cucumber/messages/message/dummy_messages'
+
+describe Cucumber::Messages::Message::Deserialization do
+  describe '#from_json' do
+    subject { Cucumber::Messages::Message.from_json(json_document) }
+
+    let(:json_document) { '' }
+
+    context 'with a valid JSON document' do
+      let(:json_document) { '{"simpleMessage":{"isString":"answer"}}' }
+
+      it 'deserialize the message using #from_h' do
+        allow(Cucumber::Messages::Message).to receive(:from_h)
+
+        subject
+
+        expect(Cucumber::Messages::Message)
+          .to have_received(:from_h)
+          .with({ simpleMessage: { isString: "answer" } })
+      end
+    end
+
+    context 'with an invalid JSON document' do
+      let(:json_document) { '{foo: bar}' }
+
+      it { expect { subject }.to raise_error(JSON::ParserError) }
+    end
+  end
+end

data/spec/cucumber/messages/message/dummy_messages.rb

@@ -0,0 +1,38 @@
+require 'cucumber/messages/message'
+
+module Cucumber::Messages
+  class SimpleMessage < Message
+    attr_reader :is_nil, :is_string, :is_array, :is_number
+
+    def initialize(is_nil: nil, is_string: '', is_array: [], is_number: 0)
+      @is_nil = is_nil
+      @is_string = is_string
+      @is_array = is_array
+      @is_number = is_number
+    end
+  end
+
+  class EnumMessage
+    ENUM = 'an enum'
+  end
+
+  class ComprehensiveMessage < Message
+    attr_reader :simple_message, :message_array, :is_enum
+
+    def initialize(
+      simple_message: SimpleMessage.new,
+      message_array: [SimpleMessage.new, SimpleMessage.new],
+      is_enum: EnumMessage::ENUM
+    )
+      @simple_message = simple_message
+      @message_array = message_array
+      @is_enum = is_enum
+    end
+
+    private
+
+    def self.message_array_from_h(hash)
+      SimpleMessage.from_h(hash)
+    end
+  end
+end

data/spec/cucumber/messages/message/serialization_spec.rb

@@ -0,0 +1,89 @@
+require 'rspec'
+require 'cucumber/messages/message/dummy_messages'
+
+describe Cucumber::Messages::Message::Serialization do
+  context 'with a simple message' do
+    describe '#to_h' do
+      subject { Cucumber::Messages::SimpleMessage.new.to_h }
+
+      it 'returns a Hash with all the attributes of the Message' do
+        expect(subject).to eq({ is_nil: nil, is_string: '', is_array: [], is_number: 0 })
+      end
+
+      context 'whith camelize: true' do
+        subject { Cucumber::Messages::SimpleMessage.new.to_h(camelize: true) }
+
+        it 'camelize the keys of the resulting hash' do
+          expect(subject).to eq({ isNil: nil, isString: '', isArray: [], isNumber: 0 })
+        end
+      end
+
+      context 'with reject_nil_values: true' do
+        subject { Cucumber::Messages::SimpleMessage.new.to_h(reject_nil_values: true) }
+
+        it 'rejects nil values from the resulting hash' do
+          expect(subject).to eq({ is_string: '', is_array: [], is_number: 0 })
+        end
+      end
+    end
+
+    describe '#to_json' do
+      subject { Cucumber::Messages::SimpleMessage.new.to_json }
+
+      it 'returns a JSON document with all the attributes of the Message except nil values' do
+        expect(subject).to eq({ isString: '', isArray: [], isNumber: 0 }.to_json)
+      end
+    end
+  end
+
+  context 'with a message which embeds other messages' do
+    describe '#to_h' do
+      subject { Cucumber::Messages::ComprehensiveMessage.new.to_h }
+
+      it 'includes hash representation of embedded messages' do
+        expect(subject[:simple_message]).to eq({ is_nil: nil, is_string: '', is_array: [], is_number: 0 })
+        expect(subject[:is_enum]).to eq 'an enum'
+      end
+
+      it 'includes hash representation of messages arrays' do
+        expect(subject[:message_array]).to eq([
+          { is_nil: nil, is_string: '', is_array: [], is_number: 0 },
+          { is_nil: nil, is_string: '', is_array: [], is_number: 0 }
+        ])
+      end
+
+      context 'whith camelize: true' do
+        subject { Cucumber::Messages::ComprehensiveMessage.new.to_h(camelize: true) }
+
+        it 'camelize the keys of the embedded messages resulting hashes' do
+          expect(subject[:simpleMessage]).to eq({ isNil: nil, isString: '', isArray: [], isNumber: 0 })
+        end
+
+        it 'camelize the keys of hashes for messages arrays' do
+          expect(subject[:messageArray]).to eq([
+            { isNil: nil, isString: '', isArray: [], isNumber: 0 },
+            { isNil: nil, isString: '', isArray: [], isNumber: 0 }
+          ])
+        end
+      end
+    end
+
+    describe '#to_json' do
+      subject { Cucumber::Messages::ComprehensiveMessage.new.to_json }
+
+      it 'returns a JSON document with embedded messages' do
+        expect(subject).to include({ isString: '', isArray: [], isNumber: 0}.to_json)
+        expect(subject).to include('"isEnum":"an enum"')
+      end
+
+      it 'returns a JSON document with messages arrays' do
+        expect(subject).to include(
+          [
+            { isString: '', isArray: [], isNumber: 0},
+            { isString: '', isArray: [], isNumber: 0}
+          ].to_json
+        )
+      end
+    end
+  end
+end

data/spec/cucumber/messages/message/utils_spec.rb

@@ -0,0 +1,30 @@
+require 'rspec'
+require 'cucumber/messages/message/utils'
+
+class DummyTestClass
+  include Cucumber::Messages::Message::Utils
+end
+
+describe Cucumber::Messages::Message::Utils do
+  subject { DummyTestClass }
+
+  describe '#underscore' do
+    it { expect(subject.underscore('test')).to eq 'test' }
+    it { expect(subject.underscore('testTest')).to eq 'test_test' }
+    it { expect(subject.underscore('')).to eq '' }
+    it { expect(subject.underscore('T')).to eq 't' }
+    it { expect(subject.underscore('test123test456Test')).to eq 'test123test456_test' }
+    it { expect(subject.underscore('test-test')).to eq 'test_test' }
+    it { expect(subject.underscore('TEST_Test')).to eq 'test_test' }
+    it { expect(subject.underscore('test-Test')).to eq 'test_test' }
+  end
+
+  describe '#camelize' do
+    it { expect(subject.camelize('test')).to eq 'test' }
+    it { expect(subject.camelize('test_test')).to eq 'testTest' }
+    it { expect(subject.camelize('Test_TeSt')).to eq 'TestTest' }
+    it { expect(subject.camelize('')).to eq '' }
+    it { expect(subject.camelize('test123test4_5_6_test')).to eq 'test123test456Test' }
+    it { expect(subject.camelize('test-test')).to eq 'test-test' }
+  end
+end