tb 0.1 → 0.2

data/lib/tb/csv.rb

@@ -27,13 +27,38 @@
 require 'csv'
 
 class Tb
+  def Tb.load_csv(filename, *header_fields, &block)
+    Tb.parse_csv(File.read(filename), *header_fields, &block)
+  end
+
+  def Tb.parse_csv(csv, *header_fields)
+    aa = []
+    csv_stream_input(csv) {|ary|
+      aa << ary
+    }
+    aa = yield aa if block_given?
+    if header_fields.empty?
+      reader = Tb::Reader.new(aa)
+      arys = []
+      reader.each {|ary|
+        arys << ary
+      }
+      header = reader.header
+    else
+      header = header_fields
+      arys = aa
+    end
+    t = Tb.new(header)
+    arys.each {|ary|
+      ary << nil while ary.length < header.length
+      t.insert_values header, ary
+    }
+    t
+  end
+
   def Tb.csv_stream_input(csv, &b)
     csvreader = CSVReader.new(csv)
-    begin
-      csvreader.each(&b)
-    ensure
-      csvreader.close
-    end
+    csvreader.each(&b)
     nil
   end
 
@@ -79,7 +104,6 @@ class Tb
     end
 
     def close
-      @csv.close
     end
   end
 

data/lib/tb/fieldset.rb

@@ -27,12 +27,44 @@
 class Tb::FieldSet
   def initialize(*fs)
     @header = []
-    add_fields(*fs) if !fs.empty?
+    @field2index = {}
+    fs.each {|f| add_field(f) }
   end
   attr_reader :header
 
+  def add_field(hint)
+    hint = '1' if hint.nil? || hint == ''
+    while @field2index[hint]
+      case hint
+      when /\A[1-9][0-9]*\z/
+        hint = (hint.to_i + 1).to_s
+      when /\([1-9][0-9]*\)\z/
+        hint = hint.sub(/\(([1-9][0-9]*)\)\z/) { "(#{$1.to_i + 1})" }
+      else
+        hint = "#{hint}(2)"
+      end
+    end
+    @field2index[hint] = @header.length
+    @header << hint
+    hint
+  end
+  private :add_field
+
+  def index_from_field_ex(f)
+    i = @field2index[f]
+    return i if !i.nil?
+    if /\A[1-9][0-9]*\z/ !~ f
+      raise ArgumentError, "unexpected field name: #{f.inspect}"
+    end
+    while true
+      if add_field(nil) == f
+        return @header.length-1
+      end
+    end
+  end
+
   def index_from_field(f)
-    i = self.header.index(f)
+    i = @field2index[f]
     if i.nil?
       raise ArgumentError, "unexpected field name: #{f.inspect}"
     end
@@ -40,17 +72,16 @@ class Tb::FieldSet
   end
 
   def field_from_index_ex(i)
-    if self.length <= i
-      fs2 = extend_length(i+1)
-      fs2.last
-    else
-      field_from_index(i)
+    raise ArgumentError, "negative index: #{i}" if i < 0
+    until i < @header.length
+      add_field(nil)
     end
+    @header[i]
   end
 
   def field_from_index(i)
     raise ArgumentError, "negative index: #{i}" if i < 0
-    f = self.header[i]
+    f = @header[i]
     if f.nil?
       raise ArgumentError, "index too big: #{i}"
     end
@@ -60,37 +91,4 @@ class Tb::FieldSet
   def length
     @header.length
   end
-
-  def extend_length(len)
-    fs = [""] * (len - self.length)
-    add_fields(*fs)
-  end
-
-  def add_fields(*fs)
-    h = {}
-    max = {}
-    @header.each {|f|
-      h[f] = true
-      if /\((\d+)\)\z/ =~ f
-        prefix = $`
-        n = $1.to_i
-        max[prefix] = n if !max[prefix] || max[prefix] < n
-      end
-    }
-    fs2 = []
-    fs.each {|f|
-      f ||= ''
-      if !h[f]
-        f2 = f
-      else
-        max[f] = 1 if !max[f]
-        max[f] += 1
-        f2 = "#{f}(#{max[f]})"
-      end
-      fs2 << f2
-      h[f2] = true
-    }
-    @header.concat fs2
-    fs2
-  end
 end

data/lib/tb/pager.rb

@@ -0,0 +1,132 @@
+begin
+  require 'io/console'
+rescue LoadError
+end
+
+class Tb::Pager
+  def self.open
+    pager = self.new
+    begin
+      yield pager
+    ensure
+      pager.close
+    end
+  end
+
+  def initialize
+    if STDOUT.tty?
+      @io = nil
+      @buf = ''
+    else
+      @io = STDOUT
+      @buf = nil
+    end
+  end
+
+  def <<(obj)
+    write obj.to_s
+    self
+  end
+
+  def print(*args)
+    s = ''
+    args.map {|a| s << a.to_s }
+    write s
+    nil
+  end
+
+  def printf(format, *args)
+    write sprintf(format, *args)
+    nil
+  end
+
+  def putc(ch)
+    if Integer === ch
+      write [ch].pack("C")
+    else
+      write ch.to_s
+    end
+    ch
+  end
+
+  def puts(*objs)
+    if objs.empty?
+      write "\n"
+    else
+      objs.each {|o|
+        o = o.to_s
+        write o
+        write "\n" if /\n\z/ !~ o
+      }
+    end
+    nil
+  end
+
+  def write_nonblock(str)
+    write str.to_s
+  end
+
+  def expand_tab(str, tabstop=8)
+    col = 0
+    str.gsub(/(\t+)|[^\t]+/) {
+      if $1
+        ' ' * (($1.length * tabstop) - (col + 1) % tabstop)
+      else
+        $&
+      end
+    }
+  end
+
+  DEFAULT_LINES = 24
+  DEFAULT_COLUMNS = 80
+
+  def winsize
+    if STDOUT.respond_to? :winsize
+      lines, columns = STDOUT.winsize
+      return [lines, columns] if lines != 0 && columns != 0
+    end
+    [DEFAULT_LINES, DEFAULT_COLUMNS]
+  end
+
+  def single_screen?(str)
+    lines, columns = winsize
+    n = 0
+    str.each_line {|line|
+      line = expand_tab(line).chomp
+      cols = line.length # xxx: 1 column/character assumed.
+      cols = 1 if cols == 0
+      m = (cols + columns - 1) / columns # termcap am capability is assumed.
+      n += m
+    }
+    n <= lines-1
+  end
+
+  def write(str)
+    str = str.to_s
+    if !@io
+      @buf << str
+      if !single_screen?(@buf)
+        @io = IO.popen(ENV['PAGER'] || 'more', 'w')
+        @io << @buf
+        @buf = nil
+      end
+    else
+      @io << str
+    end
+  end
+
+  def flush
+    @io.flush if @io
+    self
+  end
+
+  def close
+    if !@io
+      STDOUT.print @buf
+    else
+      # don't need to ouput @buf because @buf is nil.
+      @io.close if @io != STDOUT
+    end
+    nil
+  end
+end

data/lib/tb/pnm.rb

@@ -0,0 +1,357 @@
+# lib/tb/pnm.rb - tools for (very small) PNM images.
+#
+# Copyright (C) 2010-2011 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+class Tb
+  # :call-seq:
+  #   Tb.load_pnm(pnm_filename) -> tb
+  #
+  def Tb.load_pnm(pnm_filename)
+    pnm_content = File.open(pnm_filename, "rb") {|f| f.read }
+    Tb.parse_pnm(pnm_content)
+  end
+
+  # :call-seq:
+  #   Tb.parse_pnm(pnm_content) -> tb
+  #
+  def Tb.parse_pnm(pnm_content)
+    reader = PNMReader.new(pnm_content)
+    header = reader.shift
+    t = Tb.new(header)
+    reader.each {|ary|
+      t.insert_values header, ary
+    }
+    t
+  end
+
+  # :call-seq:
+  #   Tb.pnm_stream_input(pnm_io) {|ary| ... }
+  #
+  def Tb.pnm_stream_input(pnm_io)
+    pnm_io.binmode
+    content = pnm_io.read
+    PNMReader.new(content)
+  end
+
+  # practical only for (very) small images.
+  class PNMReader
+    WSP = /(?:[ \t\r\n]|\#[^\r\n]*[\r\n])+/
+
+    def initialize(pnm_content)
+      pnm_content.force_encoding("ASCII-8BIT") if pnm_content.respond_to? :force_encoding
+      if /\A(P[63])(#{WSP})(\d+)(#{WSP})(\d+)(#{WSP})(\d+)[ \t\r\n]/on =~ pnm_content
+        magic, wsp1, w, wsp2, h, wsp3, max, raster = $1, $2, $3.to_i, $4, $5.to_i, $6, $7.to_i, $'
+        pixel_component = %w[R G B]
+      elsif /\A(P[52])(#{WSP})(\d+)(#{WSP})(\d+)(#{WSP})(\d+)[ \t\r\n]/on =~ pnm_content
+        magic, wsp1, w, wsp2, h, wsp3, max, raster = $1, $2, $3.to_i, $4, $5.to_i, $6, $7.to_i, $'
+        pixel_component = %w[V]
+      elsif /\A(P[41])(#{WSP})(\d+)(#{WSP})(\d+)[ \t\r\n]/on =~ pnm_content
+        magic, wsp1, w, wsp2, h, raster = $1, $2, $3.to_i, $4, $5.to_i, $'
+        wsp3 = nil
+        max = 1
+        pixel_component = %w[V]
+      else
+        raise ArgumentError, "not PNM format"
+      end
+      raise ArgumentError, "unsupported max value: #{max}" if 65535 < max
+
+      @ary = [
+        ['type', 'x', 'y', 'component', 'value'],
+        ['meta', nil, nil, 'pnm_type', magic],
+        ['meta', nil, nil, 'width', w],
+        ['meta', nil, nil, 'height', h],
+        ['meta', nil, nil, 'max', max]
+      ]
+
+      [wsp1, wsp2, wsp3].each {|wsp|
+        next if !wsp
+        wsp.scan(/\#([^\r\n]*)[\r\n]/) { @ary << ['meta', nil, nil, 'comment', $1] }
+      }
+
+      if /P[65]/ =~ magic # raw (binary) PPM/PGM
+        if max < 0x100
+          each_pixel_component = method(:raw_ppm_pgm_1byte_each_pixel_component)
+        else
+          each_pixel_component = method(:raw_ppm_pgm_2byte_each_pixel_component)
+        end
+      elsif /P4/ =~ magic # raw (binary) PBM
+        each_pixel_component = make_raw_pbm_each_pixel_component(w)
+      elsif /P[32]/ =~ magic # plain (ascii) PPM/PGM
+        each_pixel_component = method(:plain_ppm_pgm_each_pixel_component)
+      elsif /P1/ =~ magic # plain (ascii) PBM
+        each_pixel_component = method(:plain_pbm_each_pixel_component)
+      end
+      n = w * h * pixel_component.length
+      i = 0
+      each_pixel_component.call(raster) {|value|
+        break if i == n
+        y, x = (i / pixel_component.length).divmod(w)
+        c = pixel_component[i % pixel_component.length]
+        @ary << ['pixel', x, y, c, value.to_f / max]
+        i += 1
+      }
+      if i != n
+        raise ArgumentError, "PNM raster data too short."
+      end
+    end
+
+    def raw_ppm_pgm_1byte_each_pixel_component(raster, &b)
+      raster.each_byte(&b)
+    end
+
+    def raw_ppm_pgm_2byte_each_pixel_component(raster)
+      raster.enum_for(:each_byte).each_slice(2) {|byte1, byte2|
+        word = byte1 * 0x100 + byte2
+        yield word
+      }
+    end
+
+    def plain_ppm_pgm_each_pixel_component(raster)
+      raster.scan(/\d+/) { yield $&.to_i }
+    end
+
+    def plain_pbm_each_pixel_component(raster)
+      raster.scan(/[01]/) { yield 1 - $&.to_i }
+    end
+
+    def make_raw_pbm_each_pixel_component(width)
+      iter = Object.new
+      iter.instance_variable_set(:@width, width)
+      def iter.call(raster)
+        numbytes = (@width + 7) / 8
+        y = 0
+        while true
+          return if raster.size <= y * numbytes
+          line = raster[y * numbytes, numbytes]
+          x = 0
+          while x < @width
+            i, j = x.divmod(8)
+            return if line.size <= i
+            byte = line[x/8].ord
+            yield 1 - ((byte >> (7-j)) & 1)
+            x += 1
+          end
+          y += 1
+        end
+      end
+      iter
+    end
+
+    def shift
+      @ary.shift
+    end
+
+    def each
+      while ary = self.shift
+        yield ary
+      end
+      nil
+    end
+
+    def to_a
+      result= []
+      each {|ary| result << ary }
+      result
+    end
+
+    def close
+    end
+  end
+
+  # :call-seq:
+  #   generate_pnm(out='')
+  #
+  def generate_pnm(out='')
+    undefined_field = ['x', 'y', 'component', 'value'] - self.list_fields
+    if !undefined_field.empty?
+      raise ArgumentError, "field not defined: #{undefined_field.inspect[1...-1]}"
+    end
+    pnm_type = nil
+    width = height = nil
+    comments = []
+    max_value = nil
+    max_x = max_y = 0
+    values = { 0.0 => true, 1.0 => true }
+    components = {}
+    self.each {|rec|
+      case rec['component']
+      when 'pnm_type'
+        pnm_type = rec['value']
+      when 'width'
+        width = rec['value'].to_i
+      when 'height'
+        height = rec['value'].to_i
+      when 'max'
+        max_value = rec['value'].to_i
+      when 'comment'
+        comments << rec['value']
+      when 'R', 'G', 'B', 'V'
+        components[rec['component']] = true
+        x = rec['x'].to_i
+        y = rec['y'].to_i
+        max_x = x if max_x < x
+        max_y = y if max_y < y
+        values[rec['value'].to_f] = true
+      end
+
+    }
+    if !(components.keys - %w[V]).empty? &&
+       !(components.keys - %w[R G B]).empty?
+      raise ArgumentError, "inconsistent color component: #{components.keys.sort.inspect[1...-1]}"
+    end
+    case pnm_type
+    when 'P1', 'P4' then raise ArgumentError, "unexpected compoenent for PBM: #{components.keys.sort.inspect[1...-1]}" if !(components.keys - %w[V]).empty?
+    when 'P2', 'P5' then raise ArgumentError, "unexpected compoenent for PGM: #{components.keys.sort.inspect[1...-1]}" if !(components.keys - %w[V]).empty?
+    when 'P3', 'P6' then raise ArgumentError, "unexpected compoenent for PPM: #{components.keys.sort.inspect[1...-1]}" if !(components.keys - %w[R G B]).empty?
+    end
+    comments.each {|c|
+      if /[\r\n]/ =~ c
+        raise ArgumentError, "comment cannot contain a newline: #{c.inspect}"
+      end
+    }
+    if !width
+      width = max_x + 1
+    end
+    if !height
+      height = max_y + 1
+    end
+    if !max_value
+      min_interval = 1.0
+      values.keys.sort.each_cons(2) {|v1, v2|
+        d = v2-v1
+        min_interval = d if d < min_interval
+      }
+      if min_interval < 0.0039 # 1/255 = 0.00392156862745098...
+        max_value = 0xffff
+      elsif min_interval < 1.0 || !(components.keys & %w[R G B]).empty?
+        max_value = 0xff
+      else
+        max_value = 1
+      end
+    end
+    if pnm_type
+      if !pnm_type.kind_of?(String) || /\AP[123456]\z/ !~ pnm_type
+        raise ArgumentError, "unexpected PNM type: #{pnm_type.inspect}"
+      end
+    else
+      if (components.keys - ['V']).empty?
+        if max_value == 1
+          pnm_type = 'P4' # PBM
+        else
+          pnm_type = 'P5' # PGM
+        end
+      else
+        pnm_type = 'P6' # PPM
+      end
+    end
+    header = "#{pnm_type}\n"
+    comments.each {|c| header << '#' << c << "\n" }
+    header << "#{width} #{height}\n"
+    header << "#{max_value}\n" if /P[2536]/ =~ pnm_type
+    if /P[14]/ =~ pnm_type # PBM
+      max_value = 1
+    end
+    bytes_per_component = bytes_per_line = component_fmt = component_template = nil
+    case pnm_type
+    when 'P1' then bytes_per_component = 1; raster = '1' * (width * height)
+    when 'P4' then bytes_per_line = (width + 7) / 8; raster = ["1"*width].pack("B*") * height
+    when 'P2' then bytes_per_component = max_value.to_s.length+1; component_fmt = "%#{bytes_per_component}d"; raster = (component_fmt % 0) * (width * height)
+    when 'P5' then bytes_per_component, component_template = max_value < 0x100 ? [1, 'C'] : [2, 'n']; raster = "\0" * (bytes_per_component * width * height)
+    when 'P3' then bytes_per_component = max_value.to_s.length+1; component_fmt = "%#{bytes_per_component}d"; raster = (component_fmt % 0) * (3 * width * height)
+    when 'P6' then bytes_per_component, component_template = max_value < 0x100 ? [1, 'C'] : [2, 'n']; raster = "\0" * (bytes_per_component * 3 * width * height)
+    else
+      raise
+    end
+    raster.force_encoding("ASCII-8BIT") if raster.respond_to? :force_encoding
+    self.each {|rec|
+      c = rec['component']
+      next if /\A[RGBV]\z/ !~ c
+      x = rec['x'].to_i
+      y = rec['y'].to_i
+      next if x < 0 || width <= x
+      next if y < 0 || height <= y
+      v = rec['value'].to_f
+      if v < 0
+        v = 0
+      elsif 1 < v
+        v = 1
+      end
+      case pnm_type
+      when 'P1'
+        v = v < 0.5 ? '1' : '0'
+        raster[y * width + x] = v
+      when 'P4'
+        xhi, xlo = x.divmod(8)
+        i = y * bytes_per_line + xhi
+        byte = raster[i].ord
+        if v < 0.5
+          byte |= 0x80 >> xlo
+        else
+          byte &= 0xff7f >> xlo
+        end
+        raster[i] = [byte].pack("C")
+      when 'P2'
+        v = (v * max_value).round
+        raster[(y * width + x) * bytes_per_component, bytes_per_component] = component_fmt % v
+      when 'P5'
+        v = (v * max_value).round
+        raster[(y * width + x) * bytes_per_component, bytes_per_component] = [v].pack(component_template)
+      when 'P3'
+        v = (v * max_value).round
+        i = (y * width + x) * 3
+        if c == 'G' then i += 1
+        elsif c == 'B' then i += 2
+        end
+        raster[i * bytes_per_component, bytes_per_component] = component_fmt % v
+      when 'P6'
+        v = (v * max_value).round
+        i = (y * width + x) * 3
+        if c == 'G' then i += 1
+        elsif c == 'B' then i += 2
+        end
+        raster[i * bytes_per_component, bytes_per_component] = [v].pack(component_template)
+      else
+        raise
+      end
+    }
+    if pnm_type == 'P1'
+      raster.gsub!(/[01]{#{width}}/, "\\&\n")
+      if 70 < width
+        raster.gsub!(/[01]{70}/, "\\&\n")
+      end
+      raster << "\n" if /\n\z/ !~ raster
+    elsif /P[23]/ =~ pnm_type
+      components_per_line = /P2/ =~ pnm_type ? width : 3 * width
+      raster.gsub!(/  +/, ' ')
+      raster.gsub!(/( \d+){#{components_per_line}}/, "\\&\n")
+      raster.gsub!(/(\A|\n) +/, '\1')
+      raster.gsub!(/.{71,}\n/) {
+        $&.gsub(/(.{1,69})[ \n]/, "\\1\n")
+      }
+      raster << "\n" if /\n\z/ !~ raster
+    end
+    out << (header+raster)
+  end
+end