nats 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9001307af28148c669590f0964512c8ddc60cff4
-  data.tar.gz: 97ffb35dca621454dddcda8aad90d081b7d51520
+  metadata.gz: a79cc55bf741a649b4ee2ae245b57c15bbc65bd1
+  data.tar.gz: 2ab66dfaa047037ae06543de3e398154e0bd81f2
 SHA512:
-  metadata.gz: a2aaddd687461480f22bd596d60d1b28cf10af716d011d2531e9e7f31f6b5391c9e67f33f494378c8d39c7973ae426bce6e93227e8ce65ec30d3988d045f02f1
-  data.tar.gz: 446229594e7a0f4aa88aba27e5e3f12abe8adffdde363674a7e464ed541567ed81370ef939a25c77d455051407078fd6dce73f89d310bb5e0bd5637c7e2b5032
+  metadata.gz: 7bebf05b5735ee2c65de1ca58298ab5626f90ec31e2e743a7b90ac0d6a3243d379a04926c630aa6e8dd63ce133f5a6a1624448142ff762d5ad8e787e4afde43c
+  data.tar.gz: 9ab82b046d006ee3aab898577fb439568d142157ecaba641a12903fd8ed9c65022d850e10a02ebc50558486fa33a0cd1c98bfbed200a7cfc5bedee6132fe4b24

data/README.md

@@ -3,24 +3,20 @@
 A [Ruby](http://ruby-lang.org) client for the [NATS messaging system](https://nats.io).
 
 [![License MIT](https://img.shields.io/npm/l/express.svg)](http://opensource.org/licenses/MIT)
-[![Build Status](https://travis-ci.org/nats-io/ruby-nats.svg)](http://travis-ci.org/nats-io/ruby-nats) [![Gem Version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=rb&type=5&v=0.5.0)](https://rubygems.org/gems/nats/versions/0.5.0) [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/nats-io/ruby-nats)
+[![Build Status](https://travis-ci.org/nats-io/ruby-nats.svg)](http://travis-ci.org/nats-io/ruby-nats) [![Gem Version](https://d25lcipzij17d.cloudfront.net/badge.svg?id=rb&type=5&v=0.7.0)](https://rubygems.org/gems/nats/versions/0.7.0) [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/nats-io/ruby-nats)
 
 
 ## Supported Platforms
 
 This gem and the client are known to work on the following Ruby platforms:
 
-- MRI 1.9, 2.0, 2.1
+- MRI 1.9, 2.0, 2.1, 2.2, 2.3.0
 - JRuby 1.6.8 (experimental)
 
-Note: This installation installs a version of the NATS server written in Ruby that has been deprecated. Please utilize a supported server such as [gnatsd](https://github.com/apcera/gnatsd). nats-server will be removed in a future release.
-
 ## Getting Started
 
 ```bash
-[sudo] gem install nats
-== or ==
-[sudo] rake geminstall
+gem install nats
 
 nats-sub foo &
 nats-pub foo 'Hello World!'
@@ -79,11 +75,21 @@ NATS.subscribe(subject, :queue => 'job.workers') { |msg| puts "Received '#{msg}'
 ```
 
 ## Clustered Usage
+
 ```ruby
-NATS.start(:servers => ['nats://127.0.0.1:4222', 'nats://127.0.0.1:4223'] do |c|
-  puts "NATS is connected to #{c.connected_server}"
-  c.on_reconnect do
-    puts "Reconnected to server at #{c.connected_server}"
+NATS.start(:servers => ['nats://127.0.0.1:4222', 'nats://127.0.0.1:4223']) do |nc|
+  puts "NATS is connected to #{nc.connected_server}"
+
+  nc.on_reconnect do
+    puts "Reconnected to server at #{nc.connected_server}"
+  end
+
+  nc.on_disconnect do |reason|
+    puts "Disconnected: #{reason}"
+  end
+
+  nc.on_close do
+    puts "Connection to NATS closed"
   end
 end
 
@@ -101,6 +107,7 @@ end
 ```
 
 ## Advanced Usage
+
 ```ruby
 # Publish with closure, callback fires when server has processed the message
 NATS.publish('foo', 'You done?') { puts 'msg processed!' }
@@ -117,21 +124,74 @@ NATS.unsubscribe(sid, MAX_WANTED)
 
 # Multiple connections
 NATS.subscribe('test') do |msg|
-    puts "received msg"
-    NATS.stop
+  puts "received msg"
+  NATS.stop
 end
 
 # Form second connection to send message on
 NATS.connect { NATS.publish('test', 'Hello World!') }
 ```
 
+### TLS
+
+Advanced customizations options for setting up a secure connection can be done by including them on connect:
+
+```ruby
+options = {
+  :servers => [
+   'nats://secret:deadbeef@127.0.0.1:4443',
+   'nats://secret:deadbeef@127.0.0.1:4444'
+  ],
+  :max_reconnect_attempts => 10,
+  :reconnect_time_wait => 2,
+  :tls => {
+    :private_key_file => './spec/configs/certs/key.pem',
+    :cert_chain_file  => './spec/configs/certs/server.pem'
+    # Can enable verify_peer functionality optionally by passing
+    # the location of a ca_file.
+    # :verify_peer => true,
+    # :ca_file => './spec/configs/certs/ca.pem'
+  }
+}
+
+# Set default callbacks
+NATS.on_error do |e|
+  puts "Error: #{e}"
+end
+
+NATS.on_disconnect do |reason|
+  puts "Disconnected: #{reason}"
+end
+
+NATS.on_reconnect do |nats|
+  puts "Reconnected to NATS server at #{nats.connected_server}"
+end
+
+NATS.on_close do
+  puts "Connection to NATS closed"
+  EM.stop
+end
+
+NATS.start(options) do |nats|
+  puts "Connected to NATS at #{nats.connected_server}"
+
+  nats.subscribe("hello") do |msg|
+    puts "Received: #{msg}"
+  end
+
+  nats.flush do
+    nats.publish("hello", "world")
+  end
+end
+```
+
 See examples and benchmarks for more information..
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010-2015 Derek Collison
+Copyright (c) 2010-2016 Derek Collison
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/lib/nats/client.rb

@@ -58,7 +58,7 @@ module NATS
   # When the NATS server sends us an ERROR message, this is raised/passed by default
   class ServerError < Error; end #:nodoc:
 
-  # When we detect error on the client side (e.g. Fast Producer)
+  # When we detect error on the client side (e.g. Fast Producer, TLS required)
   class ClientError < Error; end #:nodoc:
 
   # When we cannot connect to the server (either initially or after a reconnect), this is raised/passed
@@ -69,8 +69,7 @@ module NATS
 
   class << self
     attr_reader   :client, :reactor_was_running, :err_cb, :err_cb_overridden #:nodoc:
-    attr_reader   :reconnect_cb  #:nodoc
-    attr_accessor :timeout_cb #:nodoc
+    attr_reader   :reconnect_cb, :close_cb, :disconnect_cb  #:nodoc
 
     alias :reactor_was_running? :reactor_was_running
 
@@ -84,6 +83,7 @@ module NATS
     # @option opts [Boolean] :verbose Boolean that is sent to server for setting verbose protocol mode.
     # @option opts [Boolean] :pedantic Boolean that is sent to server for setting pedantic mode.
     # @option opts [Boolean] :ssl Boolean that is sent to server for setting TLS/SSL mode.
+    # @option opts [Hash]    :tls Map of options for configuring secure connection handled to EM#start_tls directly.
     # @option opts [Integer] :max_reconnect_attempts Integer that can be used to set the max number of reconnect tries
     # @option opts [Integer] :reconnect_time_wait Integer that can be used to set the number of seconds to wait between reconnect tries
     # @option opts [Integer] :ping_interval Integer that can be used to set the ping interval in seconds.
@@ -117,6 +117,32 @@ module NATS
 
       uri = opts[:uris] || opts[:servers] || opts[:uri]
 
+      if opts[:tls]
+        case
+        when opts[:tls][:ca_file]
+          # Ensure that the file exists before going further
+          # in order to report configuration errors during
+          # connect synchronously.
+          if !File.readable?(opts[:tls][:ca_file])
+            raise(Error, "TLS Verification is enabled but ca_file %s is not readable" % opts[:tls][:ca_file])
+          end
+
+          # Certificate is supplied so assume we mean verification by default,
+          # but still allow disabling explicitly by setting to false.
+          opts[:tls][:verify_peer] ||= true
+        when (opts[:tls][:verify_peer] && !opts[:tls][:ca_file])
+          raise(Error, "TLS Verification is enabled but ca_file is not set")
+        else
+          # Otherwise, disable verifying peer by default,
+          # thus never reaching EM#ssl_verify_peer
+          opts[:tls][:verify_peer] = false
+        end
+
+        # Allow overriding directly but default to those which server supports.
+        opts[:tls][:ssl_version] ||= %w(tlsv1 tlsv1_1 tlsv1_2)
+        opts[:tls][:protocols]   ||= %w(tlsv1 tlsv1_1 tlsv1_2)
+      end
+
       # If they pass an array here just pass along to the real connection, and use first as the first attempt..
       # Real connection will do proper walk throughs etc..
       unless uri.nil?
@@ -127,6 +153,8 @@ module NATS
       end
 
       @err_cb = proc { |e| raise e } unless err_cb
+      @close_cb = proc { } unless close_cb
+      @disconnect_cb = proc { } unless disconnect_cb
 
       client = EM.connect(@uri.host, @uri.port, self, opts)
       client.on_connect(&blk) if blk
@@ -157,6 +185,9 @@ module NATS
       client.close if (client and (client.connected? || client.reconnecting?))
       blk.call if blk
       @err_cb = nil
+      @close_cb = nil
+      @reconnect_cb = nil
+      @disconnect_cb = nil
     end
 
     # @return [URI] Connected server
@@ -202,6 +233,20 @@ module NATS
       @client.on_reconnect(&callback) unless @client.nil?
     end
 
+    # Set the default on_disconnect callback.
+    # @param [Block] &callback called whenever client disconnects from a server.
+    def on_disconnect(&callback)
+      @disconnect_cb = callback
+      @client.on_disconnect(&callback) unless @client.nil?
+    end
+
+    # Set the default on_closed callback.
+    # @param [Block] &callback called when will reach a state when will no longer be connected. 
+    def on_close(&callback)
+      @close_cb = callback
+      @client.on_close(&callback) unless @client.nil?
+    end
+
     # Publish a message using the default client connection.
     # @see NATS#publish
     def publish(*args, &blk)
@@ -282,6 +327,7 @@ module NATS
   attr_reader :connected, :connect_cb, :err_cb, :err_cb_overridden, :pongs_received #:nodoc:
   attr_reader :closing, :reconnecting, :server_pool, :options, :server_info #:nodoc
   attr_reader :msgs_received, :msgs_sent, :bytes_received, :bytes_sent, :pings
+  attr_reader :disconnect_cb, :close_cb
 
   alias :connected? :connected
   alias :closing? :closing
@@ -290,16 +336,26 @@ module NATS
   def initialize(options)
     @options = options
     process_uri_options
-    @ssl = false
-    @ssl = options[:ssl] if options[:ssl]
+
     @buf = nil
     @ssid, @subs = 1, {}
     @err_cb = NATS.err_cb
-    @reconnect_timer, @needed = nil, nil
+    @close_cb = NATS.close_cb
     @reconnect_cb = NATS.reconnect_cb
+    @disconnect_cb = NATS.disconnect_cb
+    @reconnect_timer, @needed = nil, nil
     @connected, @closing, @reconnecting, @conn_cb_called = false, false, false, false
     @msgs_received = @msgs_sent = @bytes_received = @bytes_sent = @pings = 0
     @pending_size = 0
+    @server_info = { }
+
+    # Mark whether we should be connecting securely, try best effort
+    # in being compatible with present ssl support.
+    @ssl = false
+    @tls = nil
+    @tls = options[:tls] if options[:tls]
+    @ssl = options[:ssl] if options[:ssl] or @tls
+
     send_connect_command
   end
 
@@ -411,17 +467,29 @@ module NATS
   end
 
   # Define a callback to be called when errors occur on the client connection.
-  # @param [Block] &blk called when the connection is closed.
+  # @param [Block] &callback called when an error has been detected.
   def on_error(&callback)
     @err_cb, @err_cb_overridden = callback, true
   end
 
   # Define a callback to be called when a reconnect attempt is made.
-  # @param [Block] &blk called when the connection is closed.
+  # @param [Block] &callback called when a reconnect attempt is made.
   def on_reconnect(&callback)
     @reconnect_cb = callback
   end
 
+  # Define a callback to be called when client is disconnected from server.
+  # @param [Block] &callback called whenever client disconnects from a server.
+  def on_disconnect(&callback)
+    @disconnect_cb = callback
+  end
+
+  # Define a callback to be called when client is disconnected from server.
+  # @param [Block] &callback called when will reach a state when will no longer be connected.
+  def on_close(&callback)
+    @close_cb = callback
+  end
+
   # Close the connection to the server.
   def close
     @closing = true
@@ -448,7 +516,7 @@ module NATS
     cs = {
       :verbose => @options[:verbose],
       :pedantic => @options[:pedantic],
-      :lang => "ruby",
+      :lang => :ruby,
       :version => VERSION
     }
     if auth_connection?
@@ -456,6 +524,8 @@ module NATS
       cs[:pass] = @uri.password
     end
     cs[:ssl_required] = @ssl if @ssl
+    cs[:tls_required] = true if @tls
+
     "CONNECT #{cs.to_json}#{CR_LF}"
   end
 
@@ -567,27 +637,55 @@ module NATS
     # parser gets what it needs. For the json gem :symbolize_name, for yajl
     # :symbolize_keys, and for oj :symbol_keys.
     @server_info = JSON.parse(info, :symbolize_keys => true, :symbolize_names => true, :symbol_keys => true)
-    if @server_info[:ssl_required] && @ssl
-      start_tls
+
+    case
+    when (server_using_secure_connection? and client_using_secure_connection?)
+      # Allow parameterizing secure connection via EM#start_tls directly if present.
+      start_tls(@tls || {})
+    when (server_using_secure_connection? and !client_using_secure_connection?)
+      # Call unbind since there is a configuration mismatch between client/server
+      # anyway and communication cannot happen in this state.
+      err_cb.call(NATS::ClientError.new('TLS/SSL required by server'))
+      close_connection_after_writing
+    when (client_using_secure_connection? and !server_using_secure_connection?)
+      err_cb.call(NATS::ClientError.new('TLS/SSL not supported by server'))
+      close_connection_after_writing
     else
-      if @server_info[:ssl_required]
-        err_cb.call(NATS::ClientError.new('TLS/SSL required by server'))
-      elsif @ssl
-        err_cb.call(NATS::ClientError.new('TLS/SSL not supported by server'))
-      end
+      # Otherwise, use a regular connection.
     end
+
     if @server_info[:auth_required]
       current = server_pool.first
       current[:auth_required] = true
+      # Send pending connect followed by ping/pong to ensure we're authorized.
       queue_server_rt { current[:auth_ok] = true }
       flush_pending
     end
+
     @server_info
   end
 
-  def ssl_handshake_completed
-    @connected = true
-    flush_pending
+  def client_using_secure_connection?
+    @tls || @ssl
+  end
+
+  def server_using_secure_connection?
+    @server_info[:ssl_required] || @server_info[:tls_required]
+  end
+
+  def ssl_verify_peer(cert)
+    ca_file = File.read(@options[:tls][:ca_file])
+    ca = OpenSSL::X509::Certificate.new(ca_file)
+    incoming = OpenSSL::X509::Certificate.new(cert)
+
+    unless incoming.issuer.to_s == ca.subject.to_s && incoming.verify(ca.public_key)
+      err_cb.call(NATS::ConnectError.new("TLS Verification failed checking issuer based on CA %s" % @options[:ca_file]))
+      false
+    else
+      true
+    end
+  rescue NATS::ConnectError
+    false
   end
 
   def cancel_ping_timer
@@ -598,23 +696,43 @@ module NATS
   end
 
   def connection_completed #:nodoc:
-    @connected = true unless @ssl
+    @parse_state = AWAITING_CONTROL_LINE
+
+    # Delay sending CONNECT or any other command here until we are sure
+    # that we have a valid established secure connection.
+    return if (@ssl or @tls)
+
+    # Mark that we established already TCP connection to the server. In case of TLS,
+    # prepare commands which will be dispatched to server and delay flushing until
+    # we have processed the INFO line sent by the server and done the handshake.
+    @connected = true 
+    process_connect
+  end
+
+  def ssl_handshake_completed
+    @connected = true
+    process_connect
+  end
 
+  def process_connect #:nodoc:   
+    # Reset reconnect attempts since TCP connection has been successful at this point.
     current = server_pool.first
     current[:was_connected] = true
-    current[:reconnect_attempts] = 0
+    current[:reconnect_attempts] ||= 0
     cancel_reconnect_timer if reconnecting?
 
-    # whip through any pending SUB commands since we replay
+    # Whip through any pending SUB commands since we replay
     # all subscriptions already done anyway.
-    @pending.delete_if { |sub| sub[0..2] == SUB_OP }
+    @pending.delete_if { |sub| sub[0..2] == SUB_OP } if @pending
     @subs.each_pair { |k, v| send_command("SUB #{v[:subject]} #{v[:queue]} #{k}#{CR_LF}") }
 
     unless user_err_cb? or reconnecting?
       @err_cb = proc { |e| raise e }
     end
 
-    flush_pending unless @ssl
+    # We have validated the connection at this point so send CONNECT
+    # and any other pending commands which we need to the server.
+    flush_pending
 
     if (connect_cb and not @conn_cb_called)
       # We will round trip the server here to make sure all state from any pending commands
@@ -625,17 +743,18 @@ module NATS
       end
     end
 
+    # Notify via reconnect callback that we are again plugged again into the system.
     if reconnecting?
       @reconnecting = false
-      @reconnect_cb.call unless @reconnect_cb.nil?
+      @reconnect_cb.call(self) unless @reconnect_cb.nil?
     end
 
-    @parse_state = AWAITING_CONTROL_LINE
-
     # Initialize ping timer and processing
     @pings_outstanding = 0
     @pongs_received = 0
-    @ping_timer = EM.add_periodic_timer(@options[:ping_interval]) { send_ping }
+    @ping_timer = EM.add_periodic_timer(@options[:ping_interval]) do
+      send_ping
+    end
   end
 
   def send_ping #:nodoc:
@@ -656,7 +775,7 @@ module NATS
   end
 
   def should_delay_connect?(server)
-    server[:was_connected] && server[:reconnect_attempts] >= 1
+    server[:was_connected] && server[:reconnect_attempts] >= 0
   end
 
   def schedule_reconnect #:nodoc:
@@ -666,9 +785,14 @@ module NATS
   end
 
   def unbind #:nodoc:
+    # Allow notifying from which server we were disconnected,
+    # but only when we didn't trigger disconnecting ourselves.
+    if @disconnect_cb and connected? and not closing?
+      disconnect_cb.call(NATS::ConnectError.new(disconnect_error_string))
+    end
+
     # If we are closing or shouldn't reconnect, go ahead and disconnect.
     process_disconnect and return if (closing? or should_not_reconnect?)
-
     @reconnecting = true if connected?
     @connected = false
     @pending = @pongs = nil
@@ -698,12 +822,18 @@ module NATS
   end
 
   def disconnect_error_string
-    return "Client disconnected from server on #{@uri}." if @connected
+    return "Client disconnected from server on #{@uri}" if @connected
     return "Could not connect to server on #{@uri}"
   end
 
   def process_disconnect #:nodoc:
-    err_cb.call(NATS::ConnectError.new(disconnect_error_string)) if not closing? and @err_cb
+    # Mute error callback when user has called NATS.close on purpose.
+    if not closing? and @err_cb
+      # Always call error callback for compatibility with previous behavior.
+      err_cb.call(NATS::ConnectError.new(disconnect_error_string))
+    end
+    close_cb.call if @close_cb
+
     true # Chaining
   ensure
     cancel_ping_timer
@@ -716,13 +846,17 @@ module NATS
   end
 
   def can_reuse_server?(server) #:nodoc:
-    reconnecting? && server[:was_connected] && server[:reconnect_attempts] <= @options[:max_reconnect_attempts]
+    # If we will retry a number of times to reconnect to a server
+    # unless we got an error from it already.
+    reconnecting? && server[:reconnect_attempts] <= @options[:max_reconnect_attempts] && !server[:error_received]
   end
 
   def attempt_reconnect #:nodoc:
     @reconnect_timer = nil
     current = server_pool.first
-    current[:reconnect_attempts] += 1 if current[:reconnect_attempts]
+    current[:reconnect_attempts] ||= 0
+    current[:reconnect_attempts] += 1
+
     send_connect_command
     begin
       EM.reconnect(@uri.host, @uri.port, self)
@@ -734,11 +868,15 @@ module NATS
   end
 
   def send_command(command, priority = false) #:nodoc:
-    EM.next_tick { flush_pending } if (connected? && @pending.nil?)
+    needs_flush = (connected? && @pending.nil?)
+
     @pending ||= []
     @pending << command unless priority
     @pending.unshift(command) if priority
     @pending_size += command.bytesize
+
+    EM.next_tick { flush_pending } if needs_flush
+
     flush_pending if (connected? && @pending_size > MAX_PENDING_SIZE)
     if (@options[:fast_producer_error] && pending_data_size > FAST_PRODUCER_THRESHOLD)
       err_cb.call(NATS::ClientError.new("Fast Producer: #{pending_data_size} bytes outstanding"))
@@ -773,12 +911,20 @@ module NATS
   def schedule_primary_and_connect #:nodoc:
     # Dump the one we were trying if it wasn't connected
     current = server_pool.shift
-    # FIXME(dlc) - Should we remove from the list on error?
-    server_pool << current if (current && (options[:max_reconnect_attempts] < 0 || can_reuse_server?(current) && !current[:error_received]))
-    # If we are out of options, go ahead and disconnect.
+
+    # In case there was an error from the server we will take it out from rotation
+    # unless we specify infinite reconnects via setting :max_reconnect_attempts to -1
+    if current && (options[:max_reconnect_attempts] < 0 || can_reuse_server?(current))
+      server_pool << current
+    end
+
+    # If we are out of options, go ahead and disconnect then
+    # handle closing connection to NATS.
     process_disconnect and return if server_pool.empty?
+
     # bind new one
     next_server = bind_primary
+
     # If the next one was connected and we are trying to reconnect
     # set up timer if we tried once already.
     if should_delay_connect?(next_server)

data/lib/nats/version.rb

@@ -1,3 +1,3 @@
 module NATS
-  VERSION = "0.6.0".freeze
+  VERSION = "0.7.0".freeze
 end

data/nats.gemspec

@@ -17,7 +17,7 @@ spec = Gem::Specification.new do |s|
   s.authors = ['Derek Collison']
   s.email = ['derek.collison@gmail.com']
 
-  s.add_dependency('eventmachine', '~> 1.0', '= 1.0.7')
+  s.add_dependency('eventmachine', '~> 1.2', '>= 1.2.0')
   s.add_dependency('json_pure', '~> 1.8', '>= 1.8.1')
   s.add_dependency('daemons', '~> 1.1', '>= 1.2.2')
   s.add_dependency('thin', '~> 1.6', '>= 1.6.3')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nats
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Derek Collison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-23 00:00:00.000000000 Z
+date: 2016-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '='
+        version: '1.2'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-    - - '='
+        version: '1.2'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.7
+        version: 1.2.0
 - !ruby/object:Gem::Dependency
   name: json_pure
   requirement: !ruby/object:Gem::Requirement