simple_pvr 0.0.1

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,219 @@
+# Taken from the cucumber-rails project.
+# IMPORTANT: This file is generated by cucumber-sinatra - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a
+# newer version of cucumber-sinatra. Consider adding your own code to a new file
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(locator) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^\"]*)"(?: within "([^\"]*)")?$/ do |button, selector|
+  with_scope(selector) do
+    click_button(button)
+  end
+end
+
+When /^(?:|I )follow "([^\"]*)"(?: within "([^\"]*)")?$/ do |link, selector|
+  with_scope(selector) do
+    click_link(link)
+  end
+end
+
+When /^(?:|I )fill in "([^\"]*)" with "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, value, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+When /^(?:|I )fill in "([^\"]*)" for "([^\"]*)"(?: within "([^\"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following(?: within "([^\"]*)")?:$/ do |selector, fields|
+  with_scope(selector) do
+    fields.rows_hash.each do |name, value|
+      When %{I fill in "#{name}" with "#{value}"}
+    end
+  end
+end
+
+When /^(?:|I )select "([^\"]*)" from "([^\"]*)"(?: within "([^\"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    select(value, :from => field)
+  end
+end
+
+When /^(?:|I )check "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    check(field)
+  end
+end
+
+When /^(?:|I )uncheck "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    uncheck(field)
+  end
+end
+
+When /^(?:|I )choose "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    choose(field)
+  end
+end
+
+When /^(?:|I )attach the file "([^\"]*)" to "([^\"]*)"(?: within "([^\"]*)")?$/ do |path, field, selector|
+  with_scope(selector) do
+    attach_file(field, path)
+  end
+end
+
+Then /^(?:|I )should see JSON:$/ do |expected_json|
+  require 'json'
+  expected = JSON.pretty_generate(JSON.parse(expected_json))
+  actual   = JSON.pretty_generate(JSON.parse(response.body))
+  expected.should == actual
+end
+
+Then /^(?:|I )should see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_content(text)
+    else
+      assert page.has_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/(?: within "([^\"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_xpath('//*', :text => regexp)
+    else
+      assert page.has_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_content(text)
+    else
+      assert page.has_no_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/(?: within "([^\"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_xpath('//*', :text => regexp)
+    else
+      assert page.has_no_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field(?: within "([^\"]*)")? should contain "([^\"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field(?: within "([^\"]*)")? should not contain "([^\"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" checkbox(?: within "([^\"]*)")? should be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should == 'checked'
+    else
+      assert_equal 'checked', field_checked
+    end
+  end
+end
+
+Then /^the "([^\"]*)" checkbox(?: within "([^\"]*)")? should not be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should_not
+      field_checked.should_not == 'checked'
+    else
+      assert_not_equal 'checked', field_checked
+    end
+  end
+end
+
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')}
+
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end

data/features/support/env.rb

@@ -0,0 +1,28 @@
+ENV['RACK_ENV'] = 'test'
+require 'capybara'
+require 'capybara/cucumber'
+require 'rspec'
+
+require File.join(File.dirname(__FILE__), '../../lib/simple_pvr')
+
+SimplePvr::PvrInitializer.setup_for_integration_test
+SimplePvr::RecordingPlanner.read
+
+Capybara.app = eval "Rack::Builder.new {( " + SimplePvr::PvrInitializer.rack_maps_file + ")}"
+Capybara.default_driver = :selenium
+Capybara.default_wait_time = 5
+Capybara.ignore_hidden_elements = true # AngularJS shows and hides elements all the time, so this is important
+
+class SimplePvrWorld
+  include Capybara::DSL
+  include RSpec::Expectations
+  include RSpec::Matchers
+end
+
+World do
+  SimplePvrWorld.new
+end
+
+Before do
+  SimplePvr::Model::DatabaseInitializer.clear
+end

data/features/support/paths.rb

@@ -0,0 +1,17 @@
+module NavigationHelpers
+  def path_to(page_name)
+    case page_name
+    when 'the schedules page'
+      '/'
+    when 'the channel overview page'
+      '/channels'
+    when 'the status page'
+      '/status'
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/features/week_overview.feature

@@ -0,0 +1,39 @@
+Feature: Week overview
+  In order to find out what's on a specific channel
+  As a user
+  I want the weekly schedules for a channel
+
+Background:
+  Given the following channels:
+    | name      |
+    | Channel 1 |
+    | Channel 2 |
+  And the following programmes:
+    | title              | subtitle                        | channel   | day |
+    | Bonderøven         | Danish documentary              | Channel 1 |   1 |
+    | Blood and Bone     | American action movie from 2009 | Channel 1 |   2 |
+    | The future is here | American action movie from 2032 | Channel 1 |   8 |
+    | The past is here   | American action movie from 1992 | Channel 1 |  -1 |
+    | Noddy              | Children's programme            | Channel 2 |   3 |
+  And I have navigated to the week overview for channel "Channel 1"
+
+Scenario: I see programmes for the following week on the channel
+  Then I should see "Bonderøven"
+  And I should see "Blood and Bone"
+  But I should not see "The future is here"
+  And I should not see "Noddy"
+
+Scenario: I can go to the next week
+  When I follow ">>"
+  Then I should see "The future is here"
+  But I should not see "Bonderøven"
+
+Scenario: I can go to the previous week
+  When I follow "<<"
+  Then I should see "The past is here"
+  But I should not see "Bonderøven"
+
+Scenario: I can go to the programme description
+  Given I follow "Bonderøven"
+  Then I should see "Danish documentary"
+  And I should see "Episode 23/40"

data/lib/simple_pvr/ffmpeg.rb

@@ -0,0 +1,22 @@
+module SimplePvr
+  class Ffmpeg
+    def self.create_thumbnail_for(path)
+      thumbnail_file_name = path + '/thumbnail.png'
+      log_file_name = path + '/thumbnail.png.log'
+
+      pid = Process.spawn("ffmpeg -i \"#{path}/stream.ts\" -ss 00:05:00.000 -f image2 -vframes 1 -vf scale=300:ih*300/iw \"#{thumbnail_file_name}\" > \"#{log_file_name}\" 2>&1")
+      Process.detach(pid)
+    end
+
+    def self.transcode_to_webm(path)
+      stream_file_name = path + '/stream.ts'
+      webm_file_name = path + '/stream.webm'
+      log_file_name = path + '/stream.webm.log'
+
+      unless File.exists?(webm_file_name)
+        pid = Process.spawn("ffmpeg -i \"#{stream_file_name}\" -b 64k -vf scale=640:ih*640/iw \"#{webm_file_name}\" > \"#{log_file_name}\" 2>&1")
+        Process.detach(pid)
+      end
+    end
+  end
+end

data/lib/simple_pvr/hdhomerun.rb

@@ -0,0 +1,103 @@
+module SimplePvr
+  #
+  # Simple fake version of HDHomeRun class. Makes it possible to run integration tests.
+  #
+  class HDHomeRunFake
+    def scan_for_channels; end
+    def start_recording(tuner, frequency, programme_id, directory); end
+    def stop_recording(tuner); end
+  end
+  
+  #
+  # Encapsulates all the HDHomeRun-specific functionality. Do not initialize HDHomeRun objects yourself,
+  # but get the current instance through PvrInitializer.
+  #
+  class HDHomeRun
+    attr_reader :device_id
+
+    def initialize
+      @device_id = discover
+      @tuner_pids = [nil, nil]
+      FileUtils.rm(tuner_control_file(0)) if File.exists?(tuner_control_file(0))
+      FileUtils.rm(tuner_control_file(1)) if File.exists?(tuner_control_file(1))
+    end
+
+    def scan_for_channels
+      file_name = 'channels.txt'
+      scan_channels_with_tuner(file_name)
+      Model::Channel.clear
+      read_channels_file(file_name)
+    end
+
+    def start_recording(tuner, frequency, program_id, directory)
+      set_tuner_to_frequency(tuner, frequency)
+      set_tuner_to_program(tuner, program_id)
+      @tuner_pids[tuner] = spawn_recorder_process(tuner, directory)
+      PvrLogger.info("Process ID for recording on tuner #{tuner}: #{@tuner_pids[tuner]}")
+    end
+
+    def stop_recording(tuner)
+      pid = @tuner_pids[tuner]
+      PvrLogger.info("Stopping process #{pid} for tuner #{tuner}")
+      send_control_c_to_process(tuner, pid)
+      reset_tuner_frequency(tuner)
+      @tuner_pids[tuner] = nil
+    end
+
+    private
+    def discover
+      IO.popen('hdhomerun_config discover') do |pipe|
+        output = pipe.read
+        return $1 if output =~ /^hdhomerun device (.*) found at .*$/
+    
+        raise Exception, "No device found: #{output}"
+      end
+    end
+
+    def scan_channels_with_tuner(file_name)
+      system "hdhomerun_config #{@device_id} scan /tuner0 #{file_name}"
+    end
+  
+    def read_channels_file(file_name)
+      channel_frequency = nil
+
+      File.open(file_name, 'r:UTF-8') do |file|
+        file.each_line do |line|
+          if line =~ /^SCANNING: (\d*) .*$/
+            channel_frequency = $1.to_i
+          elsif line =~ /^PROGRAM (\d*): \d* (.*)$/
+            channel_id = $1.to_i
+            channel_name = $2.strip
+            Model::Channel.add(channel_name, channel_frequency, channel_id)
+          end
+        end
+      end
+    end
+
+    def set_tuner_to_frequency(tuner, frequency)
+      system "hdhomerun_config #{@device_id} set /tuner#{tuner}/channel auto:#{frequency}"
+    end
+
+    def set_tuner_to_program(tuner, program_id)
+      system "hdhomerun_config #{@device_id} set /tuner#{tuner}/program #{program_id}"
+    end
+
+    def spawn_recorder_process(tuner, directory)
+      FileUtils.touch(tuner_control_file(tuner))
+      spawn File.dirname(__FILE__) + "/hdhomerun_save.sh #{@device_id} #{tuner} \"#{directory}/stream.ts\" \"#{directory}/hdhomerun_save.log\" \"#{tuner_control_file(tuner)}\""
+    end
+  
+    def reset_tuner_frequency(tuner)
+      system "hdhomerun_config #{@device_id} set /tuner#{tuner}/channel none"
+    end
+
+    def send_control_c_to_process(tuner, pid)
+      FileUtils.rm(tuner_control_file(tuner))
+      Process.wait(pid)
+    end
+  
+    def tuner_control_file(tuner)
+      File.dirname(__FILE__) + "/tuner#{tuner}.lock"
+    end
+  end
+end

data/lib/simple_pvr/hdhomerun_save.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+hdhomerun_config $1 save /tuner$2 "$3" > "$4" 2>&1 &
+COMMAND_PID=$!
+
+while [ -f $5 ]; do
+	sleep 1
+done
+
+kill -SIGINT $COMMAND_PID

data/lib/simple_pvr/model/channel.rb

@@ -0,0 +1,72 @@
+module SimplePvr
+  module Model
+    class Channel
+      include DataMapper::Resource
+      storage_names[:default] = 'channels'
+    
+      property :id, Serial
+      property :name, String
+      property :frequency, Integer
+      property :channel_id, Integer
+      property :icon_url, String, length: 250
+      property :hidden, Boolean, required: true, default: false
+    
+      has n, :programmes
+    
+      def self.add(name, frequency, id)
+        self.create(
+          name: name,
+          frequency: frequency,
+          channel_id: id
+        )
+      end
+
+      def self.with_current_programmes(id)
+        decorated_with_current_programmes(get(id), Time.now)
+      end
+    
+      def self.all_with_current_programmes
+        now = Time.now
+        self.all(order: :name).map {|channel| decorated_with_current_programmes(channel, now) }
+      end
+    
+      def self.clear
+        Programme.destroy
+        self.destroy
+      end
+    
+      def self.with_name(name)
+        result = self.first(name: name)
+        raise "Unknown channel: '#{name}'" unless result
+        result
+      end
+
+      private
+      def self.decorated_with_current_programmes(channel, now)
+        current_programme = current_programme_for(channel, now)
+        number_of_upcoming_programmes = current_programme ? 3 : 4
+        upcoming_programmes = upcoming_programmes_for(channel, number_of_upcoming_programmes, now)
+        {
+          channel: channel,
+          current_programme: current_programme,
+          upcoming_programmes: upcoming_programmes
+        }
+      end
+
+      def self.current_programme_for(channel, now)
+        unless channel.hidden
+          result = Programme.all(:channel => channel, :start_time.lt => now, fields: [:id, :title, :start_time, :duration], order: :start_time.desc, limit: 1)[0]
+          result if result && result.start_time.advance(seconds: result.duration) >= now
+        end
+      end
+
+      def self.upcoming_programmes_for(channel, limit, now)
+        if channel.hidden
+          []
+        else
+          Programme.all(:channel => channel, :start_time.gte => now, fields: [:id, :title, :start_time], order: :start_time, limit: limit)
+        end
+      end
+    end
+  end
+end

data/lib/simple_pvr/model/database_initializer.rb

@@ -0,0 +1,36 @@
+require 'data_mapper'
+require 'dm-migrations'
+require 'active_support/time_with_zone'
+require File.dirname(__FILE__) + '/channel'
+require File.dirname(__FILE__) + '/programme'
+require File.dirname(__FILE__) + '/schedule'
+require File.dirname(__FILE__) + '/recording'
+
+DataMapper.finalize
+
+module SimplePvr
+  module Model
+    class DatabaseInitializer
+      def self.setup(database_file_name = nil)
+        database_file_name ||= Dir.pwd + '/database.sqlite'
+        DataMapper.setup(:default, "sqlite://#{database_file_name}")
+        DataMapper.auto_upgrade!
+      end
+    
+      def self.clear
+        Schedule.destroy
+        Programme.destroy
+        Channel.destroy
+      end
+    
+      def self.prepare_for_test
+        return if @initialized
+      
+        @database_file_name = Dir.pwd + '/spec/resources/test.sqlite'
+        File.delete(@database_file_name) if File.exists?(@database_file_name)
+        self.setup(@database_file_name)
+        @initialized = true
+      end
+    end
+  end
+end

data/lib/simple_pvr/model/programme.rb

@@ -0,0 +1,58 @@
+module SimplePvr
+  module Model
+    class Programme
+      include DataMapper::Resource
+      storage_names[:default] = 'programmes'
+
+      property :id, Serial
+      property :title, String, index: true, :length => 255
+      property :subtitle, String, :length => 255
+      property :description, Text
+      property :start_time, DateTime
+      property :duration, Integer
+      property :episode_num, String, index: true
+
+      belongs_to :channel
+
+      def self.clear
+        Programme.destroy
+      end
+
+      def self.add(channel, title, subtitle, description, start_time, duration, episode_num)
+        channel.programmes.create(
+          channel: channel,
+          title: title,
+          subtitle: subtitle,
+          description: description,
+          start_time: start_time,
+          duration: duration.to_i,
+          episode_num: episode_num)
+      end
+
+      def self.with_title(title)
+        Programme.all(title: title, order: :start_time)
+      end
+
+      def self.on_channel_with_title(channel, title)
+        Programme.all(channel: channel, title: title, order: :start_time)
+      end
+
+      def self.on_channel_with_title_and_start_time(channel, title, start_time)
+        Programme.all(channel: channel, title: title, start_time: start_time)
+      end
+
+      def self.titles_containing(text)
+        # Maybe there's a smarter way to do substring search than constructing "%#{text}%"? I'd like
+        # a version where the original input is escaped properly. However, this method is not
+        # dangerous, it just means that the user can enter "%" or "_" in the search string for a
+        # wildcard.
+        Programme.all(:title.like => "%#{text}%", fields: [:title], order: :title, limit: 8, unique: true).map {|programme| programme.title }
+      end
+
+      def self.with_title_containing(text)
+        # Same "LIKE" comments as above...
+        Programme.all(:title.like => "%#{text}%", order: :start_time, limit: 20)
+      end
+    end
+  end
+end

data/lib/simple_pvr/model/recording.rb

@@ -0,0 +1,45 @@
+module SimplePvr
+  module Model
+    class Recording
+      attr_accessor :channel, :show_name, :start_time, :duration, :programme, :conflicting
+
+      def initialize(channel, show_name, start_time, duration, programme=nil)
+        @channel = channel
+        @show_name = show_name
+        @start_time = start_time
+        @duration = duration
+        @programme = programme
+      end
+
+      def expired?
+        expired_at(Time.now)
+      end
+      
+      def expired_at(time)
+        end_time < time
+      end
+      
+      def conflicting?
+        conflicting
+      end
+
+      def inspect
+        "'#{@show_name}' from '#{@channel.name}' at '#{@start_time}' with duration #{@duration} and programme #{@programme}"
+      end
+
+      def ==(other)
+        other != nil &&
+        other.channel == @channel &&
+        other.show_name == @show_name &&
+        other.start_time == @start_time &&
+        other.duration == @duration &&
+        other.programme == @programme
+      end
+      
+      private
+      def end_time
+        @start_time.advance(seconds: duration)
+      end
+    end
+  end
+end

data/lib/simple_pvr/model/schedule.rb

@@ -0,0 +1,33 @@
+module SimplePvr
+  module Model
+    class Schedule
+      include DataMapper::Resource
+      storage_names[:default] = 'schedules'
+      
+      property :id, Serial
+      property :type, Enum[:specification, :exception]
+      property :title, String, :length => 255
+      # If specified (and channel is specified too), this schedule is for a specific
+      # programme at a specific channel at a specific time
+      property :start_time, DateTime
+      property :filter_by_weekday, Boolean
+      property :monday, Boolean
+      property :tuesday, Boolean
+      property :wednesday, Boolean
+      property :thursday, Boolean
+      property :friday, Boolean
+      property :saturday, Boolean
+      property :sunday, Boolean
+
+      belongs_to :channel, required: false
+    
+      def self.add_specification(options)
+        Schedule.create(
+          type: :specification,
+          title: options[:title],
+          channel: options[:channel],
+          start_time: options[:start_time])
+      end
+    end
+  end
+end