network_executive 0.0.4 → 0.0.7

data/spec/unit/program_schedule_spec.rb

@@ -0,0 +1,191 @@
+describe NetworkExecutive::ProgramSchedule do
+
+  it 'should define an Occurrence structure' do
+    occ = described_class::Occurrence.new
+
+    occ.should respond_to(:start_time)
+    occ.should respond_to(:duration)
+    occ.should respond_to(:end_time)
+  end
+
+  describe '#initialize' do
+    context 'with an unknown program name' do
+      before do
+        NetworkExecutive::Program.stub( :find_by_name ).and_return nil
+      end
+
+      it 'should raise a ProgramNameError' do
+        expect{ described_class.new( 'null_prog' ) }.to raise_error NetworkExecutive::ProgramNameError
+      end
+    end
+
+    context 'with a known program name' do
+      let(:known_program) { double('program') }
+      let(:duration) { nil }
+
+      before do
+        NetworkExecutive::Program.stub( :find_by_name ).and_return known_program
+      end
+
+      subject { described_class.new( 'known', duration:duration ) }
+
+      it { should respond_to(:start_time) }
+      its(:program) { should == known_program }
+
+      context 'and no duration specified' do
+        its(:duration) { should == 24.hours }
+      end
+
+      context 'and a duration specified' do
+        let(:duration) { 35.minutes }
+
+        its(:duration) { should == 35.minutes }
+      end
+
+    end
+  end
+
+  describe '#proxy' do
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return true
+    end
+
+    subject { described_class.new('p').proxy }
+
+    it 'should have a schedule proxy' do
+      subject.should be_a NetworkExecutive::ProgramScheduleProxy
+    end
+
+    it 'should execute the block' do
+      canary = 'alive'
+
+      described_class.new('p'){ canary = 'dead' }.proxy
+
+      subject
+
+      canary.should == 'dead'
+    end
+  end
+
+  describe '#start_time=' do
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return true
+    end
+
+    it 'should reset the proxy' do
+      time = Time.now
+
+      NetworkExecutive::ProgramScheduleProxy.should_receive(:new).with( time, anything )
+
+      described_class.new('p').start_time = time
+    end
+  end
+
+  describe '#duration=' do
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return true
+    end
+
+    it 'should reset the proxy' do
+      time = 10.minutes
+
+      NetworkExecutive::ProgramScheduleProxy.should_receive(:new).with( anything, time )
+
+      described_class.new('p').duration = time
+    end
+  end
+
+  describe '#occurs_at?' do
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return true
+    end
+
+    subject { described_class.new('p').occurs_at? Time.now }
+
+    it 'should delegate to its proxy' do
+      NetworkExecutive::ProgramScheduleProxy.any_instance.should_receive( :occurs_at? )
+
+      subject
+    end
+  end
+
+  describe '#play' do
+    let(:program) { double('program') }
+
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return program
+    end
+
+    subject { described_class.new('p').play }
+
+    it 'should delegate to its proxy' do
+      program.should_receive( :play )
+
+      subject do
+        # ...
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:program) { double('program') }
+
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return program
+    end
+
+    subject { described_class.new('p').update }
+
+    it 'should delegate to its proxy' do
+      program.should_receive( :update )
+
+      subject do
+        # ...
+      end
+    end
+  end
+
+  describe '#whats_on?' do
+    before do
+      Timecop.freeze
+
+      NetworkExecutive::Program.stub( :find_by_name ).and_return double('program')
+    end
+
+    subject { described_class.new( 'p').whats_on? }
+
+    it 'should indicate if the schedule has anything occuring at the given time' do
+      NetworkExecutive::ProgramScheduleProxy.any_instance.should_receive( :occurring_at? ).with Time.now
+
+      subject
+    end
+  end
+
+  describe '#occurrence_at' do
+    before do
+      NetworkExecutive::Program.stub( :find_by_name ).and_return true
+
+      NetworkExecutive::ProgramScheduleProxy
+        .any_instance
+        .stub(:occurrences_between)
+        .and_return [ Time.now.end_of_day ]
+    end
+
+    let(:time) { Time.now.end_of_day }
+
+    subject do
+      described_class.new('p', start_time:time, duration:1.minute).occurrence_at time
+    end
+
+    it 'should build an Occurrence' do
+      start_time = time.dup
+      duration   = 1.minute - 1
+      end_time   = start_time + duration
+
+      subject.start_time.should eq start_time
+      subject.duration.should   eq duration
+      subject.end_time.should   eq end_time
+    end
+  end
+
+end

data/spec/unit/scheduled_program_spec.rb

@@ -0,0 +1,57 @@
+require 'ostruct'
+
+describe NetworkExecutive::ScheduledProgram do
+
+  it { should respond_to(:program) }
+  it { should respond_to(:occurrence) }
+  it { should respond_to(:remainder) }
+  it { should respond_to(:portion) }
+
+  describe '#display_name' do
+    let(:program) { double('program', display_name:'foo') }
+
+    subject { described_class.new(program).display_name }
+
+    it { should == 'foo' }
+  end
+
+  describe '#+' do
+    context 'with a mismatched program' do
+      it 'should raise an ArgumentError' do
+        expect { subject + double('program') }.to raise_error ArgumentError
+      end
+    end
+
+    context 'with the same program type' do
+      let(:end_time)   { Time.now }
+      let(:program_a)  { OpenStruct.new( duration:59.seconds ) }
+      let(:occurrence) { OpenStruct.new( duration:59.seconds, end_time:end_time ) }
+      let(:program_b)  { OpenStruct.new( duration:59.seconds ) }
+
+      subject do
+        described_class.new( program_a, occurrence ) + program_b
+      end
+
+      before do
+        program_a.stub(:occurrence).and_return double('occurrence').as_null_object
+      end
+
+      it 'should extend its duration with that of the other program' do
+        subject.program.duration.should == 119.seconds
+      end
+
+      it 'should extend its occurrences duration with that of the other program' do
+        subject.occurrence.duration.should == 119.seconds
+      end
+
+      it 'should extend its occurrences end time with that of the other program' do
+        subject.occurrence.end_time.should == end_time + 1.minute
+      end
+
+      it 'should return itself' do
+        subject.should be_a NetworkExecutive::ScheduledProgram
+      end
+    end
+  end
+
+end

data/spec/unit/scheduling_spec.rb

@@ -1,106 +1,95 @@
 describe NetworkExecutive::Scheduling do
 
-  describe '.every' do
-    it 'should schedule the program' do
-      channel = Class.new( NetworkExecutive::Channel ) do
-        include NetworkExecutive::Scheduling
-
-        every :day, play:'my_show'
-      end
-
-      channel.schedule.first.should be_a NetworkExecutive::ProgramSchedule
+  let(:klass) do
+    Class.new do
+      include NetworkExecutive::Scheduling
     end
   end
 
-  describe 'schedule' do
-    it 'should be a ChannelSchedule' do
-      channel = Class.new( NetworkExecutive::Channel ) do
-        include NetworkExecutive::Scheduling
-      end
-
-      channel.schedule.should be_a NetworkExecutive::ChannelSchedule
-    end
+  before do
+    stub_const 'MyChannel', klass
   end
 
-  describe '#whats_on?' do
-    let(:channel) do
-      Class.new( NetworkExecutive::Channel ) do
-        include NetworkExecutive::Scheduling
+  subject { MyChannel.new }
+
+  describe '.schedule' do
+    context 'with a block' do
+      it 'should add a program' do
+        params = [
+          'program',
+          kind_of(Hash)
+        ]
+
+        NetworkExecutive::ChannelSchedule.any_instance.should_receive( :add ).with( *params )
+
+        MyChannel.schedule( 'program' ) do
+          # ...
+        end
       end
     end
 
-    context 'with nothing scheduled' do
-      it 'should return nil' do
-        channel.new.whats_on?.should be_nil
+    context 'without a block' do
+      it 'should be a ChannelSchedule' do
+        MyChannel.schedule.should be_a NetworkExecutive::ChannelSchedule
       end
     end
+  end
 
-    it 'should return the most appropriate program for a given time' do
-      program_c = double('program c', include?: true)
-
-      channel.schedule.add double('program a', include?: false)
-      channel.schedule.add double('program b', include?: true)
-      channel.schedule.add program_c
-      channel.schedule.add double('program d', include?: false)
-
-      channel.new.whats_on?.should == program_c
+  describe '#schedule' do
+    it 'should be a ChannelSchedule' do
+      subject.schedule.should be_a NetworkExecutive::ChannelSchedule
     end
+  end
 
-    it 'should return all programs scheduled for a range of times' do
-      program_b = double 'program b'
-      program_b.stub(:include?).and_return true, false
-
-      program_c = double 'program c'
-      program_c.stub(:include?).and_return false, true
-
-      channel.schedule.add double('program a', include?: false)
-      channel.schedule.add program_b
-      channel.schedule.add program_c
-      channel.schedule.add double('program d', include?: false)
+  describe '#whats_on?' do
+    before { Timecop.freeze }
 
-      shows = channel.new.whats_on?( 1.hour.ago, 1.hour.from_now )
+    it 'should return what is on right now' do
+      subject.should_receive( :whats_on_at? ).with( Time.now.change(sec:0) )
 
-      shows.first[:program].should be program_b
-      shows.last[:program].should be program_c
+      subject.whats_on?
     end
+  end
 
-    it 'should yield a block when provided a stop_time' do
-      program_a = double('program a', include?: true)
-      channel.schedule.add program_a
+  describe '#whats_on_at?' do
+    context 'with nothing scheduled' do
+      before do
+        NetworkExecutive::ChannelSchedule.any_instance.stub(:find).and_return nil
+      end
 
-      channel.new.whats_on?( 1.hour.ago, 1.hour.from_now) do |program|
-        program.should be program_a
+      it 'should return OffAir' do
+        subject.whats_on_at?( Time.now ).should be_a NetworkExecutive::OffAirSchedule
       end
     end
-  end
 
-  describe '#with_showtimes_between' do
-    let(:klass) do
-      Class.new( NetworkExecutive::Channel ) do
-        include NetworkExecutive::Scheduling
+    context 'with something scheduled' do
+      let(:prog_1) { double('unscheduled', whats_on?: false) }
+      let(:prog_2) { double('scheduled',   whats_on?: true)  }
+      let(:prog_3) { double('unscheduled', whats_on?: false) }
 
-        every :day, play:'my_show'
+      before do
+        subject.schedule << prog_1
+        subject.schedule << prog_2
+        subject.schedule << prog_3
       end
-    end
-
-    let(:channel) { klass.new }
 
-    subject do
-      program_a = double 'program_a', include?: true
+      it 'should return the scheduled program' do
+        subject.whats_on_at?( Time.now ).should == prog_2
+      end
+    end
+  end
 
-      channel.schedule.add program_a
+  describe '#whats_on_between?' do
+    it 'should ask the ChannelSchedule what is on between two dates' do
+      date_a = Time.now
+      date_b = date_a + 1.5.hours
 
-      range = [ 1.hour.ago, 1.hour.from_now ]
+      args = [ date_a, date_b, nil ]
 
-      channel.with_showtimes_between( *range ) do |showtime, program|
-        'block retval'
-      end
-    end
+      NetworkExecutive::ChannelSchedule.any_instance.should_receive(:whats_on_between?).with( *args )
 
-    it 'should contain the blocks return value' do
-      subject.all?{ |x| x == 'block retval' }.should be_true
+      subject.whats_on_between? date_a, date_b
     end
-
   end
 
 end

data/vendor/assets/javascripts/bigtext.js

@@ -0,0 +1,264 @@
+;(function(window, $)
+{
+    var counter = 0,
+        $headCache = $('head'),
+        oldBigText = window.BigText,
+        oldjQueryMethod = $.fn.bigtext,
+        BigText = {
+            DEFAULT_MIN_FONT_SIZE_PX: null,
+            DEFAULT_MAX_FONT_SIZE_PX: 528,
+            GLOBAL_STYLE_ID: 'bigtext-style',
+            STYLE_ID: 'bigtext-id',
+            LINE_CLASS_PREFIX: 'bigtext-line',
+            EXEMPT_CLASS: 'bigtext-exempt',
+            DEFAULT_CHILD_SELECTOR: '> div',
+            childSelectors: {
+                div: '> div',
+                ol: '> li',
+                ul: '> li'
+            },
+            noConflict: function(restore)
+            {
+                if(restore) {
+                    $.fn.bigtext = oldjQueryMethod;
+                    window.BigText = oldBigText;
+                }
+                return BigText;
+            },
+            init: function()
+            {
+                if(!$('#'+BigText.GLOBAL_STYLE_ID).length) {
+                    $headCache.append(BigText.generateStyleTag(BigText.GLOBAL_STYLE_ID, ['.bigtext * { white-space: nowrap; }',
+                                                                                    '.bigtext .' + BigText.EXEMPT_CLASS + ', .bigtext .' + BigText.EXEMPT_CLASS + ' * { white-space: normal; }']));
+                }
+            },
+            bindResize: function(eventName, resizeFunction)
+            {
+                if($.throttle) {
+                    // https://github.com/cowboy/jquery-throttle-debounce
+                    $(window).unbind(eventName).bind(eventName, $.throttle(100, resizeFunction));
+                } else {
+                    if($.fn.smartresize) {
+                        // https://github.com/lrbabe/jquery-smartresize/
+                        eventName = 'smartresize.' + eventName;
+                    }
+                    $(window).unbind(eventName).bind(eventName, resizeFunction);
+                }
+            },
+            getStyleId: function(id)
+            {
+                return BigText.STYLE_ID + '-' + id;
+            },
+            generateStyleTag: function(id, css)
+            {
+                return $('<style>' + css.join('\n') + '</style>').attr('id', id);
+            },
+            clearCss: function(id)
+            {
+                var styleId = BigText.getStyleId(id);
+                $('#' + styleId).remove();
+            },
+            generateCss: function(id, linesFontSizes, lineWordSpacings, minFontSizes)
+            {
+                var css = [];
+
+                BigText.clearCss(id);
+
+                for(var j=0, k=linesFontSizes.length; j<k; j++) {
+                    css.push('#' + id + ' .' + BigText.LINE_CLASS_PREFIX + j + ' {' +
+                        (minFontSizes[j] ? ' white-space: normal;' : '') +
+                        (linesFontSizes[j] ? ' font-size: ' + linesFontSizes[j] + 'px;' : '') +
+                        (lineWordSpacings[j] ? ' word-spacing: ' + lineWordSpacings[j] + 'px;' : '') +
+                        '}');
+                }
+
+                return BigText.generateStyleTag(BigText.getStyleId(id), css);
+            },
+            jQueryMethod: function(options)
+            {
+                BigText.init();
+        
+                options = $.extend({
+                            minfontsize: BigText.DEFAULT_MIN_FONT_SIZE_PX,
+                            maxfontsize: BigText.DEFAULT_MAX_FONT_SIZE_PX,
+                            childSelector: '',
+                            resize: true
+                        }, options || {});
+            
+                return this.each(function()
+                {
+                    var $t = $(this).addClass('bigtext'),
+                        childSelector = options.childSelector ||
+                                    BigText.childSelectors[this.tagName.toLowerCase()] ||
+                                    BigText.DEFAULT_CHILD_SELECTOR,
+                        maxWidth = $t.width(),
+                        id = $t.attr('id');
+        
+                    if(!id) {
+                        id = 'bigtext-id' + (counter++);
+                        $t.attr('id', id);
+                    }
+        
+                    if(options.resize) {
+                        BigText.bindResize('resize.bigtext-event-' + id, function()
+                        {
+                            BigText.jQueryMethod.call($('#' + id), options);
+                        });
+                    }
+        
+                    BigText.clearCss(id);
+        
+                    $t.find(childSelector).addClass(function(lineNumber, className)
+                    {
+                        // remove existing line classes.
+                        return [className.replace(new RegExp('\\b' + BigText.LINE_CLASS_PREFIX + '\\d+\\b'), ''),
+                                BigText.LINE_CLASS_PREFIX + lineNumber].join(' ');
+                    });
+        
+                    var sizes = calculateSizes($t, childSelector, maxWidth, options.maxfontsize, options.minfontsize);
+                    $headCache.append(BigText.generateCss(id, sizes.fontSizes, sizes.wordSpacings, sizes.minFontSizes));
+                });
+            }
+        };
+
+    function testLineDimensions($line, maxWidth, property, size, interval, units)
+    {
+        var width;
+        $line.css(property, size + units);
+
+        width = $line.width();
+
+        if(width >= maxWidth) {
+            $line.css(property, '');
+
+            if(width == maxWidth) {
+                return {
+                    match: 'exact',
+                    size: parseFloat((parseFloat(size) - 0.1).toFixed(3))
+                };
+            }
+
+            return {
+                match: 'estimate',
+                size: parseFloat((parseFloat(size) - interval).toFixed(3))
+            };
+        }
+
+        return false;
+    }
+
+    function calculateSizes($t, childSelector, maxWidth, maxFontSize, minFontSize)
+    {
+        var $c = $t.clone(true)
+                    .addClass('bigtext-cloned')
+                    .css({
+                        fontFamily: $t.css('font-family'),
+                        'min-width': parseInt(maxWidth, 10),
+                        width: 'auto',
+                        position: 'absolute',
+                        left: -9999,
+                        top: -9999
+                    }).appendTo(document.body);
+
+        // font-size isn't the only thing we can modify, we can also mess with:
+        // word-spacing and letter-spacing.
+        // Note: webkit does not respect subpixel letter-spacing or word-spacing,
+        // nor does it respect hundredths of a font-size em.
+        var fontSizes = [],
+            wordSpacings = [],
+            minFontSizes = [],
+            ratios = [];
+
+        $c.find(childSelector).css({
+            'float': 'left',
+            'clear': 'left'
+        }).each(function(lineNumber) {
+            var $line = $(this),
+                intervals = [4,1,.4,.1],
+                lineMax;
+
+            if($line.hasClass(BigText.EXEMPT_CLASS)) {
+                fontSizes.push(null);
+                ratios.push(null);
+                minFontSizes.push(false);
+                return;
+            }
+
+            // TODO we can cache this ratio?
+            var autoGuessSubtraction = 20, // px
+                currentFontSize = parseFloat($line.css('font-size')),
+                lineWidth = $line.width(),
+                ratio = (lineWidth / currentFontSize).toFixed(6),
+                newFontSize = parseFloat(((maxWidth - autoGuessSubtraction) / ratio).toFixed(3));
+
+            outer: for(var m=0, n=intervals.length; m<n; m++) {
+                inner: for(var j=1, k=4; j<=k; j++) {
+                    if(newFontSize + j*intervals[m] > maxFontSize) {
+                        newFontSize = maxFontSize;
+                        break outer;
+                    }
+
+                    lineMax = testLineDimensions($line, maxWidth, 'font-size', newFontSize + j*intervals[m], intervals[m], 'px');
+                    if(lineMax !== false) {
+                        newFontSize = lineMax.size;
+
+                        if(lineMax.match == 'exact') {
+                            break outer;
+                        }
+                        break inner;
+                    }
+                }
+            }
+
+            ratios.push(maxWidth / newFontSize);
+
+            if(newFontSize > maxFontSize) {
+                fontSizes.push(maxFontSize);
+                minFontSizes.push(false);
+            } else if(!!minFontSize && newFontSize < minFontSize) {
+                fontSizes.push(minFontSize);
+                minFontSizes.push(true);
+            } else {
+                fontSizes.push(newFontSize);
+                minFontSizes.push(false);
+            }
+        }).each(function(lineNumber) {
+            var $line = $(this),
+                wordSpacing = 0,
+                interval = 1,
+                maxWordSpacing;
+
+            if($line.hasClass(BigText.EXEMPT_CLASS)) {
+                wordSpacings.push(null);
+                return;
+            }
+
+            // must re-use font-size, even though it was removed above.
+            $line.css('font-size', fontSizes[lineNumber] + 'px');
+
+            for(var m=1, n=5; m<n; m+=interval) {
+                maxWordSpacing = testLineDimensions($line, maxWidth, 'word-spacing', m, interval, 'px');
+                if(maxWordSpacing !== false) {
+                    wordSpacing = maxWordSpacing.size;
+                    break;
+                }
+            }
+
+            $line.css('font-size', '');
+            wordSpacings.push(wordSpacing);
+        }).removeAttr('style');
+
+        $c.remove();
+
+        return {
+            fontSizes: fontSizes,
+            wordSpacings: wordSpacings,
+            ratios: ratios,
+            minFontSizes: minFontSizes
+        };
+    }
+
+    $.fn.bigtext = BigText.jQueryMethod;
+    window.BigText = BigText;
+
+})(this, jQuery);