trecs 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6e8706df641c011fc594a3589b732af9903e583
+  data.tar.gz: 55584a0ad79f7860e323e92717158cecd52b495d
+SHA512:
+  metadata.gz: 87c2377954222bf2af45037321ff28fe74a9ab8a302d0b78e8f3391f08fc2d6a3d07b1e31e38e32c68d64869f73558ee58131470cce8142d704148221623b622
+  data.tar.gz: c4118a76ee41f5c279d0b911a19772fdb8953319c7f7d4b310fbd51e15855f793daab5486c44610b85d1bbd14d439a1b4287d4a08e66598488e1696aa544ccf7

data/.bundle/config

@@ -0,0 +1 @@
+--- {}

data/.gitignore

@@ -0,0 +1,4 @@
+tmp/
+doc/todo.org
+/sandbox/*
+/README.html

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 2.1.0
+  - 2.1.1
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    trecs (0.0.1.alpha)
+      rubyzip (~> 1.0.0)
+      trollop (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    given_core (3.5.4)
+      sorcerer (>= 0.3.7)
+    rake (10.3.2)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-given (3.5.4)
+      given_core (= 3.5.4)
+      rspec (>= 2.12)
+    rspec-mocks (2.13.1)
+    rubyzip (1.0.0)
+    sorcerer (1.0.2)
+    trollop (2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  rake
+  rspec (~> 2.12)
+  rspec-given (~> 3.5.4)
+  trecs!

data/LICENCE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Federico Iachetti
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.org

@@ -0,0 +1,44 @@
+#+TITLE:     README.org
+#+AUTHOR:    Federico Martín Iachetti
+#+EMAIL:     iachetti.federico@gmail.com
+#+LANGUAGE:  en
+#+OPTIONS:   H:3 num:t toc:t \n:nil @:t ::t |:t ^:nil -:t f:t *:t <:t
+#+OPTIONS:   TeX:t LaTeX:t skip:nil d:nil todo:t pri:nil tags:not-in-toc
+#+INFOJS_OPT: view:nil toc:nil ltoc:t mouse:underline buttons:0 path:http://orgmode.org/org-info.js
+#+EXPORT_SELECT_TAGS: export
+#+EXPORT_EXCLUDE_TAGS: noexport
+
+#+BEGIN_EXAMPLE
+                __________
+               /  o       \
+               |      ____|
+               |     |___
+               |    ____/
+              _|   |
+            _|     |===E
+   /\     _|       ===E
+   \ \___|         |
+    \___          /
+ _____ ____     _/              
+|_   _|  _ \ ___  ___ ___ 
+  | | | |_) / _ \/ __/ __|
+  | | |  _ <  __/ (__\__ \
+  |_| |_| \_\___|\___|___/
+
+#+END_EXAMPLE
+* T-Recs
+Text Recordings.
+
+Record screencasts in plain text.
+
+** Just an Idea
+The idea is to create a tool that allows to record text somehow and then reproduce it just as you would reproduce a video.
+
+** Some specifications
+
+- It should have controls (play, pause, ffw, rew, stop, rec)
+- It should have some kind of timestamp, so it can be synchronized with other resources
+- The other resources:
+  + Audio track
+  + Video track
+  + Browser extension (so, if you are recording the development of a web page, you could see in a browser the current snapshot of the page)

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/trecs

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require "trollop"
+
+require "timestamps"
+require "players/zip_file_player"
+
+options = Trollop::options do
+  opt :file_name,    "File to process",                   short: 'f', type: String
+  opt :time,         "Frame at time",                     short: 't', type: String
+  opt :current_time, "Returns the current playback time", short: 'c'
+  opt :step,         "Time im ms between frames",         short: 's', default: 100
+
+  opt :timestamps,   "Returns the list of existing frame timestamps"
+
+  opt :testing,      "Ticks without waiting. Use this option only for testing purpuses"
+end
+
+file_name = options[:file_name]
+if file_name
+  if File.exist?(file_name)
+    player = TRecs::ZipFilePlayer.new(options)
+    if options[:timestamps]
+      p player.timestamps
+    else
+      player.play
+    end
+  else
+    puts "File #{file_name} does not exist."
+  end
+end

data/bin/trecs_message

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require "trollop"
+
+require "recorders/message_recorder"
+
+options = Trollop::options do
+  opt :file_name, "File to process",                     short: 'f', type: String
+  opt :message,   "Message to record",                   short: 'm', type: String
+  opt :step,      "Time between frames in milliseconds", short: 's', default: 100
+end
+
+if options[:file_name]
+  recorder = TRecs::MessageRecorder.new(options)
+  recorder.record
+else
+  puts "Please give a file name"
+end

data/bin/trecs_terminal

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+
+require "trollop"
+
+require "recorders/ttyrec_recorder"
+
+options = Trollop::options do
+  # opt :input_file,  "File to process", short: 'i', type: String
+  opt :output_file, "Output file",     short: 'o', type: String
+end
+
+options[:input_file] ||= "/tmp/ttyrecord"
+
+if options[:output_file] # && options[:input_file]
+  puts "Recording ..."
+  options[:height], options[:width] = `stty size`.split(" ").map(&:to_i)
+  system "ttyrec #{options[:input_file]}"
+  recorder = TRecs::TtyrecRecorder.new(options)
+  recorder.record
+  puts "Finish Recording ..."
+else
+  puts "Please give an input and an output file file name"
+end

data/doc/steps.org

@@ -0,0 +1,18 @@
+#+OPTIONS:   H:3 num:t toc:t \n:nil @:t ::t |:t ^:nil -:t f:t *:t <:t
+#+OPTIONS:   TeX:t LaTeX:t skip:nil d:nil todo:t pri:nil tags:not-in-toc
+#+INFOJS_OPT: view:nil toc:nil ltoc:t mouse:underline buttons:0 path:http://orgmode.org/org-info.js
+
+* Crear el binario trecs
+Ésto es para poder comenzar a testear con código que funcione de una
+trecs reproduce un archivo *.trecs conformado por un zip y una serie de archivos que representan los frames
+
+* Extraer Player en su propia clase
+Hacer que el binario llame directamente a la clase
+
+* Extraer todo lo relacionado con el formato en particular a una nueva clase
+Extraer todo lo relacionado con el formato en particular a una nueva clase, dejando sólo lo relacionado con reproducir frames, timestamps en Player
+
+* Crear clase Screen
+Screen sería el lugar sonde va a ir a parar el frame para ser visualizado.
+* Extraer todo lo posible del binario hacia player
+Hacer que el binario sea una cáscara y que el player sea el verdadero "main"

data/lib/player.rb

@@ -0,0 +1,75 @@
+require "timestamps"
+require "screens/terminal_screen"
+
+module TRecs
+  class Player
+    attr_reader :output
+
+    def initialize(time: nil, step: 100, output: TerminalScreen.new, testing: false, **options)
+      @current_time = time
+      @step         = step
+      @ticks        = time ? Array(time.to_i) : ticks
+      @output       = output
+      @testing      = testing
+    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/players/zip_file_player.rb

@@ -0,0 +1,56 @@
+require "zip"
+require "player"
+
+module TRecs
+  class ZipFilePlayer < Player
+    include FileUtils
+
+    def initialize(file_name: "", **options)
+      @file_name = file_name
+
+      create_directory
+      extract_file
+
+      super(**options)
+    end
+
+    # this
+    def get_frame(time)
+      File.read(file_to_read(time))
+    end
+
+    # this
+    def get_timestamps
+      return [] unless file_name
+      Dir.glob("#{dir}/*").each.map do |line|
+        line[/\/(\d++)\Z/, 1].to_i
+      end
+    end
+
+    private
+    attr_reader   :file_name
+    attr_reader   :dir
+
+    def file_to_read(time)
+      file_array = []
+      file_array << @dir
+      file_array << "/"
+      file_array << time
+      file_to_read = file_array.join
+    end
+
+    def create_directory
+      @dir = Dir.mktmpdir
+    end
+
+    def extract_file
+      Zip::File.open(file_name) do |file|
+        file.each do |f|
+          f.extract "#{dir}/#{f.name}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/recorder.rb

@@ -0,0 +1,68 @@
+module TRecs
+  class Recorder
+    attr_writer :current_time
+    attr_reader :step
+
+    def initialize(step: 100, **options)
+      @step = step
+    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(time: next_timestamp, 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
+
+    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/recorders/message_recorder.rb

@@ -0,0 +1,18 @@
+require "timestamps"
+
+require "recorders/zip_file_recorder"
+require "recording_strategies/incremental_recording_strategy"
+
+
+module TRecs
+  class MessageRecorder < ZipFileRecorder
+    attr_reader :message
+
+    def initialize(message:, **options)
+      @message = message
+      @recording_strategy = IncrementalRecordingStrategy.new(recorder: self, message: message)
+      super(**options)
+    end
+
+  end
+end

data/lib/recorders/ttyrec_recorder.rb

@@ -0,0 +1,13 @@
+require "timestamps"
+
+require "recorders/zip_file_recorder"
+require "recording_strategies/ttyrec_recording_strategy"
+
+module TRecs
+  class TtyrecRecorder < ZipFileRecorder
+    def initialize(input_file:, output_file:, **options)
+      @recording_strategy = TtyrecRecordingStrategy.new(recorder: self, file: input_file, **options)
+      super(file_name: output_file, **options)
+    end
+  end
+end

data/lib/recorders/zip_file_recorder.rb

@@ -0,0 +1,41 @@
+require "zip"
+require "recorder"
+
+module TRecs
+  class ZipFileRecorder < Recorder
+    include FileUtils
+    def initialize(file_name:, **options)
+      super(**options)
+      @file_name = file_name
+      delete_file
+    end
+
+    private
+    attr_reader :file_name
+    attr_reader :frames
+
+    # this
+    def setup
+      @frames = {}
+    end
+
+    def render
+      Zip::File.open(file_name, Zip::File::CREATE) do |trecs_file|
+        frames.each do |timestamp, content|
+          Tempfile.open(timestamp.to_s) do |temp_file|
+            temp_file.write(content)
+            trecs_file.add(timestamp.to_s, temp_file)
+          end
+        end
+      end
+    end
+
+    def create_frame
+      frames[current_time] = current_content
+    end
+
+    def delete_file
+      rm file_name if File.exists? file_name
+    end
+  end
+end

data/lib/recording_strategies/incremental_recording_strategy.rb

@@ -0,0 +1,25 @@
+require "recording_strategy"
+module TRecs
+  class IncrementalRecordingStrategy < RecordingStrategy
+    def initialize(message:, **options)
+      @message = message
+      super(**options)
+    end
+
+    def perform
+      message.each_char.each_with_object("") do |current_char, current_msg|
+        current_msg << current_char
+
+        time    = timestamp_for(current_msg)
+        content = current_msg.dup
+        recorder.current_frame(time: time, content: content)
+      end
+    end
+    private
+    attr_reader :message
+
+    def timestamp_for(message)
+      (message.size - 1) * recorder.step
+    end
+  end
+end

data/lib/recording_strategies/ttyrec_recording_strategy.rb

@@ -0,0 +1,30 @@
+require "recording_strategy"
+module TRecs
+  class TtyrecRecordingStrategy < RecordingStrategy
+    def initialize(file:, height: 24, width: 80, **options)
+      @file = File.new(file)
+      @frames = []
+      @full_output = ""
+      @height = height
+      @width = width
+      super
+    end
+
+    def perform
+      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
+
+        prev_timestamp ||= [ sec, usec ].join('.').to_f
+        curr_timestamp   = [ sec, usec ].join('.').to_f
+        offset = ((curr_timestamp - prev_timestamp)*1000).to_i
+
+        recorder.current_frame(time: offset, content: frame)
+      end
+    end
+  end
+end

data/lib/recording_strategy.rb

@@ -0,0 +1,10 @@
+module TRecs
+  class RecordingStrategy
+    def initialize(recorder:, **optionsx)
+      @recorder = recorder
+    end
+
+    private
+    attr_reader :recorder
+  end
+end

data/lib/screens/terminal_screen.rb

@@ -0,0 +1,22 @@
+require "delegate"
+
+module TRecs
+  class TerminalScreen < SimpleDelegator
+    def clear
+      puts "\e[H\e[2J"
+    end
+
+    def initialize
+      @obj = $stdout
+      super(@obj)
+    end
+
+    def __getobj__
+      @obj
+    end
+
+    def __setobj__(obj)
+      @obj = obj
+    end
+  end
+end

data/lib/timestamps.rb

@@ -0,0 +1,22 @@
+class Timestamps
+  attr_reader :collection
+
+  def initialize(collection)
+    @collection = collection
+  end
+
+  def time_at(time=0)
+    time = time.to_s.to_i
+    return 0 if collection.empty?
+    return collection.first  if time <= collection.first
+    return collection.last   if time >= collection.last
+    collection.each_cons(2) do |a, b|
+      if b == time
+        return b
+      end
+      if b > time
+        return a
+      end
+    end
+  end
+end

data/lib/trecs/version.rb

@@ -0,0 +1,3 @@
+module TRecs
+  VERSION = "0.0.1.alpha"
+end

data/sandbox/create_recording.rb

@@ -0,0 +1,28 @@
+require "fileutils"
+require 'zip'
+
+include FileUtils
+def create_recording(file_name: "")
+  rm file_name if File.exists? file_name
+  recording_dir = "./frames"
+  rm_rf recording_dir
+  mkdir_p recording_dir
+
+  yield recording_dir
+
+  files_to_record = Dir.glob("#{recording_dir}/*")
+
+  Zip::File.open(file_name, Zip::File::CREATE) do |trecs_file|
+    files_to_record.each do |file_to_rec|
+      dest_file_name = File.basename(file_to_rec)
+      trecs_file.add(dest_file_name, file_to_rec)
+    end
+  end
+  rm_rf Dir.glob("#{recording_dir}")
+end
+
+def create_frame(content: "", time: 0)
+  File.open("./frames/#{time.to_i}", File::WRONLY|File::CREAT) do |f|
+    f << content
+  end
+end

data/sandbox/lipsum_end

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.

data/sandbox/lipsum_start

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet.