trecs 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: c70e79d4e4e1ea582f79bf7bcec4b07c9a7f58ab
-  data.tar.gz: f39499ec8e9709e515436d5138a1744165726c27
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGY1NWJjMWVhZmIyZjkzMjIwMmNmZjU0N2JlMmU5ZWYwODY3YjFhNw==
+  data.tar.gz: !binary |-
+    MDMyNTg1YTYyOGIxYjRiYTVlOGM3ZWEzNzA0ZTQyYzlmZjZlZGNkNg==
 SHA512:
-  metadata.gz: f075f2ba5d1e44ff73dc7c6057e611f89fabe6f1c788fc5d90e97586e952c24fe0bad6c8e5fd2ab9756a6db73b0275e21a644e99c5a9fe02e92c9b3bae777261
-  data.tar.gz: 97faa57c7ea63c15ef2976984c21e5e4709db60741b1926ee099b3784c9934606984e7683a295544aea706f053062e9b4f000e3ba3af06053deb52b1d0df85b3
+  metadata.gz: !binary |-
+    YTMzNzQ4ZGFkZDYzNGI4MTRlNTdhYjhmNTFjOGZlZDhhNmU4NWUxNjVmN2Q5
+    NTc4ZmNiY2YwZTkzODM1NTBhMTZlYjMyOGE0MjQzZDYxM2FlMWIwMTAxNGM2
+    MzhjNDllNDhjYWNkYTk2YWE1MjNmMjA3OTFkMzI2Zjg2ZWIyYzM=
+  data.tar.gz: !binary |-
+    MDdhYTMwODk1NWMwNzQ1MThkMDEzODQzZjlhMjdkM2U5NGYyYzQ2NDNjNTdk
+    YjJmYzZiNmZmZjkzYmRkNjlkZmEyYjA2NGQ5MTRjMGMxY2FkYmNkNDdmZDg5
+    YWQ4YzdkNGM2OGVhZTg2Y2JjZTFjYWZiNDBhYmRiOWQzM2JlOWM=

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    trecs (0.1.11)
+    trecs (0.1.12)
+      minitar (~> 0.5.4)
       trollop (~> 2.0)
 
 GEM
@@ -10,6 +11,7 @@ GEM
     diff-lcs (1.2.5)
     given_core (3.5.4)
       sorcerer (>= 0.3.7)
+    minitar (0.5.4)
     rake (10.3.2)
     rspec (2.99.0)
       rspec-core (~> 2.99.0)

data/bin/trecs

@@ -3,75 +3,55 @@
 $:.unshift(File.expand_path("../../lib", __FILE__))
 require "trecs"
 require "player"
+require "sources/tgz_source"
+
 require "trollop"
 
+def finish(opts)
+  puts "Finished"
+  puts "Replay with:"
+  puts "trecs #{opts[:trecs_file]}"
+end
+
+trap "SIGINT" do
+  finish(opts)
+  exit rescue nil
+end
 
 opts = Trollop::options do
   version TRecs::VERSION
 
-  opt :step, "Time in ms between frames", short: 's', default: 100
-  opt :format, "File format", type: String, default: "json"
-  opt :ticker, "Ticker", type: String, default: "clock"
+  opt :step,        "Time in ms between frames", short: 's',               default: 100
+  opt :ticker,      "Ticker",                                type: String, default: "clock"
 
-  opt :from,  "Play from",     type: Integer, default: 0
-  opt :to,    "Play to",       type: Integer, default: 0
-  opt :speed, "Playinx speed", type: Float, default: 1.0
+  opt :from,        "Play from",                             type: Integer, default: 0
+  opt :to,          "Play to",                               type: Integer, default: 0
+  opt :speed,       "Playing speed",                         type: Float,   default: 1.0
 
-  opt :ticker_file, "File to watch", type: String, default: "/tmp/ticker"
-
-  opt :audio, "Play with audio",                         type: String
+  opt :ticker_file, "File to watch",                         type: String, default: "/tmp/ticker"
 end
 opts[:trecs_file] = ARGV[0]
 
-reader_file = "readers/#{opts[:format]}_reader"
-require reader_file
-reader_class = Kernel.const_get([
-    "TRecs::",
-    opts[:format].split(/[-_\s]/).map(&:capitalize),
-    "Reader"
-  ].join
-  )
-
+source = TRecs::TgzSource.new(trecs_file: opts.fetch(:trecs_file))
+reader = source.reader(opts)
 
-ticker_separator = '_' unless opts[:ticker] == ''
-ticker_file = "tickers/#{opts[:ticker]}#{ticker_separator}ticker"
+ticker_file = "tickers/#{opts[:ticker]}_ticker"
 require ticker_file
-ticker_class = Kernel.const_get([
+ticker_class_name = [
     "TRecs::",
     opts[:ticker].split(/[-_\s]/).map(&:capitalize),
     "Ticker"
   ].join
-  )
-
-########## AUDIO ##########
-def start_sound_player(file_name='sound.ogg')
-  return unless File.exist?(file_name)
-  # at_exit { system('stty echo') }
-  STDOUT.puts "=> Starting sound player..."
-  @sox_pid = fork do
-    `play #{file_name} 2>&1`
-  end
-end
-
-def stop_sound_player
-  return unless File.exist?(file_name)
-  STDOUT.puts "=> Stopping sound player..."
-  Process.waitpid(@sox_pid)
-end
-######## END AUDIO ########
-
+ticker_class = ticker_class_name.split("::").reduce(Object) { |a, e| a.const_get e }
+ticker = ticker_class.new(opts)
 
 player_options = {
-  reader: reader_class.new(opts),
-  ticker: ticker_class.new(opts),
+  reader: reader,
+  ticker: ticker,
   step:   opts[:step],
 }
 
 player = TRecs::Player.new(player_options)
-
-opts[:audio] && start_sound_player(opts[:audio])
 player.play
 
-puts "Finished"
-puts "Replay with:"
-puts "trecs #{opts[:trecs_file]}"
+finish(opts)

data/bin/trecs_record

@@ -9,40 +9,31 @@ require "trollop"
 opts = Trollop::options do
   version TRecs::VERSION
 
-  opt :step, "Time in ms between frames", short: 's',                default: 100
-  opt :format, "File format",                         type: String,  default: "json"
-  opt :strategy, "Strategy",                          type: String,  default: "incremental"
+  opt :step,       "Time in ms between frames", short: 's',                default: 100
+  opt :strategy,   "Strategy",                              type: String,  default: "incremental"
 
-  opt :message, "Message to record",                  type: String,  default: "TRecs!"
-  opt :width, "Width",                                type: Integer, default: 10
-  opt :command, "Command"          ,      short: "c", type: String
-  opt :input_file, "File to record",                  type: String,  default: ""
-  opt :terminal, "Launch terminal",                                  default: true
-  opt :color, "Record colors",                                       default: true
-
-  opt :audio, "Record audio",                         type: String
+  opt :message,    "Message to record",                     type: String,  default: "TRecs!"
+  opt :width,      "Width",                                 type: Integer, default: 10
+  opt :command,    "Command"          ,         short: "c", type: String
+  opt :input_file, "File to record",                        type: String,  default: ""
+  opt :terminal,   "Launch terminal",                                      default: true
+  opt :color,      "Record colors",                                        default: true
 
+  opt :audio,      "Record audio",                          type: String
 end
 opts[:trecs_file] = ARGV[0]
 
-writer_file = "writers/#{opts[:format]}_writer"
-require writer_file
-writer_class = Kernel.const_get([
-    "TRecs::",
-    opts[:format].split(/[-_\s]/).map(&:capitalize),
-    "Writer"
-  ].join
-  )
-
+require "writers/json_writer"
+writer_class = TRecs::JsonWriter
 
 strategy_file = "recording_strategies/#{opts[:strategy]}_strategy"
 require strategy_file
-strategy_class = Kernel.const_get([
+strategy_class_name = [
     "TRecs::",
     opts[:strategy].split(/[-_\s]/).map(&:capitalize),
     "Strategy"
   ].join
-  )
+strategy_class = strategy_class_name.split("::").reduce(Object) { |a, e| a.const_get e }
 
 ########## AUDIO ##########
 def start_sound_recording(file_name='sound.ogg')
@@ -66,32 +57,37 @@ end
 
 ######## END AUDIO ########
 
+if strategy_class.to_s == "TRecs::TmuxSessionStrategy" && !ENV['TMUX']
+  puts "You need to be inside a tmux session to use the Tmux Session Strategy"
+  exit(0)
+end
 
 puts "Recording ..."
 
-
-if strategy_class.to_s == "TRecs::TtyrecStrategy"
+if strategy_class.to_s == "TRecs::TtyrecStrategy" || strategy_class.to_s == "TRecs::TmuxSessionStrategy"
   opts[:height], opts[:width] = `stty size`.split(" ").map(&:to_i)
   opts[:audio] && start_sound_recording(opts[:audio])
+
   system "ttyrec #{opts[:input_file]}" if opts[:terminal]
 end
 
+opts[:audio_files] = [opts[:audio]] if opts[:audio]
+
 recorder_options = {
   writer:   writer_class.new(opts),
   strategy: strategy_class.new(opts),
   step:     opts[:step],
 }
 
-opts[:audio] && stop_sound_recording
 RECORDER = TRecs::Recorder.new(recorder_options)
 
 trap "SIGINT" do
+  opts[:audio] && stop_sound_recording
   RECORDER.stop
 end
 
-
 RECORDER.record
 
 puts "Recording finished"
 puts "Play with:"
-puts "  trecs #{opts[:trecs_file]}"
+puts "trecs #{opts[:trecs_file]}"

data/lib/trecs/frame.rb

@@ -0,0 +1,37 @@
+module TRecs
+  class Frame
+    include Enumerable
+    attr_accessor :content
+    def initialize(content="")
+      @content = content
+    end
+
+    def width
+      content.each_line.map { |line|
+        line.chomp.size
+      }.max
+    end
+
+    def height
+      content.lines.count
+    end
+
+    def each
+      content.each_line
+    end
+
+    def to_s
+      content
+    end
+    alias :to_str :to_s
+  end
+
+  def Frame(value)
+    case value
+    when Frame then value
+    else
+      Frame.new(value.to_str)
+    end
+  end
+  module_function :Frame
+end

data/lib/trecs/player.rb

@@ -40,7 +40,7 @@ module TRecs
     end
 
     def timestamps
-      @timestamps ||= reader.timestamps
+      @timestamps ||= reader.timestamps.sort
     end
 
     def time_to_play(time)

data/lib/trecs/readers/json_reader.rb

@@ -1,25 +1,31 @@
-require 'json'
-require "pathname"
+require "sources/tgz_source"
 
 module TRecs
   class JsonReader
     attr_accessor :player
     attr_reader :frames
-    attr_reader :file
     attr_reader :timestamps
+    attr_reader :source
 
     def initialize(options={})
-      @file = options.fetch(:trecs_file)
-      json_string = File.read(@file)
-      @frames = {}
-      parsed_json = JSON.parse(json_string)
-      parsed_json.each do |time, content|
-        @frames[Integer(time)] = content
-      end
-
+      trecs_file = options.fetch(:trecs_file)
+      @source  = options.fetch(:source)
+      @frames = get_frames
       @timestamps = @frames.keys
     end
 
+    def get_frames
+      frames = {}
+      source.read do
+        json_string = source.read_file("frames.json")
+        parsed_json = JSON.parse(json_string)
+        parsed_json.each do |time, content|
+          frames[Integer(time)] = content
+        end
+      end
+      frames
+    end
+
     def setup
       true
     end
@@ -32,5 +38,6 @@ module TRecs
       "<#{self.class}>"
     end
     alias :inspect :to_s
+
   end
 end

data/lib/trecs/recorder.rb

@@ -3,42 +3,43 @@ module TRecs
     attr_reader :writer
     attr_reader :strategy
     attr_reader :step
-    attr_reader :offset
     attr_reader :recording
     attr_reader :current_time
     attr_reader :current_content
 
+    attr_accessor :offset
 
     def initialize(options={})
-      @writer   = options.fetch(:writer)
-      @writer.recorder = self
+      @writer            = options.fetch(:writer)
+      @writer.recorder   = self
 
-      @strategy = options.fetch(:strategy)
+      @strategy          = options.fetch(:strategy)
       @strategy.recorder = self
 
-      @step = options.fetch(:step) { 100 }
+      @step   = options.fetch(:step)   { 100 }
       @offset = options.fetch(:offset) { 0 }
-      @recording = false
+
+      @recording    = false
       @current_time = nil
     end
 
     def record
-      self.current_time = nil
-      self.recording = true
-      writer.setup
-      strategy.perform
-      writer.render
-      self.recording = false
+      do_record do
+        writer.setup
+        strategy.perform
+        writer.render
+      end
     end
 
     def current_frame(options={})
-      time = options.fetch(:time) { next_timestamp }
+      time    = options.fetch(:time) { next_timestamp }
       content = options.fetch(:content)
-      @current_time = time
+      
+      @current_time    = time
       @current_content = content
 
       if @previous_content != content
-        new_current_time = current_time + offset
+        new_current_time  = current_time + offset
         writer.create_frame(time: new_current_time, content: current_content)
         @previous_content = content
       end
@@ -58,5 +59,12 @@ module TRecs
     attr_writer :current_time
     attr_writer :current_content
 
+    def do_record
+      self.current_time = nil
+      self.recording    = true
+      yield
+      self.recording    = false
+    end
+
   end
 end

data/lib/trecs/recording_strategies/config_strategy.rb

@@ -0,0 +1,31 @@
+require "recording_strategies/strategy"
+
+module TRecs
+  class ConfigStrategy
+    include Strategy
+    attr_reader :step
+    attr_reader :format
+    attr_reader :strategies
+
+    def initialize(options={})
+      @step       = options.fetch(:step)       { 100 }
+      @format     = options.fetch(:format)     { "json" }
+      @strategies = options.fetch(:strategies) { [] }
+    end
+
+    def <<(strategies)
+      Array(strategies).each do |strategy|
+        @strategies << strategy
+      end
+    end
+
+    def perform
+      strategies.each do |strategy|
+        strategy.recorder = recorder
+        strategy.perform
+        recorder.offset = recorder.next_timestamp
+      end
+    end
+
+  end
+end

data/lib/trecs/recording_strategies/file_frames_strategy.rb

@@ -0,0 +1,30 @@
+require "recording_strategies/strategy"
+module TRecs
+  class FileFramesStrategy
+    include Strategy
+    attr_accessor :frames
+
+    def initialize(dirname)
+      @frames = Dir.entries(dirname)
+        .select { |d| d =~ /\d+/}
+        .each_with_object(Hash.new) do |filename, h|
+        h[filename.to_i] = File.read(dirname + "/" + filename)
+      end
+    end
+
+    def perform
+      @frames.each do |time, content|
+        current_time(time)
+        current_content(content)
+        save_frame
+      end
+    end
+
+    def stop
+    end
+
+    def inspect
+      "<#{self.class}: frames: #{frames}>"
+    end
+  end
+end