shove 1.0.7 → 1.0.8

data/Gemfile

@@ -16,5 +16,4 @@ end
 
 gem "em-http-request", ">= 1.0.0"
 gem "em-ws-client", ">= 0.2.0"
-gem "yajl-ruby", ">= 1.1.0"
-gem "confstruct", ">= 0.2.1"
+gem "yajl-ruby", ">= 1.1.0"

data/README.markdown

@@ -1,6 +1,6 @@
-shove ruby client
-=================
-Ruby client and CLI for the shove.io HTTP and WebSocket APIs
+shove
+=====
+HTTP and WebSocket clients for shove.io
 
 <a name="installation"></a>
 Installation
@@ -11,53 +11,42 @@ gem install shove
 ```
 
 <a name="configuration"></a>
-Configuring Shove
------------------
+Using Shove
+-----------
 
-If you are using a single shove app within your project, you can configure
-shove though the Shove module:
+To use shove, you must first create a Shove::App object.
 
 ```ruby
-Shove.configure do
-  app_id "myappid"
-  app_key "myappkey"
-end
-```
-
-If you want to work with different shove apps in one project, you can 
-create App objects
-
-```ruby
-app = Shove::App.new do
-  app_id "myappid"
-  app_key "myappkey"
-end
+app = Shove::App.new(
+  app_id: "myappid",
+  app_key: "myappkey"
+)
 ```
 
-Grab your App ID and App Key from shove: [https://shove.io][0]
+Get your app_id, and app_key at [shove.io][0]
 
 <a name="http_client"></a>
 Using the HTTP Client
 ---------------------
 The HTTP client gives publishing and access control capabilities without
-a persistent WebSocket connection.  The HTTP client does not act as a subscriber.
+a persistent WebSocket connection.  The HTTP client cannot act as a subscriber.
 
-Simple Publish
+Publish to a channel
 
 ```ruby
-Shove.channel("notifications").publish("Hello World!")
+app.channel("notifications").publish("Hello World!")
 ```
 
 Publish Direct
 
 ```ruby
-Shove.channel("direct:buddy").publish("Hey buddy")
+app.channel("direct:buddy").publish("Hey buddy")
 ```
 
 Publish and handle the HTTP response
 
 ```ruby
-Shove.channel("notifications").publish("...") do |response|
+app.channel("notifications").publish("...") do |response|
   if reponse.error?
     puts "#{response.status} - #{response.error}"
   end
@@ -70,25 +59,25 @@ granular security.
 Grant subscription on the notifications channel
 
 ```ruby
-Shove.channel("notifications").grant_subscribe("dan@shove.io")
+app.channel("notifications").grant_subscribe("dan@shove.io")
 ```
 
 Grant subscription on all channels to client dan
 
 ```ruby
-Shove.channel("*").grant_subscribe("dan@shove.io")
+app.channel("*").grant_subscribe("dan@shove.io")
 ```
 
 Grant publishing on chat:client_22733 channel to client dan
 
 ```ruby
-Shove.channel("chat:client_22733").grant_publish("dan")
+app.channel("chat:client_22733").grant_publish("dan")
 ```
 
 Deny publishing on chat:client_22733 channel to dan
 
 ```ruby
-Shove.channel("chat:client_22733").deny_publish("dan")
+app.channel("chat:client_22733").deny_publish("dan")
 ```
 
 Sometimes it's easier to give out an access key to a specific
@@ -98,37 +87,37 @@ channel, which is also an option.
 Channel Keys
 ------------
 You can generate channel keys which allow clients of
-your shove network to publish and subscribe to specific
+your shove network to subscribe or publish to specific
 channels.
 
 Example: Create a key for the channel groups:788
 
 ```ruby
-key = Shove.channel_key "group:788"
+key = app.channel_key "group:788"
 ```
 
-If it's for a particular App, use:
+Subscribe only
 
 ```ruby
-key = app.channel_key "group:788"
+key = app.subscribe_key "group:788"
 ```
 
 This functionality becomes useful when you want to give
-you site users access.  A little haml for you:
+you site users access.  In your view:
 
-```haml
-:javascript
-  var channel = "#{@channel}";
-  var key = "#{@shove.channel_key(@channel)}";
+```erb
+var channel = "<%= @channel %>";
+var key = "<%= @app.channel_key(@channel) %>";
 ```
 
-Note: Channel keys are based off the app key.  So, in order for
-them to work, you must specify the app key:
+Note: Channel keys are based off the app key (master key).  So, in order for
+them to work, you must specify the app key in your app.
 
 ```ruby
-  Shove.configure do
-    app_key "key"
-  end
+app = Shove::App.new(
+  app_id: "myappid",
+  app_key: "myappkey"
+)
 ```
 
 <a name="websocket_client"></a>
@@ -139,28 +128,15 @@ requires that you are running an EventMachine reactor.
 
 ```ruby
 EM.run do
-  app = Shove::App.new do
-    app_id "myapp"
-  end
-
-  app.connect
+  app = Shove::App.new(
+    app_id "myapp",
+    app_key: "myappkey"
+  )
 
-  # alternatively, supply your user id
-  client = app.connect "unique_id"
+  client = app.connect
 end
 ```
 
-### Authorization
-The client is treated like any other websocket
-client and must be authorized to publish and subscribe.
-
-```ruby
-client.authorize "app_key"
-
-# self authorize a particular channel
-client.channel("channel").authorize "channel_key"
-```
-
 ### Client events
 
 Connect event:
@@ -195,7 +171,7 @@ client.on("connect_denied") do |id|
 end
 ```
 
-### Publish and Subscribe
+### Channels & Publish and Subscribe
 
 Subscribe to a channel or get a subscribed channel
 
@@ -265,37 +241,27 @@ channel.publish("hi!")
 channel.publish(obj.to_json)
 ```
 
-Using the Command Line
-----------------------
-
-A CLI utility is included with the gem, run help to see options
-
-```bash
-shove help
-```
-
-Publish a message
-
-```bash
-shove publish -c channel1 -m "Hello world!"
-```
-
-Publish to a specific app
-
-```bash
-shove publish -a app_id -c chan1 -m "hi"
-```
+<a name="websocket_client"></a>
+WebSocket Client without App Key
+--------------------------------
+If you are connecting to someone elses app
+and have limited scope and access, you can get by.
 
-Set the default app for the CLI
+```ruby
+EM.run do
+  app = Shove::App.new(
+    app_id "myapp"
+  )
 
-```bash
-shove apps:default -a app_id
-```
+  client = app.connect "connect-key"
 
-Watch all activity on a channel
+  channel = client.channel("channel")
+  channel.auth "channelkey"
 
-```bash
-shove watch -c chan
+  channel.on("message") do |message|
+    puts message
+  end
+end
 ```
 
 [0]: https://shove.io

data/Rakefile

@@ -28,26 +28,3 @@ task :autospec => :spec do
   end
   
 end
-
-desc "Generate the README HTML"
-task :readme do
-
-  require "redcarpet"
-  require "albino"
-
-  # Create a custom renderer that uses albino to
-  # make pretty code
-  class Colorizer < Redcarpet::Render::HTML
-    def block_code(code, language)
-      Albino.colorize(code, language)
-    end
-  end
-
-  content = Redcarpet::Markdown.new(Colorizer, :fenced_code_blocks => true)
-    .render(File.read("README.markdown"))
-
-  File.open("README.html", "w") do |f|
-    f << content
-  end
-
-end

data/lib/shove.rb

@@ -7,7 +7,6 @@ require "em-http-request"
 require "em-ws-client"
 require "yajl"
 require "yaml"
-require "confstruct"
 require "digest/sha1"
 
 ##
@@ -18,80 +17,14 @@ require "digest/sha1"
 # See https://github.com/shove/shove for js client documentation
 module Shove
   
-  Version = "1.0.7"
-  
-  class ShoveException < Exception; end
-  
-  class << self
-
-    attr_accessor :config, :app
-
-    # configure shover
-    # +settings+ the settings for the created client as 
-    # a string for a yaml file, or as a hash
-    def configure params=nil, &block
-
-      unless defined? @config
-        @config = Confstruct::Configuration.new do
-          api_url "https://api.shove.io"
-        end
-      end
-      
-      if params
-        @config.configure params
-      end
+  Version = "1.0.8"
 
-      if block
-        @config.configure(&block)
-      end
-
-      unless defined? @app
-        @app = App.new(@config)
-      else
-        
-      end
-    end
-
-    # fetch a channel by name
-    # +name+ the name of the channel
-    def channel name
-      @app.channel(name)
-    end
-
-    # fetch a client by id
-    def client id
-      @app.client(id)
-    end
-    
-    # validate network settings
-    # used for the CLI
-    def valid?
-      @app.valid?
-    end
-    
-    # fetch the available stream nodes
-    # for this network.
-    def hosts
-      @app.hosts
-    end
-
-    # Connect to the default app with a 
-    # WebSocket connection
-    def connect
-      @app.connect
-    end
-
-    # Create a channel key
-    # +channel+ the name of the channel
-    def channel_key channel
-      @app.channel_key channel
-    end
+  # Exception class for all shove exception
+  class ShoveException < Exception; end
 
-  end
 end
 
 require "shove/app"
-require "shove/app_directory"
 require "shove/protocol"
 require "shove/client/connection"
 require "shove/client/channel"

data/lib/shove/app.rb

@@ -1,38 +1,24 @@
 module Shove
   class App
 
-    attr_accessor :config
+    attr_accessor :app_key, :app_id, :api_url, :ws_url
 
     # create an API client
     # +config+ optional Confstruct
     # +&block+ config block
     # Example:
-    # Shove::App.new do
-    #   app_id "myappid"
-    #   app_key "myappkey"
-    # end
-    def initialize config=Confstruct::Configuration.new, &block
-      @config = config
-      configure(&block)
-    end
-
-    def configure params={}, &block
-
-      @config.configure do
-        api_url Shove.config.api_url || "https://api.shove.io"
-      end
+    # Shove::App.new(
+    #   app_id: "myappid"
+    #   app_key: "myappkey"
+    # )
+    def initialize config={}
+      @config  = config
+      @app_id  = config[:app_id]
+      @app_key = config[:app_key]
+      @api_url = config[:api_url] || "https://api.shove.io"
+      @ws_url  = config[:ws_url]
 
-      if params
-        @config.configure params
-      end
-      
-      if block
-        @config.configure(&block)
-      end
-
-      unless @config.app_id
-        raise ShoveException.new("App ID required")
-      end
+      raise ShoveException.new("App ID required") unless @app_id
     end
 
     # is the app valid?
@@ -43,7 +29,7 @@ module Shove
     
     # get a list of websocket hosts
     def hosts
-      request("hosts").exec_sync(:get).parse
+      @hosts ||= request("hosts").exec_sync(:get).parse
     end
 
     # create a channel context for acting on a channel
@@ -60,29 +46,50 @@ module Shove
 
     # the base URL based on the settings
     def url
-      "#{@config.api_url}/apps/#{@config.app_id}"
+      "#{@api_url}/apps/#{@app_id}"
     end
 
     # Create a default request object with the base URL
     # +path+ extra path info
     def request path
-      Http::Request.new("#{url}/#{path}", @config)
+      Http::Request.new("#{url}/#{path}", self)
     end
 
     # Generate a channel key for a client to self authorize
     # publish and subscribe actions.
     # +channel+ the name of the channel
     def channel_key channel
-      Digest::SHA1.hexdigest "#{@config.app_key}-#{channel}"
+      Digest::SHA1.hexdigest "#{@app_key}-#{channel}!"
+    end
+
+    # Generate a channel key for a client to self authorize
+    # publish and subscribe actions.
+    # +channel+ the name of the channel
+    def publish_key channel
+      channel_key channel
+    end
+
+    # Generate a channel key for a client to self authorize
+    # subscribe actions.
+    # +channel+ the name of the channel
+    def subscribe_key channel
+      Digest::SHA1.hexdigest "#{@app_key}-#{channel}"
+    end
+
+    # Generate a connect key for a client to self authorize
+    # publish and subscribe actions.
+    # +channel+ the name of the channel
+    def connect_key
+      Digest::SHA1.hexdigest "#{@app_key}-connect"
     end
 
     ####
 
     # Connect to shove as a client in the current process
     # +id+ optional shove id to supply
-    def connect id=nil
-      client = Client::Connection.new(self, id)
-      client.connect
+    def connect connect_key=nil
+      client = Client::Connection.new(self)
+      client.connect connect_key
       client
     end