dcm 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98e2a0e565c14da029309665dedc6b4b62eefb485dd2307f8f3f1856004bee9b
-  data.tar.gz: d4ac7611510ee45d60dc7c33cdeb2b04ecd7961220c5aa767c7234086bd5934a
+  metadata.gz: '08657a06d9b268272d9612ac57be02f24d885507770897bb03ac3b4cc60d808c'
+  data.tar.gz: e40e12fc73ebf44db690396983226e62218195fbbda0fa4b9879e5e714037305
 SHA512:
-  metadata.gz: ce70b31fdfb6aad38d3da275cadaf18e8081d623375b72ecf800b2257c01412f515e3b07dc672a029416ece0e37d09977d77169cfc4b104dc9cf323e7a1ce1cd
-  data.tar.gz: 494d1ea75f17345c1f092e357edf1699f0ef81ef1ec39da50edb60a330b10d6877b9e965b7b8d647347d6a740de7835c20c0b30db0f611626842ba0bfb7c51d3
+  metadata.gz: a7dc09f008c91acc39e4357ee77d4f2304efb586a4ec3d906f293104b359891e8cd9f75d316fd3882625f1e095cccd40cb5c8c42b68f2ff787ed1ff208f45443
+  data.tar.gz: cca6aecae8bc75568acccbef03c422f1dd64036fcbe4fb60e20d988e731dd075fa80433e865bae5b1c2f13ebbbe03effb182070c7b08efae53c799c74e537b2b

data/lib/cli.rb

@@ -1,8 +1,6 @@
 require "rubygems"
 require "bundler"
 
-$LOAD_PATH.unshift "../automotive-ecu/lib"
-
 require "ecu"
 require "thor"
 require "filesize"
@@ -12,8 +10,8 @@ require_relative "file_reader"
 require_relative "codinginfo"
 require_relative "tempfile_handler"
 require_relative "diff_viewer"
-require_relative "label_selector"
 require_relative "variant_filter"
+require_relative "list_colorizer"
 require_relative "core_ext"
 require_relative "version"
 
@@ -56,13 +54,6 @@ module Dcm
       exit 1
     end
 
-    desc "liveview FILE", "Live search and view labels in FILE"
-    def liveview(file=nil)
-      list = parse_file(file)
-      selector = LabelSelector.new(list)
-      loop { selector.choose }
-    end
-
     desc "creta2begu FILTER CODING FILE", "Convert a hierarchical DCM to a flat DCM"
     def creta2begu(expr, codingpath, file)
       filter = VariantFilter.new(expr)

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Dcm
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dcm
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Jonas Mueller
@@ -180,9 +180,7 @@ files:
 - lib/core_ext.rb
 - lib/diff_viewer.rb
 - lib/file_reader.rb
-- lib/label_selector.rb
 - lib/list_colorizer.rb
-- lib/selecta.rb
 - lib/tempfile_handler.rb
 - lib/variant_filter.rb
 - lib/version.rb

data/lib/label_selector.rb

@@ -1,28 +0,0 @@
-require_relative "core_ext"
-require_relative "selecta"
-require_relative "list_colorizer"
-
-class LabelSelector
-  def initialize(list)
-    @keys   = list.map(&:name)
-    @values = list.map { |e| ListColorizer.call(e.to_s(detail: true)) }
-  end
-
-  def choose
-    view = selecta(@keys, @values)
-    print view
-    STDIN.gets
-  rescue Interrupt => e
-    clear_screen
-    exit 0
-  end
-
-  def selecta(keys, values)
-    clear_screen
-    Selecta.new.main_api(keys: keys, values: values, options: { height: "full" }).tap { clear_screen }
-  end
-
-  def clear_screen
-    print "\e[2J\e[H"
-  end
-end

data/lib/selecta.rb

@@ -1,803 +0,0 @@
-#!/usr/bin/env bash
-# vim: set ft=ruby:
-
-# This file executes as a bash script, which turns around and executes Ruby via
-# the line below. The -x argument to Ruby makes it discard everything before
-# the second "!ruby" shebang. This allows us to work on Linux, where the
-# shebang can only have one argument so we can't directly say
-# "#!/usr/bin/env ruby --disable-gems". Thanks for that, Linux.
-#
-# If this seems confusing, don't worry. You can treat it as a normal Ruby file
-# starting with the "!ruby" shebang below.
-
-if RUBY_VERSION < '1.9.3'
-  abort "error: Selecta requires Ruby 1.9.3 or higher."
-end
-
-require "optparse"
-require "io/console"
-require "io/wait"
-require "set"
-
-KEY_CTRL_C = ?\C-c
-KEY_CTRL_N = ?\C-n
-KEY_CTRL_P = ?\C-p
-KEY_CTRL_U = ?\C-u
-KEY_CTRL_H = ?\C-h
-KEY_CTRL_W = ?\C-w
-KEY_CTRL_J = ?\C-j
-KEY_CTRL_M = ?\C-m
-KEY_DELETE = 127.chr # Equivalent to ?\C-?
-
-class Selecta
-  VERSION = [0, 0, 6]
-
-  def main_api(keys:, values: keys, options: {})
-    unless keys.size == values.size
-      $stderr.puts("Keys and values must be arrays of equals size!")
-      exit(1)
-    end
-    # We have to parse options before setting up the screen or trying to read
-    # the input in case the user did '-h', an invalid option, etc. and we need
-    # to terminate.
-    options = Configuration.parse_options(options)
-    input_lines = keys
-
-    search = Screen.with_screen do |screen, tty|
-      begin
-        config = Configuration.from_inputs(input_lines, options, screen.height)
-        run_in_screen(config, screen, tty)
-      ensure
-        config.visible_choices.times { screen.newline }
-        screen.cursor_up(config.height - 1)
-        screen.write(Text[""])
-        screen.cursor_up(1)
-      end
-    end
-
-    unless search.selection == Search::NoSelection
-      values[keys.index(search.selection)]
-    end
-  rescue Screen::NotATTY
-    $stderr.puts(
-      "Can't get a working TTY. Selecta requires an ANSI-compatible terminal.")
-    exit(1)
-  rescue Abort
-    # We were aborted via ^C.
-    #
-    # If we didn't mess with the TTY configuration at all, then ^C would send
-    # SIGINT to the entire process group. That would terminate both Selecta and
-    # anything piped into or out of it. Because Selecta puts the terminal in
-    # raw mode, that doesn't happen; instead, we detect the ^C as normal input
-    # and raise Abort, which leads here.
-    #
-    # To make pipelines involving Selecta behave as people expect, we send
-    # SIGINT to our own process group, which should exactly match what termios
-    # would do to us if the terminal weren't in raw mode. "Should!" <- Remove
-    # those scare quotes if ten years pass without this breaking!
-    #
-    # The SIGINT will cause Ruby to raise Interrupt, so we also have to handle
-    # that here.
-    begin
-      Process.kill("INT", -Process.getpgrp)
-    rescue Interrupt
-      exit(1)
-    end
-  end
-
-  def run_in_screen(config, screen, tty)
-    search = Search.from_config(config)
-    search = ui_event_loop(search, screen, tty)
-    search
-  end
-
-  # Use the search and screen to process user actions until they quit.
-  def ui_event_loop(search, screen, tty)
-    while not search.done?
-      Renderer.render!(search, screen)
-      search = handle_keys(search, tty)
-    end
-    search
-  end
-
-  def handle_keys(search, tty)
-    new_query_chars = ""
-
-    # Read through all of the buffered input characters. Process control
-    # characters immediately. Save any query characters to be processed
-    # together at the end, since there's no reason to process intermediate
-    # results when there are more characters already buffered.
-    tty.get_available_input.chars.each do |char|
-      is_query_char = !!(char =~ /[[:print:]]/)
-      if is_query_char
-        new_query_chars << char
-      else
-        search = handle_control_character(search, char)
-      end
-    end
-
-    if new_query_chars.empty?
-      search
-    else
-      search.append_search_string(new_query_chars)
-    end
-  end
-
-  # On each keystroke, generate a new search object
-  def handle_control_character(search, key)
-    case key
-
-    when KEY_CTRL_N then search.down
-    when KEY_CTRL_P then search.up
-
-    when KEY_CTRL_U then search.clear_query
-    when KEY_CTRL_W then search.delete_word
-    when KEY_CTRL_H, KEY_DELETE then search.backspace
-
-    when ?\r, KEY_CTRL_J, KEY_CTRL_M then search.done
-
-    when KEY_CTRL_C then raise Abort
-
-    else search
-    end
-  end
-
-  class Abort < RuntimeError; end
-end
-
-class Configuration < Struct.new(:height, :initial_search, :choices)
-  def initialize(height, initialize, choices)
-    # Constructor is defined to force argument presence; otherwise Struct
-    # defaults missing arguments to nil
-    super
-  end
-
-  def visible_choices
-    height - 1
-  end
-
-  def self.from_inputs(choices, options, screen_height=21)
-    # Shrink the number of visible choices if the screen is too small
-    if options.fetch(:height) == "full"
-      height = screen_height
-    else
-      height = [options.fetch(:height), screen_height].min
-    end
-
-    choices = massage_choices(choices)
-    Configuration.new(height, options.fetch(:search), choices)
-  end
-
-  def self.default_options
-    parse_options({})
-  end
-
-  def self.parse_options(options)
-    defaults = { search: "", height: 21 }
-    defaults.merge(options)
-  end
-
-  def self.massage_choices(choices)
-    choices.map do |choice|
-      # Encoding to UTF-8 with `:invalid => :replace` isn't good enough; it
-      # still leaves some invalid characters. For example, this string will fail:
-      #
-      # echo "девуш\xD0:" | selecta
-      #
-      # Round-tripping through UTF-16, with `:invalid => :replace` as well,
-      # fixes this. I don't understand why. I found it via:
-      #
-      # http://stackoverflow.com/questions/2982677/ruby-1-9-invalid-byte-sequence-in-utf-8
-      if choice.valid_encoding?
-        choice
-      else
-        utf16 = choice.encode('UTF-16', 'UTF-8', :invalid => :replace, :replace => '')
-        utf16.encode('UTF-8', 'UTF-16')
-      end.strip
-    end
-  end
-end
-
-class Search
-  attr_reader :index, :query, :config, :original_matches, :all_matches, :best_matches
-
-  def initialize(vars)
-    @config = vars.fetch(:config)
-    @index = vars.fetch(:index)
-    @query = vars.fetch(:query)
-    @done = vars.fetch(:done)
-    @original_matches = vars.fetch(:original_matches)
-    @all_matches = vars.fetch(:all_matches)
-    @best_matches = vars.fetch(:best_matches)
-    @vars = vars
-  end
-
-  def self.from_config(config)
-    trivial_matches = config.choices.reject(&:empty?).map do |choice|
-      Match.trivial(choice)
-    end
-
-    search = new(:config => config,
-                 :index => 0,
-                 :query => "",
-                 :done => false,
-                 :original_matches => trivial_matches,
-                 :all_matches => trivial_matches,
-                 :best_matches => trivial_matches)
-
-    if config.initial_search.empty?
-      search
-    else
-      search.append_search_string(config.initial_search)
-    end
-  end
-
-  # Construct a new Search by merging in a hash of changes.
-  def merge(changes)
-    vars = @vars.merge(changes)
-
-    # If the query changed, throw away the old matches so that new ones will be
-    # computed.
-    matches_are_stale = vars.fetch(:query) != @query
-    if matches_are_stale
-      vars = vars.reject { |key| key == :matches }
-    end
-
-    Search.new(vars)
-  end
-
-  def done?
-    @done
-  end
-
-  def selection
-    if @aborted
-      NoSelection
-    else
-      match = best_matches.fetch(@index) { NoSelection }
-      if match == NoSelection
-        match
-      else
-        match.original_choice
-      end
-    end
-  end
-
-  def down
-    move_cursor(1)
-  end
-
-  def up
-    move_cursor(-1)
-  end
-
-  def max_visible_choices
-    [@config.visible_choices, all_matches.count].min
-  end
-
-  def append_search_string(string)
-    merge(:index => 0,
-          :query => @query + string)
-    .recompute_matches(all_matches)
-  end
-
-  def backspace
-    merge(:index => 0,
-          :query => @query[0...-1])
-    .recompute_matches
-  end
-
-  def clear_query
-    merge(:index => 0,
-          :query => "")
-    .recompute_matches
-  end
-
-  def delete_word
-    merge(:index => 0,
-          :query => @query.sub(/[^ ]* *$/, ""))
-    .recompute_matches
-  end
-
-  def done
-    merge(:done => true)
-  end
-
-  def abort
-    merge(:aborted => true)
-  end
-
-  def recompute_matches(previous_matches=self.original_matches)
-    if self.query.empty?
-      merge(:all_matches => original_matches,
-            :best_matches => original_matches)
-    else
-      all_matches = recompute_all_matches(previous_matches)
-      best_matches = recompute_best_matches(all_matches)
-      merge(:all_matches => all_matches, :best_matches => best_matches)
-    end
-  end
-
-  private
-
-  def recompute_all_matches(previous_matches)
-    query = self.query.downcase
-    query_chars = query.chars.to_a
-
-    matches = previous_matches.map do |match|
-      choice = match.choice
-      score, range = Score.score(choice, query_chars)
-      range ? match.refine(score, range) : nil
-    end.compact
-  end
-
-  def recompute_best_matches(all_matches)
-    return [] if all_matches.empty?
-
-    count = [@config.visible_choices, all_matches.count].min
-    matches = []
-
-    best_score = all_matches.min_by(&:score).score
-
-    # Consider matches, beginning with the best-scoring. A match always ranks
-    # higher than other matches with worse scores. However, the ranking between
-    # matches of the same score depends on other factors, so we always have to
-    # consider all matches of a given score.
-    (best_score..Float::INFINITY).each do |score|
-      matches += all_matches.select { |match| match.score == score }
-      # Stop if we have enough matches.
-      return sub_sort_matches(matches)[0, count] if matches.length >= count
-    end
-  end
-
-  def sub_sort_matches(matches)
-    matches.sort_by do |match|
-      [match.score, match.matching_range.count, match.choice.length]
-    end
-  end
-
-  def move_cursor(direction)
-    if max_visible_choices > 0
-      index = (@index + direction) % max_visible_choices
-      merge(:index => index)
-    else
-      self
-    end
-  end
-
-  class NoSelection; end
-end
-
-class Match < Struct.new(:original_choice, :choice, :score, :matching_range)
-  def self.trivial(choice)
-    empty_range = (0...0)
-    new(choice, choice.downcase, 0, empty_range)
-  end
-
-  def to_text
-    if matching_range.none?
-      Text[original_choice]
-    else
-      before = original_choice[0...matching_range.begin]
-      matching = original_choice[matching_range.begin..matching_range.end]
-      after = original_choice[(matching_range.end + 1)..-1]
-      Text[before, :red, matching, :default, after]
-    end
-  end
-
-  def refine(score, range)
-    Match.new(original_choice, choice, score, range)
-  end
-end
-
-class Score
-  class << self
-    # A word boundary character is any ASCII character that's not alphanumeric.
-    # This isn't strictly correct: characters like ZERO WIDTH NON-JOINER,
-    # non-Latin punctuation, etc. will be incorrectly treated as non-boundary
-    # characters. This is necessary for performance: even building a Set of
-    # boundary characters based only on the input text is prohibitively slow (2-3
-    # seconds for 80,000 input paths on a 2014 MacBook Pro).
-    BOUNDARY_CHARS = (0..127).map(&:chr).select do |char|
-      char !~ /[A-Za-z0-9_]/
-    end.to_set
-
-    def score(string, query_chars)
-      query_chars -= [" "] # Change by Jonas Müller
-      first_char, *rest = query_chars
-
-      # Keep track of the best match that we've seen. This is uglier than
-      # building a list of matches and then sorting them, but it's faster.
-      best_score = Float::INFINITY
-      best_range = nil
-
-      # Iterate over each instance of the first query character. E.g., if we're
-      # querying the string "axbx" for "x", we'll start at index 1 and index 3.
-      each_index_of_char_in_string(string, first_char) do |first_index|
-        score = 1
-
-        # Find the best score starting at this index.
-        score, last_index = find_end_of_match(string, rest, score, first_index)
-
-        # Did we do better than we have for the best starting point so far?
-        if last_index && score < best_score
-          best_score = score
-          best_range = (first_index..last_index)
-        end
-      end
-
-      [best_score, best_range]
-    end
-
-    # Find all occurrences of the character in the string, returning their indexes.
-    def each_index_of_char_in_string(string, char)
-      index = 0
-      while index
-        index = string.index(char, index)
-        if index
-          yield index
-          index += 1
-        end
-      end
-    end
-
-    # Find each of the characters in the string, moving strictly left to right.
-    def find_end_of_match(string, chars, score, first_index)
-      last_index = first_index
-
-      # Remember the type of the last character match for special scoring.
-      last_type = nil
-
-      chars.each do |this_char|
-        # Where's the next occurrence of this character? The optimal algorithm
-        # would consider all instances of query character, but that's slower
-        # than this eager method.
-        index = string.index(this_char, last_index + 1)
-
-        # This character doesn't occur in the string, so this can't be a match.
-        return [nil, nil] unless index
-
-        if index == last_index + 1
-          # This matching character immediately follows the last matching
-          # character. The first two sequential characters score; subsequent
-          # ones don't.
-          if last_type != :sequential
-            last_type = :sequential
-            score += 1
-          end
-        # This character follows a boundary character.
-        elsif BOUNDARY_CHARS.include?(string[index - 1])
-          if last_type != :boundary
-            last_type = :boundary
-            score += 1
-          end
-        # This character isn't special.
-        else
-          last_type = :normal
-          score += index - last_index
-        end
-
-        last_index = index
-      end
-
-      [score, last_index]
-    end
-  end
-end
-
-class Renderer < Struct.new(:search)
-  def self.render!(search, screen)
-    rendered = Renderer.new(search).render
-    width = screen.width
-
-    screen.with_cursor_hidden do
-      rendered.choices.each_with_index do |choice, index|
-        choice = choice.truncate_to_width(width)
-        is_last_line = (index == rendered.choices.length - 1)
-        choice += Text["\n"] unless is_last_line
-        screen.write(choice)
-      end
-
-      # Move back up to the search line and redraw it, which will naturally
-      # leave the cursor at the end of the query.
-      screen.cursor_up(rendered.choices.length - 1)
-      screen.write(rendered.search_line.truncate_to_width(width))
-    end
-  end
-
-  def render
-    search_line = Text["#{match_count_label} > " + search.query]
-
-    matches = search.best_matches[0, search.config.visible_choices]
-    matches = matches.each_with_index.map do |match, index|
-      if index == search.index
-        Text[:inverse] + match.to_text + Text[:reset]
-      else
-        match.to_text
-      end
-    end
-    matches = correct_match_count(matches)
-    lines = [search_line] + matches
-    Rendered.new(lines, search_line)
-  end
-
-  def match_count_label
-    choice_count = search.original_matches.length
-    max_label_width = choice_count.to_s.length
-    match_count = search.all_matches.count
-    match_count.to_s.rjust(max_label_width)
-  end
-
-  def correct_match_count(matches)
-    limited = matches[0, search.config.visible_choices]
-    padded = limited + [Text[""]] * (search.config.visible_choices - limited.length)
-    padded
-  end
-
-  class Rendered < Struct.new(:choices, :search_line)
-  end
-
-  private
-
-  def replace_array_element(array, index, new_value)
-    array = array.dup
-    array[index] = new_value
-    array
-  end
-end
-
-class Screen
-  def self.with_screen
-    SelectaTTY.with_tty do |tty|
-      screen = self.new(tty)
-      screen.configure_tty
-      begin
-        raise NotATTY if screen.height == 0
-        yield screen, tty
-      ensure
-        screen.restore_tty
-        tty.puts
-      end
-    end
-  end
-
-  class NotATTY < RuntimeError; end
-
-  attr_reader :tty
-
-  def initialize(tty)
-    @tty = tty
-    @original_stty_state = tty.stty("-g")
-  end
-
-  def configure_tty
-    # -echo: terminal doesn't echo typed characters back to the terminal
-    # -icanon: terminal doesn't  interpret special characters (like backspace)
-    tty.stty("raw -echo -icanon")
-  end
-
-  def restore_tty
-    tty.stty("#{@original_stty_state}")
-  end
-
-  def suspend
-    restore_tty
-    begin
-      yield
-      configure_tty
-    rescue
-      restore_tty
-    end
-  end
-
-  def with_cursor_hidden(&block)
-    write_bytes(ANSI.hide_cursor)
-    begin
-      block.call
-    ensure
-      write_bytes(ANSI.show_cursor)
-    end
-  end
-
-  def height
-    tty.winsize[0]
-  end
-
-  def width
-    tty.winsize[1]
-  end
-
-  def cursor_up(lines)
-    write_bytes(ANSI.cursor_up(lines))
-  end
-
-  def newline
-    write_bytes("\n")
-  end
-
-  def write(text)
-    write_bytes(ANSI.clear_line)
-    write_bytes("\r")
-
-    text.components.each do |component|
-      if component.is_a? String
-        write_bytes(expand_tabs(component))
-      elsif component == :inverse
-        write_bytes(ANSI.inverse)
-      elsif component == :reset
-        write_bytes(ANSI.reset)
-      else
-        if component =~ /_/
-          fg, bg = component.to_s.split(/_/).map(&:to_sym)
-        else
-          fg, bg = component, :default
-        end
-        write_bytes(ANSI.color(fg, bg))
-      end
-    end
-  end
-
-  def expand_tabs(string)
-    # Modified from http://markmail.org/message/avdjw34ahxi447qk
-    tab_width = 8
-    string.gsub(/([^\t\n]*)\t/) do
-      $1 + " " * (tab_width - ($1.size % tab_width))
-    end
-  end
-
-  def write_bytes(bytes)
-    tty.console_file.write(bytes)
-  end
-end
-
-class Text
-  attr_reader :components
-
-  def self.[](*args)
-    if args.length == 1 && args[0].is_a?(Text)
-      # When called as `Text[some_text]`, just return the existing text.
-      args[0]
-    else
-      new(args)
-    end
-  end
-
-  def initialize(components)
-    @components = components
-  end
-
-  def ==(other)
-    components == other.components
-  end
-
-  def +(other)
-    Text[*(components + other.components)]
-  end
-
-  def truncate_to_width(width)
-    chars_remaining = width
-
-    # Truncate each string to the number of characters left within our
-    # allowed width. Leave anything else alone. This may result in empty
-    # strings and unused ANSI control codes in the output, but that's fine.
-    components = self.components.map do |component|
-      if component.is_a?(String)
-        component = component[0, chars_remaining]
-        chars_remaining -= component.length
-      end
-      component
-    end
-
-    Text.new(components)
-  end
-end
-
-class ANSI
-  ESC = 27.chr
-
-  class << self
-    def escape(sequence)
-      ESC + "[" + sequence
-    end
-
-    def clear
-      escape "2J"
-    end
-
-    def hide_cursor
-      escape "?25l"
-    end
-
-    def show_cursor
-      escape "?25h"
-    end
-
-    def cursor_up(lines)
-      escape "#{lines}A"
-    end
-
-    def clear_line
-      escape "2K"
-    end
-
-    def color(fg, bg=:default)
-      fg_codes = {
-        :black => 30,
-        :red => 31,
-        :green => 32,
-        :yellow => 33,
-        :blue => 34,
-        :magenta => 35,
-        :cyan => 36,
-        :white => 37,
-        :default => 39,
-      }
-      bg_codes = {
-        :black => 40,
-        :red => 41,
-        :green => 42,
-        :yellow => 43,
-        :blue => 44,
-        :magenta => 45,
-        :cyan => 46,
-        :white => 47,
-        :default => 49,
-      }
-      fg_code = fg_codes.fetch(fg)
-      bg_code = bg_codes.fetch(bg)
-      escape "#{fg_code};#{bg_code}m"
-    end
-
-    def inverse
-      escape("7m")
-    end
-
-    def reset
-      escape("0m")
-    end
-  end
-end
-
-class SelectaTTY < Struct.new(:console_file)
-  def self.with_tty(&block)
-    # Selecta reads data from stdin and writes it to stdout, so we can't draw
-    # UI and receive keystrokes through them. Fortunately, all modern
-    # Unix-likes provide /dev/tty, which IO.console gives us.
-    console_file = IO.console
-    tty = SelectaTTY.new(console_file)
-    block.call(tty)
-  end
-
-  def get_available_input
-    input = console_file.getc
-    while console_file.ready?
-      input += console_file.getc
-    end
-    input
-  end
-
-  def puts
-    console_file.puts
-  end
-
-  def winsize
-    console_file.winsize
-  end
-
-  def stty(args)
-    command("stty #{args}").strip
-  end
-
-  private
-
-  # Run a command with the TTY as stdin, capturing the output via a pipe
-  def command(command)
-    IO.pipe do |read_io, write_io|
-      pid = Process.spawn(command, :in => "/dev/tty", :out => write_io)
-      Process.wait(pid)
-      raise "Command failed: #{command.inspect}" unless $?.success?
-      write_io.close
-      read_io.read
-    end
-  end
-end