lita-sonos-commander 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71a47b802acd8b74a12165728bd3b0fded035ab5
-  data.tar.gz: 49ecca4439098ff7827f4d2b6ac78ddde816e4e3
+  metadata.gz: 8df08a9fd7ffbbe94ff51a5cc8ffbb77c26ab062
+  data.tar.gz: 6ce9bbb507eeec26eb03b8dc5715393762e487c6
 SHA512:
-  metadata.gz: dae726c2765371f5459269bc7c95a6468f224d32cf0f64de0656c932241e3bc24c36028959114135512adcfa876a26ed2d390fb85acd500fe9bb22f8f9f106fd
-  data.tar.gz: 4d22468f6a65ea06c68d426628d1908d68c53606c2cbc301ad0b26e3f6e776593a55099ce71eeea8d04e518a09f0e5dd016d8d1784720d4aa0e6353f6e5a926d
+  metadata.gz: e9699b15935e3210d61dcc4414097d3a176de14674ec8fbe5849ece61e0db6b751636a006ec71890d58e4126a21f9ac7dc1603ac6fb1d1a5bcb44f4290191310
+  data.tar.gz: 5ee1e48df4353a064d6edde6166de70ff064891f7fd1435ce653f4ceaae92b1b579de7f8a39ce1bebd83f007fb2ca69e0d1465288b17faaa91c692bb2bb509f9

data/lib/lita/commander_middleware.rb

@@ -1,47 +1,58 @@
-Lita::CommanderMiddleware = lambda do |env|
-
-  if Faye::WebSocket.websocket?(env)
-    ws = Faye::WebSocket.new(env)
-
-    Lita::Handlers::SonosCommander.add_socket(ws)
+class Lita::CommanderMiddleware
+  def self.build(open_sockets:)
+    new.build open_sockets: open_sockets
+  end
 
-    ws.on :open do |event|
+  attr_reader :env, :open_sockets
+
+  def build(open_sockets:)
+    @open_sockets = open_sockets
+
+    return lambda do |env|
+      if Faye::WebSocket.websocket?(env)
+        @env = env
+        handle_env_has_socket
+      else
+        [
+          200,
+          { 'Content-Type' => 'text/plain' },
+          ['Hello from a Lita chatbot! Feed me a websocket connection!']
+        ]
+      end
     end
+  end
 
-    ws.on :connect do |event|
-    end
+  def build_socket(env)
+    ws = Faye::WebSocket.new(env)
+    open_sockets << ws
+    Lita.logger.debug "Sonos client count: #{open_sockets.count}"
+    ws
+  end
 
-    ws.on :message do |event|
-      ws.send({ message: event.data }.to_json)
+  def close_socket(ws)
+    open_sockets.delete_if { |s| s == ws }
+    Lita.logger.debug "Sonos client count: #{open_sockets.count}"
+    p [:close, event.code, event.reason]
+    ws = nil
+  end
 
-      sleep 0.5
-      ws.send({ message: 'WE DID IT TWITCH', command: 'echo' }.to_json)
-    end
+  def handle_message(ws, event)
+    ws.send({ message: event.data }.to_json)
+    maybe_send_debug_message(ws)
+  end
 
-    ws.on :close do |event|
-      Lita::Handlers::SonosCommander.drop_socket(ws)
+  def maybe_send_debug_message(ws)
+    sleep 0.5
+    ws.send({ message: 'WE DID IT TWITCH', command: 'echo' }.to_json)
+  end
 
-      p [:close, event.code, event.reason]
-      ws = nil
-    end
+  def handle_env_has_socket
+    ws = build_socket(env)
+
+    ws.on(:message) { |event| handle_message(ws, event) }
+    ws.on(:close) { |event| close_socket(ws) }
 
     # Return async Rack response
     ws.rack_response
-
-  else
-    # Normal HTTP request
-    [200, {'Content-Type' => 'text/plain'}, ['Hello']]
-  end
-end
-
-def register_faye(arg)
-  @@_sockets ||= []
-  middleware = robot.registry.config.http.middleware
-  result = middleware.use App
-end
-
-def sonos_connector(request, response)
-  middlewares.each do |mw|
-    mw.middleware.call(request.env)
   end
 end

data/lib/lita/handlers/sonos_commander.rb

@@ -1,3 +1,5 @@
+require 'pry'
+
 require 'json'
 require 'faye/websocket'
 require 'uri'
@@ -6,70 +8,93 @@ module Lita
   module Handlers
     class SonosCommander < Handler
 
-      http.get '/sonos/listen', :sonos_connector
+      # START:socket_registry
+      @_sockets ||= []
+
+      def self.sockets
+        @_sockets
+      end
+
+      def sockets
+        self.class.sockets
+      end
+      # END:socket_registry
+
+      # START:routing
+      http.get '/sonos/listen', :websocket_creator
 
-      route /^play_url (.+)/, :sonos_play_url
-      route /^say_text (.+)/, :sonos_say_text
+      route(/^play url (http.+)/i, :handle_sonos_play_url)
+      route(/^speak words (.+)/i, :handle_sonos_say_text)
 
       on :loaded, :register_faye
+      # END:routing
 
-      def sonos_play_url(message)
-        text = message.matches.last.last
-        emit_message command: 'play_url', data: URI.escape(text)
+      # START:create_sockets
+      def websocket_creator(request, _response)
+        # could probably skip straight to the Commander middleware
+        # but it's cleaner to leave them all in play.
+
+        middleware_registry.each do |mw|
+          mw.middleware.call(request.env)
+        end
       end
+      # END:create_sockets
+
+      # START:chat_handlers
+      def handle_sonos_play_url(message)
+        return message.reply('No clients found!') unless sockets.any?
 
-      def sonos_say_text(message)
         text = message.matches.last.last
-        emit_message command: 'play_text', data: text
-      end
+        play_url message.matches.last.last
 
-      def emit_message(command:, data:)
-        puts "emitting #{command} \t #{data}"
-        sockets.each do |ws|
-          ws.send(
-            { command: command, data: { text: data, volume: 20 } }.to_json
-          )
-        end
+        message.reply "Command sent: [play_url] #{text}!"
       end
 
-      def middlewares
-        robot.registry.config.http.middleware
+      def play_url(url)
+        emit_message command: 'play_url', data: URI.escape(url)
       end
 
-      def sockets
-        self.class.sockets
-      end
+      def handle_sonos_say_text(message)
+        return message.reply('No clients found!') unless sockets.any?
 
-      def self.sockets
-        @@_sockets ||= []
-      end
+        text = message.matches.last.last
+        say_text text
 
-      def self.add_socket(socket)
-        puts "Tracking socket #{socket}"
-        @@_sockets ||= []
-        @@_sockets << socket
+        message.reply "Command sent: [play_text] #{text}!"
       end
 
-      def self.drop_socket(socket)
-        puts "Forgetting socket #{socket}"
-        sockets.delete_if { |s| s == socket }
+      def say_text(text)
+        emit_message command: 'play_text', data: text
       end
+      # END:chat_handlers
 
-      def self.serialize(message)
+      # START:faye_hookup
+      def register_faye(_arg)
+        socket_manager = Lita::CommanderMiddleware.build(open_sockets: sockets)
+        middleware_registry.use socket_manager
       end
 
-      def register_faye(arg)
-        @@_sockets ||= []
-        middleware = robot.registry.config.http.middleware
-        result = middleware.use Lita::CommanderMiddleware
+      def middleware_registry
+        robot.registry.config.http.middleware
       end
+      # END:faye_hookup
 
-      def sonos_connector(request, response)
-        middlewares.each do |mw|
-          mw.middleware.call(request.env)
+      # START:message_emission
+      def emit_message(command:, data:)
+        puts "emitting #{command} \t #{data}"
+
+        sockets.each do |ws|
+          ws.send serialize(command: command, text: data)
         end
       end
 
+      def serialize(command:, text:)
+        {
+          command: command,
+          data: { text: text, volume: 20 }
+        }.to_json
+      end
+      # END:message_emission
 
       Lita.register_handler(self)
     end

data/lita-sonos-commander.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-sonos-commander'
-  spec.version       = '1.0.0'
+  spec.version       = '1.1.0'
   spec.authors       = ['Daniel J. Pritchett']
   spec.email         = ['dpritchett@gmail.com']
   spec.description   = 'Control your Sonos with Lita chatbot commands'

data/spec/lita/commander_middleware_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'date'
+
+describe Lita::CommanderMiddleware do
+  let(:handler) { double 'handler' }
+  let(:result) { subject.build({}) }
+
+  it 'returns a lambda' do
+    result = subject.class.build(open_sockets: [])
+    expect(result.is_a?(Proc)).to be_truthy
+  end
+end

data/spec/lita/handlers/sonos_commander_spec.rb

@@ -11,51 +11,104 @@ describe Lita::Handlers::SonosCommander, lita_handler: true do
   describe 'routes' do
     it {
       is_expected.to route_http(:get, '/sonos/listen')
-        .to(:sonos_connector)
+        .to(:websocket_creator)
     }
 
-    it { is_expected.to route('Lita sonos alpha bravo')
-      .to(:send_to_sonos) }
+    it {
+      is_expected.to(route('Lita play url http://zombo.com')
+      .to(:handle_sonos_play_url))
+    }
+    it {
+      is_expected.to(route('Lita play url https://www.youtube.com/watch?v=dQw4w9WgXcQ')
+      .to(:handle_sonos_play_url))
+    }
+    it {
+      is_expected.to(route('Lita speak words i like turtles')
+      .to(:handle_sonos_say_text))
+    }
+
+    it { is_expected.to route_event(:loaded).to(:register_faye) }
   end
   # END:routes
 
-  describe 'exploratory' do
-    it "let's play" do
-      subject.explorer
+  describe 'sending messages to clients' do
+    let(:client) { double('socket client') }
+    before { subject.stub(:sockets).and_return [client] }
+
+    it 'should :send some commanding json to the client' do
+      expect(client).to receive(:send).with(/play_url.+http.+volume/)
+
+      subject.play_url 'http://bana.nas'
     end
-  end
-  # START:save_message
-  describe ':save_message' do
-    let(:body) { 'hello, alexa!' }
-    it 'saves a message and acknowledges' do
-      result = subject.save_message(username: 'dpritchett', message: body)
 
-      expect(result.fetch(:message)).to eq body
+    it 'should :send some commanding json to the client' do
+      expect(client).to receive(:send).with(/play_text.+turtles.+volume/)
+
+      subject.say_text 'i like turtles'
     end
 
-    it { is_expected.to route_event(:save_alexa_message).to(:save_message) }
+    it 'can grab a message from chat and store it' do
+      send_message 'lita speak words i like turtles'
+      response = replies.last
+
+      expect(response).to match(/No clients found/i)
+    end
   end
-  # END:save_message
 
-  # START:alexify
-  describe ':alexify' do
-    let(:message) do
-      subject.save_message username: 'daniel', message: 'test message'
+  describe 'socket registry' do
+    let(:sockets) { subject.sockets }
+    it 'has a socket registry shared amongst instances of the handler' do
+      sockets << 'banana'
+      another_one = Lita::Handlers::SonosCommander.new({})
+
+      expect(another_one.sockets).to include('banana')
     end
 
-    it 'should return a hash with an alexa-specific shape' do
-      result = subject.alexify(message)
-      expect(result.fetch(:mainText)).to eq('test message')
+    it 'allows addition and deletion to the socket registry via array methods' do
+      canary = rand(10_000).to_s
+      sockets << canary
+      expect(sockets).to include(canary)
+
+      sockets.delete_if { |socket| socket.eql? canary }
+      expect(sockets).to_not include(canary)
     end
   end
-  # END:alexify
 
-  it 'can grab a message from chat and store it' do
-    send_message "lita newsfeed hello there #{DateTime.now}"
-    response = replies.last
-    expect(response =~ /hello there/i).to be_truthy
-    expect(response =~ /Saved message for Alexa/).to be_truthy
+  describe 'text serializer' do
+    it 'creates a json payload' do
+      result = subject.serialize(command: 'phone_call', text: 'call your mother')
+
+      deserialized = JSON.parse(result)
+
+      expect(deserialized.fetch('command')).to eq 'phone_call'
+      expect(deserialized.dig('data', 'volume')).to_not be_falsey
+    end
   end
 
-end
+  describe 'socket middleware registration' do
+    let(:middlewares) { double 'middlewares' }
+    before { subject.stub(:middleware_registry).and_return(middlewares) }
+
+    let(:commander) { double 'commander' }
+    before { Lita::CommanderMiddleware.stub(:build).and_return(commander) }
+
+    it 'should register the commander middleware' do
+      expect(middlewares).to receive(:use).with(commander)
+
+      subject.register_faye(nil)
+    end
+  end
+
+  describe ':websocket_creator' do
+    let(:request) { double 'request' }
+    let(:request_env) { double 'request' }
+    let(:middleware) { double 'middleware' }
+
+    before { subject.stub_chain(:middleware_registry, :each).and_return [middleware] }
+    before { request.stub(:env).and_return(request_env) }
 
+    it 'passes incoming any request environments to registered middlewares' do
+      subject.websocket_creator(request, nil)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-sonos-commander
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Daniel J. Pritchett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-26 00:00:00.000000000 Z
+date: 2018-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -156,6 +156,7 @@ files:
 - lib/lita/handlers/sonos_commander.rb
 - lita-sonos-commander.gemspec
 - locales/en.yml
+- spec/lita/commander_middleware_spec.rb
 - spec/lita/handlers/sonos_commander_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dpritchett/lita-sonos-commander
@@ -184,5 +185,6 @@ signing_key:
 specification_version: 4
 summary: Control your Sonos with Lita chatbot commands
 test_files:
+- spec/lita/commander_middleware_spec.rb
 - spec/lita/handlers/sonos_commander_spec.rb
 - spec/spec_helper.rb