ruku 0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Aaron Royer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,96 @@
+= Ruku -- Roku™ set-top box remote control, command line and web interfaces
+
+== Installation
+
+  gem install ruku
+
+== Usage
+
+The following launches the web interface. See it at http://localhost:3030
+
+  ruku --web
+
+You can use this to scan for or add boxes and start controlling them. I recommend
+using the keyboard (super snappy controlling!). Arrow keys (and vi directional
+keys) work, Space plays and pauses, Enter selects, and Esc is home.
+
+You can also just use the command line. Ruku needs to know about your Roku
+box(es). If you haven't added any boxes with the web interface, try:
+
+  ruku scan
+
+This will try to scan your network to find boxes. Read on below if it didn't.
+Assuming you have a least one box set up, you can start sending commands.
+
+  ruku pause   # Play/pause
+  ruku left
+  ruku up
+  ruku select
+  ruku fwd     # Fast forward
+  ruku back    # Rewind
+
+Known commands are: up down left right select home fwd back pause
+
+Making an alias for 'ruku pause' is nice for quick pause/play while computing.
+
+If scanning doesn't work for adding boxes then you'll have to figure out what
+the IP of the box is - it's available in Settings -> Player Info on the box.
+Then add it manually:
+
+  ruku add IP
+
+Any method of adding boxes creates a '.ruku-boxes' file in your $HOME directory
+that contains an IP or hostname per line (followed optionally by a colon and a
+nickname for that box). You can edit or create this yourself. You can see all
+known boxes with:
+
+  ruku list
+
+For more help:
+
+  ruku --help
+
+== Development
+
+=== Source Repository
+
+http://github.com/aaronroyer/ruku
+
+Git clone URL is
+
+* git://github.com/aaronroyer/ruku.git
+
+=== Issues and Bug Reports
+
+You can open issues at Github
+
+* http://github.com/aaronroyer/ruku/issues
+
+Or you can send me an email: aaronroyer@gmail.com
+
+== Legal/Disclaimer
+
+Roku and the Roku logo are trademarks of Roku Inc. in the United States and other countries.
+
+Ruku is not made, supported, or endorsed by Roku Inc.
+
+== License
+
+Ruku is MIT licensed.
+
+:include: MIT-LICENSE
+
+= Other stuff
+
+Author::   Aaron Royer <aaronroyer@gmail.com>
+Requires:: Ruby 1.8.6 or later
+License::  Copyright 2010 by Aaron Royer.
+           Released under an MIT-style license.  See the LICENSE file
+           included in the distribution.
+
+== Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantability and fitness for a particular
+purpose.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ruku'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/test_*.rb']
+    t.verbose = true
+  end
+rescue LoadError
+end
+
+desc "Build gem package"
+task :package => 'ruku.gemspec' do
+  sh "gem build ruku.gemspec"
+end
+
+task :default => [:test]

data/bin/ruku

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+begin
+  require 'ruku/clients/simple'
+  require 'ruku/clients/web'
+rescue LoadError
+  # For testing and dev and stuff
+  $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+  require 'ruku/clients/simple'
+  require 'ruku/clients/web'
+end
+
+if ARGV.empty? || ARGV.include?('-h') || ARGV.include?('--help')
+  help = <<HELP
+Usage: ruku COMMAND/OPERATION
+
+Controller for Roku set top boxes. You will need to first scan the network for
+boxes using 'ruku scan' or add boxes manually using 'ruku add HOST'. Once
+'ruku list' shows an active box, you can start sending commands like
+'ruku pause' (play/pause) or 'ruku left' (Roku remote left button).
+
+COMMAND is a command to be sent to the active Roku box, if there is one.
+Known Roku commands:
+  #{Ruku::Remote::KNOWN_COMMANDS.join(', ')}
+  (you can send unknown commands; the box should ignore)
+The -c is available in case you need to explicitly send a command to the
+  Roku box, to disambiguate from a ruku operation (see below)
+
+OPERATION is for managing the Roku boxes for ruku to use.
+ruku operations:
+  scan                        Scan for Roku boxes on the network
+  list                        List Roku boxes
+  name NUM NAME               Set the name of a box from the list
+  add HOST_OR_IP NAME         Add a box with the HOST_OR_IP and (optional) NAME
+
+Alternatively, use 'ruku --web' to start the server for the web client. You
+should then be able to visit http://localhost:3030 to see the interface. You
+can specify a different port with '-p PORT'.
+
+Options:
+  -c, --force-roku-command    Force send command to the active Roku box
+      --web                   Fire up the web client (port 3030 default)
+  -p, --port PORT             Specify port (only use with --web)
+  -h, --help                  Show this message
+HELP
+  puts help
+elsif ARGV.include?('--web')
+  Ruku::Clients::Web.new.start
+else
+  Ruku::Clients::Simple.new.run_from_command_line
+end

data/lib/ruku/clients/simple.rb

@@ -0,0 +1,232 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. ruku])
+require 'optparse'
+require 'ostruct'
+
+module Ruku
+  module Clients
+    # Provides a little wrapper around a Ruku::Remotes for ease of making
+    # a command line client or messing around in an IRB session
+    class Simple
+      OPERATION_NAMES = %w[scan list add remove name activate help]
+
+      attr_accessor :remotes
+
+      def initialize(rs=Ruku::Remotes.new)
+        @remotes = rs
+      end
+
+      # Run from the command line. This parses options as well as the command
+      # or Ruku operation to run.
+      def run_from_command_line
+        handle_exceptions do
+          remotes.load
+          handle_options
+          execute_command_from_command_line
+        end
+      end
+
+      # Checks the command line arguments for a command (options should have already
+      # been parsed and removed) and then sends a Roku command or runs an operation
+      # on the RemoteManager.
+      def execute_command_from_command_line
+        cmd = ARGV[0]
+        if not cmd
+          puts CMD_LINE_HELP
+        elsif OPERATION_NAMES.include?(cmd) && !options.force_command
+          begin
+            self.send(*ARGV)
+          rescue ArgumentError => ex
+            $stderr.puts "Wrong number of arguments (#{ARGV.size-1}) for operation: #{cmd}"
+          end
+        else
+          send_roku_command cmd
+        end
+      end
+
+      # Client options generally parsed from the command line
+      def options
+        @options ||= OpenStruct.new
+      end
+
+      # Parse and handle command line options
+      def handle_options
+        opts = OptionParser.new do |opts|
+          opts.on('-c', '--force-roku-command') { options.force_command = true }
+        end.parse!
+      end
+
+      # Send a command to the active box
+      def send_roku_command(cmd)
+        if remotes.empty?
+          raise UsageError, "No known Roku boxes\n" +
+            "Try 'ruku scan' to find them, or 'ruku add HOST NAME' to add one manually"
+        else
+          remotes.active.send_roku_command cmd
+        end
+      end
+
+      # Ruku command line "operations" follow
+
+      # Scan for boxes
+      def scan
+        remotes.boxes = Ruku::Remote.scan
+        remotes.each_with_index do |box, i|
+          box.name = "My Roku Box#{i == 1 ? i+1 : ''}"
+        end
+        if remotes.empty?
+          puts 'Did not find any Roku boxes'
+        else
+          puts 'Roku boxes found:'
+          remotes.each_with_index do |box, i|
+            print "#{i+1}. #{box.name || '(no name)'} at #{box.host}"
+            print "#{' <-- active' if i == remotes.active_index && remotes.size > 1}\n"
+          end
+          store
+        end
+      end
+
+      # List the boxes we know about
+      def list
+        if remotes.empty?
+          puts "No Roku boxes known\n" +
+            "Use the scan or add operations to find or add boxes"
+        else
+          puts 'Roku boxes:'
+          remotes.each_with_index do |box, i|
+            print "#{i+1}. #{box.name || '(no name)'} at #{box.host}"
+            print "#{' <-- active' if i == remotes.active_index}\n"
+          end
+        end
+      end
+
+      # Add a box
+      def add(host=nil, name='My Roku Box')
+        raise UsageError, 'Must specify host of box to add' if not host
+
+        if existing = remotes.find_by_host(host)
+          existing.name = name
+        else
+          remotes.add(Ruku::Remote.new(host, name))
+        end
+        store
+        puts "Added remote with host: #{host} and name: #{name}"
+      end
+
+      # Remove a box with the given number (from the list operation) or hostname
+      def remove(number=nil)
+        raise UsageError, 'Must specify number from boxes list or hostname/IP address' if not number
+
+        prev_count = remotes.size
+        msg = 'Box '
+        if number.is_a?(Integer) || number =~ /^\d+$/
+          index = number.to_i - 1
+          remotes.boxes.delete_at(index)
+          msg << (index + 1).to_s
+        else
+          remotes.remove(number)
+          msg << "with IP/host #{number}"
+        end
+        msg << ' removed'
+
+        if prev_count == remotes.size + 1
+          remotes.store
+          puts msg
+        else
+          puts "Could not remove box: #{number}"
+        end
+      end
+
+      def name(number=nil, name=nil)
+        raise UsageError, 'Must specify number from remotes list or IP/hostname' if not number
+        raise UsageError, 'Must specify name for box' if not name
+
+        msg = 'Box '
+        if number.is_a?(Integer) || number =~ /^\d+$/
+          self[number.to_i].name = name
+          msg << (number).to_s
+        else
+          remotes.find_by_host(number).name = name
+          msg << "with IP/host #{number}"
+        end
+        msg << " renamed to #{name}"
+        store
+        puts msg
+      end
+
+      def activate(number=nil)
+        raise UsageError, 'Must specify number from remotes list or IP/hostname' if not number
+
+        msg = 'Box '
+        box = if number.is_a?(Integer) || number =~ /^\d+$/
+          msg << (number).to_s
+          self[number.to_i]
+        else
+          msg << "with IP/host #{number}"
+          remotes.find_by_host(number)
+        end
+
+        if box
+          remotes.set_active(box)
+          store
+          puts msg + ' activated for use'
+        else
+          puts 'Unknown box specified'
+        end
+      end
+
+      def help
+        puts CMD_LINE_HELP
+      end
+
+      # Methods not directly available from the command line
+
+      # Get remotes using 1-based index for the command line
+      def [](num)
+        remotes[num-1]
+      end
+
+      # Assign and store remotes using 1-based index for the command line
+      def []=(num, box)
+        remotes[num-1] = box
+        store
+      end
+
+      def store
+        remotes.store
+      end
+
+      private
+
+      def handle_exceptions
+        begin
+          yield
+        rescue SystemExit
+          exit
+        rescue UsageError => ex
+          $stderr.puts ex.message
+          exit 1
+        rescue OptionParser::InvalidOption => ex
+          $stderr.puts ex.message
+          exit 1
+        rescue Exception => ex
+          display_error_message ex
+          exit 1
+        end
+      end
+
+      def display_error_message(ex)
+        msg = <<MSG
+The Ruku application has aborted! If this is unexpected, you may want to open
+an issue at github.com/aaronroyer/ruku to get a possible bug fixed. If you do,
+please include the debug information below.
+MSG
+        $stderr.puts msg
+        $stderr.puts ex.message
+        $stderr.puts ex.backtrace
+      end
+    end
+
+    class UsageError < Exception
+    end
+  end
+end

data/lib/ruku/clients/tk.rb

@@ -0,0 +1,36 @@
+
+module Ruku
+  class TkClient
+    def initialize
+      sm = YAMLStorage.new
+      sm.load
+      @remote = Remote.new(sm.boxes.first.host, 8080)
+
+      launch
+    end
+
+    def launch
+      require 'tk'
+      root = TkRoot.new() { title "Roku Remote"}
+      root.bind('KeyPress-Left'){
+        @remote.left
+      }
+      root.bind('KeyPress-Right'){
+        @remote.right
+      }
+      root.bind('KeyPress-Up'){
+        @remote.up
+      }
+      root.bind('KeyPress-Down'){
+        @remote.down
+      }
+      root.bind('KeyPress-Return'){
+        @remote.select
+      }
+      root.bind('KeyPress-space'){
+        @remote.pause
+      }
+      Tk.mainloop
+    end
+  end
+end

data/lib/ruku/clients/web.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. ruku])
+require 'rubygems'
+require 'json'
+require 'webrick'
+
+include WEBrick
+
+module Ruku
+  module Clients
+    class Web
+      attr_reader :options
+
+      def initialize(opts={})
+        @options = OpenStruct.new(opts)
+        handle_options
+
+        server_options = {
+          :Port => options.port || 3030,
+          :DocumentRoot => File.join(File.dirname(__FILE__), 'web_static')
+        }
+        @server = HTTPServer.new(server_options)
+
+        ['INT', 'TERM'].each do |signal|
+          trap(signal) { @server.shutdown }
+        end
+
+        @server.mount("/ajax", AjaxServlet)
+      end
+
+      def start
+        @server.start
+      end
+
+      # Parse and handle command line options
+      def handle_options
+        OptionParser.new do |opts|
+          opts.on('-p', '--port PORT') {|p| options.port = p.to_i }
+          opts.on('--web') { } # ignore
+        end.parse!
+      end
+
+      class AjaxServlet < HTTPServlet::AbstractServlet
+        def do_GET(req, resp)
+          @remote_manager ||= Remotes.new
+          @remote_manager.load
+
+          cmd = req.query['command']
+          action = req.query['action']
+          if cmd
+            resp.body = run_command(cmd, req.query['host'])
+            raise HTTPStatus::OK
+          elsif action
+            resp.body = perform_action(action, req.query['data'])
+            raise HTTPStatus::OK
+          else
+            raise HTTPStatus::PreconditionFailed.new("Missing parameter: 'command' or 'action'")
+          end
+        end
+
+        protected
+
+        # Send a regular remote command to the active remote or the remote with the specified host
+        def run_command(cmd, host=nil)
+          remote = host.nil? ? @remote_manager.active : @remote_manager.find_by_host(host)
+          if remote
+            remote.send_roku_command cmd
+            "success"
+          else
+            "error"
+          end
+        end
+
+        # Perform some remote management action
+        def perform_action(action, data)
+          if action == 'list'
+            # Get a list of known remotes
+            @remote_manager.remotes_to_json
+          elsif action == 'update'
+            @remote_manager.remotes_from_json(data)
+            @remote_manager.store
+            "success"
+          elsif action =~ /^scan/
+            # Scan the network for Roku boxes - two different action values are
+            # expected: scanForFirst or scanForAll
+
+            # With scanForFirst try to find only one box because that will be the common case
+            @remote_manager = Remotes.new(Remote.scan(action == 'scanForFirst'))
+            @remote_manager.active.name = 'My Roku Box' if @remote_manager.active
+            @remote_manager.store
+            @remote_manager.remotes_to_json
+          else
+            raise HTTPStatus::PreconditionFailed.new("Unknown action: '#{action}'")
+          end
+        end
+      end
+    end
+  end
+
+  class Remote
+    def to_json
+      "{\"host\":\"#{@host}\",\"name\":\"#{@name}\",\"port\":#{@port}}"
+    end
+  end
+
+  class Remotes
+    def remotes_to_json
+      "{\"remotes\":[#{ @boxes.map{|b| b.to_json}.join(',') }], \"active\":#{@active_index}}"
+    end
+
+    def remotes_from_json(json)
+      parsed = JSON.parse(json)
+      @boxes = []
+      parsed['remotes'].each {|r| @boxes << Remote.new(r['host'], r['name'], r['port'] || 8080) }
+      @active_index = parsed['active'] || 0
+    end
+  end
+end