trecs 0.0.3 → 0.0.4

data/lib/player.rb

@@ -1,76 +0,0 @@
-require "timestamps"
-require "screens/terminal_screen"
-
-module TRecs
-  class Player
-    attr_reader :output
-
-    def initialize(options={})
-      time = options.fetch(:time) { nil }
-      @current_time = time
-      @step         = options.fetch(:step) { 100 }
-      @output       = options.fetch(:output) { TerminalScreen.new }
-      @testing      = options.fetch(:testing) { false }
-      @ticks        = time ? Array(time.to_i) : ticks
-    end
-
-    def play
-      ticks.each do |time|
-        play_frame(time)
-        sleep(sleep_time) unless testing
-      end
-    end
-
-    def tick(time=current_time)
-      self.current_time = time
-      get_frame(time)
-    end
-
-    def timestamps
-      @timestamps ||= get_timestamps.sort
-    end
-
-    def generate_ticks
-      ticks = [0]
-      curr  = 0
-      while(curr < timestamps.last.to_i)
-        curr += step
-        ticks << curr
-      end
-      ticks
-    end
-
-    def ticks
-      @ticks ||= generate_ticks
-    end
-
-    def play_frame(time)
-      output.clear
-      output.puts tick(time_at(time))
-    end
-
-    def time_at(time)
-      Timestamps.new(timestamps).time_at(time)
-    end
-
-    private
-    attr_accessor :current_time
-    attr_reader   :step
-    attr_reader   :testing
-
-
-
-    def get_timestamps
-      []
-    end
-
-    def get_frame(time)
-      ""
-    end
-
-    def sleep_time
-      # TODO: Fix this to use the current time
-      @sleep_time ||= (step/1000.0)*0.8
-    end
-  end
-end

data/lib/recorder.rb

@@ -1,74 +0,0 @@
-module TRecs
-  class Recorder
-    attr_writer :current_time
-    attr_reader :step
-
-    def initialize(options={})
-      @step = options.fetch(:step) { 100 }
-    end
-
-    def next_timestamp
-      @current_time = -step unless @current_time
-      @current_time += step
-    end
-
-    def current_time(time=nil)
-      if time
-        @current_time = time
-      end
-      @current_time
-    end
-
-    def current_content(content=nil)
-      if content
-        @current_content = content
-      end
-      @current_content
-    end
-
-    def current_frame(options={})
-      time = options.fetch(:time) { next_timestamp }
-      content = options.fetch(:content)
-      current_time(time)
-      current_content(content)
-
-      if previous_content != content
-        create_frame
-        self.previous_content = content
-      end
-    end
-
-    def record
-      start
-      perform_recording
-      finish
-    end
-
-    def stop
-      recording_strategy.stop
-    end
-    
-    private
-    attr_accessor :recording
-    attr_accessor :previous_content
-    attr_reader :recording_strategy
-
-    def start
-      self.current_time = nil
-      self.recording = true
-      setup
-    end
-
-    def finish
-      render
-      self.recording = false
-    end
-
-    def create_frame
-    end
-
-    def perform_recording
-      recording_strategy.perform
-    end
-  end
-end

data/lib/recording_strategies/raw_file_recording_strategy.rb

@@ -1,42 +0,0 @@
-require "recording_strategy"
-module TRecs
-  class RawFileRecordingStrategy < RecordingStrategy
-    def initialize(options)
-      file = options.fetch(:file) 
-      raise "File does not exist: #{file}" unless File.exist?(file)
-      @file = File.new(file)
-      
-      @height = options.fetch(:height) { 24  }
-      @width  = options.fetch(:width)  { 80  }
-      @step   = options.fetch(:step)   { 100 }
-
-      super
-    end
-
-    def perform
-      @recording = true
-      start_time = Time.now
-
-      while @recording
-        time    = timestamp(Time.now - start_time)
-        content = File.read(@file)
-        recorder.current_frame(time: time, content: content)
-        sleep(sleep_time)
-      end
-    end
-
-    def stop
-      @recording = false
-    end
-
-    private
-    def sleep_time
-      # TODO: Fix this to use the current time
-      @sleep_time ||= (@step/1000.0)
-    end
-
-    def timestamp(time)
-      (time * 1000).to_i
-    end
-  end
-end

data/spec/recorder_spec.rb

@@ -1,249 +0,0 @@
-require "spec_helper"
-
-require "recorders/message_recorder"
-
-module TRecs
-  describe Recorder do
-    class DummyRecorder < Recorder
-      attr_reader :result
-
-      def initialize(options={})
-        frames = options.fetch(:frames) { nil }
-        @frames = frames.is_a?(Hash) ? frames : Array(frames)
-        super
-      end
-
-      def perform_recording
-        if @frames.is_a?(Hash)
-          @frames.each do |time, content|
-            current_frame(time: time, content: content)
-          end
-        else
-          @frames.each do |content|
-            current_frame(content: content)
-          end
-        end
-      end
-
-      def create_frame
-        @result[current_time] = current_content
-      end
-
-      def setup
-        @result = {}
-      end
-
-      def render
-        # no-op
-      end
-    end
-
-    context "recording" do
-      context "with custom timestamps" do
-        it "records a one frame trecs" do
-          rec = DummyRecorder.new frames: {0 => "a"}
-          rec.record
-
-          rec.result.should == {0 => "a"}
-        end
-
-        it "records a two frames trecs" do
-          rec = DummyRecorder.new frames: {
-            0 => "a",
-            100 => "b"
-          }
-          rec.record
-
-          rec.result.should == {
-            0 => "a",
-            100 => "b"
-          }
-        end
-
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: {
-            0   => "a",
-            100 => "b",
-            150 => "c"
-          }
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            100 => "b",
-            150 => "c"
-          }
-        end
-
-        it "calls start_recording" do
-          rec = DummyRecorder.new
-          rec.should_receive(:setup)
-
-          rec.record
-        end
-
-        it "calls finish_recording" do
-          rec = DummyRecorder.new
-          rec.should_receive(:render)
-
-          rec.record
-        end
-
-      end
-
-      context "with custom timestamps" do
-        it "records a one frame trecs" do
-          rec = DummyRecorder.new frames: ["a"]
-          rec.record
-
-          rec.result.should == {0 => "a"}
-        end
-
-        it "records a two frames trecs" do
-          rec = DummyRecorder.new frames: ["a", "b"]
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            100 => "b"
-          }
-        end
-
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: ["a", "b", "c"]
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            100 => "b",
-            200 => "c"
-          }
-        end
-
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: ["a", "b", "c"], step: 75
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            75  => "b",
-            150 => "c"
-          }
-        end
-      end
-
-      context "sanitizing the recording" do
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: {
-            0   => "a",
-            50  => "b",
-            100 => "b",
-            150 => "c",
-          }
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            50  => "b",
-            150 => "c",
-          }
-        end
-
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: {
-            0   => "a",
-            50  => "a",
-            100 => "b",
-            150 => "c",
-          }
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            100 => "b",
-            150 => "c",
-          }
-        end
-
-        it "records a three frames trecs" do
-          rec = DummyRecorder.new frames: {
-            0   => "a",
-            50  => "b",
-            100 => "c",
-            150 => "c",
-          }
-          rec.record
-
-          rec.result.should == {
-            0   => "a",
-            50  => "b",
-            100 => "c",
-          }
-        end
-
-      end
-    end
-
-
-    context "timestamps" do
-      it "starts with 0 as the current time" do
-        rec = Recorder.new
-
-        rec.current_time.should == nil
-      end
-
-      it "calculates the next timestamp" do
-        rec = Recorder.new(step: 100)
-
-        rec.next_timestamp.should == 0
-        rec.current_time.should   == 0
-      end
-
-      it "calculates the second next timestamp" do
-        rec = Recorder.new(step: 100)
-
-        rec.next_timestamp
-        rec.next_timestamp.should == 100
-        rec.current_time.should   == 100
-      end
-    end
-
-    describe "#current_time" do
-      it "sets the current time" do
-        rec = Recorder.new
-
-        rec.current_time(40)
-
-        rec.current_time.should == 40
-      end
-    end
-
-    describe "#current_content" do
-      it "sets the current time" do
-        rec = Recorder.new
-
-        rec.current_content("HELLO")
-
-        rec.current_content.should == "HELLO"
-      end
-    end
-
-    describe "#current_frame" do
-      it "sets the current time and content" do
-        rec = Recorder.new
-
-        rec.current_frame(time: 40, content: "HELLO")
-
-        rec.current_time.should    == 40
-        rec.current_content.should == "HELLO"
-      end
-
-      it "sets the current time and content" do
-        rec = Recorder.new()
-        rec.should_receive(:create_frame)
-
-        rec.current_frame(time: 40, content: "HELLO")
-      end
-    end
-  end
-end