sensible-cinema 0.6.0

data/spec/spec.keyboard_input.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/common')
+require_relative '../lib/keyboard_input'
+
+describe KeyboardInput do
+
+  class Go
+    @time = 58
+    def self.cur_time
+      @time += 1
+    end
+
+    def self.got
+      @got
+    end
+
+    @muted = true
+    class << self
+      attr_accessor :muted
+    end
+
+    def self.status
+      @muted = !@muted
+      if @muted
+        "muted"
+      else
+        "unmuted"
+      end
+    end
+
+    def self.keyboard_input input
+      @got = input
+    end
+  end
+
+  before do
+    @a = KeyboardInput.new Go
+    Go.muted = true
+  end
+
+  it "should display on one line" do
+    @a.get_line_printout.should include("\b\b\b")
+  end
+
+  it "should display whether muted or not" do
+    @a.get_line_printout.should include("unmuted")
+    @a.get_line_printout.should_not include("unmuted")
+  end
+
+  it "should translate keys to characters" do
+    @a.handle_keystroke 77
+    Go.got.should == "M"
+    @a.handle_keystroke 109
+    Go.got.should == "m"
+  end
+
+end

data/spec/spec.mouse.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'sane'
+require_relative '../lib/mouse'
+
+begin
+Timeout::timeout(2) {
+  Mouse::jitter_forever_in_own_thread.join
+}
+rescue
+end
+puts 'mouse should have moved...'

data/spec/spec.muter.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/common"
+require_relative '../lib/muter'
+
+describe 'manual muter' do
+  # functional test
+  
+  3.times {
+    Muter.mute!
+    puts 'muted'
+    sleep 1
+    Muter.unmute!
+    puts 'unmuted'
+    sleep 1
+  }
+  # these rest *should* be able to pass...
+  
+  Muter.mute!
+  Muter.mute!
+  puts 'silence'
+  sleep 1
+  Muter.unmute!
+  puts 'non silence'
+  sleep 1
+  Muter.unmute!
+  puts 'non silence'
+  sleep 1
+  puts 'single takes'
+  p Benchmark.realtime { 1.times{Muter.hit_volume_down_key}}
+  puts 'triple takes'
+  p Benchmark.realtime { 1.times{Muter.unmute!}} # 0.00023848s
+  # seems actually like reasonable speed
+  Muter.unmute!
+end

data/spec/spec.ocr.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/common'
+require_relative "../lib/ocr"
+
+describe OCR do
+  
+  it "should be able to output help output" do
+    OCR.version.should_not be_blank
+  end
+  
+  it "should be able to grab some digits" do
+    success = true
+    for file in Dir['images/*[0-9].bmp']
+      options = {}
+      options[:should_invert] = true if file =~ /hulu/
+      file =~ /(.)\.bmp/
+      expected_digit = $1.to_i
+      if OCR.identify_digit(File.binread(file), options) != expected_digit
+        p "fail:" + file
+        success = false
+      end
+    end
+    fail unless success
+  end
+  
+  it "should be able to grab a colon" do
+    OCR.identify_digit(File.binread("images/colon.bmp"), :might_be_colon => true).should == ":"
+  end
+  
+  it "should return nil if it can't identify a digit" do
+    OCR.identify_digit(File.binread("images/black.bmp")).should be_nil
+  end
+  
+end

data/spec/spec.overlayer.rb

@@ -0,0 +1,331 @@
+require File.expand_path(File.dirname(__FILE__) + '/common')
+require_relative '../lib/overlayer'
+
+# tell it not to actually mute during testing...
+$DEBUG = true
+
+def start_good_blank
+  assert !@o.blank?
+end
+
+def start_bad_blank
+  assert @o.blank?
+end
+
+
+describe OverLayer do
+  
+  before do
+    File.write 'temp.yml', YAML.dump({:mutes => {2.0 => 4.0}} )
+    @o = OverLayer.new('temp.yml')
+  end
+  
+  after do
+    Thread.join_all_others
+    File.delete 'temp.yml'
+  end
+  
+  def start_good
+    assert !@o.muted?
+    sleep 1
+  end
+  
+  def start_bad
+    assert @o.muted? # note this uses @o!
+    sleep 1
+  end
+  
+  it 'should reject overlapping settings...I guess'
+  
+  it 'should be able to mute' do
+    # several combinations...
+    assert !@o.muted?
+    @o.mute!
+    assert @o.muted?
+    @o.unmute!
+    assert !@o.muted?
+    @o.mute!
+    assert @o.muted?
+  end
+  
+  context 'given you know when to start' do
+    
+    it 'should mute based on time' do   
+      @o.start_thread
+      # make sure we enter the mute section
+      sleep 2.25
+      start_bad
+      sleep 1
+      start_good
+    end
+    
+    it 'should handle multiple mutes in a row' do
+      File.write 'temp.yml', YAML.dump({:mutes => {2.0 => 4.0, 5.0 => 7.0}})
+      @o = OverLayer.new 'temp.yml'
+      @o.start_thread
+      sleep 2.5
+      start_bad # 1s
+      sleep 2 # => 5.5
+      start_bad
+    end
+    
+    it 'should be able to mute teeny sequences' do
+      File.write 'temp.yml', YAML.dump({:mutes => {0.0001 => 0.0002, 1.0 => 1.0001}})
+      o = OverLayer.new 'temp.yml'
+      o.continue_until_past_all false
+    end
+  end
+  
+  context 'startup' do
+    it 'should allow you to change the current time' do
+      @o.start_thread
+      sleep 0.1 # wow ruby is slow...
+      assert @o.cur_time > 0
+      @o.set_seconds 5
+      sleep 0.1
+      assert @o.cur_time > 5
+    end
+    
+    it 'should be able to hit keys to affect input' do
+      @o = OverLayer.new 'test_yaml.yml'
+      @o.cur_time
+      @o.keyboard_input 'm'
+      assert @o.cur_time > 59 
+      @o.keyboard_input 'M'
+      assert @o.cur_time < 59
+      60.times {
+        @o.keyboard_input 's'
+      }
+      assert @o.cur_time > 59 
+      60.times {
+        @o.keyboard_input 'S'
+      }
+      assert @o.cur_time < 59 
+      600.times { 
+        @o.keyboard_input 't' 
+      }
+      assert @o.cur_time > 59 
+      600.times { 
+        @o.keyboard_input 'T' 
+      }
+      assert @o.cur_time < 59 
+    
+    end
+    
+  end
+
+  it 'should have help output' do
+    @o.status.should include("MmSs")
+  end  
+
+  it 'should allow for real yaml files somehow and use it' do
+    # 2 - 3 , 4-5 should be muted
+    @o = OverLayer.new 'test_yaml.yml'
+    @o.start_thread
+    start_good # takes 1s
+    sleep 1.25
+    start_bad
+    start_good
+    start_bad
+    start_good
+  end
+  
+  def write_yaml yaml
+    File.write 'temp.yml', yaml
+  end
+  
+  it 'should allow for 1:00.0 minute style input' do
+    write_yaml <<YAML
+:mutes:
+  "0:02.0" : "0:03.0"
+YAML
+    @o = OverLayer.new 'temp.yml'
+    @o.start_thread
+    start_good
+    start_good
+    sleep 0.25
+    start_bad
+    start_good
+  end
+
+  it "should reload the YAML file on the fly to allow for editing it" do
+    # start it with one far later
+    write_yaml <<YAML
+:mutes:
+  "0:11.0" : "0:12.0"
+YAML
+    @o = OverLayer.new 'temp.yml'
+    @o.start_thread
+    start_good
+    write_yaml <<YAML
+:mutes:
+  "0:00.0" : "0:01.5"
+YAML
+    # go forward a tenth
+    # should reload it...
+    @o.keyboard_input 'T'
+    sleep 0.1 # blug
+    start_bad
+    start_good
+  end
+  
+  it "should translate yaml well" do
+    yaml = <<-YAML
+:mutes:
+  "0:02.0" : "0:03.0"
+:blank_outs:
+  "0:02.0" : "0:03.0"  
+     YAML
+     out = OverLayer.translate_yaml yaml
+     out[:mutes].to_a.first.should == [2.0, 3.0]
+     out[:blank_outs].to_a.first.should == [2.0, 3.0]
+     yaml = <<-YAML
+:mutes:
+  "1:02.11" : "1:03.0"
+     YAML
+     out = OverLayer.translate_yaml yaml
+     out[:mutes].to_a.first.should == [62.11, 63.0]
+  end
+
+  it "should translate strings as well as symbols" do
+         yaml = <<-YAML
+mutes:
+  "1" : "3
+     YAML
+     out = OverLayer.translate_yaml yaml
+    out[:mutes].to_a.first.should == [1, 3]    
+  end  
+
+  it "should disallow negative length intervals"
+
+  it "should allow for 1:01:00.0 (double colon) style input" do
+    write_yaml <<-YAML
+:mutes:
+  "1:00.11" : "1:03.0"
+    YAML
+    @o = OverLayer.new 'temp.yml'
+    @o.start_thread
+    start_good
+    @o.set_seconds 61
+    sleep 0.1 # ruby rox again!
+    start_bad
+    sleep 2
+    start_good
+  end
+  
+  it "should be able to tell the player to sync to the closest second when the screen only changes" do
+    @o.start_thread
+    start = Time.now
+    while((Time.now - start) < 3) do
+      @o.timestamp_changed nil, nil
+      sleep 0.1
+    end
+    @o.cur_time.should be < 1
+    sleep 1
+    10.times { @o.timestamp_changed(nil, nil) }
+    @o.cur_time.should be >= 1
+    sleep 0.6
+    @o.timestamp_changed nil, nil
+    @o.cur_time.should be >= 2
+  end
+  
+  it "should be able to handle it when the sync message includes a new timestamp" do
+    @o.start_thread
+    @o.timestamp_changed "1:00:01", 0
+    @o.cur_time.should be > 60*60
+    @o.timestamp_changed "0:00:01", 0
+    @o.cur_time.should be < 60*60
+  end
+  
+  it "should handle deltas to created timestamps" do
+    @o.start_thread
+    @o.timestamp_changed "1:00:00", 1
+    @o.cur_time.should be >= 60*60 + 1
+  end
+    
+  context "should handle blanks, too" do
+
+    it "should be able to discover next states well" do
+      for type in [:blank_outs, :mutes] do
+        @o = OverLayer.new_raw({type => {2.0 => 4.0}})
+        @o.discover_state(type, 3).should == [2.0, 4.0, true]
+        @o.discover_state(type, 0.5).should == [2.0, 4.0, false]
+        @o.discover_state(type, 5).should == [nil, nil, :done]
+        @o.discover_state(type, 2.0).should == [2.0, 4.0, true]
+        @o.discover_state(type, 4.0).should == [nil, nil, :done]
+      end
+    end
+    
+    context "with a list of blanks" do
+    
+      it "should blank" do
+        @o = OverLayer.new_raw({:blank_outs => {2.0 => 4.0}})
+      
+        @o.start_thread
+        start_good_blank
+        sleep 1
+        start_good_blank
+        sleep 1.1
+        start_bad_blank
+        sleep 2
+        start_good_blank
+      end
+    end
+    
+    def at time
+       @o.stub!(:cur_time) {
+          time
+        }
+        yield
+    end
+    
+    context "mixed blanks and others" do
+      it "should allow for mixed" do
+        @o = OverLayer.new_raw({:mutes => {2.0 => 3.5}, :blank_outs => {3.0 => 4.0}})
+        at(1.5) do
+          @o.cur_time.should == 1.5
+          @o.get_current_state.should == [false, false, 2.0]
+        end
+        
+        at(2.0) do
+          @o.get_current_state.should == [true, false, 3.0]
+        end
+        
+        at(3.0) do
+          @o.get_current_state.should == [true, true, 3.5]
+        end
+        
+        at(3.75) do
+          @o.get_current_state.should == [false, true, 4.0]
+        end
+        
+        at(4) do
+          @o.get_current_state.should == [false, false, :done]
+        end
+        
+      end
+    end
+    
+    it "should not fail with verbose on, after it's past next states" do
+      at(500_000) do
+        @o.status.should == "Current time: 138:53:20.0 no more actions after this point... (HhMmSsTtdvq): "
+      end
+      
+    end
+    
+  end
+  
+  it "should be human readable" do  
+    @o.translate_time_to_human_readable(3600).should == "1:00:00.0" 
+    @o.translate_time_to_human_readable(3600.0).should == "1:00:00.0" 
+    @o.translate_time_to_human_readable(3601).should == "1:00:01.0" 
+    @o.translate_time_to_human_readable(3661).should == "1:01:01.0" 
+  end
+  
+  it "should accept human readable input" do
+    o = OverLayer.new 'temp.yml', "01:01.5"
+    o.cur_time.should be == 61.5
+    
+  end
+  
+end

data/spec/spec.screen_tracker.rb

@@ -0,0 +1,211 @@
+require File.expand_path(File.dirname(__FILE__) + '/common')
+require_relative '../lib/overlayer'
+require_relative '../lib/screen_tracker'
+require 'pathname'
+
+describe ScreenTracker do
+
+  if RUBY_PLATFORM =~ /java/
+    it "is pending a java bug..."
+  else
+    before(:all) do
+      begin
+        Win32::Screenshot.window(/silence.wav/, 0) {}
+      rescue
+        # this way we'll only have one up...
+        @pid1 = IO.popen('open.bat').pid # jruby can't open it directly yet
+        sleep 2
+      end
+    end
+
+    before do
+      @a = ScreenTracker.new(/silence.*VLC/,10,10,20,20)
+    end
+
+    it "can take a regex or string" do
+      ScreenTracker.new(/silence.*VLC/,10,10,20,20)
+      ScreenTracker.new("silence",10,10,20,20)
+    end
+
+    it "should be able to grab a picture from screen coords...probably from the current active window" do
+      @a.get_bmp.should_not be_nil
+    end
+
+    it "should loop if unable to find the right window" do
+      proc {
+        Timeout::timeout(1) do
+          ScreenTracker.new("unknown window",10,10,20,20)
+        end
+      }.should raise_error(Timeout::Error)
+    end
+
+    it "should be at least somewhat fast" do
+      Benchmark.realtime { @a.get_bmp }.should be < 0.3
+    end
+
+    it "should not allow for negative widths" do
+      proc {ScreenTracker.new("VLC",10,10,-20,20)}.should raise_error
+    end
+
+    it "should disallow size 0 widths" do
+      proc {ScreenTracker.new("VLC",10,10,0,0)}.should raise_error
+    end
+
+    it "should have different bmp if sizes different" do
+      a = ScreenTracker.new("VLC",10,10,5,5)
+      assert a.get_relative_coords == [10,10,15,15]
+      b = ScreenTracker.new("VLC",10,10,50,50)
+      assert a.get_bmp != b.get_bmp
+    end
+
+    it "should allow for straight desktop if they specify Desktop or desktop" do
+      a = ScreenTracker.new("desktop",0,0,100,100)
+    end
+
+    context "negative numbers should result in an offset" do
+
+      it "should allow for negative sizes" do
+        a = ScreenTracker.new("VLC",-10,10,5,5)
+        a.get_bmp
+        a = ScreenTracker.new("VLC",-10,-10,10,10) # right to the edge
+        a.get_bmp
+        a = ScreenTracker.new("VLC",10,-10,5,5)
+        a.get_bmp
+      end
+
+      it "should assign right coords" do
+        a = ScreenTracker.new("VLC",-10,-10,5,5)
+        a.get_bmp
+        x,y,x2,y2=a.get_relative_coords
+        hwnd = Win32::Screenshot::BitmapMaker.hwnd("VLC")
+        always_zero, always_zero, max_x, max_y = Win32::Screenshot::BitmapMaker.dimensions_for(hwnd)
+        x.should == max_x-10
+        y.should == max_y-10
+        x2.should == x+5
+        y2.should == y+5
+      end
+
+      it "should look different with negative than with positive" do
+        a = ScreenTracker.new("VLC",10,10,50,50)
+        b = ScreenTracker.new("VLC",10,10,50,50)
+        c = ScreenTracker.new("VLC",-99,-99,50,50)
+        assert a.get_bmp == b.get_bmp
+        assert c.get_relative_coords != b.get_relative_coords
+        cb = c.get_bmp
+        bb = b.get_bmp
+        c.get_bmp.length == b.get_bmp.length
+        assert c.get_bmp != b.get_bmp
+      end
+
+      it "should fail with out of bounds or zero sizes" do
+        proc { a = ScreenTracker.new(/silence.*VLC/,-10,10,20,20) }.should raise_error
+        proc { a = ScreenTracker.new(/silence.*VLC/,10,-10,20,20) }.should raise_error
+        proc { a = ScreenTracker.new(/silence.*VLC/,-10,10,0,2) }.should raise_error
+        proc { a = ScreenTracker.new(/silence.*VLC/,10,10,2,0) }.should raise_error
+      end
+
+    end
+
+    # lodo: this 7 looks rather redundant...
+    it "should parse yaml appropro" do
+      yaml = <<-YAML
+      name: VLC
+      x: 32
+      y: 34
+      width: 100
+      height: 20
+      digits:
+        :hours:
+        :minute_tens:
+        - -90
+        - 7
+        :minute_ones:
+        - -82
+        - 7
+        :second_tens:
+        - -72
+        - 7
+        :second_ones:
+        - -66
+        - 7      
+      YAML
+      a = ScreenTracker.new_from_yaml(yaml,nil)
+      a.get_relative_coords.should == [32,34,132,54]
+    end
+
+    it "should be able to dump its contents" do
+      @a.dump_bmp
+      assert File.exist?('dump.bmp') && File.exist?('all.dump.bmp')
+    end
+
+    context "given a real player that is moving" do
+
+      before do
+        @a = ScreenTracker.new("silence.wav", -111, -16, 86, 13)
+      end
+
+      it "should be able to poll the screen to know when something changes" do
+        @a.wait_till_next_change
+        # it updates every 1 second...
+        Benchmark.realtime { @a.wait_till_next_change }.should be > 0.2
+        @a.dump_bmp # for debugging...
+      end
+
+      context "using OCR" do
+
+        before do
+          # vlc_non_full_screened_under_an_hour.yml
+          @a = ScreenTracker.new("silence.wav", -111, -16, 86, 13,
+          {:hours => nil, :minute_tens => [-90,7], :minute_ones => [-82, 7], :second_tens => [-72, 7], :second_ones => [-66, 7]} )
+        end
+
+        it "should be able to snapshot digits" do
+          @a.dump_bmp
+          Pathname.new('minute_tens.bmp').should exist
+          Pathname.new('minute_tens.bmp').size.should be > 0
+          Pathname.new('hours.bmp').should_not exist
+        end
+
+        it "should use OCR against the changes appropriately" do
+          output = @a.wait_till_next_change
+          output[0].should be_a(String)
+          output[0].should include("00:0")# let's hope it runs quickly...
+          output[0].should match(/[1-9]/)
+        end
+
+        context "with an OCR that can change willy-nilly from hour to second" do
+          it "should ocr slash...[in other]"
+          it "with VLC should be able to recognize when it goes past an hour somehow...probably by presence of hourly colon" # might already do this
+          it "should work with hulu too, because of ads"
+        end
+
+        it "should be able to use invert on images" do
+          @a = ScreenTracker.new("silence.wav", -111, -16, 86, 13,
+          {:should_invert => true, :hours => nil, :minute_tens => [-90,7], :minute_ones => [-82, 7], :second_tens => [-72, 7], :second_ones => [-66, 7]} )
+          got_it = nil
+          OCR.stub!(:identify_digit) {|*args|
+            got_it = args
+          }
+          @a.identify_digit('some binary bitmap data')
+          got_it[1][:should_invert].should be_true
+        end
+
+      end
+
+      after(:all) do
+        begin
+          # bring redcar to the foreground
+          # this seg faults on windows 7 for me for some reason when run inside the editor itself...swt bug?
+          unless Socket.gethostname == "PACKRD-1GK7V"
+            Win32::Screenshot.window(/universal/, 0) rescue nil
+          end
+          Process.kill 9, @pid1 rescue nil # need this re-started each time or the screen won't change for the screen changing test
+          FileUtils.rm_rf Dir['*.bmp'] unless $DEBUG
+        rescue => e
+          puts 'got after bug:', e # until this bug is fixed... http://github.com/rspec/rspec-core/issues#issue/21
+          throw e
+        end
+      end
+    end
+  end
+end

data/spec/test_yaml.yml

@@ -0,0 +1,4 @@
+title: Forever Strong
+:mutes:
+  2.0 : 3.0
+  4.0 : 5.0