tabmani 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4354a2b6bde336a87c348be716782869b8bdeb5
+  data.tar.gz: 756757244859d56327254b3cd0a542a8a8dcca44
+SHA512:
+  metadata.gz: 399da63041ae6721161cb2a6ba40630526d40457dba97d35cd6832c472e67fe154c69daae92328ee2974d40dccedee31b656b270be0fdf7d0952e3398fc323d4
+  data.tar.gz: 40e65f68834e5247001a699fbf23f578cc1b9120c21b3b3d4cb104b495470848bc16dba1d8c2772c3c0011f31765ed77b060c939d84f50b4af444352e95a8032

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/CHANGES

@@ -0,0 +1,7 @@
+= tabmani changelog
+
+== Master (for 0.0.1)
+
+== Version 0.0.0 [2018-09-25]
+
+- Initial release

data/Gemfile

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rdoc", "~> 6.0.4"
+  gem "bundler", "~> 1.16"
+  gem "jeweler", "~> 2.3"
+  gem "simplecov", ">= 0"
+  gem "test-unit", "~> 3.2.4"
+  gem "tefil", '~> 1.0'
+  gem "builtinextension", '~> 0.1'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2018 ippei94da
+
+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.rdoc

@@ -0,0 +1,19 @@
+= tabmani
+
+This GEM provide tabmani command, which help you manipulate table with text format.
+
+== Contributing to tabmani
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2018 ippei94da. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "tabmani"
+  gem.homepage = "http://github.com/ippei94da/tabmani"
+  gem.license = "MIT"
+  gem.summary = %Q{Table manipulator}
+  gem.description = %Q{This GEM provide tabmani command, which help you manipulate table with text format.}
+  gem.email = "ippei94da@gmail.com"
+  gem.authors = ["ippei94da"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tabmani #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/tabmani

@@ -0,0 +1,81 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "pp"
+require "optparse"
+require "tabmani"
+require 'thor'
+
+USAGE = <<HERE
+  Usage: #{File.basename(__FILE__)} [options] [key=val ...] [key]
+HERE
+
+## option analysis
+options = {}
+op = OptionParser.new
+op.banner = USAGE
+op.on("-r" , "--right"     ,"justify to right"       ){ options[:just     ] = :right}
+op.on("-t" , "--transpose" ,"transpose matrix"       ){ options[:transpose] = true}
+op.on("-k" , "--show-key"  ,"show key charcters"     ){ options[:key] = true}
+op.on(       "--sum=key"   ,"indicate output format" ){|v|options[:sum     ] = v}
+op.on("-a" , "--analyze"   ,"show analysis report"   ){
+  options[:analyze  ] = true
+  options[:key  ] = true
+}
+
+op.on("-c",      "--input-csv"    ,"input style as CSV"    ){options[:input] = :csv     }
+op.on("-b",      "--input-blank"  ,"input style as blanks" ){options[:input] = :blank   }
+op.on(           "--input-column" ,"input style as column" ){options[:input] = :column  }
+op.on("-s char", "--input-separator=char","input style as indicated character separated"  ){ |v|
+  options[:input] = :separator
+  options[:in_separator] = v
+}
+
+op.on("-C",  "--output-csv"    ,"output style as CSV"    ){options[:output] = :csv   }
+op.on(       "--output-column" ,"output style as column" ){options[:output] = :column}
+op.on(       "--output-mds"    ,"output style as markdown simple" ){options[:output] = :mds}
+op.on(       "--output-tex" ,"output style as latex" ){options[:output] = :tex}
+op.on("-S char", "--output-separator=char","output style as indicated character separated"  ){ |v|
+  options[:output] = :column
+  options[:out_separator] = v
+}
+
+op.on(       "--reform" ,"reform key 1, 2, 3 as x, y, value." ){options[:reform] = true}
+op.on(       "--title"  ,"use the first line as title" ){ options[:title] = true}
+op.parse!(ARGV)
+
+# default settings
+options[ :just          ] ||= :left
+options[ :input         ] ||= :blank
+options[ :output        ] ||= :column
+options[ :out_separator ] ||= ' '
+
+## TODO: Argument check
+
+table = Tabmani::Table.parse(io: $stdin, style: options[:input], separator: options[:in_separator])
+
+table.set_title if options[:title]
+
+filter_conds = {}
+ARGV.select{|v| v.include? '='}.each do |str|
+  key, val = str.split('=')
+  filter_conds[key] = val
+end
+filter_conds.each { |key, val| table.filter!(key, val) }
+
+table.transpose!             if options[:transpose]
+table.add_sum(options[:sum]) if options[:sum]
+begin
+  table.reform(ARGV[0], ARGV[1], ARGV[2])           if options[:reform]
+rescue Tabmani::Table::DuplicateCellError => message
+  puts message
+end
+
+table.dump(style: options[:output],
+           io: $stdout,
+           just: options[:just],
+           separator: options[:out_separator]
+          )
+
+table.show_keys                        if options[:key]
+table.analyze(io: $stdout, keys: ARGV) if options[:analyze  ] 

data/lib/tabmani.rb

@@ -0,0 +1,6 @@
+
+class Tabmani; end
+
+require 'tefil'
+
+require 'tabmani/table.rb'

data/lib/tabmani/table.rb

@@ -0,0 +1,446 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+#INPUT_SEPARATOR = /\s+/
+
+#
+#
+#
+class Tabmani::Table < Tefil::TextFilterBase
+
+  attr_reader :matrix , :titles, :indent
+
+  class DuplicateCellError < StandardError; end
+  class ParseError < StandardError; end
+  class SymbolMismatchError < StandardError; end
+
+  def initialize(matrix: , indent: 0)
+    @matrix = matrix
+    @titles = nil
+    @indent = indent
+    @hlines = []
+  end
+
+  ## Wrapper for various parse method.
+  # style: :csv, :blank, or :column
+  # separator: option for separator style
+  def self.parse(io: , style: , separator: ',')
+    case style
+    when :csv    ; self.parse_csv(io)
+    when :blank  ; self.parse_blanks_separated_value(io)
+    when :column ; self.parse_column_based_value(io)
+    when :separator ; self.parse_separator(io, separator)
+    else;
+      raise ParseError, "Unknown style: #{style}"
+    end
+  end
+
+  ## CSV
+  def self.parse_csv(io)
+    self.new(matrix: CSV.parse(io))
+  end
+
+  def self.parse_separator(io, separator)
+
+    lines = io.readlines
+    matrix = lines.map { |line| line.chomp.split(separator) }
+    self.new(matrix: matrix)
+  end
+
+  ## blanks_separated_value
+  def self.parse_blanks_separated_value(io)
+    lines = io.readlines
+    indent = lines.map{|line| /^(\s*)/ =~ line; $1.length}.min
+    matrix = lines.map { |line| line.strip.split(/\s+/) }
+
+    lines.map { |line| line.strip.split(/\s+/) }
+
+    self.new(matrix: matrix, indent: indent)
+  end
+
+  ## column_based_value
+  # 縦に貫通する空白列を区切りにする。
+  # 各要素の空白は strip する。
+  def self.parse_column_based_value(io)
+    lines = io.readlines
+    return if lines.empty?
+    lines.map!      { |line| line.chomp  }
+    lines.delete_if { |line| line.empty? } # delete line consist of linefeed only.
+    ranges = self.get_ranges(self.projection_ary(lines))
+    matrix = lines.map { |line| ranges.map { |range| line[range].to_s.strip} }
+    self.new(matrix: matrix)
+  end
+
+  def self.dump_column_format(matrix:,
+                              hlines: [],
+                              io: $stdout,
+                              indent: 0,
+                              titles: nil,
+                              just: :left,
+                              separator: ' ')
+    matrix = [titles, * matrix] if titles
+    maxima =  self.max_lengths(matrix)
+    lines = matrix.map do |row|
+      self.line_str(items: row,
+                    lengths: maxima,
+                    separator: separator,
+                    just: just,
+                    indent: indent)
+    end
+    hlines.sort.reverse.each { |index| lines.insert(index, '-' * whole_length(matrix)) }
+    io.puts lines.join("\n")
+  end
+
+  def self.print_size(string)
+    string.each_char.map{|c| c.bytesize == 1 ? 1 : 2}.reduce(0, &:+)
+  end
+
+  # true の範囲を示す二重配列を返す。
+  # 各要素は 始点..終点 の各インデックスで出来た範囲。
+  ## 各要素は[始点, 終点] の各インデックス。
+  def self.get_ranges(ary)
+    results = []
+    start = nil
+    prev = false
+    ary << false # for true in final item
+    ary.each_with_index do |cur, i|
+      if prev == false && cur == true
+        start = i
+        prev = cur
+      elsif prev == true && cur == false
+        results << (start..(i - 1))
+        prev = cur
+      else
+        next
+      end
+    end
+    ary.pop
+    results
+  end
+
+  # 全ての文字列の最大長を要素数とする配列で、
+  # 空白文字以外があれば true, 全て空白文字ならば false にした配列。
+  def self.projection_ary(lines)
+    return [] if lines.empty?
+    max_length = lines.max_by{|line| line.size}.size
+    results = Array.new(max_length).fill(false)
+    lines.each do |line|
+      line.chomp.size.times do |i|
+        c = line[i]
+        next if results[i] == true
+        if c == ' '
+          next
+        else
+          results[i] = true
+        end
+      end
+    end
+    results
+  end
+
+  def self.padding(str: , width: , padding: ' ', place: :left)
+    output_width = str.each_char.map{|c| c.bytesize == 1 ? 1 : 2}.reduce(0, &:+)
+    padding_size = [0, width - output_width].max
+
+    case place
+    when :left   ; left = 0                ; right = padding_size
+    when :right  ; left = padding_size     ; right = 0
+    when :center ; left = padding_size / 2 ; right = padding_size - left
+    else
+      raise SymbolMismatchError, place
+    end
+    (padding * left) + str + (padding * right)
+  end
+
+  def self.whole_length(matrix)
+    result = 0
+    self.max_lengths(matrix).each { |l| result += l}
+    result += num_columns(matrix) - 1
+  end
+
+  def self.num_columns(matrix)
+    matrix.map{|items| items.size}.max
+  end
+
+  def self.line_str(items: ,
+                    lengths: ,
+                    lineend: nil,
+                    just: :left,
+                    indent: 0,
+                    separator: ' ')
+
+    new_items = []
+    lengths.each_with_index do |length, index|
+      item = items[index].to_s
+      new_items[index] = self.padding(str: item, width: lengths[index], place: just)
+    end
+    str = " " * indent
+    str += new_items.join(separator)
+    if lineend
+      str += lineend
+    else
+      str.sub!(/ +$/, "")
+    end
+    str
+  end
+
+  # return array of max size of item at index
+  def self.max_lengths(matrix)
+    results = []
+    matrix.each do |row|
+      row.each_with_index do |item, index|
+        item = item.to_s
+        results[index] ||= 0
+        size = Tabmani::Table.print_size(item)
+        results[index] = size if results[index] < size
+      end
+    end
+    results
+  end
+
+  ## Wrapper for various dump method.
+  def dump(io: , style: , just: :left, separator: ' ')
+    case style
+    when :column ; dump_column_format(io: io, just: just, separator: separator )
+    when :csv    ; dump_csv(io: io)
+    when :mds    ; dump_md_simple(io: io, just: just )
+    when :tex    ; dump_tex(io: io, just: just )
+    else
+      raise ParseError, "Unknown style: #{style}"
+    end
+  end
+
+  def dump_column_format(io: $stdout, just: :left, separator: ' ')
+    self.class.dump_column_format(matrix: @matrix,
+                                  hlines: @hlines,
+                                  titles: @titles,
+                                  io: io,
+                                  indent: @indent,
+                                  just: just,
+                                  separator: separator)
+  end
+
+  def dump_csv(io: )
+    matrix = @matrix
+    matrix = [@titles, * @matrix] if @titles
+    csv_string = CSV.generate do |csv|
+      matrix.each { |items| csv << items }
+    end
+    io.print csv_string
+  end
+
+  ## markdown simple table style
+  def dump_md_simple(io: $stdout, just: :left)
+    if @titles
+      matrix = [@titles, * @matrix] if @titles
+    else
+      matrix = @matrix.clone
+    end
+    matrix.insert(1, line_row)
+    self.class.dump_column_format(io: io, matrix: matrix, just: just)
+  end
+
+  def dump_tex(io: $stdout, just: :left)
+    case just
+    when :left   ; just_char = 'l'
+    when :right  ; just_char = 'r'
+    when :center ; just_char = 'c'
+    end
+
+    maxima = max_lengths
+    h_size = @matrix.map{|row| row.size }.max
+
+    io.puts "\\begin{tabular}{#{just_char * h_size }}"
+
+    lines = []
+    if @titles
+      lines << self.class.line_str(items: @titles,
+                    lengths: maxima,
+                    separator: " & ",
+                    just: just,
+                    lineend: ' \\\\',
+                    indent: 2)
+      @hlines << 1
+    end
+
+    @matrix.each do |row|
+      lines << self.class.line_str(items: row,
+                    lengths: maxima,
+                    separator: " & ",
+                    just: just,
+                    lineend: ' \\\\',
+                    indent: 2)
+    end
+    #@hlines = [0, maxima.size] if @hlines.empty?
+    @hlines << 0
+    @hlines << maxima.size
+    @hlines.sort.reverse.each do |index|
+      lines.insert(index, "  \\hline")
+    end
+    io.puts lines.join("\n")
+    io.puts "\\end{tabular}"
+  end
+
+  def show_keys(io: $stdout, separator: ' ')
+    matrix = []
+    matrix << line_row
+
+    tmp = []
+    max_lengths.size.times do |i|
+      tmp << (i + 1).to_s
+    end
+    matrix << tmp
+
+    self.class.dump_column_format(matrix: matrix, io: io, indent: @indent)
+  end
+
+  # transpose matrix.
+  # empty cell is filled by empty String, ''.
+  # thanks: http://www.tom08.net/entry/2017/12/21/125127
+  def transpose!
+    max_length = @matrix.max_by(&:size).size
+    @matrix = @matrix.map { |m| m.fill('', m.size, max_length - m.size) }.transpose
+  end
+
+  def transpose
+    result = Marshal.load(Marshal.dump(self))
+    result.transpose!
+    result
+  end
+
+  def filter!(key, val)
+    @matrix.select! do |items|
+      items[key.to_i - 1] == val
+    end
+  end
+
+  def filter(key, val)
+    result = Marshal.load(Marshal.dump(self))
+    result.filter!(key, val)
+    result
+  end
+
+  def reform(key_x, key_y, key_val)
+    x_index = key_x  .to_i - 1
+    y_index = key_y  .to_i - 1
+    v_index = key_val.to_i - 1
+
+    data_hash = {}
+    xs = []
+    ys = []
+    @matrix.each do |items|
+      next if items.empty?
+      x = items[x_index]
+      y = items[y_index]
+      v = items[v_index]
+      data_hash[y] ||= {}
+      raise DuplicateCellError, "Duplicated condition: #{x}, #{y}" if data_hash[y][x]
+      data_hash[y][x] = v
+      xs << x
+      ys << y
+    end
+
+    xs = xs.sort.uniq
+    ys = ys.sort.uniq
+    matrix = []
+    matrix << [''] + xs
+    ys.each do |y|
+      items = []
+      items << y
+      xs.each { |x| items << data_hash[y][x] }
+      matrix << items
+    end
+    @matrix = matrix
+  end
+
+  # return array of max size of item at index
+  def max_lengths
+    matrix = @matrix
+    matrix = [@titles, * @matrix] if @titles
+    self.class.max_lengths(matrix)
+  end
+
+
+  def analyze(io: , keys:)
+    io.puts
+
+    unless @titles
+      @titles = []
+      num_columns.times do |i|
+        @titles[i] = @matrix[0][i].to_s
+      end
+    end
+
+    if @matrix.size != 0
+      results = []
+      results << %w(key head types)
+      @titles.size.times do |i|
+        results << [(i+1).to_s, @titles[i].strip,
+          @matrix.map {|items| items[i]}.sort_by{|j| j.to_s}.uniq.size.to_s
+        ]
+      end
+      Tabmani::Table.dump_column_format(matrix: results, io: io)
+    end
+
+    unless keys.empty?
+      io.puts
+      io.puts "key analysis"
+      keys.each do |key|
+        io.puts "(key=#{key})"
+        values = @matrix.map{|items| items[key.to_i-1] }
+        names = values.sort.uniq
+        results = []
+        names.each { |name| results << [name, values.count(name).to_s] }
+        results.sort_by!{|v| v[1].to_i}
+        Tabmani::Table.dump_column_format(matrix: results, io: io)
+        io.puts
+      end
+    end
+  end
+
+  def add_sum(key)
+    index = key.to_i - 1
+    sum = 0
+    @matrix.each do |items|
+      str = items[index]
+      if str.include?('.')
+        sum += str.to_f
+      else
+        sum += str.to_i
+      end
+    end
+    items = Array.new(num_columns).fill('')
+    items[index] = sum.to_s
+    add_hline( @matrix.size)
+    @matrix << items
+  end
+
+  # num is the index of row number below the horizontal line.
+  def add_hline(num)
+    @hlines << num
+  end
+
+  # delete spaces head or tail in each items. Destructive
+  def strip
+    @matrix.map! do |items|
+      items.map {|str| str.strip}
+    end
+  end
+
+  def set_title
+    @titles = @matrix.shift
+  end
+
+  private
+
+  def line_row
+    max_lengths.map {|i| '-' * i}
+  end
+
+  def num_columns
+    self.class.num_columns(@matrix)
+  end
+
+end
+
+