asciinema-rails 0.1.1

data/lib/asciinema/frame.rb

@@ -0,0 +1,26 @@
+require 'asciinema/frame_diff'
+
+class Frame
+
+  attr_reader :snapshot, :cursor
+
+  def initialize(snapshot, cursor)
+    @snapshot = snapshot
+    @cursor = cursor
+  end
+
+  def diff(other)
+    FrameDiff.new(snapshot_diff(other), cursor_diff(other))
+  end
+
+  private
+
+  def snapshot_diff(other)
+    snapshot.diff(other && other.snapshot)
+  end
+
+  def cursor_diff(other)
+    cursor.diff(other && other.cursor)
+  end
+
+end

data/lib/asciinema/frame_diff.rb

@@ -0,0 +1,20 @@
+class FrameDiff
+
+  def initialize(line_changes, cursor_changes)
+    @line_changes = line_changes
+    @cursor_changes = cursor_changes
+  end
+
+  def as_json(*)
+    json = {}
+    json[:lines] = line_changes unless line_changes.blank?
+    json[:cursor] = cursor_changes unless cursor_changes.blank?
+
+    json
+  end
+
+  private
+
+  attr_reader :line_changes, :cursor_changes
+
+end

data/lib/asciinema/frame_diff_list.rb

@@ -0,0 +1,26 @@
+require 'active_support/all'
+
+class FrameDiffList
+  include Enumerable
+
+  delegate :each, :to => :frame_diffs
+
+  def initialize(frames)
+    @frames = frames
+  end
+
+  private
+
+  attr_reader :frames
+
+  def frame_diffs
+    previous_frame = nil
+
+    frames.map { |delay, frame|
+      diff = frame.diff(previous_frame)
+      previous_frame = frame
+      [delay, diff]
+    }
+  end
+
+end

data/lib/asciinema/grid.rb

@@ -0,0 +1,51 @@
+class Grid
+  require 'active_support/core_ext/enumerable'
+
+  attr_reader :width, :height, :lines
+
+  def initialize(lines)
+    @lines = lines
+    @width = lines.first && lines.first.sum(&:size) || 0
+    @height = lines.size
+  end
+
+  def crop(x, y, width, height)
+    cropped_lines = lines[y...y+height].map { |line| crop_line(line, x, width) }
+
+    self.class.new(cropped_lines)
+  end
+
+  def diff(other)
+    (0...height).each_with_object({}) do |y, diff|
+      if other.nil? || other.lines[y] != lines[y]
+        diff[y] = lines[y]
+      end
+    end
+  end
+
+  def as_json(*)
+    lines.as_json
+  end
+
+  private
+
+  def crop_line(line, x, width)
+    n = 0
+    cells = []
+
+    line.each do |cell|
+      if n <= x && x < n + cell.size
+        cells << cell[x-n...x-n+width]
+      elsif x < n && x + width >= n + cell.size
+        cells << cell
+      elsif n < x + width && x + width < n + cell.size
+        cells << cell[0...x+width-n]
+      end
+
+      n += cell.size
+    end
+
+    cells
+  end
+
+end

data/lib/asciinema/json_file_writer.rb

@@ -0,0 +1,21 @@
+class JsonFileWriter
+
+  def write_enumerable(file, array)
+    first = true
+    file << '['
+
+    array.each do |item|
+      if first
+        first = false
+      else
+        file << ','
+      end
+
+      file << item.to_json
+    end
+
+    file << ']'
+    file.close
+  end
+
+end

data/lib/asciinema/rails.rb

@@ -0,0 +1,8 @@
+require "asciinema/rails/engine"
+require "asciinema/rails/version"
+require "asciinema/rails/convertor"
+
+module Asciinema
+  module Rails
+  end
+end

data/lib/asciinema/rails/convertor.rb

@@ -0,0 +1,97 @@
+require 'json'
+require 'asciinema/asciicast'
+require 'asciinema/asciicast_frames_file_updater'
+require 'asciinema/asciicast_snapshot_updater'
+
+
+
+module Asciinema
+  module Rails
+    class Convertor
+
+      # Generate an asciicast from Sudosh log files.
+
+      # *Params*:
+      # - sudosh_timing_file_path: path to the Sudosh timing file
+      # - sudosh_script_file_path: path to the Sudosh script file
+      # - options: Additional options hash: 
+      #   * +:original_terminal_cols+: width of the Sudosh session terminal
+      #   * +:original_terminal_rows+: height of the Sudosh session terminal
+      #   * +:asciicast_path+: file to write output to
+      # *Returns*:
+      # - A File object pointing to the generated asciicast.
+
+      def self.sudosh_to_asciicast(sudosh_timing_file_path, sudosh_script_file_path, options = {})
+        original_terminal_cols = options[:original_terminal_cols] || 180
+        original_terminal_rows = options[:original_terminal_rows] || 43
+        asciicast_path = options[:asciicast_path]
+        
+        timings = []
+        byte_offsets = []
+
+        # Split the sudosh timing file into individual time splits and data byte offsets.
+        # When paired with the Sudosh data file, each time split can be though of as an animation 'frame'
+        File.open(sudosh_timing_file_path) do |f|
+          f.each_line.each do |line|
+            split = line.split(' ')
+            timings << split[0].to_f
+            byte_offsets << split[1].to_i
+          end
+        end
+        duration = timings.inject(:+) ## add all of the time splits to get the total duration
+      
+        # Split the script file into segments as defined by the byte offsets in the timing file.
+        # TODO: Write stdout directly to file rather than into memory first.
+        stdout = []
+        File.open(sudosh_script_file_path, 'rb') do |file|
+          until file.eof?
+            timestamp = '%.5f' % timings.shift.to_f
+            terminal_chunk = file.read(byte_offsets.shift)
+            stdout << [Float(timestamp), terminal_chunk]
+          end
+        end
+      
+        json = {version: 1, width: original_terminal_cols, height: original_terminal_rows, duration: duration}
+        json[:stdout] = stdout 
+
+        self.to_file(JSON.pretty_generate(json), asciicast_path)
+        
+      end
+
+      # Generate a playback file from an asciicast.
+
+      # *Params*:
+      # - asciicast_path: path to the asciicast file
+      # - options: Additional options hash: 
+      #   * +:playback_path+: file to write the playback data to
+      # *Returns*:
+      # - An array containing:
+      #   * the playback file content as a string
+      #   * a snapshot string
+      #   * a hash containing the original width (cols), height (rows) and duration of the asciicast.
+
+      def self.asciicast_to_playback(asciicast_path, options = {})
+        playback_path = options[:playback_path] # playback data will be written here
+
+        json = JSON.parse(File.read(asciicast_path)) # load the asciicast data into a hash 
+        asciicast = Asciicast.new(json['width'], json['height'], json['duration'], asciicast_path) # create an Asciicast object
+        AsciicastFramesFileUpdater.new.update(asciicast, playback_path) # set playback data in Asciicast object, write to file also
+        AsciicastSnapshotUpdater.new.update(asciicast) # set snapshot data in Asciicast object.
+        
+        [asciicast.stdout_frames, ActiveSupport::JSON.encode(asciicast.snapshot), {width: json['width'], height: json['height'], duration: json['duration']} ]
+
+      end
+
+      private
+
+      def self.to_file(content, outfile_location=nil)
+        out_file = outfile_location.present? ? File.new(outfile_location) : Tempfile.new('outfile')
+        File.open(out_file, "w") do |f|
+          f.write(content)
+        end
+        out_file
+      end
+    end
+    
+  end
+end

data/lib/asciinema/rails/engine.rb

@@ -0,0 +1,6 @@
+module Asciinema
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/asciinema/rails/version.rb

@@ -0,0 +1,5 @@
+module Asciinema
+  module Rails
+    VERSION = "0.1.1"
+  end
+end

data/lib/asciinema/snapshot.rb

@@ -0,0 +1,41 @@
+require 'asciinema/cell'
+require 'asciinema/brush'
+
+class Snapshot < Grid
+
+  def self.build(data)
+    data = data.map { |cells|
+      cells.map { |cell|
+        Cell.new(cell[0], Brush.new(cell[1]))
+      }
+    }
+
+    new(data)
+  end
+
+  def thumbnail(w, h)
+    x = 0
+    y = height - h - trailing_empty_lines
+    y = 0 if y < 0
+
+    crop(x, y, w, h)
+  end
+
+  private
+
+  def trailing_empty_lines
+    n = 0
+
+    (height - 1).downto(0) do |y|
+      break unless line_empty?(y)
+      n += 1
+    end
+
+    n
+  end
+
+  def line_empty?(y)
+    lines[y].empty? || lines[y].all? { |cell| cell.empty? }
+  end
+
+end

data/lib/asciinema/stdout.rb

@@ -0,0 +1,101 @@
+require 'open-uri'
+require 'oj'
+
+class Stdout
+  include Enumerable
+
+  class SingleFile < self
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def each(&blk)
+      open(path, 'r') do |f|
+        Oj.sc_parse(FrameIterator.new(blk), f)
+      end
+    end
+
+    class FrameIterator < ::Oj::ScHandler
+
+      def initialize(callback)
+        @callback = callback
+      end
+
+      def array_start
+        if @top # we're already inside top level array
+          [] # <- this will hold pair [delay, data]
+        else
+          @top = []
+        end
+      end
+
+      def array_append(a, v)
+        if a.equal?(@top)
+          @callback.call(*v)
+        else
+          a << v
+        end
+      end
+
+    end
+
+  end
+
+  class MultiFile < self
+    attr_reader :data_path, :timing_path
+
+    def initialize(data_path, timing_path)
+      @data_path = data_path
+      @timing_path = timing_path
+    end
+
+    def each
+      File.open(data_path, 'rb') do |file|
+        File.foreach(timing_path) do |line|
+          yield(*delay_and_data_for_line(file, line))
+        end
+      end
+    end
+
+    private
+
+    def delay_and_data_for_line(file, line)
+      delay, size = TimingParser.parse_line(line)
+      data = file.read(size).to_s.force_encoding('utf-8')
+
+      [delay, data]
+    end
+
+  end
+
+  class Buffered < self
+    MIN_FRAME_LENGTH = 1.0 / 60
+
+    attr_reader :stdout
+
+    def initialize(stdout)
+      @stdout = stdout
+    end
+
+    def each
+      buffered_delay, buffered_data = 0.0, []
+
+      stdout.each do |delay, data|
+        if buffered_delay + delay < MIN_FRAME_LENGTH || buffered_data.empty?
+          buffered_delay += delay
+          buffered_data << data
+        else
+          yield(buffered_delay, buffered_data.join)
+          buffered_delay = delay
+          buffered_data = [data]
+        end
+      end
+
+      yield(buffered_delay, buffered_data.join) unless buffered_data.empty?
+    end
+
+  end
+
+end

data/lib/asciinema/terminal.rb

@@ -0,0 +1,65 @@
+require 'open3'
+require 'yajl'
+require 'asciinema/grid'
+require 'asciinema/snapshot'
+require 'asciinema/cursor'
+
+class Terminal
+
+  # BINARY_PATH = (File.dirname(__FILE__) + "/../../bin/" + "terminal").to_s
+  BINARY_PATH = 'terminal'
+
+  def initialize(width, height)
+    @process = Process.new("#{BINARY_PATH} #{width} #{height}")
+  end
+
+  def feed(data)
+    process.write("d\n#{data.bytesize}\n")
+    process.write(data)
+  end
+
+  def snapshot
+    process.write("p\n")
+    lines = Yajl::Parser.new.parse(process.read_line)
+
+    Snapshot.build(lines)
+  end
+
+  def cursor
+    process.write("c\n")
+    c = Yajl::Parser.new.parse(process.read_line)
+
+    Cursor.new(c['x'], c['y'], c['visible'])
+  end
+
+  def release
+    process.stop
+  end
+
+  private
+
+  attr_reader :process
+
+  class Process
+
+    def initialize(command)
+      @stdin, @stdout, @thread = Open3.popen2(command)
+    end
+
+    def write(data)
+      raise "terminal died" unless @thread.alive?
+      @stdin.write(data)
+    end
+
+    def read_line
+      raise "terminal died" unless @thread.alive?
+      @stdout.readline.strip
+    end
+
+    def stop
+      @stdin.close
+    end
+
+  end
+
+end