trecs 0.0.3 → 0.0.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NDJhM2IwN2MzYzlhOTFhNjNjYmY1YWRiNTExNmY2OGI4MWU3ZWNiYg==
-  data.tar.gz: !binary |-
-    OTk1Njk3M2RhYzJhZTFhODg5ZTBhM2IzMmZhYzI5YjcyNjY1NDQ4YQ==
+SHA1:
+  metadata.gz: 6b9b65056214045e29a8c560870c4e53b4bc04b7
+  data.tar.gz: f8ed9275619e0d6afc1ab51f4580dbced02be455
 SHA512:
-  metadata.gz: !binary |-
-    ZWYxOGI0NTU1YTM3MjRkYjk5NDgxNThjZGNjOGE3YTRhMzNmMjZjMmU5NmJm
-    YzE0NjAwZWYyZDQxODRlMmZjYzdmMzFhZmY5NWJkNTBiYjE3NzMyNmU5Nzky
-    YmI3YTUxYmYwYTVkMWIyNWQ3ODYwYTM4MDZhMTM0OWYzMDcwODM=
-  data.tar.gz: !binary |-
-    NTQzY2U1NmM2Yjc3YjkyODdjOGU3NmQxYzY2NDE4MzFkODk5ODY4YTk2YzRl
-    MjA0YWM0M2ZmYTQ0OGM2ZTg3MGU0N2NlZTA5NTg4NmQ0ZTA2YzI3OGYwN2I0
-    Mjc4ZDQ4MGFkNzU2ZWI4ZjlkZDU3N2NhZTE5YTQ0Y2RkOTEyOTk=
+  metadata.gz: 19da3e8a8954ded968fc30564efc5f6f0aebe8f331cca3cb75932a1cb45820d508432d026a090fa94d07dd15a027359e01b330db2a019c101b40bb3e68033b0b
+  data.tar.gz: da0ef87b85613a53b6f0345a2f1e2e3438739fcc28e37c4a0df6ecbd30fb71f371a80d030387f2df349ec0b92df90ce4bf90e3ed7595d2e187ecbb54a1633704

data/Gemfile.lock

@@ -1,16 +1,24 @@
 PATH
   remote: .
   specs:
-    trecs (0.0.3)
+    trecs (0.0.4)
       rubyzip (~> 1.1.4)
       trollop (~> 2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    coderay (1.1.0)
     diff-lcs (1.2.5)
     given_core (3.5.4)
       sorcerer (>= 0.3.7)
+    method_source (0.8.2)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-nav (0.2.3)
+      pry (~> 0.9.10)
     rake (10.3.2)
     rspec (2.99.0)
       rspec-core (~> 2.99.0)
@@ -24,14 +32,18 @@ GEM
       rspec (>= 2.12)
     rspec-mocks (2.99.0)
     rubyzip (1.1.4)
+    slop (3.5.0)
     sorcerer (1.0.2)
     trollop (2.0)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
   bundler (~> 1.6)
+  pry
+  pry-nav
   rake
   rspec (~> 2.12)
   rspec-given (~> 3.5.4)

data/bin/trecs_message

@@ -13,6 +13,10 @@ options = Trollop::options do
 end
 
 if options[:file_name]
+
+  recorder = Recorder.new(
+    persistence_strategy: ZipFileRecorder.new(file_name: file_name),
+    recording_strategy: IncrementalRecordingStrategy.new(message: message)
   recorder = TRecs::MessageRecorder.new(options)
   recorder.record
 else

data/lib/trecs/player.rb

@@ -0,0 +1,128 @@
+require "screens/terminal_screen"
+
+module TRecs
+  class Player
+    attr_reader :reader
+    attr_reader :screen
+    attr_reader :ticker
+    attr_reader :step
+    attr_reader :current_time
+
+    def initialize(options={})
+      time = options.fetch(:time) { nil }
+      @reader        = options.fetch(:reader)
+      @reader.player = self
+
+      @ticker        = options.fetch(:ticker)
+      @ticker.player = self
+
+      @screen       = options.fetch(:screen) { TerminalScreen.new }
+
+      @testing      = options.fetch(:testing) { false }
+
+      @current_time = time
+      @step         = options.fetch(:step) { 100 }
+    end
+
+    def play
+      reader.setup
+      ticker.start
+    end
+
+    def tick(time=current_time)
+      content = reader.frame_at(time)
+      if content != @prev_content
+        screen.clear
+        screen.puts(content)
+        @prev_content = content
+      end
+    end
+
+    def timestamps
+      reader.timestamps
+    end
+    
+    private
+    attr_writer :current_time
+    attr_reader   :testing
+
+  end
+end
+
+
+# require "timestamps"
+# require "screens/terminal_screen"
+
+# module TRecs
+#   class Player
+#     attr_reader :screen
+
+#     def initialize(options={})
+#       time = options.fetch(:time) { nil }
+#       @current_time = time
+#       @step         = options.fetch(:step) { 100 }
+#       @screen       = options.fetch(:screen) { 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)
+#       screen.clear
+#       screen.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/trecs/recorder.rb

@@ -0,0 +1,59 @@
+module TRecs
+  class Recorder
+    attr_reader :writer
+    attr_reader :strategy
+    attr_reader :step
+    attr_reader :recording
+    attr_reader :current_time
+    attr_reader :current_content
+
+
+    def initialize(options={})
+      @writer   = options.fetch(:writer)
+      @writer.recorder = self
+
+      @strategy = options.fetch(:strategy)
+      @strategy.recorder = self
+
+      @step = options.fetch(:step) { 100 }
+      @recording = false
+      @current_time = nil
+    end
+
+    def record
+      self.current_time = nil
+      self.recording = true
+      writer.setup
+      strategy.perform
+      writer.render
+      self.recording = false
+    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
+        writer.create_frame(time: current_time, content: current_content)
+        @previous_content = content
+      end
+    end
+
+    def next_timestamp
+      @current_time = -step unless @current_time
+      @current_time += step
+    end
+
+    def stop
+      strategy.stop
+    end
+
+    private
+    attr_writer :recording
+    attr_writer :current_time
+    attr_writer :current_content
+
+  end
+end

data/lib/trecs/recording_strategies/custom_strategy.rb

@@ -0,0 +1,5 @@
+CustomStrategy = Struct.new(:recorder, :action) do
+  def perform
+    self.action.call
+  end
+end

data/lib/trecs/recording_strategies/hash_strategy.rb

@@ -0,0 +1,17 @@
+class HashStrategy
+  attr_accessor :recorder
+  attr_accessor :frames
+
+  def initialize(frames)
+    @frames = frames || Hash.new
+  end
+
+  def perform
+    @frames.each do |time, content|
+      recorder.current_frame(time: time, content: content)
+    end
+  end
+
+  def stop
+  end
+end

data/lib/{recording_strategies/incremental_recording_strategy.rb → trecs/recording_strategies/incremental_strategy.rb}

@@ -1,9 +1,11 @@
 require "recording_strategy"
 module TRecs
-  class IncrementalRecordingStrategy < RecordingStrategy
+  class IncrementalStrategy
+    attr_reader :message
+    attr_accessor :recorder
+
     def initialize(options={})
       @message = options.fetch(:message)
-      super(options)
     end
 
     def perform
@@ -16,7 +18,6 @@ module TRecs
       end
     end
     private
-    attr_reader :message
 
     def timestamp_for(message)
       (message.size - 1) * recorder.step

data/lib/trecs/recording_strategies/raw_file_strategy.rb

@@ -0,0 +1,54 @@
+require "recording_strategy"
+module TRecs
+  class RawFileStrategy
+    attr_accessor :recorder
+    attr_reader :file
+
+    def initialize(options={})
+      file  = options.fetch(:file)
+      @file = File.open(file)
+
+      @clock   = options.fetch(:clock) { Time }
+      @testing = options.fetch(:testing) { false }
+      #
+      #@height = options.fetch(:height) { 24  }
+      #@width  = options.fetch(:width)  { 80  }
+      #
+    end
+
+    def perform
+      @recording = true
+      start_time = clock.now
+
+      while @recording
+        time    = timestamp(clock.now - start_time)
+        content = File.read(@file)
+        recorder.current_frame(time: time, content: content)
+        custom_sleep(recorder.step)
+      end
+    end
+
+    def custom_sleep(millis)
+      if testing
+        clock.sleep(millis)
+      else
+        @sleep_time ||= (millis/1000.0)
+        sleep(@sleep_time)
+      end
+    end
+
+    def stop
+      @recording = false
+    end
+
+    private
+    attr_reader :clock
+    attr_reader :testing
+
+
+
+    def timestamp(time)
+      (time * 1000).to_i
+    end
+  end
+end

data/lib/trecs/version.rb

@@ -1,3 +1,3 @@
 module TRecs
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/trecs/writers/in_memory_writer.rb

@@ -0,0 +1,17 @@
+class InMemoryWriter
+  attr_accessor :recorder
+  attr_reader :frames
+
+  def setup
+    @frames = {}
+  end
+
+  def create_frame(options={})
+    time = options.fetch(:time)
+    content = options.fetch(:content)
+    @frames[time] = content
+  end
+
+  def render
+  end
+end

data/lib/{recorders/zip_file_recorder.rb → trecs/writers/zip_file_writer.rb}

@@ -2,18 +2,16 @@ require "zip"
 require "recorder"
 
 module TRecs
-  class ZipFileRecorder < Recorder
+  class ZipFileRecorder
+    attr_accessor :recorder
+
     include FileUtils
     def initialize(options={})
-      super(options)
       @file_name = options.fetch(:file_name)
       delete_file
     end
 
-    private
-    attr_reader :file_name
-    attr_reader :frames
-
+    
     # this
     def setup
       @frames = {}
@@ -30,10 +28,14 @@ module TRecs
       end
     end
 
+    
     def create_frame
-      frames[current_time] = current_content
+      frames[recorder.current_time] = recorder.current_content
     end
 
+    private
+    attr_reader :frames
+
     def delete_file
       rm file_name if File.exists? file_name
     end

data/lib/trecs.rb

@@ -0,0 +1,3 @@
+$:.unshift(File.expand_path("../trecs/", __FILE__))
+
+require "pry"

data/{spec → old_specs/recorders}/zip_file_recorder_spec.rb

@@ -7,11 +7,12 @@ require "players/zip_file_player"
 module TRecs
   describe ZipFileRecorder do
     class DummyRecordingStrategy
-      attr_reader :recorder
+      attr_accessor :recorder
 
       def initialize(options={})
-        @recorder = options.fetch(:recorder)
+        #@recorder = options.fetch(:recorder)
       end
+
       def perform
         recorder.current_frame(time: 0, content: "zero")
         recorder.current_frame(time: 1, content: "one")
@@ -27,12 +28,15 @@ module TRecs
     end
 
     it "expects a file name" do
-      expect { ZipFileRecorder.new }.to raise_error
+      expect {
+        Recorder.new( persistence_strategy: ZipFileRecorder.new, recording_strategy: DummyRecordingStrategy.new) }.to raise_error
     end
 
     it "generates a .trecs compressed file" do
       file_name = "tmp/i_should_exist.trecs"
-      recorder  = DummyZipFileRecorder.new(file_name: file_name)
+      recorder = Recorder.new(
+        persistence_strategy: ZipFileRecorder.new(file_name: file_name),
+        recording_strategy: DummyRecordingStrategy.new)
 
       recorder.record
 
@@ -42,7 +46,9 @@ module TRecs
 
     it "has the correct frames" do
       file_name = "tmp/zero_one_two.trecs"
-      recorder  = DummyZipFileRecorder.new(file_name: file_name)
+      recorder = Recorder.new(
+        persistence_strategy: ZipFileRecorder.new(file_name: file_name),
+        recording_strategy: DummyRecordingStrategy.new)
 
       recorder.record
 

data/spec/spec_helper.rb

@@ -1,32 +1,102 @@
-# 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
+require File.expand_path("../../lib/trecs", __FILE__)
+
+require "rspec/given"
+require "ostruct"
+
 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__))
+class Spy
+  attr_reader :calls
+
+  @calls = {}
+  @index = 0
+
+  def initialize(name)
+    @calls = {}
+    @index = 0
+    @name = name
+    @skips = []
+  end
+
+  def self.clear
+    @calls = {}
+    @index = 0
+  end
+
+  def method_missing(method, *args)
+    unless @skips.include? method
+      @index = @index + 1
+      self.class.inc_index
+
+      @calls[@index] = add_call(method, args)
+      self.class.add_call(@name, method, args)
+    end
+  end
+
+  def ignore(*methods)
+    methods.each do |method|
+      @skips << method
+    end
+    self
+  end
+  alias :skip :ignore
+
+  def self.inc_index
+    @index = @index + 1
+  end
 
-def create_dir(dir_path)
-  mkdir_p dir_path unless File.exist?(dir_path)
-  dir_path
+  def add_call(method, args)
+    @calls[@index] = [method, args]
+  end
+
+  def self.add_call(name, method, args)
+    @calls[@index] = [name, method, args]
+  end
+
+  def self.calls
+    @calls
+  end
+end
+
+
+class CustomTicker
+  attr_accessor :player
+  def initialize(*ticks)
+    @ticks = ticks
+  end
+  def start
+    @ticks.each do |time|
+      player.tick(time)
+    end
+  end
 end
 
-def file_name(string=nil)
-  if string
-    @file_name = "#{project_dir}/#{string}.trecs"
-  else
-    @file_name
+class CustomReader
+  attr_accessor :player
+  def initialize(frames={})
+    @frames = frames
+  end
+  def frame_at(n)
+    @frames[n]
+  end
+  def setup
   end
 end
+
+# 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/trecs/player_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+require "player"
+
+module TRecs
+  describe Player do
+    context "initialization" do
+      Given(:reader) { OpenStruct.new }
+      Given(:ticker) { OpenStruct.new }
+      Given(:screen) { Object.new }
+
+      When(:player) {
+        Player.new(
+          reader: reader,
+          ticker: ticker,
+          screen: screen,
+          )
+      }
+
+      Then { player.reader == reader }
+      Then { reader.player == player}
+
+      Then { player.ticker == ticker }
+      Then { ticker.player == player}
+
+      Then { player.step == 100}
+      Then { player.screen == screen}
+    end
+
+    context "Playing" do
+      Given { Spy.clear }
+      Given(:reader)   { Spy.new("reader").ignore(:player=) }
+      Given(:ticker)   { Spy.new("ticker").ignore(:player=) }
+      Given(:player) {
+        Player.new(reader: reader, ticker: ticker)
+      }
+
+      When { player.play }
+
+      Then { Spy.calls[1] == ["reader", :setup,   []] }
+      Then { Spy.calls[2] == ["ticker", :start, []] }
+    end
+
+    context "Playing some frames" do
+      Given { Spy.clear }
+      Given(:screen)   { Spy.new("screen") }
+      Given(:player) {
+        Player.new(reader: reader, ticker: ticker, screen: screen)
+      }
+
+      When { player.play }
+
+      context "no repetitions" do
+        Given(:reader)   { CustomReader.new(0 => "a", 100 => "b") }
+        Given(:ticker)   { CustomTicker.new(0, 100) }
+
+        Then { screen.calls[1] == [:clear, []] }
+        Then { screen.calls[2] == [:puts,  ["a"]] }
+        Then { screen.calls[3] == [:clear, []] }
+        Then { screen.calls[4] == [:puts,  ["b"]] }
+        Then { screen.calls.size == 4 }
+      end
+
+      context "with repetitions" do
+        Given(:reader)   { CustomReader.new(0 => "a", 100 => "b", 200 => "b") }
+        Given(:ticker)   { CustomTicker.new(0, 100, 200) }
+
+        Then { screen.calls[1] == [:clear, []] }
+        Then { screen.calls[2] == [:puts,  ["a"]] }
+        Then { screen.calls[3] == [:clear, []] }
+        Then { screen.calls[4] == [:puts,  ["b"]] }
+        Then { screen.calls.size == 4 }
+      end
+    end
+  end
+end