shove 0.52 → 1.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+shove.yml
+example.rb
+Gemfile.lock
+README.html
+*.gem

data/Gemfile

@@ -0,0 +1,17 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+group :development do
+  gem "rake"
+  gem "redcarpet"
+  gem "albino"
+end
+
+group :test do
+  gem "rspec"
+  gem "vcr", "2.0.0.rc1"
+  gem "webmock"
+  gem "net-http-spy"
+end
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    shove (1.0.1)
+      confstruct (>= 0.2.1)
+      em-http-request (>= 1.0.0)
+      em-ws-client (>= 0.1.1)
+      yajl-ruby (>= 1.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.6)
+    albino (1.3.3)
+      posix-spawn (>= 0.3.6)
+    confstruct (0.2.1)
+    cookiejar (0.3.0)
+    crack (0.3.1)
+    diff-lcs (1.1.3)
+    em-http-request (1.0.1)
+      addressable (>= 2.2.3)
+      cookiejar
+      em-socksify
+      eventmachine (>= 1.0.0.beta.4)
+      http_parser.rb (>= 0.5.3)
+    em-socksify (0.1.0)
+      eventmachine
+    em-ws-client (0.1.1)
+      eventmachine (~> 1.0.0.beta.3)
+      state_machine (~> 1.0.2)
+    eventmachine (1.0.0.beta.4)
+    http_parser.rb (0.5.3)
+    net-http-spy (0.2.1)
+    posix-spawn (0.3.6)
+    rake (0.9.2.2)
+    redcarpet (2.1.0)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    state_machine (1.0.3)
+    vcr (2.0.0.rc1)
+    webmock (1.7.10)
+      addressable (~> 2.2, > 2.2.5)
+      crack (>= 0.1.7)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  albino
+  net-http-spy
+  rake
+  redcarpet
+  rspec
+  shove!
+  vcr (= 2.0.0.rc1)
+  webmock

data/README.markdown

@@ -0,0 +1,263 @@
+shove ruby client
+=================
+Ruby client and CLI for the shove.io HTTP and WebSocket APIs
+
+Installation
+------------
+
+```bash
+gem install shove
+```
+
+Grab your App ID and App Key from shove at [https://shove.io/apps][0]
+
+Configuring Shove
+-----------------
+
+If you are using a single shove app within your project, you can configure
+shove though the Shove module:
+
+```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
+```
+
+Using the HTTP Client
+---------------------
+The HTTP client gives publishing and access control capabilities without
+a persistent WebSocket connection
+
+Publish "Hello World!" to all connections on the notifications channel
+
+```ruby
+Shove.channel("notifications").publish("Hello World!") do |response|
+  # handle response
+end
+```
+
+Publish "Hey buddy" to the client with id buddy.
+
+```ruby
+Shove.channel("direct:buddy").publish("Hey buddy") do |response|
+  # handle response
+end
+```
+
+Apps, channels, and clients can be controlled from the HTTP API
+
+Grant a connection to dan@shove.io
+```ruby
+Shove.grant_connect("dan@shove.io") do |response|
+  # handle response
+end
+```
+
+Grant subscription on the notifications channel to client dan
+
+```ruby
+Shove.channel("notifications").grant_subscribe("dan") do |response|
+  # handle response
+end
+```
+
+Grant subscription on all channels to client dan
+
+```ruby
+Shove.channel("*").grant_subscribe("dan@shove.io") do |response|
+  # handle response
+end
+```
+
+Grant publishing on chat:client_22733 channel to client dan
+
+```ruby
+Shove.channel("chat:client_22733").grant_publish("dan") do |response|
+  # handle response
+end
+```
+
+Deny publishing on chat:client_22733 channel to dan
+
+```ruby
+Shove.channel("chat:client_22733").deny_publish("dan") do |response|
+  # handle response
+end
+```
+
+Using the WebSocket Client
+--------------------------
+
+Create a WebSocket client on the default app
+
+```ruby
+client = Shove.app.connect
+```
+
+Or
+
+```ruby
+app = Shove::App.new do
+  app_id "myappid"
+end
+client = app.connect
+```
+
+Create a client with a custom ID
+
+```ruby
+client = Shove.app.connect("unique_id")
+```
+
+### Client events
+
+Handle connect event
+
+```ruby
+client.on("connect") do
+  # Connected!
+end
+```
+
+Handle connect denies (private app)
+
+```ruby
+client.on("connect_denied") do |id|
+  # Silly, but:
+  Shove.client(id).grant_connect do |response|
+    # At this point, the client should receive
+    # a connect event (through the shove app)
+  end
+end
+```
+
+And disconnect events
+
+```ruby
+client.on("disconnect") do
+end
+```
+
+If there is any kind of error, log it
+
+```ruby
+client.on("error") do |error|
+  log.error "Shove error: #{error}"
+end
+```
+
+### Clients and Channels
+
+Subscribe to a channel or get a subscribed channel
+
+```ruby
+channel = client.channel("channel")
+```
+
+Handle a message published on a channel
+
+```ruby
+channel.on("message") do |msg|
+  widget.append msg
+end
+```
+
+Handle the subscribe callback for a given channel
+
+```ruby
+channel.on("subscribe") do
+  # channel is subscribed
+end
+```
+
+If the app denies subscriptions by default, you should
+handle the subscribe_denied event
+
+```ruby
+channel.on("subscribe_denied") do
+  # Silly example
+  Shove.client(client.id).grant_subscribe(channel.name)
+end
+```
+
+You can get the binding for a callback and cancel it
+
+```ruby
+binding = channel.on("message") do |msg|
+end
+
+binding.cancel
+```
+
+Handle a direct message
+
+```ruby
+client.channel("direct").on("message") do |msg|
+  # handle direct message
+end
+```
+
+Unsubscribe from a channel, optionally handle the event
+
+```ruby
+channel.on("unsubscribe_complete") do
+end
+
+channel.unsubscribe
+```
+
+Publish a message from the WebSocket client
+
+```ruby
+channel.publish("hi!")
+
+# publish json
+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"
+```
+
+Set the default app for the CLI
+
+```bash
+shove apps:default -a app_id
+```
+
+Watch all activity on a channel
+
+```bash
+shove watch -c chan
+```
+
+[0]: https://shove.io/apps
+[1]: http://shove.io/documentation/cli

data/Rakefile

@@ -4,3 +4,50 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
+task :autospec => :spec do
+  require "eventmachine"
+  
+  $time = Time.now
+
+  module Handler
+    def file_modified
+      if Time.now - $time > 1
+        $time = Time.now
+        Rake::Task["spec"].execute
+      end
+    end
+  end
+
+  EM.kqueue = true if EM.kqueue?
+  EM.run do
+    ["spec","lib"].collect { |dir|
+      Dir.glob(File.dirname(__FILE__) + "/#{dir}/**/*.rb")
+    }.flatten.each do |file|  
+      EM.watch_file file, Handler
+    end
+  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/bin/shove

@@ -1,133 +1,155 @@
 #!/usr/bin/env ruby
 
-require "rubygems"
-require "commander/import"
+$:.unshift File.dirname(__FILE__) + "/../lib"
+
+require "optparse"
 require "shove"
 
-ymlpath = File.expand_path("~/.shove.yml") 
-
-# get network, key, cluster
-unless FileTest.exist?(ymlpath)
-
-  access = {}
-  
-  loop do
-    
-    say "Please enter your network information."
-    say "Visit http://shove.io/customer/network/api_access for more info."
-    
-    access[:cluster] = ask "Enter Cluster Group: "
-    access[:network] = ask "Enter Network Id: "
-    access[:key] = ask "Enter Network Key: "
-
-    Shove.configure access
-    
-    check = Shove.validate
-    if check.status >= 400
-      say "Unable to validate network settings.  Error: #{check.message}"
-    else
-      break
-    end
-    
+action  = ARGV[0]
+channel = nil
+client  = nil
+message = nil
+app     = nil
+app_dir = Shove::AppDirectory.new
+
+OptionParser.new do |o|
+
+  o.banner = "Usage: shove "
+
+  o.on("-h", "--help") do
+    action = "help" 
   end
 
-  File.open(ymlpath, "w") do |f|
-    f << access.to_yaml
+  o.on("-v", "--version") do
+    action = "version"
   end
-    
-end
 
-Shove.configure(ymlpath)
+  o.on("-l", "--list") do
+    action = "apps"
+  end
 
-# Commander specification
+  o.on("-a", "--app app", "the app to work with") do |arg|
+    app = arg
+  end
 
-program :name, "shove"
-program :version, Shove::Version
-program :description, "CLI for the shove.io push platform"
-program :help, "Author", "Dan Simpson <dan@shove.io>"
-program :formatter, :compact
+  o.on("-c", "--channel channel", "the channel to operate on") do |arg| 
+    channel = arg 
+  end
 
-command :stream do |c|
-  c.syntax = "shove stream channel"
-  c.example "Streams the default channel", "shove stream default"
-  c.description = "Stream all data on a given channel to the console"
-  c.action do |args, opts|
-    if args.empty?
-      say_invalid c
-    else
-      EM.run do
-        Shove.stream(args.first) { |m| 
-          puts m[:channel]
-          puts m[:event]
-          puts m[:to] # this will either be empty or self
-          puts m[:from] # message sender
-          puts m[:data] # the payload
-          puts "============"
-        }
-      end
-    end
+  o.on("-u", "--client client", "the client to operate on") do |arg|
+    client = arg
   end
-end
-alias_command :subscribe, :stream
-
-command :broadcast do |c|
-  c.syntax = "shove broadcast channel event data"
-  c.example "Broadcast x,y coordinates on the grid channel", "shove broadcast grid coords '1522,234'"
-  c.description = "Broadcast event and data to all subscribers of a given channel"
-  c.action do |args, opts|
-    if args.length != 3
-      say_invalid c
-    else
-      say "Broadcasting on channel #{args.first}"
-      Shove.broadcast(*args) do |response|
-        say response.message
-      end
-    end
+
+  o.on("-m", "--message message", "the message to publish") do |arg|
+    message = arg
   end
+
+  o.parse!(ARGV)
 end
 
-command :direct do |c|
-  c.syntax = "shove direct user event data"
-  c.example "Send a message to user with id 9812737890", "shove direct 9812737890 message 'Your account expires in 2 minutes'"
-  c.description = "Send a message directly to a specific shove subscriber"
-  c.action do |args, opts|
-    if args.length != 3
-      say_invalid c
+begin
+
+  case action
+  when "version"
+    puts "shove version #{Shove::Version}"
+  when "apps"
+
+    apps = app_dir.apps
+
+    if apps.empty?
+      puts "No apps found.  Run: shove apps:add"
     else
-      say "Sending data directly to user #{args.first}"
-      Shove.direct(*args) do |response|
-        say response.message
+      puts "App Id\t\tApp Key"
+      puts "-----------------------"
+      apps.each_pair do |id,key|
+        puts "#{id}\t\t#{key}"
       end
     end
-  end
-end
 
-command :authorize do |c|
-  c.syntax = "shove authorize user channel"
-  c.example "Authorize user 9812737890 access to channel internal-bus", "shove authorize 9812737890 internal-bus"
-  c.description = "Authorize a pending channel subscription.  Only required for private channels."
-  c.action do |args, opts|
-    if args.length != 2
-      say_invalid c
-    else
-      say "Authorizing user #{args.first} on channel #{args.last}"
-      Shove.authorize(*args) do |response|
-        say response.message
+  when "apps:add"
+    app_dir.get_config app
+  when "apps:default"
+    app_dir.default = app
+  when "hosts"
+    Shove.configure(app_dir.get_config(app))
+
+    Shove.hosts.each do |host|
+      puts host
+    end
+
+  when "publish"
+
+    Shove.configure(app_dir.get_config(app))
+
+    errors = []
+    errors << "channel not defined" unless channel
+    errors << "message not defined" unless message
+
+    if errors.empty?
+      Shove.channel(channel).publish(message) do |r|
+        if r.error? 
+          puts "Error: #{r.message}"
+        else
+          puts "Published"
+        end
       end
+    else
+      puts "Errors: #{errors.join(",")}"
     end
-  end
-end
 
+  when "watch"
 
-def say_invalid cmd
-  puts "Invalid #{cmd.name} command. Syntax: #{cmd.syntax}"
-  unless cmd.examples.empty?
-    puts "Examples"
-    cmd.examples.each do |ex|
-      puts "---------"
-      puts ex.first
-      puts ex.last
+    Shove.configure(app_dir.get_config(app))
+
+    if channel
+
+      EM.run do
+        client = Shove.connect
+        client.authorize(app_dir.key(app))
+
+        client.on("error") do |error|
+          puts "Watch Error #{error}"
+          EM.stop
+        end
+
+        channel = client.channel(channel)
+        channel.on("message") do |msg|
+          puts "#{Time.now}: #{msg}"
+        end
+      end
+
+    else
+      puts "You must provide the channel with: -c channel_name"
     end
+        
+  else
+    puts File.read(__FILE__).split("__END__").last
   end
+
+
+rescue Exception => ex
+
+  puts ex.message
+  puts ex.backtrace
+
+  abort File.read(__FILE__).split("__END__").last
 end
 
+__END__
+Usage: shove action [options]
+
+
+Options
+  -h, --help
+    Show this message
+
+Actions
+  publish         publish a message to the app
+                  example: shove publish -c chan -m "Hello"
+
+  hosts           List available hosts for your app
+  watch           Watch the messages on a given channel
+
+  apps            List known apps
+  apps:default    Use a particular app
+  apps:add        Add a new app