trecs 0.0.1.alpha

data/sandbox/record

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require_relative "./create_recording"
+require "trollop"
+
+def com(c)
+  IO.popen(c).read
+end
+
+def cowsay(msg="")
+  com "cowsay '#{msg}'"
+end
+
+def figlet(msg="")
+  com "figlet '#{msg}'"
+end
+
+
+def map_increments(s='')
+  0.upto(s.size-1).map do |i|
+    s[0..i]
+  end
+end
+
+options = Trollop::options do
+  opt :file,    "File name", short: 'f', type: String
+  opt :message, "Message",   short: 'm', type: String
+  opt :step,    "step",      short: 's', type: String
+  opt :cow
+  opt :figlet
+end
+
+step = (options[:step] || 250).to_i
+
+frames = map_increments(options[:message])
+
+create_recording(file_name: options[:file]) do
+  frames.each_with_index do |frame, i|
+    frame = if options[:cow]
+              cowsay(frame)
+            elsif options[:figlet]
+              figlet(frame)
+            else
+              frame
+            end
+    create_frame time: i*step, content: frame
+  end
+end
+
+puts "Recorded to: #{options[:file]}"

data/sandbox/record_diff

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require_relative "./create_recording"
+require "trollop"
+
+def run_cmd(cmd="")
+  IO.popen(cmd).read
+end
+
+options = Trollop::options do
+  opt :start, "Starting file", short: 's', type: String
+  opt :end,   "End file",      short: 'e', type: String
+end
+
+start_file = options[:start]
+end_file   = options[:end]
+
+number_of_lines = 100
+
+cmd = %W[diff #{start_file} #{end_file}]
+
+diff = run_cmd(cmd).split("\n")
+
+
+
+puts diff.inspect

data/sandbox/record_script_file

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require_relative "./create_recording"
+#require "trollop"
+#
+#options = Trollop::options do
+#  opt :file,       "File name",  short: 'f', type: String
+#  opt :inputfile, "Input File", short: 'i', type: String
+#  opt :timesfile, "Times File", short: 't', type: String
+#end
+
+
+Timing = Struct.new(:time, :chars)
+
+timings = [].concat(File.open(ARGV[2]).each_line.map { |l|
+  ll = l.split(" ")
+  Timing.new(ll[0].to_f, ll[1].to_i)
+}.sort_by{|t|t.time}
+)
+
+@start = 0
+@end = 0
+file = File.open(ARGV[1]) do |f|
+  timings.each do |time|
+    time.chars.times do
+      print f.getc
+    end
+    sleep (time.time)
+  end
+end
+
+#[46, 33].each do |t|
+#    t.times do
+#    print file.gets
+#  end
+#end
+#frames = []
+#
+#create_recording(file_name: ARGV[0]) do
+#  frames.each_with_index do |frame, i|
+#    create_frame time: i*step, content: frame
+#  end
+#end
+
+puts "Recorded to: #{ARGV[0]}"

data/spec/player_spec.rb

@@ -0,0 +1,196 @@
+require "spec_helper"
+
+require "player"
+require "screens/terminal_screen"
+
+module TRecs
+  class DummyPlayer < Player
+    def initialize(frames:, **options)
+      @frames = frames
+      super
+    end
+
+    def get_timestamps
+      @frames.keys
+    end
+
+    def get_frame(time)
+      @frames[time]
+    end
+  end
+
+  class DummyOutput
+    def initialize
+      @output = []
+    end
+
+    def puts(str=nil)
+      @output << str.to_s
+    end
+
+    def clear
+      @output << :clear_screen
+    end
+
+    def raw_output
+      @output
+    end
+
+    def output
+      @output.select { |f| f.is_a? String }
+    end
+  end
+
+
+  describe Player do
+    define :have_frames do |expected|
+      match do |actual|
+        raw_expected = expected.map { |o| [:clear_screen, o]  }.flatten
+        a = actual.raw_output == raw_expected
+        b = actual.output     == expected
+        a && b
+      end
+    end
+
+    def create_recording
+      frames = {}
+      yield frames
+      DummyPlayer.new(frames: frames, output: output)
+    end
+
+    let(:output) { DummyOutput.new }
+
+    it "reads a one frame screencast" do
+      player = create_recording do |frames|
+        frames[0] = "FIRST FRAME"
+      end
+
+      player.play
+
+      output.should have_frames ["FIRST FRAME"]
+    end
+
+    it "returns the frame at certain time" do
+      player = create_recording do |frames|
+        frames[0]   = "FIRST FRAME",
+        frames[100] = "FRAME AT 100"
+      end
+
+      player.play_frame(100)
+
+      output.should have_frames ["FRAME AT 100"]
+    end
+
+    it "returns the previous frame if no frame at certain time" do
+      player = create_recording do |frames|
+        frames[0]   = "FIRST FRAME"
+        frames[100] = "FRAME AT 100"
+        frames[200] = "FRAME AT 200"
+      end
+
+      player.play_frame(111)
+
+      output.output.should == ["FRAME AT 100"]
+    end
+
+    it "returns the last frame if asking for exceeding time" do
+      player = create_recording do |frames|
+        frames[0]   = "FIRST FRAME"
+        frames[100] = "FRAME AT 100"
+        frames[200] = "FRAME AT 200"
+      end
+
+      player.play_frame(201)
+
+      output.should have_frames ["FRAME AT 200"]
+
+    end
+
+    describe "multiple frame screencast" do
+      it "playing two frames" do
+        player = create_recording do |frames|
+          frames[0]   = "FIRST FRAME"
+          frames[100] = "FRAME AT 100"
+        end
+
+        player.play
+
+        output.should have_frames [
+          "FIRST FRAME",
+          "FRAME AT 100"
+        ]
+      end
+
+      it "playing all the frames" do
+        player = create_recording do |frames|
+          frames[0]   = "FIRST FRAME"
+          frames[100] = "FRAME AT 100"
+          frames[200] = "FRAME AT 200"
+        end
+
+        player.play
+
+        output.should have_frames [
+          "FIRST FRAME",
+          "FRAME AT 100",
+          "FRAME AT 200"
+        ]
+      end
+
+      it "playing a recording" do
+        player = create_recording do |frames|
+          frames[0]   = "FIRST FRAME"
+          frames[100] = "FRAME AT 100"
+          frames[200] = "FRAME AT 200"
+          frames[301] = "FRAME AT 301"
+          frames[499] = "FRAME AT 499"
+          frames[599] = "FRAME AT 599"
+        end
+
+        player.play
+
+        output.should have_frames [
+          "FIRST FRAME",
+          "FRAME AT 100",
+          "FRAME AT 200",
+          "FRAME AT 200",
+          "FRAME AT 301",
+          "FRAME AT 499",
+          "FRAME AT 599",
+        ]
+      end
+    end
+
+    context "Timestamps" do
+      it "returns all the frame timestamps" do
+        player = create_recording do |frames|
+          frames[0]   = "FIRST FRAME"
+          frames[100] = "FRAME AT 100"
+          frames[200] = "FRAME AT 200"
+        end
+
+        player.timestamps.should == [0, 100, 200]
+
+      end
+
+    end
+
+    context "output" do
+      it "receives a Screen object to manage output" do
+        player = Player.new(output: :output)
+
+        player.output.should == :output
+      end
+
+      it "defaults to the Terminal Screen" do
+        player = Player.new
+
+        player.output.class.should == TerminalScreen
+      end
+
+      context "message ... puts ... print" do
+      end
+    end
+  end
+
+end

data/spec/recorder_spec.rb

@@ -0,0 +1,248 @@
+require "spec_helper"
+
+require "recorders/message_recorder"
+
+module TRecs
+  describe Recorder do
+    class DummyRecorder < Recorder
+      attr_reader :result
+
+      def initialize(frames: nil, **options)
+        @frames = frames.is_a?(Hash) ? frames : Array(frames)
+        super(**options)
+      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

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+$:.unshift(File.expand_path("../lib", __FILE__))
+
+def create_dir(dir_path)
+  mkdir_p dir_path unless File.exist?(dir_path)
+  dir_path
+end
+
+def file_name(string=nil)
+  if string
+    @file_name = "#{project_dir}/#{string}.trecs"
+  else
+    @file_name
+  end
+end

data/spec/timestamps_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "timestamps"
+
+describe Timestamps do
+  context "invalid inputs" do
+    it "returns 0 with invalid imputs" do
+      ts = Timestamps.new([0, 10, 20, 30])
+      [-1, :a, "hola", Object.new].each do |input|
+        ts.time_at(input).should == 0
+      end
+    end
+  end
+
+  context "empty collection" do
+    it "returns 0 at 0" do
+      ts = Timestamps.new([])
+      ts.time_at(0).should == 0
+    end
+
+    it "returns 0 at > 0" do
+      ts = Timestamps.new([])
+      ts.time_at(10).should == 0
+    end
+  end
+
+  context "with timestamps and valid imputs" do
+    let(:subject) { Timestamps.new([0, 10, 20]) }
+
+    it "returns the exact time" do
+      subject.time_at(0).should == 0
+      subject.time_at(10).should == 10
+      subject.time_at(20).should == 20
+    end
+
+    it "returns the previous valid time if no exact time in the collection" do
+      subject.time_at(5).should == 0
+      subject.time_at(15).should == 10
+    end
+
+    it "returns the last time when passing a time greater than the greater time" do
+      subject.time_at(25).should == 20
+    end
+  end
+end