ably-pubsub-core 0.0.1.pre → 2.0.0

data/lib/ably/models/stats.rb

@@ -1,5 +1,3 @@
-require 'ably/models/stats_types'
-
 module Ably::Models
   # Convert stat argument to a {Stats} object
   #
@@ -17,16 +15,15 @@ module Ably::Models
 
   # A class representing an individual statistic for a specified {#interval_id}
   #
+  # @spec TS12
+  #
   class Stats
     include Ably::Modules::ModelCommon
     extend Ably::Modules::Enum
 
     # Describes the interval unit over which statistics are gathered.
     #
-    # MINUTE		Interval unit over which statistics are gathered as minutes.
-    # HOUR		  Interval unit over which statistics are gathered as hours.
-    # DAY		    Interval unit over which statistics are gathered as days.
-    # MONTH		  Interval unit over which statistics are gathered as months.
+    # @spec TS12c
     #
     GRANULARITY = ruby_enum('GRANULARITY',
       :minute,
@@ -103,123 +100,83 @@ module Ably::Models
 
     # {Stats} initializer
     #
-    # @param hash_object  [Hash]  object with the underlying stat details
+    # @param hash_object [Hash] object with the underlying stat details
     #
     def initialize(hash_object)
-      @raw_hash_object  = hash_object
+      @raw_hash_object = hash_object
       set_attributes_object hash_object
     end
 
-    # A {Ably::Models::Stats::MessageTypes} object containing the aggregate count of all message stats.
+    # The interval ID for this stats object.
     #
-    # @spec TS12e
-    #
-    # @return [Stats::MessageTypes]
-    #
-    def all
-      @all ||= Stats::MessageTypes.new(attributes[:all])
-    end
-
-    # A {Ably::Models::Stats::MessageTraffic} object containing the aggregate count of inbound message stats.
-    #
-    # @spec TS12f
-    #
-    # @return [Ably::Models::Stats::MessageTraffic]
-    #
-    def inbound
-      @inbound ||= Stats::MessageTraffic.new(attributes[:inbound])
-    end
-
-    # A {Ably::Models::Stats::MessageTraffic} object containing the aggregate count of outbound message stats.
-    #
-    # @spec TS12g
-    #
-    # @return [Ably::Models::Stats::MessageTraffic]
-    #
-    def outbound
-      @outbound ||= Stats::MessageTraffic.new(attributes[:outbound])
-    end
-
-    # A {Ably::Models::Stats::MessageTraffic} object containing the aggregate count of persisted message stats.
-    #
-    # @spec TS12h
+    # @spec TS12a
     #
-    # @return [Ably::Models::Stats::MessageTraffic]
+    # @return [String]
     #
-    def persisted
-      @persisted ||= Stats::MessageTypes.new(attributes[:persisted])
+    def interval_id
+      attributes.fetch(:interval_id)
     end
 
-    # A {Ably::Models::Stats::ConnectionTypes} object containing a breakdown of connection related stats, such as min, mean and peak connections.
+    # Represents the intervalId as a time object.
     #
-    # @spec TS12i
+    # @spec TS12p
     #
-    # @return [Ably::Models::Stats::ConnectionTypes]
+    # @return [Time]
     #
-    def connections
-      @connections ||= Stats::ConnectionTypes.new(attributes[:connections])
+    def interval_time
+      self.class.from_interval_id(interval_id)
     end
 
-    # A {Ably::Models::Stats::ResourceCount} object containing a breakdown of connection related stats, such as min, mean and peak connections.
+    # The unit of the interval, as provided by the API response.
     #
-    # @spec TS12j
+    # @spec TS12c
     #
-    # @return [Ably::Models::Stats::ResourceCount]
+    # @return [String]
     #
-    def channels
-      @channels ||= Stats::ResourceCount.new(attributes[:channels])
+    def unit
+      attributes[:unit]
     end
 
-    # A {Ably::Models::Stats::RequestCount} object containing a breakdown of API Requests.
+    # For entries that are still in progress, the last sub-interval included.
     #
-    # @spec TS12k
+    # @spec TS12q
     #
-    # @return [Ably::Models::Stats::RequestCount]
+    # @return [String, nil]
     #
-    def api_requests
-      @api_requests ||= Stats::RequestCount.new(attributes[:api_requests])
+    def in_progress
+      attributes[:in_progress]
     end
 
-    # A {Ably::Models::Stats::RequestCount} object containing a breakdown of Ably Token requests.
+    # A flat dictionary of statistics entries with dot-separated keys.
     #
-    # @spec TS12l
+    # @spec TS12r
     #
-    # @return [Ably::Models::Stats::RequestCount]
+    # @return [Hash]
     #
-    def token_requests
-      @token_requests ||= Stats::RequestCount.new(attributes[:token_requests])
+    def entries
+      raw_entries = raw_hash_object[:entries] || raw_hash_object['entries']
+      return {} unless raw_entries
+      raw_entries.is_a?(Hash) ? raw_entries : {}
     end
 
-    # The UTC time at which the time period covered begins. If unit is set to minute this will be in
-    # the format YYYY-mm-dd:HH:MM, if hour it will be YYYY-mm-dd:HH, if day it will be YYYY-mm-dd:00
-    # and if month it will be YYYY-mm-01:00.
+    # The JSON schema URI for this stats object.
     #
-    # @spec TS12a
+    # @spec TS12s
     #
     # @return [String]
     #
-    def interval_id
-      attributes.fetch(:interval_id)
+    def schema
+      attributes[:schema]
     end
 
-    # Represents the intervalId as a time object.
+    # The Ably application ID this stats object relates to.
     #
-    # @spec TS12b
+    # @spec TS12t
     #
-    # @return [Time]
-    #
-    def interval_time
-      self.class.from_interval_id(interval_id)
-    end
-
-    # The length of the interval the stats span. Values will be a [StatsIntervalGranularity]{@link StatsIntervalGranularity}.
-    #
-    # @spec TS12c
-    #
-    # @return [GRANULARITY] The granularity of the interval for the stat such as :day, :hour, :minute, see {GRANULARITY}
+    # @return [String]
     #
-    def interval_granularity
-      self.class.granularity_from_interval_id(interval_id)
+    def app_id
+      attributes[:app_id]
     end
 
     def attributes

data/lib/ably/models/update_delete_result.rb

@@ -0,0 +1,32 @@
+module Ably::Models
+  # Contains the result of an update or delete message operation.
+  #
+  # @spec UDR
+  #
+  class UpdateDeleteResult
+    include Ably::Modules::ModelCommon
+
+    # @param attributes [Hash]
+    # @option attributes [String, nil] :version_serial The new version serial string of the updated or deleted message.
+    #   Will be nil if the message was superseded by a subsequent update before it could be published.
+    #
+    def initialize(attributes = {})
+      @hash_object = IdiomaticRubyWrapper(attributes || {})
+      @hash_object.freeze
+    end
+
+    # The version serial of the updated or deleted message, or nil if superseded.
+    #
+    # @spec UDR2a
+    #
+    # @return [String, nil]
+    #
+    def version_serial
+      attributes[:version_serial]
+    end
+
+    def attributes
+      @hash_object
+    end
+  end
+end

data/lib/ably/modules/ably.rb

@@ -1,23 +1,24 @@
-# Ably is the base namespace for the Ably {Ably::Realtime Realtime} & {Ably::Rest Rest} client libraries.
+# Ably is the base namespace for the Ably {Ably::PubSub::Realtime Realtime} & {Ably::PubSub::Http Rest} client libraries.
 #
 # Please refer to the {file:README.md Readme} on getting started.
 #
 # @see file:README.md README
 module Ably
-  # Fallback hosts to use when a connection to rest/realtime.ably.io is not possible due to
-  # network failures either at the client, between the client and Ably, within an Ably data center, or at the IO domain registrar
+  # Default routing policy used when the +:endpoint+ client option is not provided
+  # @spec REC1a
+  ENDPOINT = 'main'.freeze
+
+  PROD_ROOT_DOMAIN = 'ably.net'.freeze
+  PROD_FALLBACK_DOMAIN = 'ably-realtime.com'.freeze
+
+  # Fallback hosts are used when a connection to the primary domain is not possible due to
+  # network failures either at the client, between the client and Ably, within an Ably data center, or at the domain registrar
   # see https://ably.com/docs/client-lib-development-guide/features/#RSC15a
-  #
-  FALLBACK_DOMAIN = 'ably-realtime.com'.freeze
   FALLBACK_IDS = %w(a b c d e).freeze
 
-  # Default production fallbacks a.ably-realtime.com ... e.ably-realtime.com
-  FALLBACK_HOSTS = FALLBACK_IDS.map { |host| "#{host}.#{FALLBACK_DOMAIN}".freeze }.freeze
-
-  # Custom environment default fallbacks {ENV}-a-fallback.ably-realtime.com ... {ENV}-a-fallback.ably-realtime.com
-  CUSTOM_ENVIRONMENT_FALLBACKS_SUFFIXES = FALLBACK_IDS.map do |host|
-    "-#{host}-fallback.#{FALLBACK_DOMAIN}".freeze
-  end.freeze
+  # Default production fallbacks main.a.fallback.ably-realtime.com ... main.e.fallback.ably-realtime.com
+  # @spec REC2c1
+  FALLBACK_HOSTS = FALLBACK_IDS.map { |id| "#{ENDPOINT}.#{id}.fallback.#{PROD_FALLBACK_DOMAIN}".freeze }.freeze
 
   INTERNET_CHECK = {
     url:     '//internet-up.ably-realtime.com/is-the-internet-up.txt',

data/lib/ably/modules/channels_collection.rb

@@ -1,5 +1,5 @@
 module Ably::Modules
-  # ChannelsCollection module provides common functionality to the Rest and Realtime Channels objects
+  # ChannelsCollection module provides common functionality to the HTTP and Realtime Channels objects
   # such as #get, #[], #fetch, and #release
   module ChannelsCollection
     include Enumerable

data/lib/ably/modules/http_helpers.rb

@@ -2,12 +2,12 @@ require 'base64'
 
 require 'ably/version'
 
-require 'ably/rest/middleware/encoder'
-require 'ably/rest/middleware/external_exceptions'
-require 'ably/rest/middleware/fail_if_unsupported_mime_type'
-require 'ably/rest/middleware/logger'
-require 'ably/rest/middleware/parse_json'
-require 'ably/rest/middleware/parse_message_pack'
+require 'ably/pubsub/http/middleware/encoder'
+require 'ably/pubsub/http/middleware/external_exceptions'
+require 'ably/pubsub/http/middleware/fail_if_unsupported_mime_type'
+require 'ably/pubsub/http/middleware/logger'
+require 'ably/pubsub/http/middleware/parse_json'
+require 'ably/pubsub/http/middleware/parse_message_pack'
 
 module Ably::Modules
   # HttpHelpers provides common private methods to classes to simplify HTTP interactions with Ably
@@ -23,19 +23,19 @@ module Ably::Modules
 
     def setup_outgoing_middleware(builder)
       # Convert request params to "www-form-urlencoded"
-      builder.use Ably::Rest::Middleware::Encoder
+      builder.use Ably::PubSub::Http::Middleware::Encoder
     end
 
     def setup_incoming_middleware(builder, logger, options = {})
-      builder.use Ably::Rest::Middleware::Logger, logger
+      builder.use Ably::PubSub::Http::Middleware::Logger, logger
 
       # Parse JSON / MsgPack response bodies. ParseJson must be first (default) parsing middleware
       if options[:fail_if_unsupported_mime_type] == true
-        builder.use Ably::Rest::Middleware::FailIfUnsupportedMimeType
+        builder.use Ably::PubSub::Http::Middleware::FailIfUnsupportedMimeType
       end
 
-      builder.use Ably::Rest::Middleware::ParseJson
-      builder.use Ably::Rest::Middleware::ParseMessagePack
+      builder.use Ably::PubSub::Http::Middleware::ParseJson
+      builder.use Ably::PubSub::Http::Middleware::ParseMessagePack
     end
   end
 end

data/lib/ably/{rest → pubsub/http}/channel/push_channel.rb

@@ -1,13 +1,13 @@
-module Ably::Rest
+module Ably::PubSub::Http
   class Channel
     # A push channel used for push notifications
-    # Each PushChannel maps to exactly one Rest Channel
+    # Each PushChannel maps to exactly one HTTP Channel
     #
     class PushChannel
       attr_reader :channel
 
       def initialize(channel)
-        raise ArgumentError, "Unsupported channel type '#{channel.class}'" unless channel.kind_of?(Ably::Rest::Channel)
+        raise ArgumentError, "Unsupported channel type '#{channel.class}'" unless channel.kind_of?(Ably::PubSub::Http::Channel)
         @channel = channel
       end
 

data/lib/ably/pubsub/http/channel.rb

@@ -0,0 +1,284 @@
+module Ably
+  module PubSub
+    module Http
+      # Enables messages to be published and historic messages to be retrieved for a channel.
+      #
+      class Channel
+        include Ably::Modules::Conversions
+
+        # Ably client associated with this channel
+        # @return [Ably::PubSub::Realtime::Client]
+        # @api private
+        attr_reader :client
+
+        # The channel name.
+        # @return [String]
+        attr_reader :name
+
+        attr_reader :options
+
+        # A {Ably::PubSub::Http::Channel::PushChannel} object
+        # @spec RSH4
+        # @return [Ably::PubSub::Http::Channel::PushChannel]
+        # @api private
+        attr_reader :push
+
+        IDEMPOTENT_LIBRARY_GENERATED_ID_LENGTH = 9 # See spec RSL1k1
+
+        # Initialize a new Channel object
+        #
+        # @param client [Ably::PubSub::Http::Client]
+        # @param name [String] The name of the channel
+        # @param channel_options [Hash, Ably::Models::ChannelOptions]     A hash of options or a {Ably::Models::ChannelOptions}
+        #
+        def initialize(client, name, channel_options = {})
+          name = (ensure_utf_8 :name, name)
+
+          @options = Ably::Models::ChannelOptions(channel_options)
+          @client  = client
+          @name    = name
+          @push    = PushChannel.new(self)
+        end
+
+        # Publishes a message to the channel. A callback may optionally be passed in to this call to be notified of success or failure of the operation.
+        #
+        # @spec RSL1
+        #
+        # @param name [String, Array<Ably::Models::Message|Hash>, Ably::Models::Message, nil]   The event name of the message to publish, or an Array of [Ably::Model::Message] objects or [Hash] objects with +:name+ and +:data+ pairs, or a single Ably::Model::Message object
+        # @param data [String, Array, Hash, nil]   The message payload unless an Array of [Ably::Model::Message] objects passed in the first argument, in which case an optional hash of query parameters
+        # @param attributes [Hash, nil]   Optional additional message attributes such as :extras, :id, :client_id or :connection_id, applied when name attribute is nil or a string (Deprecated, will be removed in 2.0 in favour of constructing a Message object)
+        # @return [Ably::Models::PublishResult]  A {Ably::Models::PublishResult} containing the serials of the published messages.
+        #
+        # @example
+        #   # Publish a single message with (name, data) form
+        #   channel.publish 'click', { x: 1, y: 2 }
+        #
+        #   # Publish a single message with single Hash form
+        #   message = { name: 'click', data: { x: 1, y: 2 } }
+        #   channel.publish message
+        #
+        #   # Publish an array of message Hashes form
+        #   messages = [
+        #     { name: 'click', data: { x: 1, y: 2 } },
+        #     { name: 'click', data: { x: 2, y: 3 } }
+        #   ]
+        #   channel.publish messages
+        #
+        #   # Publish an array of Ably::Models::Message objects form
+        #   messages = [
+        #     Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+        #     Ably::Models::Message(name: 'click', data: { x: 2, y: 3 })
+        #   ]
+        #   channel.publish messages
+        #
+        #   # Publish a single Ably::Models::Message object form
+        #   message = Ably::Models::Message(name: 'click', data: { x: 1, y: 2 })
+        #   channel.publish message
+        #
+        def publish(name, data = nil, attributes = {})
+          qs_params = nil
+          qs_params = data if name.kind_of?(Enumerable) || name.kind_of?(Ably::Models::Message)
+
+          messages = build_messages(name, data, attributes) # (RSL1a, RSL1b)
+
+          if messages.sum(&:size) > (max_message_size = client.max_message_size || Ably::PubSub::Http::Client::MAX_MESSAGE_SIZE)
+            raise Ably::Exceptions::MaxMessageSizeExceeded.new("Maximum message size exceeded #{max_message_size} bytes.")
+          end
+
+          payload = messages.map do |message|
+            Ably::Models::Message(message.dup).tap do |msg|
+              msg.encode client.encoders, options
+
+              next if msg.client_id.nil?
+              if msg.client_id == '*'
+                raise Ably::Exceptions::IncompatibleClientId.new('Wildcard client_id is reserved and cannot be used when publishing messages')
+              end
+              unless client.auth.can_assume_client_id?(msg.client_id)
+                raise Ably::Exceptions::IncompatibleClientId.new("Cannot publish with client_id '#{msg.client_id}' as it is incompatible with the current configured client_id '#{client.client_id}'")
+              end
+            end.as_json
+          end.tap do |payload|
+            if client.idempotent_rest_publishing
+              # We cannot mutate for idempotent publishing if one or more messages already has an ID
+              if payload.all? { |msg| !msg['id'] }
+                # Mutate the JSON to support idempotent publishing where a Message.id does not exist
+                idempotent_publish_id = SecureRandom.base64(IDEMPOTENT_LIBRARY_GENERATED_ID_LENGTH)
+                payload.each_with_index do |msg, idx|
+                  msg['id'] = "#{idempotent_publish_id}:#{idx}"
+                end
+              end
+            end
+          end
+
+          options = qs_params ? { qs_params: qs_params } : {}
+          response = client.post("#{base_path}/publish", payload.length == 1 ? payload.first : payload, options)
+
+          parse_publish_result(response)
+        end
+
+        # Updates a previously published message on the channel.
+        #
+        # @spec RSL15
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field
+        #   and the fields to update.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata containing
+        #   :description and/or :metadata fields.
+        # @param params [Hash, nil] Optional parameters sent as part of the query string.
+        #
+        # @return [Ably::Models::UpdateDeleteResult] The result containing the version_serial.
+        #
+        def update_message(message, operation = nil, params = {})
+          send_message_action(message, Ably::Models::Message::ACTION.MessageUpdate, operation, params)
+        end
+
+        # Deletes a previously published message on the channel.
+        #
+        # @spec RSL15
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata containing
+        #   :description and/or :metadata fields.
+        # @param params [Hash, nil] Optional parameters sent as part of the query string.
+        #
+        # @return [Ably::Models::UpdateDeleteResult] The result containing the version_serial.
+        #
+        def delete_message(message, operation = nil, params = {})
+          send_message_action(message, Ably::Models::Message::ACTION.MessageDelete, operation, params)
+        end
+
+        # Appends data to a previously published message on the channel.
+        #
+        # @spec RSL15
+        #
+        # @param message [Ably::Models::Message, Hash] A Message object or Hash containing a populated :serial field
+        #   and the data to append.
+        # @param operation [Hash, Ably::Models::MessageOperation, nil] Optional operation metadata containing
+        #   :description and/or :metadata fields.
+        # @param params [Hash, nil] Optional parameters sent as part of the query string.
+        #
+        # @return [Ably::Models::UpdateDeleteResult] The result containing the version_serial.
+        #
+        def append_message(message, operation = nil, params = {})
+          send_message_action(message, Ably::Models::Message::ACTION.MessageAppend, operation, params)
+        end
+
+        # Retrieves a {Ably::Models::PaginatedResult} object, containing an array of historical {Ably::Models::Message}
+        # objects for the channel. If the channel is configured to persist messages, then messages can be retrieved from
+        # history for up to 72 hours in the past. If not, messages can only be retrieved from history for up to two minutes in the past.
+        #
+        # @spec RSL2a
+        #
+        # @param [Hash] options   the options for the message history request
+        # @option options [Integer,Time] :start      The time from which messages are retrieved, specified as milliseconds since the Unix epoch. RSL2b1
+        # @option options [Integer,Time] :end        The time until messages are retrieved, specified as milliseconds since the Unix epoch. RSL2b1
+        # @option options [Symbol]       :direction  The order for which messages are returned in. Valid values are backwards which orders messages from most recent to oldest, or forwards which orders messages from oldest to most recent. The default is backwards. RSL2b2
+        # @option options [Integer]      :limit      An upper limit on the number of messages returned. The default is 100, and the maximum is 1000. RSL2b3
+        #
+        # @return [Ably::Models::PaginatedResult<Ably::Models::Message>] A {Ably::Models::PaginatedResult} object containing an array of {Ably::Models::Message} objects.
+        #
+        def history(options = {})
+          url = "#{base_path}/messages"
+          options = {
+            :direction => :backwards,
+            :limit     => 100
+          }.merge(options)
+
+          [:start, :end].each { |option| options[option] = as_since_epoch(options[option]) if options.has_key?(option) }
+          raise ArgumentError, ":end must be equal to or after :start" if options[:start] && options[:end] && (options[:start] > options[:end])
+
+          paginated_options = {
+            coerce_into: 'Ably::Models::Message',
+            async_blocking_operations: options.delete(:async_blocking_operations),
+          }
+
+          response = client.get(url, options)
+
+          Ably::Models::PaginatedResult.new(response, url, client, paginated_options) do |message|
+            message.tap do |msg|
+              decode_message msg
+            end
+          end
+        end
+
+        # A {Ably::PubSub::Http::Presence} object.
+        # @spec RSL3
+        # @return [Ably::PubSub::Http::Presence]
+        def presence
+          @presence ||= Presence.new(client, self)
+        end
+
+        # Sets the {Ably::Models::ChannelOptions} for the channel.
+        # @spec RSL7
+        # @param channel_options [Hash, Ably::Models::ChannelOptions]  A hash of options or a {Ably::Models::ChannelOptions}
+        # @return [Ably::Models::ChannelOptions]
+        def set_options(channel_options)
+          @options = Ably::Models::ChannelOptions(channel_options)
+        end
+        alias options= set_options
+
+        # Retrieves a {Ably::Models::ChannelDetails} object for the channel, which includes status and occupancy metrics.
+        # @spec RSL8
+        # @return [Ably::Models::ChannelDetails] 	A {Ably::Models::ChannelDetails} object.
+        def status
+          Ably::Models::ChannelDetails.new(client.get(base_path).body)
+        end
+
+        private
+
+        def send_message_action(message, action_enum, operation = nil, params = {})
+          message = Ably::Models::Message(message)
+
+          raise Ably::Exceptions::InvalidRequest.new(
+            'Message serial is required. Ensure the message has a serial field.'
+          ) unless message.serial
+
+          update_attrs = message.as_json
+          update_attrs['action'] = action_enum.to_i
+
+          if operation
+            op_hash = operation.respond_to?(:as_json) ? operation.as_json : operation
+            update_attrs['version'] = op_hash
+          end
+
+          updated_message = Ably::Models::Message.new(update_attrs)
+          updated_message.encode client.encoders, options
+
+          payload = updated_message.as_json
+          serial = message.serial
+
+          request_options = params && !params.empty? ? { qs_params: params } : {}
+          response = client.patch(
+            "#{base_path}/messages/#{URI.encode_www_form_component(serial)}",
+            payload,
+            request_options
+          )
+
+          Ably::Models::UpdateDeleteResult.new(response.body || {})
+        end
+
+        def parse_publish_result(response)
+          body = response.body
+          if body.is_a?(Hash)
+            serials = body['serials'] || body[:serials] || []
+            Ably::Models::PublishResult.new(serials: serials)
+          else
+            Ably::Models::PublishResult.new(serials: [])
+          end
+        end
+
+        def base_path
+          "/channels/#{URI.encode_www_form_component(name)}"
+        end
+
+        def decode_message(message)
+          message.decode client.encoders, options
+        rescue Ably::Exceptions::CipherError, Ably::Exceptions::EncoderError => e
+          client.logger.error { "Decoding Error on channel '#{name}', message event name '#{message.name}'. #{e.class.name}: #{e.message}" }
+        end
+      end
+    end
+  end
+end
+
+require 'ably/pubsub/http/channel/push_channel'

data/lib/ably/pubsub/http/channels.rb

@@ -0,0 +1,49 @@
+module Ably
+  module PubSub
+    module Http
+      class Channels
+        include Ably::Modules::ChannelsCollection
+
+        # @return [Ably::PubSub::Http::Channels]
+        def initialize(client)
+          super client, Ably::PubSub::Http::Channel
+        end
+
+        # Return a {Ably::PubSub::Http::Channel} for the given name
+        #
+        # @param name [String] The name of the channel
+        # @param channel_options [Hash] Channel options, currently reserved for Encryption options
+        #
+        # @return [Ably::PubSub::Http::Channel]
+        #
+        def get(*args)
+          super
+        end
+
+        # Return a {Ably::PubSub::Http::Channel} for the given name if it exists, else the block will be called.
+        # This method is intentionally similar to {http://ruby-doc.org/core-2.1.3/Hash.html#method-i-fetch Hash#fetch} providing a simple way to check if a channel exists or not without creating one
+        #
+        # @param name [String] The name of the channel
+        # @yield [options] (optional) if a missing_block is passed to this method and no channel exists matching the name, this block is called
+        # @yieldparam [String] name of the missing channel
+        #
+        # @return [Ably::PubSub::Http::Channel]
+        #
+        def fetch(*args)
+          super
+        end
+
+        # Destroy the {Ably::PubSub::Http::Channel} and releases the associated resources.
+        #
+        # Releasing a {Ably::PubSub::Http::Channel} is not typically necessary as a channel consumes no resources other than the memory footprint of the
+        # {Ably::PubSub::Http::Channel} object. Explicitly release channels to free up resources if required
+        #
+        # @return [void]
+        #
+        def release(*args)
+          super
+        end
+      end
+    end
+  end
+end