trecs 0.1.11 → 0.1.12

data/lib/trecs/recording_strategies/hash_strategy.rb

@@ -18,5 +18,9 @@ module TRecs
 
     def stop
     end
+
+    def inspect
+      "<#{self.class}: frames: #{frames}>"
+    end
   end
 end

data/lib/trecs/recording_strategies/ttyrec_strategy.rb

@@ -25,7 +25,7 @@ module TRecs
         frame      = data_array[-height..-1].join
 
         frame = @prev_frame + curr_data
-        
+
         @first_timestamp ||= [ sec, usec ].join('.').to_f
         curr_timestamp   = [ sec, usec ].join('.').to_f
         offset = ((curr_timestamp - @first_timestamp)*1000).to_i
@@ -41,39 +41,3 @@ module TRecs
     end
   end
 end
-
-# module TRecs
-#   class TtyrecStrategy
-#     attr_accessor :recorder
-
-#     def initialize(options={})
-#       file = options.fetch(:input_file)
-#       @file = File.new(file)
-#       @frames = []
-#       @full_output = ""
-#       @height = options.fetch(:height) { 24 }
-#       @width = options.fetch(:width) { 80 }
-#     end
-
-#     def perform
-#       @prev_timestamp = 0
-#       while !@file.eof?
-#         sec, usec, len = @file.read(12).unpack('VVV')
-#         @full_output << @file.read(len)
-
-#         data_array = @full_output.each_line.to_a
-#         height     = data_array.size > @height ? @height : 0
-#         frame      = data_array[-height..-1].join
-
-#         @first_timestamp ||= [ sec, usec ].join('.').to_f
-#         curr_timestamp   = [ sec, usec ].join('.').to_f
-#         offset = ((curr_timestamp - @first_timestamp)*1000).to_i
-
-#         if curr_timestamp > @prev_timestamp
-#           recorder.current_frame(time: offset, content: frame)
-#           @prev_timestamp = curr_timestamp
-#         end
-#       end
-#     end
-#   end
-# end

data/lib/trecs/sources/tgz_source.rb

@@ -0,0 +1,106 @@
+require 'json'
+require "fileutils"
+require "zlib"
+require 'archive/tar/minitar'
+require "tmpdir"
+require "pathname"
+require "yaml"
+
+module TRecs
+  class TgzSource
+    include Archive::Tar
+
+    attr_reader :trecs_file
+
+    def initialize(options={})
+      @trecs_file = options.fetch(:trecs_file)
+    end
+
+    def create_recording
+      in_tmp_dir do
+        @tgz = Zlib::GzipWriter.new(File.open(trecs_file, 'wb'))
+
+        yield self
+
+        create_file('manifest.yaml') do |f|
+          f.write manifest.to_yaml
+        end
+
+        Minitar.pack(@files_to_add.flatten, @tgz)
+      end
+    end
+
+    def reader(options={})
+      reader = nil
+      options[:source] = self
+      read do |source|
+        @manifest = YAML.load(source.read_file("manifest.yaml"))
+
+        format = manifest["format"]
+        reader_file = "readers/#{format}_reader"
+        require reader_file
+        reader_class_name = [
+          "TRecs::",
+          format.split(/[-_\s]/).map(&:capitalize),
+          "Reader"
+        ].join
+        reader_class = reader_class_name.split("::").reduce(Object) { |a, e| a.const_get e }
+        reader = reader_class.new(options)
+      end
+      reader
+    end
+
+    def read
+      in_tmp_dir do
+        tgz = Zlib::GzipReader.new(File.open(trecs_file, 'rb'))
+        Minitar.unpack(tgz, "./")
+
+        yield self
+      end
+    end
+
+    def in_tmp_dir
+      Dir.mktmpdir("trecs_record") do |dir|
+        Dir.chdir(dir) do
+          yield
+        end
+      end
+    end
+
+    def read_file(file_name)
+      File.read(file_name)
+    end
+
+    def create_file(file_name)
+      File.open(file_name, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
+        yield f
+      end
+      add_file(file_name)
+    end
+
+    def add_file(file_name)
+      @files_to_add ||= []
+      @files_to_add << file_name
+    end
+
+    def add_audio_file(file_name)
+      Dir.mkdir("audio") unless File.exist? "audio"
+
+      orig_file = file_name
+      file_name = "./audio/" + Pathname(file_name).basename.to_s
+      FileUtils.symlink(orig_file, file_name)
+      add_file(file_name)
+    end
+
+    def []=(key, value)
+      manifest[key.to_s] = value
+    end
+
+    private
+
+    def manifest
+      @manifest ||= {}
+    end
+
+  end
+end

data/lib/trecs/version.rb

@@ -1,3 +1,3 @@
 module TRecs
-  VERSION = "0.1.11"
+  VERSION = "0.1.12"
 end

data/lib/trecs/writers/json_writer.rb

@@ -1,15 +1,19 @@
-require 'json'
-require "fileutils"
+require "sources/tgz_source"
 
 module TRecs
   class JsonWriter
     attr_accessor :recorder
+
     attr_reader :frames
-    attr_reader :file
+    attr_reader :audio_files
+    attr_reader :source
 
     def initialize(options={})
-      @file = options.fetch(:trecs_file)
-      FileUtils.rm(@file, force: true)
+      trecs_file = options.fetch(:trecs_file)
+      @source = TgzSource.new(trecs_file: trecs_file)
+
+      @audio_files = options.fetch(:audio_files) { [] }
+      @audio_files = Array(@audio_files)
     end
 
     def setup
@@ -23,11 +27,26 @@ module TRecs
     end
 
     def render
-      json_string = frames.to_json
-      
-      File.open(file, File::CREAT|File::TRUNC|File::RDWR, 0644) do |f|
-        f.write(json_string)
+      source.create_recording do |source|
+        source[:format] = "json"
+
+        json_string = frames.to_json
+        
+        source.create_file('frames.json') do |f|
+          f.write json_string
+        end
+
+        audio_files.each do |file|
+          source.add_audio_file(file)
+        end
+        if audio_files.any?
+          source[:defailt_audio] = audio_files.first
+        end
       end
     end
+
+    def add_audio_file(file_name)
+      audio_files << file_name
+    end
   end
 end

data/spec/trecs/frame_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "frame"
+
+module TRecs
+  describe Frame do
+    context "content" do
+      context "initializer" do
+        Given(:frame) { Frame.new("THE CONTENT") }
+        Then { frame.content == "THE CONTENT" }
+      end
+      context "set aftewards" do
+        Given(:frame) { Frame.new }
+        When { frame.content = "THE NEW CONTENT" }
+        Then { frame.content == "THE NEW CONTENT" }
+      end
+    end
+
+    context "width" do
+      context "one line" do
+        Given(:frame) { Frame.new("123456") }
+        Then { frame.width == 6 }
+      end
+      context "multiple lines" do
+        Given(:frame) { Frame.new(<<FRAME
+123
+12345
+12
+FRAME
+            ) }
+        Then { frame.width == 5 }
+      end
+    end
+
+    context "height" do
+      context "one line" do
+        Given(:frame) { Frame.new("LINE 1") }
+        Then { frame.height == 1 }
+      end
+      context "multiple lines" do
+        Given(:frame) { Frame.new(<<FRAME
+LINE 1
+LINE 2
+LINE 3
+FRAME
+            ) }
+        Then { frame.height == 3 }
+      end
+    end
+
+    context "each" do
+      Given(:content) { "a\nb\nc\n" }
+      Given(:frame) { Frame.new(content) }
+      Then {
+        frame.each
+          .zip(content.each_line)
+          .all?{ |actual, expected|
+          actual == expected
+        }
+      }
+      Then { frame.is_a? Enumerable }
+    end
+
+    context "#to_s" do
+      Given(:frame) { Frame.new("FRAME CONTENT") }
+      Then { frame.to_s == "FRAME CONTENT" }
+    end
+  end
+end

data/spec/trecs/player_spec.rb

@@ -76,7 +76,7 @@ module TRecs
     context "content at time" do
       Given(:screen) { double.as_null_object }
       Given(:ticker) { OpenStruct.new }
-      Given(:reader) { CustomReader.new(0 => "a", 100 => "b", 200 => "c") }
+      Given(:reader) { CustomReader.new(100 => "b", 0 => "a", 200 => "c") }
 
       Given(:player) {
         Player.new(reader: reader, ticker: ticker, screen: screen)

data/spec/trecs/readers/json_reader_spec.rb

@@ -3,6 +3,6 @@ require "readers/json_reader"
 
 module TRecs
   describe JsonReader do
-    Then { skip("Test JsonReader") }
+    skip("Test JsonReader")
   end
 end

data/spec/trecs/readers/yaml_store_reader_spec.rb

@@ -3,6 +3,6 @@ require "readers/yaml_store_reader"
 
 module TRecs
   describe YamlStoreReader do
-    Then { skip("Test YamlStoreReader") }
+    skip("Test YamlStoreReader")
   end
 end

data/spec/trecs/recorder_spec.rb

@@ -207,44 +207,63 @@ module TRecs
     end
 
     context "Offset" do
+      context "initialization" do
+        context "from constructor" do
+          Given(:recorder) { Recorder.new(offset: 10, writer: OpenStruct.new, strategy: OpenStruct.new) }
+          Then { recorder.offset == 10 }
+        end
+
+        context "setter" do
+          Given(:recorder) { Recorder.new(offset: 10, writer: OpenStruct.new, strategy: OpenStruct.new) }
+          When { recorder.offset =  30 }
+          Then { recorder.offset == 30 }
+        end
+      end
+
       Given   { Spy.clear }
       Given(:writer)   { Spy.new("Writer").ignore(:recorder=, :setup, :render) }
       Given(:strategy) { CustomStrategy.new }
 
       Given(:recorder) {
-        Recorder.new(writer: writer, strategy: strategy, offset: 7)
+        Recorder.new(offset: 7, writer: writer, strategy: strategy, step: 10)
       }
 
-      context "setting current frame and time with content duplicates" do
-        When {
-          strategy.action = -> {
-            recorder.current_frame(time: 0,   content: "CONTENT")
-            recorder.current_frame(time: 10, content: "CONTENT 2")
-            recorder.current_frame(time: 12, content: "CONTENT 3")
-          }
-          recorder.record
-        }
-
-        Then {
-          writer.calls[1] == [
-            :create_frame,
-            [ { time: 7, content: "CONTENT" } ]
-          ]
-        }
-        Then {
-          writer.calls[2] == [
-            :create_frame,
-            [ { time: 17, content: "CONTENT 2" } ]
-          ]
-        }
-        Then {
-          writer.calls[3] == [
-            :create_frame,
-            [ { time: 19, content: "CONTENT 3" } ]
-          ]
+      When {
+        strategy.action = -> {
+          recorder.current_frame(time: 0,  content: "CONTENT")
+          recorder.current_frame(time: 10, content: "CONTENT 2")
+          recorder.current_frame(time: 12, content: "CONTENT 3")
+          recorder.current_frame(          content: "CONTENT 4")
         }
-      end
+        recorder.record
+      }
 
+      Then {
+        writer.calls[1] == [
+          :create_frame,
+          [ { time: 7, content: "CONTENT" } ]
+        ]
+      }
+      Then {
+        writer.calls[2] == [
+          :create_frame,
+          [ { time: 17, content: "CONTENT 2" } ]
+        ]
+      }
+      Then {
+        writer.calls[3] == [
+          :create_frame,
+          [ { time: 19, content: "CONTENT 3" } ]
+        ]
+      }
+      Then { recorder.current_time == 22 }
+      Then {
+        writer.calls[4] == [
+          :create_frame,
+          [ { time: 29, content: "CONTENT 4" } ]
+        ]
+      }
     end
+
   end
 end

data/spec/trecs/recording_strategies/config_strategy_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+require "recording_strategies/config_strategy"
+require "recorder"
+require "recording_strategies/hash_strategy"
+require "writers/in_memory_writer"
+
+module TRecs
+  describe ConfigStrategy do
+    context "options" do
+
+      context "set values" do
+
+        Given(:options) {
+          {
+            step: 40,
+            format: "yaml_store",
+            strategies: [],
+            spureous_option: "something spureous",
+          }
+        }
+
+        Given(:strategy) { ConfigStrategy.new(options) }
+
+        Then { strategy.step == 40 }
+        Then { strategy.format == "yaml_store" }
+        Then { strategy.strategies == [] }
+      end
+
+      context "default values" do
+        Given(:strategy) { ConfigStrategy.new }
+
+        Then { strategy.step == 100 }
+        Then { strategy.format == "json" }
+        Then { strategy.strategies == [] }
+      end
+    end
+
+    context "strategies" do
+      context "adding strategies" do
+        Given(:strategy) { ConfigStrategy.new(strategies: [first_strategy]) }
+        Given(:first_strategy) { Object.new }
+        Given(:second_strategy) { Object.new }
+        Given(:third_strategy) { Object.new }
+
+        context "just one" do
+          Then { strategy.strategies == [first_strategy] }
+        end
+
+        context "adding later" do
+          context "one by one" do
+            When { strategy << second_strategy }
+            When { strategy << third_strategy }
+
+            Then { strategy.strategies == [
+                first_strategy,
+                second_strategy,
+                third_strategy,
+              ] }
+          end
+
+          context "in bulk" do
+            When { strategy << [second_strategy, third_strategy] }
+
+            Then { strategy.strategies == [
+                first_strategy,
+                second_strategy,
+                third_strategy,
+              ] }
+          end
+        end
+
+        context "#perform" do
+          Given(:writer)   { InMemoryWriter.new }
+          Given(:recorder) { Recorder.new(strategy: strategy, writer: writer) }
+
+          When { strategy.recorder = recorder }
+          When { recorder.record }
+
+          context "one strategy" do
+            Given(:s) { HashStrategy.new(
+                {
+                  0   => "A",
+                  100 => "B",
+                  200 => "C",
+                }
+                ) }
+
+            Given(:strategy) { ConfigStrategy.new(strategies: [s]) }
+
+            Then { writer.frames[0]   == "A" }
+            Then { writer.frames[100] == "B" }
+            Then { writer.frames[200] == "C" }
+          end
+
+          context "two strategies" do
+            Given(:s1) { HashStrategy.new(
+                {
+                  0  => "A",
+                  10 => "B",
+                  20 => "C",
+                }
+                )
+            }
+
+            Given(:s2) { HashStrategy.new(
+                {
+                  0  => "D",
+                  15 => "E",
+                  30 => "F",
+                }
+                )
+            }
+
+            Given(:strategy) { ConfigStrategy.new(strategies: [s1, s2]) }
+
+            Then { writer.frames[0]   == "A" }
+            Then { writer.frames[10]  == "B" }
+            Then { writer.frames[20]  == "C" }
+
+            Then { writer.frames[120] == "D" }
+            Then { writer.frames[135] == "E" }
+            Then { writer.frames[150] == "F" }
+          end
+
+        end
+      end
+    end
+  end
+end