ruby-mythtv 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 (2008-06-08)
+
+* Initial release onto GitHub/Rubyforge

data/License.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2008 Nick Ludlam
+
+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.txt

@@ -0,0 +1,68 @@
+= Ruby-mythtv
+  
+== Description
+
+A pure Ruby implementation of the MythTV Backend protocol to allow interaction with a MythTV server. Features include browsing and streaming of recordings, and thumbnail generation. See http://github.com/nickludlam/ruby-mythtv for more details.
+
+== Requirements
+
+This gem does not yet support multiple protocol versions, so it requires an up-to-date installation of MythTV v0.21, and specifically implements protocol version 40. For more information on the history of the MythTV protocol, see http://www.mythtv.org/wiki/index.php/Protocol
+
+== Install
+
+  $ gem sources -a http://gems.github.com/ (only required once)
+  $ gem install nickludlam-ruby-mythtv
+  
+== Source
+
+The ruby-mythtv source is available on GitHub at
+
+  http://github.com/nickludlam/ruby-mythtv
+  
+and can be cloned from
+
+  git://github.com/nickludlam/ruby-mythtv.git
+  
+== Basic usage
+
+  require 'ruby-mythtv'
+  
+  # Connect to the server
+  backend = MythTV::Backend.new(:host => 'mythtv.localdomain')
+  
+  # Get an array of recordings
+  recordings = backend.query_recordings
+  
+  # Generate a thumbnail of the most recent recording, at 60 seconds in from the start
+  preview_thumbnail = @backend.preview_image(recordings[0], :secs_in => 60)
+  File.open('preview_thumbnail.png', 'w') { |f| f.write(preview_thumbnail) }
+
+== Author
+
+Written in 2008 by Nick Ludlam <nick@recoil.org>
+
+== License
+
+Copyright (c) 2008 Nick Ludlam
+
+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/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+Gem::manage_gems
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = %q{ruby-mythtv}
+  s.version = "0.1.0"
+ 
+  s.specification_version = 2 if s.respond_to? :specification_version=
+ 
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nick Ludlam"]
+  s.date = %q{2008-06-08}
+  s.description = %q{Ruby implementation of the MythTV communication protocol}
+  s.email = %q{nick@recoil.org}
+  s.extra_rdoc_files = ["History.txt", "License.txt", "README.txt"]
+  s.files = ["History.txt", "License.txt", "README.txt", "Rakefile", "lib/ruby-mythtv.rb", "lib/mythtv/backend.rb", "lib/mythtv/recording.rb", "test/test_backend.rb", "test/test_helper.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/nickludlam/ruby-mythtv/}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{ruby-mythtv}
+  s.rubygems_version = %q{0.1.0}
+  s.summary = %q{Ruby implementation of the MythTV backend protocol}
+  s.test_files = ["test/test_backend.rb", "test/test_helper.rb"]
+end
+
+Rake::GemPackageTask.new(spec) do |pkg| 
+  pkg.need_tar = true 
+end 
+
+task :build => "pkg/#{spec.name}-#{spec.version}.gem" do
+  puts "Generated latest version"
+end
+
+desc "Run basic unit tests"
+Rake::TestTask.new("test_units") do |t|
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+  t.warning = true
+end
+
+desc "Run unit tests as default"
+task :default => :test_units

data/lib/mythtv/backend.rb

@@ -0,0 +1,416 @@
+require 'socket'
+require 'uri'
+require 'net/http'
+
+module MythTV
+
+  # Raised when we get a response that isn't what we expect
+  class CommunicationError < RuntimeError
+  end
+  
+  # Raised when we have a protocol version mismatch
+  class ProcolError < RuntimeError
+  end
+  
+  # Raised when a method is passed incomplete initialisation information
+  class ArgumentError < RuntimeError
+  end
+  
+  class Backend
+    include Socket::Constants
+  
+    # Our current protocol implementation. TODO: Consider how we support
+    # multiple protocol versions within a single gem. In theory this is
+    # just a case of limiting the number of attr_accessors that are
+    # class_eval'd onto MythTV::Recording, and bumping the number below
+    MYTHTV_PROTO_VERSION = 40
+    
+    # The currently defined field separator in responses
+    FIELD_SEPARATOR = "[]:[]"
+    
+    # The payload size we request from the backend when performing a filetransfer
+    TRANSFER_BLOCKSIZE = 65535
+
+    attr_reader :host,
+                :port,
+                :status_port,
+                :connection_type,
+                :filetransfer_port,
+                :filetransfer_size,
+                :socket
+
+    # Open the socket, make a protocol check, and announce we'd like an interactive
+    # session with the backend server
+    def initialize(options = {})
+      default_options = { :port => 6543, :status_port => 6544, :connection_type => :playback }
+      options = default_options.merge(options)
+      
+      raise ArgumentError, "You must specify a :host key and value to initialize()" unless options.has_key?(:host)
+      
+      @host = options[:host]
+      @port = options[:port]
+      @status_port = options[:status_port]
+
+      @socket = TCPSocket.new(@host, @port)
+      
+      check_proto
+      
+      if options[:connection_type] == :playback
+        announce_playback()
+      elsif options[:connection_type] == :filetransfer
+        announce_filetransfer(options[:filename])
+      else
+        raise ArgumentError, "Unknown connection type '#{options[:connection_type]}'"
+      end
+    end
+
+    ############################################################################
+    # COMMAND WRAPPERS #########################################################
+
+    # Tell the backend we speak a specific version of the protocol. Raise
+    # an error if the backend does not accept that version.
+    def check_proto
+      send("MYTH_PROTO_VERSION #{MYTHTV_PROTO_VERSION}")
+      response = recv
+      unless response[0] == "ACCEPT" && response[1] == MYTHTV_PROTO_VERSION.to_s
+        close
+        raise ProcolError, response.join(": ")
+      end
+    end
+
+    # Announce ourselves as a Playback connection.
+    # http://www.mythtv.org/wiki/index.php/Myth_Protocol_Command_ANN for details
+    def announce_playback
+      client_hostname = Socket.gethostname
+      
+      # We don't want to receive broadcast events for this connection
+      want_events = "0"
+      
+      send("ANN Playback #{client_hostname} #{want_events}")
+      response = recv
+
+      unless response[0] == "OK"
+        close
+        raise CommunicationError, response.join(": ")
+      else
+        @connection_type = :playback  # Not currently used, but may be in later versions
+      end
+    end
+
+    # Announce ourselves as a FileTransfer connection.
+    # http://www.mythtv.org/wiki/index.php/Myth_Protocol_Command_ANN for details
+    def announce_filetransfer(filename = nil)
+      raise ArgumentError, "you must specify a filename" if filename.nil?
+      
+      client_hostname = Socket.gethostname
+  
+      filename = "/" + filename if filename[0] != "/"  # Ensure leading slash
+  
+      send("ANN FileTransfer #{client_hostname}#{FIELD_SEPARATOR}#{filename}")
+      response = recv
+  
+      # Should get back something like:
+      #   OK[]:[]<socket number>[]:[]<file size high 32 bits>[]:[]<file size low 32 bits>
+      unless response[0] == "OK"
+        close
+        raise CommunicationError, response.join(": ")
+      else
+        @filetransfer_port = response[1]
+        @filetransfer_size = [response[3].to_i, response[2].to_i].pack("ll").unpack("Q")[0]
+        @connection_type = :filetransfer   # Not currently used, but may be in later versions
+      end
+    end
+
+    # Simple method to query the load of the backend server. Returns a hash with keys for
+    # :one_minute, :five_minute and :fifteen_minute
+    def query_load
+      send("QUERY_LOAD")
+      response = recv
+      { :one_minute => response[0].to_f, :five_minute => response[1].to_f, :fifteen_minute => response[2].to_f }
+    end
+
+    # List all recordings stored on the backend. You can filter via the storagegroup property,
+    # and this defaults to /Default/, to list the recordings, rather than any which are from
+    # LiveTV sessions.
+    # 
+    # Returns an array of MythTV::Recording objects
+    def query_recordings(options = {})
+      default_options = { :filter => { :storagegroup => /Default/ } }
+      options = default_options.merge(options)
+      
+      send("QUERY_RECORDINGS Play")
+      response = recv
+
+      recording_count = response.shift.to_i
+      recordings = []
+
+      while recording_count > 0
+        recording_array = response.slice!(0, Recording::RECORDINGS_ELEMENTS.length)
+
+        recording = Recording.new(recording_array)
+
+        options[:filter].each_pair do |k, v|
+          recordings.push(recording) if recording.send(k) =~ v
+        end
+        
+        recording_count -= 1
+      end
+
+      recordings = recordings.sort_by { |r| r.startts }
+      recordings.reverse!
+    end
+    
+    # This method will return the next free recorder that the backend has available to it
+    # TODO: Fix up the checking of response. Does it return an IP or address in element 1?
+    def get_next_free_recorder
+      send("GET_NEXT_FREE_RECORDER#{FIELD_SEPARATOR}-1")
+      response = recv
+
+      # If we have a recorder free, return the recorder id, otherwise false
+      response[0] == "-1" ? false : response[0].to_i
+    end
+    
+    # This will trigger the backend to start recording Live TV from a certain channel.
+    # TODO: This is currently buggy, so avoid until it's fixed in a later release
+    def spawn_live_tv(recorder_id, start_channel = 1)
+      client_hostname = Socket.gethostname
+      spawn_time = Time.now.strftime("%y-%m-%dT%H:%M:%S")
+      chain_id = "livetv-#{client_hostname}-#{spawn_time}"
+      
+      query_recorder(recorder_id, "SPAWN_LIVETV", [chain_id, 0, "#{start_channel}"])
+      response = recv
+      
+      # If we have an "OK" back, then return the chain_id, otherwise return false
+      response[0] == "OK" ? chain_id : false
+    end
+    
+    # This method returns an array of recording objects which describe which programmes
+    # are to be recorded as far as the current EPG data extends
+    def query_scheduled
+      send("QUERY_GETALLSCHEDULED")
+      response = recv
+      
+      recording_count = response.shift.to_i
+      recordings = []
+
+      while recording_count > 0
+        recording_array = response.slice!(0, Recording::RECORDINGS_ELEMENTS.length)
+        recordings << Recording.new(recording_array)
+        recording_count -= 1
+      end
+
+      recordings = recordings.sort_by { |r| r.startts }
+      recordings.reverse!
+    end
+
+    # Wrap the QUERY_MEMSTATS backend command. Returns a hash with keys for
+    # :used_memory, :free_memory, :total_swap and :free_swap
+    def query_memstats
+      send("QUERY_MEMSTATS")
+      response = recv
+      
+      # We expect to get back 4 elements only for this method
+      raise CommunicationError, "Unexpected response from QUERY_MEMSTATS: #{response.join(":")}" if response.length != 4
+
+      { :used_memory => response[0].to_i, :free_memory => response[1].to_i, :total_swap => response[2].to_i, :free_swap => response[3].to_i }
+    end
+
+    # Wrap the QUERY_UPTIME backend command. Return a single integer
+    def query_uptime
+      send("QUERY_UPTIME")
+      response = recv
+
+      # We expect to get back 1 element only for this method
+      raise CommunicationError, "Unexpected response from QUERY_UPTIME: #{response.join(":")}" if response.length != 1
+
+      response[0].to_i
+    end
+
+    # This is used when transfering files from the backend. It requests that the next block of data
+    # be sent to the socket, ready for us to recieve
+    def query_filetransfer_transfer_block(sock_num, size)
+      query = "QUERY_FILETRANSFER #{sock_num}#{FIELD_SEPARATOR}REQUEST_BLOCK#{FIELD_SEPARATOR}#{size}"
+      send(query)
+    end
+    
+    # Tell the backend we've finished talking to it for the current session
+    def close
+      send("DONE")
+      @socket.close unless @socket.nil?
+    end
+    
+    ############################################################################
+    # STATUS PORT METHODS
+    
+    # Returns a string which contains a PNG image of the this recording. The time offset
+    # into the file defaults to two minutes, and the default image width is 120 pixels.
+    # This uses the separate status port, rather than talking over the backend control port
+    def preview_image(recording, options = {})
+      default_options = { :height => 120, :secs_in => 120 }
+      options = default_options.merge(options)
+    
+      # Generate our query string for the MythTV request
+      query_string = "ChanId=#{recording.chanid}&StartTime=#{recording.myth_delimited_recstart}"
+
+      # Add in the optional parameters if they were specified
+      query_string += "&SecsIn=#{options[:secs_in]}" if options[:secs_in]
+      query_string += "&Height=#{options[:height]}" if options[:height]
+      query_string += "&Width=#{options[:width]}" if options[:width]
+    
+      url = URI::HTTP.build( { :host  => @host,
+                               :port  => @status_port,
+                               :path  => "/Myth/GetPreviewImage",
+                               :query => query_string } )
+      
+      # Make a GET request, and store the image data returned
+      image_data = Net::HTTP.get(url)
+
+      image_data
+    end
+    
+    ############################################################################
+    # FILETRANSFER RELATED METHODS
+
+    # Yield into the given block with the data buffer of size TRANSFER_BLOCKSIZE
+    def stream(recording, options = {}, &block)
+    
+      # Initialise a new connection of connection_type => :filetransfer
+      data_conn = Backend.new(:host => @host,
+                              :port => @port,
+                              :status_port => @status_port,
+                              :connection_type => :filetransfer,
+                              :filename => recording.path)
+
+      ft_port = data_conn.filetransfer_port
+      ft_size = data_conn.filetransfer_size
+    
+      blocksize = options.has_key?(:transfer_blocksize) ? options[:transfer_blocksize] : TRANSFER_BLOCKSIZE
+
+      total_transfered = 0
+
+      begin
+        # While we still have data to fetch
+        while total_transfered < ft_size
+          # Make a request for the backend to send data
+          query_filetransfer_transfer_block(ft_port, blocksize)
+
+          # Collect the socket data in a string
+          buffer = ""
+       
+          while buffer.length < blocksize
+            buffer += data_conn.socket.recv(blocksize)
+            # Special case for when the remainer to fetch is less than TRANSFER_BLOCKSIZE
+            break if total_transfered + buffer.length == ft_size
+          end
+
+          # Yield into the given block to allow the user to process as a stream
+          yield buffer
+       
+          total_transfered += buffer.length
+       
+          # If the user has only asked for a certain amount of data, stop when we hit this
+          break if options[:max_length] && total_transfered > options[:max_length]
+        end
+      ensure
+        # We need to close the data connection regardless of what is going on when we yield
+        data_conn.close
+      end
+      
+    end
+    
+    # Download the file to a given location, either with a default filename, or
+    # one specified by the caller
+    def download(recording, filename = nil)
+      
+      # If no filename is given, we default to <title>_<recstartts>.<extension>
+      if filename.nil?
+        filename = recording.title + "_" +
+                   recording.myth_nondelimited_recstart + File.extname(recording.filename) 
+      end
+
+      File.open(filename, "wb") do |f|
+        stream(recording) { |data| f.write(data) }
+      end
+    end
+    
+    # TODO: The LiveTV methods are still work-in-progress.
+    def start_livetv(channel = 1)
+      # If we have a free recorder...
+      if recorder_id = get_next_free_recorder
+        puts "Got a recorder ID of #{recorder_id}"
+        # If we can spawn live tv...
+        if chain_id = spawn_live_tv(recorder_id, channel)
+          puts "Got a chain ID of #{chain_id}"
+          # Send the two backend event messages
+          backend_message(["RECORDING_LIST_CHANGE", "empty"])
+          puts "Sent RECORDING_LIST_CHANGE"
+          backend_message(["LIVETV_CHAIN UPDATE #{chain_id}", "empty"])
+          puts "Sent LIVETV_CHAIN UPDATE"
+          
+          # Find the filename from here...
+          query_recorder(recorder_id, "GET_CURRENT_RECORDING")
+          cur_rec = recv
+          puts "Current recording is:"
+          puts cur_rec.inspect
+          recording = Recording.new(cur_rec)
+        else
+          puts "spawn_live_tv returned with false or nil"
+          return false
+        end
+      else
+        puts "get_next_free_recorder returned with false or nil"
+        return false
+      end
+    end
+
+    # TODO: Finish this off. Check response?
+    def stop_livetv(recorder_id)
+      query_recorder(recorder_id, "STOP_LIVETV")
+      response = recv
+    end
+    
+    private
+    
+    # Private method for the generic QUERY_RECORDER command, which itself
+    # wraps a number of sub-commands. 
+    def query_recorder(recorder_id, sub_command, options = [])
+      # place the recorder_id and sub_command strings on the front of options
+      # and join with the FIELD_SEPARATOR. This forms the QUERY_RECORDER command
+      cmd_string = options.unshift(recorder_id, sub_command)
+      send("QUERY_RECORDER #{options.join(FIELD_SEPARATOR)}")
+    end
+
+    # Wraps the BACKEND_MESSAGE command, which just sends events to the
+    # backend, with no responses provided. Only events expected are
+    # RECORDING_LIST_CHANGE, and LIVETV CHAIN_UPDATE
+    def backend_message(event_message = [])
+      event_message.unshift("BACKEND_MESSAGE")
+      send(message.join(FIELD_SEPARATOR))
+    end
+    
+    # Send a message to the MythTV Backend
+    def send(message)
+      length = sprintf("%-8d", message.length)
+      @socket.write("#{length}#{message}")
+    end
+    
+    # Fetch a reply from the MythTV Backend. Automatically splits around the
+    # FIELD_SEPARATOR
+    def recv
+      count = @socket.recv(8).to_i
+
+      # Where we accumulate the response
+      response = ""
+
+      # Keep fetching data until we have received the entire response
+      while (count > 0) do
+        buf = @socket.recv(TRANSFER_BLOCKSIZE)
+        response += buf
+        count -= buf.length
+      end
+
+      response.split(FIELD_SEPARATOR)
+    end
+    
+  end # end Backend
+end # end MythTV

data/lib/mythtv/recording.rb

@@ -0,0 +1,67 @@
+module MythTV
+
+  class Recording
+    # Represents a recording that is held on the MythTV Backend server we are communicating with.
+    #
+    # The keys included here, and the order in which they are specified seem to change between protocol version bumps
+    # on the MythTV backend, so this array affects both the initialize() and to_s() methods.
+    #
+    # Found inside mythtv/libs/libmythtv/programinfo.cpp in the MythTV subversion repository
+    RECORDINGS_ELEMENTS = [ :title, :subtitle, :description, :category, :chanid, :chanstr, :chansign, :channame,
+                            :pathname, :filesize_hi, :filesize_lo, :startts, :endts, :duplicate, :shareable, :findid,
+                            :hostname, :sourceid, :cardid, :inputid, :recpriority, :recstatus, :recordid, :rectype,
+                            :dupin, :dupmethod, :recstartts, :recendts, :repeat, :programflags, :recgroup, :chancommfree,
+                            :chanOutputFilters, :seriesid, :programid, :lastmodified, :stars, :originalAirDate,
+                            :hasAirDate, :playgroup, :recpriority2, :parentid, :storagegroup, :audioproperties,
+                            :videoproperties, :subtitleType ]
+    
+    # Warning, metaprogramming ahead: Create attr_accessors for each symbol defined in MythTVRecording::RECORDINGS_ELEMENTS
+    def initialize(recording_array)
+      class << self;self;end.class_eval { RECORDINGS_ELEMENTS.each { |field| attr_accessor field } }
+      
+      RECORDINGS_ELEMENTS.each_with_index do |field, i|
+        send(field.to_s + '=', recording_array[i])
+      end
+    end
+  
+    # A string representation of a Recording is used when we converse with the MythTV Backend about that recording
+    def to_s
+      RECORDINGS_ELEMENTS.collect { |field| self.send(field.to_s) }.join(MythTV::Backend::FIELD_SEPARATOR) + MythTV::Backend::FIELD_SEPARATOR
+    end
+    
+    # Convenience methods to access the start and end times as Time objects, and duration as an Float
+    def start;  Time.at(recstartts.to_i); end
+    def end;  Time.at(recendts.to_i); end
+    def duration; self.end - self.start; end
+  
+    # Cribbed from the Mythweb PHP code. Required for some method calls to the backend
+    def myth_delimited_recstart;  myth_format_time(recstartts, :delimited); end
+  
+    # Formats the start time for use in the copy process, as the latter half of the filename is a non-delimited time string
+    def myth_nondelimited_recstart; myth_format_time(recstartts, :nondelimited);  end
+    
+    # Convert the lo/hi long representation of the filesize into a string
+    def filesize
+      [filesize_lo.to_i, filesize_hi.to_i].pack("ll").unpack("Q").to_s
+    end
+    
+    # Fetch the path section of the pathname
+    def path;  URI.parse(pathname).path; end
+    
+    # Strip the filename out from the path returned by the server
+    def filename;  File.basename(URI.parse(pathname).path); end
+  
+    private
+  
+    def myth_format_time(timestamp, format = :nondelimited)
+      timestamp = timestamp.to_i if timestamp.class != Bignum
+      case format
+      when :nondelimited
+        Time.at(timestamp).strftime("%Y%m%d%H%M%S")
+      when :delimited
+        Time.at(timestamp).strftime("%Y-%m-%dT%H:%M:%S")
+      end
+    end
+      
+  end # end Recording
+end # end MythTV

data/lib/ruby-mythtv.rb

@@ -0,0 +1,31 @@
+# The MIT License
+# 
+# Copyright (c) 2008 Nick Ludlam
+# 
+# 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.
+
+module MythTV;
+  VERSION = '0.1.0'
+end
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'mythtv/backend.rb'
+require 'mythtv/recording.rb'
+

data/test/test_backend.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestBackend < Test::Unit::TestCase
+  def setup
+    abort("\nERROR: You must set the environment variable MYTHTV_BACKEND to the name of your MythTV backend server\n\n") unless ENV['MYTHTV_BACKEND']
+    host = ENV['MYTHTV_BACKEND']
+    @backend = MythTV::Backend.new(:host => host)
+  end
+  
+  def teardown
+    @backend.close
+  end
+  
+  # Assuming the system is up for more than 0 seconds!
+  def test_connection
+    uptime = @backend.query_uptime
+    assert uptime > 0
+  end
+  
+  # Assuming there is at least one recording on the test server
+  def test_get_recordings
+    recordings = @backend.query_recordings
+    assert recordings.length > 0
+    assert_kind_of MythTV::Recording, recordings[0]
+  end
+
+  # Assuming there is at least one scheduled recording on the test server
+  def test_get_scheduled
+    scheduled = @backend.query_scheduled
+    assert scheduled.length > 0
+    assert_kind_of MythTV::Recording, scheduled[0]
+  end
+  
+  # Test the generation of a preview image
+  def test_make_preview_image
+    recordings = @backend.query_recordings
+    
+    recording = recordings[0]
+    test_image = @backend.preview_image(recording, :secs_in => 1)
+    assert test_image.length > 0
+    
+    # Define an array of the decimal values of the PNG magic number
+    png_sig = [137, 80, 78, 71, 13, 10, 26, 10]
+    test_image_sig = (0..7).collect { |i| test_image[i] }
+    
+    assert_equal test_image_sig, png_sig
+  end
+  
+  # Don't run this by default as it takes a while. Possibly limit to 100kB?
+  #def test_download
+  #  recordings = @backend.query_recordings
+  #  
+  #  recording = recordings[-2]
+  #  @backend.download(recording)
+  #end
+  
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/ruby-mythtv'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-mythtv
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nick Ludlam
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-08 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Ruby implementation of the MythTV communication protocol
+email: nick@recoil.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- README.txt
+files: 
+- History.txt
+- License.txt
+- README.txt
+- Rakefile
+- lib/ruby-mythtv.rb
+- lib/mythtv/backend.rb
+- lib/mythtv/recording.rb
+- test/test_backend.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/nickludlam/ruby-mythtv/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-mythtv
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: Ruby implementation of the MythTV backend protocol
+test_files: 
+- test/test_backend.rb
+- test/test_helper.rb