deepstream 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e408d9efd700aa2a8ab393eb87f0e00dba1e43a
-  data.tar.gz: 812bb8d7c5af04a63334d7826701df0d961edf6b
+  metadata.gz: 6cd95fc9f274116e724233dc418e5341bb600504
+  data.tar.gz: 2ba1ca7d05528b7221f264ed6ff133a10ca26425
 SHA512:
-  metadata.gz: 5468d8e34eed668c48c396622422884dc0fcf551e2c258b2ea2bab8a19f1ecfb8b1f9e9cd5cc226020608af59ba482da3a16ac0d4320612f497f128ff994d315
-  data.tar.gz: 59d69c20662f95e057f7a0cd3951e31f1cd82f78a18def3976c8cce9829baeb3d91e027c32a14e2d8b880ebb7af6a5e2f60fab08d88b12ed1674a924c0f32f6c
+  metadata.gz: 4e8b66da27b17102bd5b52acb98c72638f95df219c767c2b4d5029ca7695f33084c74194cd453bfc2ba3e54d76b79085fc87d1c7e7f667e46c99badd449bb356
+  data.tar.gz: 7d0196f7f8afc7be326827ef1b93496cc2066374ed4f60279ae58e01863eb6bfaa51be66403ce990d9d30a8a809145ebd8c78686f2c909cae459d2afe0c92b9c

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/features"]
+	path = test/features
+	url = https://github.com/deepstreamIO/deepstream.io-client-specs.git

data/README.md

@@ -18,7 +18,7 @@ ds.emit 'my_event'
 # or
 ds.emit 'my_event', foo: 'bar', bar: 'foo'
 # or
-ds.emit 'my_event', { foo: 'bar', bar: 'foo' }, timeout: 3
+ds.emit 'my_event', {foo: 'bar', bar: 'foo'}, timeout: 3
 # or
 ds.emit 'my_event', nil, timeout: 3
 
@@ -41,7 +41,7 @@ foo.bar = 'bar'
 foo.set('bar', 'bar')
 
 # Set the whole record
-foo.set(foo: 'foo', bar: 1, )
+foo.set(foo: 'foo', bar: 1)
 
 # Get a list
 foo = ds.get_list('bar')
@@ -53,7 +53,7 @@ foo.add('foo')
 foo.remove('foo')
 
 # Show record names on the list
-foo.keys()
+foo.keys
 
 # Access records on the list
-foo.all()
+foo.all

data/Rakefile

@@ -0,0 +1,7 @@
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:test) do |t|
+  t.cucumber_opts = "--guess -r test/ test/features/"
+end
+
+task default: :test

data/deepstream.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "deepstream"
-  spec.version       = "0.1.7"
+  spec.version       = "0.2.0"
   spec.authors       = ["Currency-One S.A."]
   spec.email         = ["piotr.szczudlak@currency-one.com"]
 
@@ -13,8 +13,16 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/Currency-One/deepstream-ruby"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         += Dir['lib/**/*.rb']
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.3.0'
   spec.license       = "Apache-2.0"
+  spec.add_runtime_dependency 'celluloid-websocket-client', '~> 0'
+  spec.add_development_dependency 'cucumber'
+  spec.add_development_dependency 'reel'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec-expectations'
+  spec.add_development_dependency 'rake'
 end

data/lib/deepstream.rb

@@ -11,298 +11,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'socket'
-require 'json'
-require 'timeout'
-
-module Deepstream end
-
-class Deepstream::Record
-  def initialize(client, name, data, version)
-    @client, @name, @data, @version = client, name, data, version
-  end
-
-  def get_name
-    @name
-  end
-
-  def set(*args)
-    if args.size == 1
-      if @client._write('R', 'U', @name, (@version += 1), JSON.dump(args[0]))
-        @data = OpenStruct.new(args[0])
-      end
-    else
-      @client._write('R', 'P', @name, (@version += 1), args[0][0..-2], @client._typed(args[1]))
-      @data[args[0][0..-2]] = args[1]
-    end
-  rescue => e
-    print "unable to set\n"
-    print "Error: ", e.message, "\n" if @client.verbose
-  end
-
-  def _patch(version, field, value)
-    @version = version.to_i
-    @data[field] = value
-  end
-
-  def _update(version, data)
-    @version = version.to_i
-    @data = data
-  end
-
-  def method_missing(name, *args)
-    unless @data.is_a?(Array)
-      set(name, *args) if name[-1] == '='
-      @data[name] || @data[name[-1]]
-    end
-  end
-
-  def inspect
-    "Deepstream::Record (#{@version}) #{@name} #{@data.to_h}"
-  end
-end
-
-class Deepstream::List < Deepstream::Record
-  def add(record_name)
-    @data = [] unless @data.is_a?(Array)
-    unless @data.include? record_name
-      @data.push record_name
-      @client._write('R', 'U', @name, (@version += 1), JSON.dump(@data))
-    end
-    @data
-  rescue => e
-    print "unable to add ", @data.pop, "\n"
-    print "Error: ", e.message, "\n" if @client.verbose
-    @data
-  end
-
-  def remove(record_name)
-    @data.delete_if { |x| x == record_name }
-    @client._write('R', 'U', @name, (@version += 1), JSON.dump(@data))
-    @data
-  rescue => e
-    print "unable to remove ", record_name, "\n"
-    @data.push record_name
-    print "Error: ", e.message, "\n" if @client.verbose
-    @data
-  end
-
-  def all
-    @data.map { |x| @client.get_record(x) }
-  end
-
-  def keys
-    @data
-  end
-
-  def set(*args)
-    fail 'cannot use set on a list'
-  end
-
-  def inspect
-    "Deepstream::List (#{@version}) #{@name} keys: #{@data}"
-  end
-end
-
-class Deepstream::Client
-  def initialize(address, port = 6021, credentials = {})
-    @address, @port, @unread_msg, @event_callbacks, @records, @max_timeout, @timeout = address, port, nil, {}, {}, 60, 1
-    connect(credentials)
-  end
-
-  attr_accessor :verbose, :max_timeout
-  attr_reader :connected
-
-  def _login(credentials)
-    _write("A", "REQ", credentials.to_json)
-    ack = _read_socket
-    raise unless ack == %w{A A} || (ack == %w{C A} && _read_socket == %w{A A})
-  end
-
-  def _read_socket(timeout: nil)
-    Timeout.timeout(timeout) do
-      @socket.gets(30.chr).tap { |m| break m.chomp(30.chr).split(31.chr) if m }
-    end
-  end
-
-  def connect(credentials)
-    return self if @connected
-    Thread.start do
-      Thread.current[:name] = "reader#{object_id}"
-      loop do
-        break if @connected # ensures only one thread remains after reconnection
-        begin
-          Timeout.timeout(2) { @socket = TCPSocket.new(@address, @port) }
-          _login(credentials)
-          @connected = true
-          print Time.now.to_s[/.+ .+ /], "Connected\n" if @verbose
-          Thread.start do
-            _sync_records
-            _resubscribe_events
-          end
-          loop do
-            @timeout = 1
-            begin
-              _process_msg(_read_socket(timeout: 10))
-            rescue Timeout::Error
-              _write("heartbeat") # send anything to check if deepstream responds
-              _process_msg(_read_socket(timeout: 10))
-            end
-          end
-        rescue => e
-          @connected = false
-          @socket.close rescue nil
-          print Time.now.to_s[/.+ .+ /], "Can't connect to deepstream server\n" if @verbose
-          print "Error: ", e.message, "\n" if @verbose
-          sleep @timeout
-          @timeout = [@timeout * 1.2, @max_timeout].min
-        end
-      end
-    end
-    sleep 0.5
-    self
-  end
-
-  def disconnect
-    @connected = false
-    @socket.close rescue nil
-    Thread.list.find { |x| x[:name] == "reader#{object_id}" }.kill
-    self
-  end
-
-  def emit(event, value = nil, opts = { timeout: nil })
-    result = nil
-    Timeout::timeout(opts[:timeout]) do
-      sleep 1 until (result = _write('E', 'EVT', event, _typed(value)) rescue false) || opts[:timeout].nil?
-    end
-    result
-  end
-
-  def on(event, &block)
-    _write_and_read('E', 'S', event)
-    @event_callbacks[event] = block
-  rescue => e
-    print "Error: ", e.message, "\n" if @verbose
-    @event_callbacks[event] = block
-  end
-
-  def get(record_name)
-    get_record(record_name)
-  end
-
-  def get_record(record_name, list: nil)
-    name = list ? "#{list}/#{record_name}" : record_name
-    if list
-      @records[list] ||= get_list(list)
-      @records[list].add(name)
-    end
-    @records[name] ||= (
-      _write_and_read('R', 'CR', name)
-      msg = _read
-      Deepstream::Record.new(self, name, _parse_data(msg[4]), msg[3].to_i)
-    )
-    @records[name]
-  rescue => e
-    print "Error: ", e.message, "\n" if @verbose
-    @records[name] = Deepstream::Record.new(self, name, OpenStruct.new, 0)
-  end
-
-  def get_list(list_name)
-    @records[list_name] ||= (
-      _write_and_read('R', 'CR', list_name)
-      msg = _read
-      Deepstream::List.new(self, list_name, _parse_data(msg[4]), msg[3].to_i)
-    )
-  rescue => e
-    print "Error: ", e.message, "\n" if @verbose
-    @records[list_name] = Deepstream::List.new(self, list_name, [], 0)
-  end
-
-  def delete(record_name)
-    if matching = record_name.match(/(?<namespace>\w+)\/(?<record>.+)/)
-      tmp = get_list(matching[:namespace])
-      tmp.remove(record_name)
-    end
-    _write('R', 'D', record_name)
-  rescue => e
-    print "Error: ", e.message, "\n" if @verbose
-    false
-  end
-
-  def _resubscribe_events
-    @event_callbacks.keys.each do |event|
-      _write_and_read('E', 'S', event)
-    end
-  end
-
-  def _sync_records
-    @records.each do |name, record|
-      _write_and_read('R', 'CR', name)
-      msg = _read
-      @records[name]._update(msg[3].to_i, _parse_data(msg[4]))
-    end
-  end
-
-  def _write_and_read(*args)
-    @unread_msg = nil
-    _write(*args)
-    yield _read if block_given?
-  end
-
-  def _write(*args)
-    @socket.write(args.join(31.chr) + 30.chr)
-  rescue => e
-    raise "not connected" unless @connected
-    raise e
-  end
-
-  def _process_msg(msg)
-    case msg[0..1]
-    when %w{E EVT} then _fire_event_callback(msg)
-    when %w{R P} then @records[msg[2]]._patch(msg[3], msg[4], _parse_data(msg[5]))
-    when %w{R U} then @records[msg[2]]._update(msg[3], _parse_data(msg[4]))
-    when %w{R A} then @records.delete(msg[3]) if msg[2] == 'D'
-    when %w{E A} then nil
-    when %w{X E} then nil
-    when [] then nil
-    else
-      @unread_msg = msg
-    end
-  end
-
-  def _read
-    loop { break @unread_msg || (next sleep 0.01) }.tap { @unread_msg = nil }
-  end
-
-  def _fire_event_callback(msg)
-    @event_callbacks[msg[2]].tap { |cb| Thread.start { cb.(_parse_data(msg[3])) } if cb }
-  end
-
-  def _typed(value)
-    case value
-    when Hash then "O#{value.to_json}"
-    when String then "S#{value}"
-    when Numeric then "N#{value}"
-    when TrueClass then 'T'
-    when FalseClass then 'F'
-    when NilClass then 'L'
-    end
-  end
-
-  def _parse_data(payload)
-    case payload[0]
-    when 'O' then JSON.parse(payload[1..-1], object_class: OpenStruct)
-    when '{' then JSON.parse(payload, object_class: OpenStruct)
-    when 'S' then payload[1..-1]
-    when 'N' then payload[1..-1].to_f
-    when 'T' then true
-    when 'F' then false
-    when 'L' then nil
-    else JSON.parse(payload, object_class: OpenStruct)
-    end
-  end
-
-  def inspect
-    "Deepstream::Client #{@address}:#{@port} connected: #{@connected}"
-  end
-end
+require 'deepstream/client'

data/lib/deepstream/ack_timeout_registry.rb

@@ -0,0 +1,17 @@
+module Deepstream
+  class AckTimeoutRegistry
+    def initialize(client)
+      @client = client
+      @timeouts = {}
+    end
+
+    def add(name, message)
+      return unless (timeout = @client.options[:ack_timeout])
+      @timeouts[name] = Celluloid.after(timeout) { @client.on_error(message) }
+    end
+
+    def cancel(name)
+      @timeouts.delete(name)&.cancel
+    end
+  end
+end

data/lib/deepstream/client.rb

@@ -0,0 +1,205 @@
+require 'forwardable'
+require 'celluloid/websocket/client'
+require 'deepstream/constants'
+require 'deepstream/error_handler'
+require 'deepstream/event_handler'
+require 'deepstream/record_handler'
+require 'deepstream/helpers'
+require 'deepstream/message'
+require 'deepstream/exceptions'
+
+module Deepstream
+  class Client
+    attr_reader :last_hearbeat, :options, :state
+
+    include Celluloid
+    include Celluloid::Internals::Logger
+    extend Forwardable
+
+    execute_block_on_receiver :on, :subscribe, :listen
+
+    def_delegators :@event_handler, :on, :emit, :subscribe, :unsubscribe, :listen, :resubscribe, :unlisten
+    def_delegators :@error_handler, :error, :on_error
+    def_delegators :@record_handler, :get, :set, :delete, :discard, :get_list
+
+    def initialize(url, options = {})
+      @url = Helpers.url(url)
+      @error_handler = ErrorHandler.new(self)
+      @record_handler = RecordHandler.new(self)
+      @event_handler = EventHandler.new(self)
+      @options = Helpers.default_options.merge!(options)
+      @message_buffer = []
+      @last_hearbeat = nil
+      @challenge_denied, @login_requested, @deliberate_close = false
+      @failed_reconnect_attempts = 0
+      @state = CONNECTION_STATE::CLOSED
+      Celluloid.logger.level = @options[:verbose] ? LOG_LEVEL::INFO : LOG_LEVEL::OFF
+      async.connect
+    end
+
+    def on_open
+      @state = CONNECTION_STATE::AWAITING_CONNECTION
+      @failed_reconnect_attempts = 0
+    end
+
+    def on_message(data)
+      message = Message.new(data)
+      info("Incoming message: #{message.inspect}")
+      case message.topic
+      when TOPIC::AUTH       then authentication_message(message)
+      when TOPIC::CONNECTION then connection_message(message)
+      when TOPIC::EVENT      then @event_handler.on_message(message)
+      when TOPIC::ERROR      then @error_handler.on_error(message)
+      when TOPIC::RECORD     then @record_handler.on_message(message)
+      when TOPIC::RPC        then raise UnknownTopic('RPC is currently not implemented.')
+      else raise UnknownTopic(message.to_s)
+      end
+    rescue => e
+      @error_handler.on_exception(e)
+    end
+
+    def on_close(code, reason)
+      info("Websocket connection closed: #{code.inspect}, #{reason.inspect}")
+      @state = CONNECTION_STATE::CLOSED
+      reconnect unless @deliberate_close
+    rescue => e
+      @error_handler.on_exception(e)
+    end
+
+    def login(credentials = @options[:credentials])
+      @login_requested = true
+      @options[:credentials] = credentials
+      if @challenge_denied
+        on_error("this client's connection was closed")
+      elsif !connected?
+        async.connect
+      elsif @state == CONNECTION_STATE::AUTHENTICATING
+        @login_requested = false
+        send_message(TOPIC::AUTH, ACTION::REQUEST, @options[:credentials].to_json)
+      end
+      self
+    rescue => e
+      @error_handler.on_exception(e)
+      self
+    end
+
+    def close
+      return unless connected?
+      @deliberate_close = true
+      @connection.close
+      @connection.terminate
+      @state = CONNECTION_STATE::CLOSED
+    rescue => e
+      @error_handler.on_exception(e)
+    end
+
+    def connected?
+      @state != CONNECTION_STATE::CLOSED
+    end
+
+    def logged_in?
+      @state == CONNECTION_STATE::OPEN
+    end
+
+    def inspect
+      "#{self.class} #{@url} | connection state: #{@state}"
+    end
+
+    def send_message(*args)
+      message = Message.parse(*args)
+      if !logged_in? && message.needs_authentication?
+        info("Placing message #{message.inspect} in buffer, waiting for connection")
+        @message_buffer << message
+      else
+        info("Sending message: #{message.inspect}")
+        @connection.text(message.to_s)
+      end
+    rescue => e
+      @error_handler.on_exception(e)
+    end
+
+    private
+
+    def connection_message(message)
+      case message.action
+      when ACTION::ACK       then on_connection_ack
+      when ACTION::CHALLENGE then on_challenge
+      when ACTION::ERROR     then on_error(message)
+      when ACTION::PING      then on_ping
+      when ACTION::REDIRECT  then on_redirection(message)
+      when ACTION::REJECTION then on_rejection
+      else raise UnknownAction(message)
+      end
+    end
+
+    def authentication_message(message)
+      case message.action
+      when ACTION::ACK   then on_login
+      when ACTION::ERROR then on_error(message)
+      else raise UnknownAction(message)
+      end
+    end
+
+    def on_challenge
+      @state = CONNECTION_STATE::CHALLENGING
+      send_message(TOPIC::CONNECTION, ACTION::CHALLENGE_RESPONSE, @url)
+    end
+
+    def on_connection_ack
+      @state = CONNECTION_STATE::AUTHENTICATING
+      login if @options[:autologin] || @login_requested
+    end
+
+    def on_ping
+      @last_heartbeat = Time.now
+      send_message(TOPIC::CONNECTION, ACTION::PONG)
+    end
+
+    def on_login
+      @state = CONNECTION_STATE::OPEN
+      @message_buffer.each { |message| send_message(message) }.clear
+      every(@options[:heartbeat_interval]) { check_heartbeat } if @options[:heartbeat_interval]
+    end
+
+    def on_rejection
+      @challenge_denied = true
+      close
+    end
+
+    def check_heartbeat
+      return unless @last_heartbeat && Time.now - @last_heartbeat > 2 * @options[:heartbeat_interval]
+      @state = CONNECTION_STATE::CLOSED
+      on_error('Two connections heartbeats missed successively')
+    end
+
+    def on_redirection(message)
+      close
+      connect(message.data.last)
+    end
+
+    def connect(url = @url, reraise = false)
+      @connection = Celluloid::WebSocket::Client.new(url, Actor.current)
+    rescue => e
+      reraise ? raise : @error_handler.on_exception(e)
+    end
+
+    def reconnect
+      @state = CONNECTION_STATE::RECONNECTING
+      if @failed_reconnect_attempts < @options[:max_reconnect_attempts]
+        connect(@url, true)
+        resubscribe
+      else
+        @state = CONNECTION_STATE::ERROR
+      end
+    rescue Errno::ECONNREFUSED
+      @failed_reconnect_attempts += 1
+      on_error("Can't connect! Deepstream server unreachable on #{@url}")
+      sleep(reconnect_interval)
+      reconnect
+    end
+
+    def reconnect_interval
+      [@options[:reconnect_interval] * @failed_reconnect_attempts, @options[:max_reconnect_interval]].min
+    end
+  end
+end

data/lib/deepstream/constants.rb

@@ -0,0 +1,75 @@
+module Deepstream
+  MESSAGE_SEPARATOR = 30.chr
+  MESSAGE_PART_SEPARATOR = 31.chr
+
+  module LOG_LEVEL
+    DEBUG = 0
+    INFO = 1
+    WARN = 2
+    ERROR = 3
+    OFF = 100
+  end
+
+  module CONNECTION_STATE
+    CLOSED = :closed
+    AWAITING_CONNECTION = :awaiting_connection
+    CHALLENGING = :challenging
+    AWAITING_AUTHENTICATION = :awaiting_authentication
+    AUTHENTICATING = :authenticating
+    OPEN = :open
+    ERROR = :error
+    RECONNECTING = :reconnecting
+  end
+
+  module TOPIC
+    CONNECTION = :C
+    AUTH = :A
+    ERROR = :X
+    EVENT = :E
+    RECORD = :R
+    RPC = :P
+  end
+
+  module ACTION
+    ACK = :A
+    READ = :R
+    REDIRECT = :RED
+    CHALLENGE = :CH
+    CHALLENGE_RESPONSE = :CHR
+    CREATE = :C
+    UPDATE = :U
+    PATCH = :P
+    DELETE = :D
+    SUBSCRIBE = :S
+    UNSUBSCRIBE = :US
+    HAS = :H
+    SNAPSHOT = :SN
+    LISTEN = :L
+    UNLISTEN = :UL
+    LISTEN_ACCEPT = :LA
+    LISTEN_REJET = :LR
+    SUBSCRIPTION_HAS_PROVIDER = :SH
+    SUBSCRIPTION_FOR_PATTERN_FOUND = :SP
+    SUBSCRIPTION_FOR_PATTERN_REMOVED = :SR
+    PROVIDER_UPDATE = :PU
+    QUERY = :Q
+    CREATEORREAD = :CR
+    EVENT = :EVT
+    ERROR = :E
+    REQUEST = :REQ
+    RESPONSE = :RES
+    REJECTION = :REJ
+    PING = :PI
+    PONG = :PO
+  end
+
+  module TYPE
+    STRING = :S
+    OBJECT = :O
+    NUMBER = :N
+    NULL = :L
+    TRUE = :T
+    FALSE = :F
+    UNDEFINED = :U
+  end
+end

data/lib/deepstream/error_handler.rb

@@ -0,0 +1,30 @@
+require 'deepstream/constants'
+require 'deepstream/helpers'
+require 'deepstream/message'
+
+module Deepstream
+  class ErrorHandler
+    attr_reader :error
+
+    def initialize(client)
+      @client = client
+      @error = nil
+    end
+
+    def on_error(message)
+      @error =
+        if message.is_a?(Message)
+          message.topic == TOPIC::ERROR ? message.data : Helpers.to_type(message.data.last)
+        else
+          message
+        end
+      puts @error
+    end
+
+    def on_exception(exception)
+      raise exception if @client.options[:debug]
+      puts exception.message
+      puts exception.backtrace
+    end
+  end
+end

data/lib/deepstream/event_handler.rb

@@ -0,0 +1,75 @@
+require 'deepstream/ack_timeout_registry'
+require 'deepstream/constants'
+require 'deepstream/helpers'
+
+module Deepstream
+  class EventHandler
+    def initialize(client)
+      @client = client
+      @callbacks = {}
+      @listeners = {}
+      @ack_timeout_registry = AckTimeoutRegistry.new(@client)
+    end
+
+    def on(event, &block)
+      unless @callbacks[event]
+        @client.send_message(TOPIC::EVENT, ACTION::SUBSCRIBE, event)
+        @ack_timeout_registry.add(event, "No ACK message received in time for #{event}")
+      end
+      @callbacks[event] = block
+    end
+    alias subscribe on
+
+    def listen(pattern, &block)
+      pattern = pattern.is_a?(Regexp) ? pattern.source : pattern
+      @listeners[pattern] = block
+      @client.send_message(TOPIC::EVENT, ACTION::LISTEN, pattern)
+      @ack_timeout_registry.add(pattern, "No ACK message received in time for #{pattern}")
+    end
+
+    def unlisten(pattern)
+      pattern = pattern.is_a?(Regexp) ? pattern.source : pattern
+      @listeners.delete(pattern)
+      @client.send_message(TOPIC::EVENT, ACTION::UNLISTEN, pattern)
+    end
+
+    def on_message(message)
+      case message.action
+      when ACTION::ACK then @ack_timeout_registry.cancel(message.data.last)
+      when ACTION::EVENT then fire_event_callback(message)
+      when ACTION::SUBSCRIPTION_FOR_PATTERN_FOUND then fire_listen_callback(message)
+      when ACTION::SUBSCRIPTION_FOR_PATTERN_REMOVED then fire_listen_callback(message)
+      else @client.on_error(message)
+      end
+    end
+
+    def emit(event, data = nil)
+      @client.send_message(TOPIC::EVENT, ACTION::EVENT, event, Helpers.to_deepstream_type(data))
+    end
+
+    def unsubscribe(event)
+      @callbacks.delete(event)
+      @client.send_message(TOPIC::EVENT, ACTION::UNSUBSCRIBE, event)
+    end
+
+    def resubscribe
+      @callbacks.keys.each { |event| @client.send_message(TOPIC::EVENT, ACTION::SUBSCRIBE, event) }
+      @listeners.keys.each { |pattern| @client.send_message(TOPIC::EVENT, ACTION::LISTEN, pattern) }
+    end
+
+    private
+
+    def fire_event_callback(message)
+      event, data = message.data
+      data = Helpers.to_type(data)
+      Celluloid::Future.new { @callbacks[event].call(event, data) }
+    end
+
+    def fire_listen_callback(message)
+      is_subscribed = message.action == ACTION::SUBSCRIPTION_FOR_PATTERN_FOUND
+      pattern, event = message.data
+      return @client.on_error(pattern) unless @listeners[pattern]
+      @listeners[pattern].call(is_subscribed, event)
+    end
+  end
+end

data/lib/deepstream/exceptions.rb

@@ -0,0 +1,4 @@
+module Deepstream
+  class UnknownTopic < StandardError; end
+  class UnknownAction < StandardError; end
+end

data/lib/deepstream/helpers.rb

@@ -0,0 +1,55 @@
+require 'json'
+
+module Deepstream
+  module Helpers
+    SCHEME = 'ws://'
+    DEFAULT_PORT = 6020
+    DEFAULT_PATH = 'deepstream'
+
+    def self.to_deepstream_type(value)
+      case value
+      when Hash then "O#{value.to_json}"
+      when String then "S#{value}"
+      when Numeric then "N#{value}"
+      when TrueClass then 'T'
+      when FalseClass then 'F'
+      when NilClass then 'L'
+      end
+    end
+
+    def self.to_type(payload)
+      case payload[0]
+      when 'O' then JSON.parse(payload[1..-1])
+      when '{' then JSON.parse(payload)
+      when 'S' then payload[1..-1]
+      when 'N' then payload[1..-1].to_f
+      when 'T' then true
+      when 'F' then false
+      when 'L' then nil
+      else JSON.parse(payload)
+      end
+    end
+
+    def self.default_options
+      {
+        ack_timeout: nil,
+        autologin: true,
+        credentials: {},
+        heartbeat_interval: nil,
+        max_reconnect_attempts: 5,
+        max_reconnect_interval: 30,
+        reconnect_interval: 1,
+        verbose: false,
+        debug: false
+      }
+    end
+
+    def self.url(url)
+      url.tap do |url|
+        url.prepend(SCHEME) unless url.start_with?(SCHEME)
+        url.concat(":#{DEFAULT_PORT}") unless url[/\:\d+/]
+        url.concat("/#{DEFAULT_PATH}") unless url[/\/\w+$/]
+      end
+    end
+  end
+end

data/lib/deepstream/list.rb

@@ -0,0 +1,31 @@
+require 'deepstream/record'
+
+module Deepstream
+  class List < Record
+    def initialize(*args)
+      super
+      @data = []
+    end
+
+    def add(record_name)
+      set(@data.length.to_s, record_name) unless @data.include?(record_name)
+    end
+
+    def read(version, data)
+      @version = version.to_i
+      data = JSON.parse(data)
+      if data.is_a?(Array)
+        @data.concat(data).uniq!
+        set(@data) if @data.size > data.size
+      end
+    end
+
+    def remove(record_name)
+      set(@data) if @data.delete(record_name)
+    end
+
+    def all
+      @data.map { |record_name| @client.get(record_name) }
+    end
+  end
+end

data/lib/deepstream/message.rb

@@ -0,0 +1,34 @@
+require 'json'
+require 'deepstream/constants'
+
+module Deepstream
+  class Message
+    attr_reader :topic, :action, :data
+
+    def self.parse(*args)
+      args.first.is_a?(self) ? args.first : new(*args)
+    end
+
+    def initialize(*args)
+      if args.one?
+        args = args.first.delete(MESSAGE_SEPARATOR).split(MESSAGE_PART_SEPARATOR)
+      end
+      @topic, @action = args.take(2).map(&:to_sym)
+      @data = args.drop(2)
+    end
+
+    def to_s
+      args = [@topic, @action]
+      args << @data unless @data.empty?
+      args.join(MESSAGE_PART_SEPARATOR).concat(MESSAGE_SEPARATOR)
+    end
+
+    def inspect
+      "#{self.class.name}: #{@topic} #{@action} #{@data}"
+    end
+
+    def needs_authentication?
+      ![TOPIC::CONNECTION, TOPIC::AUTH].include?(@topic)
+    end
+  end
+end

data/lib/deepstream/record.rb

@@ -0,0 +1,64 @@
+require 'json'
+require 'deepstream/constants'
+require 'deepstream/helpers'
+
+module Deepstream
+  class Record
+    attr_reader :name, :data, :version
+
+    def initialize(client, name)
+      @client = client
+      @name = name
+      @data, @version = nil
+      @client.send_message(TOPIC::RECORD, ACTION::CREATEORREAD, @name)
+    end
+
+    def inspect
+      "#{self.class} #{@name} #{@version} #{@data}"
+    end
+
+    def unsubscribe
+      @client.send_message(TOPIC::RECORD, ACTION::UNSUBSCRIBE, name)
+    end
+
+    def delete
+      @client.delete(@name)
+    end
+
+    def set(*args)
+      if args.one?
+        @data = args.first
+        @client.send_message(TOPIC::RECORD, ACTION::UPDATE, @name, (@version += 1), @data.to_json) if @version
+      elsif args.size == 2
+        path, value = args
+        set_path(@data, path, value)
+        @client.send_message(TOPIC::RECORD, ACTION::PATCH, @name, (@version += 1), path, Helpers.to_deepstream_type(value)) if @version
+      end
+    end
+
+    def read(version, data)
+      update(version, data)
+    end
+
+    def patch(version, path, value)
+      @version = version.to_i
+      set_path(@data, path, Helpers.to_type(value))
+    end
+
+    def update(version, data)
+      @version = version.to_i
+      @data = JSON.parse(data)
+    end
+
+    private
+
+    def set_path(data, path, value)
+      key, subkey = path.split('.', 2)
+      if data.is_a?(Hash)
+        subkey ? set_path(data.fetch(key), subkey, value) : data[key] = value
+      elsif data.is_a?(Array)
+        subkey ? set_path(data[key.to_i], subkey, value) : data[key.to_i] = value
+      end
+    end
+  end
+end

data/lib/deepstream/record_handler.rb

@@ -0,0 +1,68 @@
+require 'deepstream/constants'
+require 'deepstream/record'
+require 'deepstream/list'
+
+module Deepstream
+  class RecordHandler
+    def initialize(client)
+      @client = client
+      @records = {}
+    end
+
+    def on_message(message)
+      case message.action
+      when ACTION::ACK then nil
+      when ACTION::PATCH then patch(message)
+      when ACTION::READ then read(message)
+      when ACTION::UPDATE then update(message)
+      else @client.on_error(message)
+      end
+    end
+
+    def get(name, list: nil)
+      if list
+        name.prepend("#{list}/")
+        @records[list] ||= List.new(@client, list)
+        @records[list].add(name)
+      end
+      @records[name] ||= Record.new(@client, name)
+    end
+
+    def get_list(name)
+      @records[name] ||= List.new(@client, name)
+    end
+
+    def set(name, *args)
+      @records[name]&.set(*args)
+    end
+
+    def unsubscribe(name)
+      @records[name]&.unsubscribe
+    end
+
+    def discard(name)
+      unsubscribe(name)
+    end
+
+    def delete(name)
+      @client.send_message(TOPIC::RECORD, ACTION::DELETE, name) if @records.delete(name)
+    end
+
+    private
+
+    def read(message)
+      name, *data = message.data
+      @records[name]&.read(*data)
+    end
+
+    def update(message)
+      name, *data = message.data
+      @records[name]&.update(*data)
+    end
+
+    def patch(message)
+      name, *data = message.data
+      @records[name]&.patch(*data)
+    end
+  end
+end

metadata

@@ -1,15 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: deepstream
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Currency-One S.A.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-14 00:00:00.000000000 Z
-dependencies: []
+date: 2017-02-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid-websocket-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Basic ruby client for the deepstream.io server
 email:
 - piotr.szczudlak@currency-one.com
@@ -18,11 +102,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitmodules"
 - Gemfile
 - LICENSE
 - README.md
+- Rakefile
 - deepstream.gemspec
 - lib/deepstream.rb
+- lib/deepstream/ack_timeout_registry.rb
+- lib/deepstream/client.rb
+- lib/deepstream/constants.rb
+- lib/deepstream/error_handler.rb
+- lib/deepstream/event_handler.rb
+- lib/deepstream/exceptions.rb
+- lib/deepstream/helpers.rb
+- lib/deepstream/list.rb
+- lib/deepstream/message.rb
+- lib/deepstream/record.rb
+- lib/deepstream/record_handler.rb
 homepage: https://github.com/Currency-One/deepstream-ruby
 licenses:
 - Apache-2.0
@@ -35,7 +132,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -43,9 +140,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: deepstream.io ruby client
 test_files: []
-has_rdoc: