solvebio 1.6.1 → 1.7.0

data/lib/resource/main.rb

@@ -1,123 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require_relative 'solveobject'
-require_relative 'annotation'
-require_relative 'apiresource'
-require_relative 'dataset'
-require_relative 'datasetfield'
-require_relative 'depository'
-require_relative 'depositoryversion'
-require_relative 'sample'
-require_relative 'user'
-
-class SolveBio::ListObject < SolveBio::SolveObject
-
-    include Enumerable
-
-    def all(params={})
-        return request('get', self['url'], {:params => params})
-    end
-
-    def create(params={})
-        return request('post', self['url'], {:params => params})
-    end
-
-    def next_page(params={})
-        if self['links']['next']
-            return request('get', self['links']['next'], {:params => params})
-        end
-        return nil
-    end
-
-    def prev_page(params={})
-        if self['links']['prev']
-            request('get', self['links']['prev'], {:params => params})
-        end
-        return nil
-    end
-
-    def at(i)
-        self.to_a[i]
-    end
-
-    def to_a
-        return to_solve_object(self['data'])
-    end
-
-    def each(*pass)
-        return self unless block_given?
-        i = 0
-        ary = self.dup
-        done = false
-        until done
-            if i >= ary['data'].size
-                ary = next_page
-                break unless ary
-                i = 0
-            end
-            yield(ary.at(i))
-            i += 1
-        end
-        return self
-    end
-
-    def first
-        self['data'][0]
-    end
-
-    # def max
-    #     self['data'][self['total']]
-    # end
-
-end
-
-
-SolveBio::SolveObject::CONVERSION = {
-    'Annotation'        => SolveBio::Annotation,
-    'Depository'        => SolveBio::Depository,
-    'DepositoryVersion' => SolveBio::DepositoryVersion,
-    'Dataset'           => SolveBio::Dataset,
-    'DatasetField'      => SolveBio::DatasetField,
-    'Sample'            => SolveBio::Sample,
-    'User'              => SolveBio::User,
-    'list'              => SolveBio::ListObject
-}
-
-if __FILE__ == $0
-    puts '-' * 50
-    resp = {
-        'class_name' => 'Dataset',
-        'data_url'   => 'https://api.solvebio.com/v1/datasets/25/data',
-        'depository' => 'ClinVar',
-        'depository_id' => 223,
-        'depository_version' => 'ClinVar/2.0.0-1',
-        'depository_version_id' => 15,
-        'description' => '',
-        'fields_url' => 'https://api.solvebio.com/v1/datasets/25/fields',
-        'full_name' => 'ClinVar/2.0.0-1/Variants',
-        'id'  => 25,
-        'name' => 'Variants',
-        'title' => 'Variants',
-        'url' => 'https://api.solvebio.com/v1/datasets/25'
-    }
-    so = to_solve_object(resp)
-    so = resp.to_solvebio
-    puts so.inspect
-    puts so.to_s
-
-    if ARGV[0]
-        require_relative './cli/auth.rb'
-        include SolveBio::Auth
-        login
-        puts '-' * 30, ' HELP ', '-' * 30
-        puts SolveBio::Depository.retrieve('ClinVar').help
-        puts '-' * 30, ' Retrieve ClinVar ','-' * 30
-        puts SolveBio::Depository.retrieve('ClinVar').to_s
-        puts '-' * 30, ' Versions ClinVar ','-' * 30
-        puts SolveBio::Depository.retrieve('Clinvar').versions.to_s
-        puts '-' * 30, ' Dataset  ','-' * 30
-        puts SolveBio::Dataset.retrieve('Clinvar/2.0.0-1/Variants').to_s
-        puts '-' * 30, ' All Depository  ','-' * 30
-        puts SolveBio::Depository.all.to_s
-    end
-end

data/lib/resource/sample.rb

@@ -1,75 +0,0 @@
-# Solvebio API Resource for Samples
-require_relative 'apiresource'
-require_relative 'solveobject'
-require_relative '../errors'
-
-#  Samples are VCF files uploaded to the SolveBio API. We currently
-#  support uncompressed, extension `.vcf`, and gzip-compressed, extension
-#   `.vcf.gz`, VCF files. Any other extension will be rejected.
-class SolveBio::Sample < SolveBio::APIResource
-
-    include SolveBio::DeletableAPIResource
-    include SolveBio::DownloadableAPIResource
-    include SolveBio::ListableAPIResource
-    include SolveBio::HelpableAPIResource
-
-    def annotate
-        SolveBio::Annotation.create :sample_id => self.id
-    end
-
-    # FIXME: Rubyize APIResource.retrieve
-    def self.retrieve(id, params={})
-        SolveBio::APIResource.retrieve(self, id)
-    end
-
-    def self.create(genome_build, params={})
-        if params.member?(:vcf_url)
-            if params.member?(:vcf_file)
-                raise TypeError,
-                'Specified both vcf_url and vcf_file; use only one'
-            end
-            self.create_from_url(genome_build, params[:vcf_url])
-        elsif params.member?(:vcf_file)
-            return create_from_file(genome_build, params[:vcf_file])
-        else
-            raise TypeError,
-            'Must specify exactly one of vcf_url or vcf_file parameter'
-        end
-    end
-
-    # Creates from the specified file.  The data of the should be in
-    # VCF format.
-    def self.create_from_file(genome_build, vcf_file)
-
-        fh = File.open(vcf_file, 'rb')
-        params = {:genome_build  => genome_build,
-                  :vcf_file => fh}
-        response = SolveBio::Client.client.post(class_url(self), params,
-                                                :no_json => true)
-        to_solve_object(response)
-    end
-
-    # Creates from the specified URL.  The data of the should be in
-    # VCF format.
-    def self.create_from_url(genome_build, vcf_url)
-
-        params = {:genome_build  => genome_build,
-                  :vcf_url       => vcf_url}
-        begin
-            response = SolveBio::Client.client.post class_url(self), params
-        rescue SolveBio::Error => response
-        end
-        to_solve_object(response)
-    end
-end
-
-if __FILE__ == $0
-    unless SolveBio::API_HOST == 'https://api.solvebio.com'
-        SolveBio::SolveObject::CONVERSION = {
-            'Sample' => SolveBio::Sample,
-        } unless defined? SolveBio::SolveObject::CONVERSION
-        url = 'http://downloads.solvebio.com/vcf/small_sample.vcf.gz'
-        response = SolveBio::Sample.create_from_url 'hg19', url
-        puts response
-    end
-end

data/lib/resource/solveobject.rb

@@ -1,122 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'json'
-require 'set'
-require_relative '../client'
-
-# Base class for all SolveBio API resource objects
-class SolveBio::SolveObject < Hash
-
-    ALLOW_FULL_NAME_ID = false  # Treat full_name parameter as an ID?
-
-    attr_reader :unsaved_values
-
-    def allow_full_name_id
-        self.class.const_get(:ALLOW_FULL_NAME_ID)
-    end
-
-    def initialize(id=nil, params={})
-
-        super()
-        # store manually updated values for partial updates
-        @unsaved_values = Set.new
-
-        if id
-            self['id'] = id
-        elsif allow_full_name_id and params['full_name']
-            self['full_name'] = params['full_name']
-            # no ID was provided so temporarily set the id as full_name
-            # this will get updated when the resource is refreshed
-            self['id'] = params['full_name']
-        end
-    end
-
-    # Element Reference — Retrieves the value object corresponding to the key object.
-    # Note: *key* is turned into a string before access, because the underlying key type
-    # is a string.
-    def [](key)
-        super(key.to_s)
-    end
-
-    def self.construct_from(cls, values)
-        instance = cls.new(values['id'])
-        instance.refresh_from(values)
-        instance
-    end
-
-    def refresh_from(values)
-        self.clear()
-        @unsaved_values = Set.new
-        values.each { |k, v| self[k] = to_solve_object(v) }
-    end
-
-    def request(method, url, params={})
-        response = SolveBio::Client.client
-            .request method, url, {:params => params}
-        to_solve_object(response)
-    end
-
-    def inspect
-        ident_parts = [self.class]
-
-        if self['id'].kind_of?(Integer)
-            ident_parts << "id=#{self['id']}"
-        end
-
-        if allow_full_name_id and self['full_name']
-            ident_parts << "full_name=#{self['full_name']}"
-        end
-
-        '<%s:%x> JSON: %s' % [ident_parts.join(' '),
-                              self.object_id, self.to_json]
-
-    end
-
-    def to_s
-        # No equivalent of Python's json sort_keys?
-        JSON.pretty_generate(self, :indent => '  ')
-        # self.to_json json.dumps(self, sort_keys=true, indent=2)
-    end
-
-    # @property
-    def id
-        self['id']
-    end
-end
-
-class Hash
-    def to_solvebio(klass=nil)
-        resp = self.dup()
-        if ! klass
-            klass_name ||= resp['class_name']
-            if klass_name.kind_of?(String)
-                klass = SolveBio::SolveObject::CONVERSION[klass_name] ||
-                        SolveBio::SolveObject
-            else
-                klass = SolveBio::SolveObject
-            end
-        end
-        SolveBio::SolveObject::construct_from(klass, resp)
-    end
-end
-
-class Array
-    def to_solvebio
-        return self.map{|i| to_solve_object(i)}
-    end
-end
-
-def to_solve_object(resp)
-    if resp.kind_of?(Array) or
-            (not resp.kind_of? SolveBio::SolveObject and resp.kind_of?(Hash))
-        resp.to_solvebio
-    else
-        return resp
-    end
-end
-
-if __FILE__ == $0
-    puts SolveBio::SolveObject.new.inspect
-    puts SolveBio::SolveObject.new(64).inspect
-
-end

data/lib/resource/user.rb

@@ -1,5 +0,0 @@
-require_relative 'apiresource'
-
-class SolveBio::User < SolveBio::APIResource
-    include SolveBio::SingletonAPIResource
-end

data/lib/tabulate.rb

@@ -1,706 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This file contains code from python-tabulate, modified for SolveBio
-#
-# Copyright © 2011-2013 Sergey Astanin
-#
-# 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.
-
-# from __future__ require 'print_function'
-# from __future__ require 'unicode_literals'
-
-# from collections require 'namedtuple'
-# from platform require 'python_version_tuple'
-
-# if python_version_tuple()[0] < "3"
-#     from itertools require 'izip_longest'
-#     _none_type = type(nil)
-#     _int_type = int
-#     _float_type = float
-#     _text_type = unicode
-#     _binary_type = str
-# else
-#     from itertools require 'zip_longest as izip_longest'
-#     from functools require 'reduce'
-#     _none_type = type(nil)
-#     _int_type = int
-#     _float_type = float
-#     _text_type = str
-#     _binary_type = bytes
-# end
-
-
-require_relative 'main'
-
-module SolveBio::Tabulate
-
-    VERSION = '0.6'
-
-    TYPES = {NilClass => 0, Fixnum => 1, Float => 2, String => 4}
-
-    INVISIBILE_CODES = %r{\\x1b\[\d*m}  # ANSI color codes
-
-    Line = Struct.new(:start, :hline, :sep, :last)
-
-    DataRow = Struct.new(:start, :sep, :last)
-
-    TableFormat = Struct.new(:lineabove, :linebelowheader,
-                             :linebetweenrows, :linebelow,
-                             :headerrow, :datarow,
-                             :padding, :usecolons,
-                             :with_header_hide,
-                             :without_header_hide)
-
-    FORMAT_DEFAULTS = {
-        :padding             => 0,
-        :usecolons           => false,
-        :with_header_hide    => [],
-        :without_header_hide => []
-    }
-
-
-    INVTYPES = {
-        4 => String,
-        2 => Float,
-        1 => Fixnum,
-        0 => NilClass
-    }
-
-    SIMPLE_DATAROW = DataRow.new('', '  ', '')
-    PIPE_DATAROW   = DataRow.new('|', '|', '|')
-
-    SIMPLE_LINE    = Line.new('', '-', '  ', '')
-    GRID_LINE      = Line.new('+', '-', '+', '+')
-
-    TABLE_FORMATS = {
-        :simple =>
-        TableFormat.new(lineabove           = nil,
-                        linebelowheader     = SIMPLE_LINE,
-                        linebetweenrows     = nil,
-                        linebelow           = SIMPLE_LINE,
-                        headerrow           = SIMPLE_DATAROW,
-                        datarow             = SIMPLE_DATAROW,
-                        padding             = 0,
-                        usecolons           = false,
-                        with_header_hide    = ['linebelow'],
-                        without_header_hide = []),
-        :grid =>
-        TableFormat.new(lineabove           = SIMPLE_LINE,
-                        linebelowheader     = Line.new('+', '=', '+', '+'),
-                        linebetweenrows     = SIMPLE_LINE,
-                        linebelow           = SIMPLE_LINE,
-                        headerrow           = PIPE_DATAROW,
-                        datarow             = PIPE_DATAROW,
-                        padding             = 1,
-                        usecolons           = false,
-                        with_header_hide    = [],
-                        without_header_hide = ['linebelowheader']),
-
-        :pipe =>
-        TableFormat.new(lineabove           = nil,
-                        linebelowheader     = Line.new('|', '-', '|', '|'),
-                        linebetweenrows     = nil,
-                        linebelow           = nil,
-                        headerrow           = PIPE_DATAROW,
-                        datarow             = PIPE_DATAROW,
-                        padding             = 1,
-                        usecolons           = true,
-                        with_header_hide    = [],
-                        without_header_hide = []),
-
-        :orgmode =>
-        TableFormat.new(lineabove=nil,
-                        linebelowheader     = Line.new('|', '-', '+', '|'),
-                        linebetweenrows     = nil,
-                        linebelow           = nil,
-                        headerrow           = PIPE_DATAROW,
-                        datarow             = PIPE_DATAROW,
-                        padding             = 1,
-                        usecolons           = false,
-                        with_header_hide    = [],
-                        without_header_hide = ['linebelowheader'])
-    }
-
-    module_function
-    def simple_separated_format(separator)
-        # FIXME? python code hard-codes separator = "\n" below.
-        return TableFormat
-            .new(
-                 :lineabove        => nil,
-                 :linebelowheader  => nil,
-                 :linebetweenrows  => nil,
-                 :linebelow        => nil,
-                 :headerrow        => nil,
-                 :datarow          => DataRow.new('', separator, ''),
-                 :padding          => 0,
-                 :usecolons        => false,
-                 :with_header_hide => [],
-                 :without_header_hide => [],
-                 )
-    end
-
-    # The least generic type, one of NilClass, Fixnum, Float, or String.
-    # _type(nil)   => NilClass
-    # _type("foo") => String
-    # _type("1")   => Fixnum
-    # _type("\x1b[31m42\x1b[0m") => Fixnum
-    def _type(obj, has_invisible=true)
-
-        obj = obj.strip_invisible if obj.kind_of?(String) and has_invisible
-
-        if obj.nil?
-            return NilClass
-        elsif obj.kind_of?(Fixnum) or obj.int?
-            return Fixnum
-        elsif obj.kind_of?(Float) or obj.number?
-            return Float
-        else
-            return String
-        end
-    end
-
-    # [string] -> [padded_string]
-    #
-    #    align_column(
-    #        ["12.345", "-1234.5", "1.23", "1234.5",
-    #         "1e+234", "1.0e234"], "decimal") =>
-    #    ['   12.345  ', '-1234.5    ', '    1.23   ',
-    #     ' 1234.5    ', '    1e+234 ', '    1.0e234']
-    def align_column(strings, alignment, minwidth=0, has_invisible=true)
-        if alignment == "right"
-            strings = strings.map{|s| s.to_s.strip}
-            padfn = :padleft
-        elsif alignment == 'center'
-            strings = strings.map{|s| s.to_s.strip}
-            padfn = :padboth
-        elsif alignment == 'decimal'
-            decimals = strings.map{|s| s.to_s.afterpoint}
-            maxdecimals = decimals.max
-            zipped = strings.zip(decimals)
-            strings = zipped.map{|s, decs|
-                s.to_s + " " * ((maxdecimals - decs))
-            }
-            padfn = :padleft
-        else
-            strings = strings.map{|s| s.to_s.strip}
-            padfn = :padright
-        end
-
-        if has_invisible
-            width_fn = :visible_width
-        else
-            width_fn = :size
-        end
-
-        maxwidth = [strings.map{|s| s.send(width_fn)}.max, minwidth].max
-        strings.map{|s| s.send(padfn, maxwidth, has_invisible) }
-    end
-
-
-    def more_generic(type1, type2)
-        moregeneric = [TYPES[type1] || 4, TYPES[type2] || 4].max
-        return INVTYPES[moregeneric]
-    end
-
-
-    # The least generic type all column values are convertible to.
-    #
-    #  column_type(["1", "2"]) => Fixnum
-    #  column_type(["1", "2.3"]) => Float
-    #  column_type(["1", "2.3", "four"]) => String
-    #  column_type(["four", '\u043f\u044f\u0442\u044c']) => String
-    #  column_type([nil, "brux"]) => String
-    #  column_type([1, 2, nil]) => Fixnum
-    def column_type(strings, has_invisible=true)
-        types = strings.map{|s| _type(s, has_invisible)}
-        # require 'trepanning'; debugger
-        return types.reduce(Fixnum){
-            |t, result|
-            more_generic(result, t)
-        }
-    end
-
-
-    # Format a value accoding to its type.
-    #
-    #  Unicode is supported:
-    #
-    #  >>> hrow = ["\u0431\u0443\u043a\u0432\u0430",
-    #              "\u0446\u0438\u0444\u0440\u0430"]
-    #      tbl = [["\u0430\u0437", 2], ["\u0431\u0443\u043a\u0438", 4]]
-    #      expected = "\\u0431\\u0443\\u043a\\u0432\\u0430      \n
-    #                  \\u0446\\u0438\\u0444\\u0440\\u0430\\n-------\n
-    #                   -------\\n\\u0430\\u0437             \n
-    #                   2\\n\\u0431\\u0443\\u043a\\u0438           4'
-    #      tabulate(tbl, hrow) => good_result
-    #  true
-    def format(val, valtype, floatfmt, missingval="")
-        if val.nil?
-            return missingval
-        end
-
-        if [Fixnum, String, Fixnum].member?(valtype)
-            return "%s" % val
-        elsif valtype.kind_of?(Float)
-            return "%#{floatfmt}" % Float(val)
-        else
-            return "%s" % val
-        end
-    end
-
-
-    def align_header(header, alignment, width)
-        if alignment == "left"
-            return header.padright(width)
-        elsif alignment == "center"
-            return header.padboth(width)
-        else
-            return header.padleft(width)
-        end
-    end
-
-
-    # Transform a supported data type to an Array of Arrays, and an
-    # Array of headers.
-    #
-    #    Supported tabular data types:
-    #
-    #    * Array-of-Arrays or another Enumerable of Enumerables
-    #
-    #    * Hash of Enumerables
-    #
-    #    The first row can be used as headers if headers="firstrow",
-    #    column indices can be used as headers if headers="keys".
-    #
-    def normalize_tabular_data(tabular_data, headers)
-        if tabular_data.respond_to?(:keys) and tabular_data.respond_to?(:values)
-            # likely a Hash
-            keys = tabular_data.keys
-            ## FIXME: what's different in the Python code?
-            # columns have to be transposed
-            # rows = list(izip_longest(*tabular_data.values()))
-            # rows = vals[0].zip(*vals[1..-1])
-            rows = tabular_data.values
-            if headers == "keys"
-                # headers should be strings
-                headers = keys.map{|k| k.to_s}
-            end
-        elsif tabular_data.kind_of?(Enumerable)
-            # Likely an Enumerable of Enumerables
-            rows = tabular_data.to_a
-            if headers == "keys" and not rows.empty?  # keys are column indices
-                headers = (0..rows[0]).map {|i| i.to_s}
-            end
-        else
-            raise(ValueError, "tabular data doesn't appear to be a Hash" +
-                  " or Array")
-        end
-
-        # take headers from the first row if necessary
-        if headers == "firstrow" and not rows.empty?
-            headers = rows[0].map{|row| [_text_type(row)]}
-            rows.shift
-        end
-
-        # pad with empty headers for initial columns if necessary
-        if not headers.empty?  and not rows.empty?
-            nhs = headers.size
-            ncols = rows[0].size
-            if nhs < ncols
-                headers = [''] * (ncols - nhs) + headers
-            end
-        end
-
-        return rows, headers
-    end
-
-    TTY_COLS = ENV['COLUMNS'].to_i || 80 rescue 80
-    # Return a string which represents a row of data cells.
-    def build_row(cells, padding, first, sep, last)
-
-        pad = ' ' * padding
-        padded_cells = cells.map{|cell| pad + cell + pad }
-
-        # SolveBio: we're only displaying Key-Value tuples (dimension of 2).
-        #  enforce that we don't wrap lines by setting a max
-        #  limit on row width which is equal to TTY_COLS (see printing)
-        rendered_cells = (first + padded_cells.join(sep) + last).rstrip
-        if rendered_cells.size > TTY_COLS
-            if not cells[-1].end_with?(' ') and not cells[-1].end_with?('-')
-                terminating_str = ' ... '
-            else
-                terminating_str = ''
-            end
-            prefix = rendered_cells[1..TTY_COLS - terminating_str.size - 1]
-            rendered_cells = "%s%s%s" % [prefix, terminating_str, last]
-        end
-
-        return rendered_cells
-    end
-
-
-    # Return a string which represents a horizontal line.
-    def build_line(colwidths, padding, first, fill, sep, last)
-        cells = colwidths.map{|w| fill * (w + 2 * padding)}
-        return build_row(cells, 0, first, sep, last)
-    end
-
-
-    #  Return a segment of a horizontal line with optional colons which
-    #  indicate column's alignment (as in `pipe` output format).
-    def _line_segment_with_colons(linefmt, align, colwidth)
-        fill = linefmt.hline
-        w = colwidth
-        if ['right', 'decimal'].member?(align)
-            return (fill[0] * (w - 1)) + ":"
-        elsif align == "center"
-            return ":" + (fill[0] * (w - 2)) + ":"
-        elsif align == "left"
-            return ":" + (fill[0] * (w - 1))
-        else
-            return fill[0] * w
-        end
-    end
-
-
-    # Produce a plain-text representation of the table.
-    def format_table(fmt, headers, rows, colwidths, colaligns)
-        lines = []
-        hidden = headers ? fmt.with_header_hide : fmt.without_header_hide
-        pad = fmt.padding || 0
-        datarow = fmt.datarow ? fmt.datarow : SIMPLE_DATAROW
-        headerrow = fmt.headerrow ? fmt.headerrow : fmt.datarow
-
-        if fmt.lineabove and hidden and hidden.member?("lineabove")
-            lines << build_line(colwidths, pad, *fmt.lineabove)
-        end
-
-        unless headers.empty?
-            lines << build_row(headers, pad, headerrow.start, headerrow.sep,
-                               headerrow.last)
-        end
-
-        if fmt.linebelowheader and not hidden.member?("linebelowheader")
-            first, _, sep, last = fmt.linebelowheader
-            if fmt.usecolons
-                segs = [
-                        colwidths.zip(colaligns).map do |w, a|
-                            _line_segment_with_colons(fmt.linebelowheader, a, w + 2 * pad)
-                        end ]
-                lines << build_row(segs, 0, first, sep, last)
-            else
-                lines << build_line(colwidths, pad, fmt.linebelowheader.start,
-                                    fmt.linebelowheader.hline,
-                                    fmt.linebelowheader.sep,
-                                    fmt.linebelowheader.last)
-            end
-        end
-
-        if rows and fmt.linebetweenrows and hidden.member?('linebetweenrows')
-            # initial rows with a line below
-            rows[1..-1].each do |row|
-                lines << build_row(row, pad, fmt.datarow.start,
-                                   fmt.datarow.sep, fmt.datarow.last)
-                lines << build_line(colwidths, pad, fmt.linebetweenrows.start,
-                                    fmt.linebelowheader.hline,
-                                    fmt.linebetweenrows.sep,
-                                    fmt.linebetweenrows.last)
-            end
-            # the last row without a line below
-            lines << build_row(rows[-1], pad, datarow.start,
-                                datarow.sep, datarow.last)
-        else
-            rows.each do |row|
-                lines << build_row(row, pad, datarow.start, datarow.sep,
-                                   datarow.last)
-
-                if fmt.linebelow and hidden.member?('linebelow')
-                    lines << build_line(colwidths, pad, fmt.linebelow.start,
-                                        fmt.linebelowheader.hline,
-                                        fmt.linebelow.sep,
-                                        fmt.linebelow.last)
-                end
-            end
-        end
-        return lines.join("\n")
-    end
-
-    # Construct a simple TableFormat with columns separated by a separator.
-    #
-    #   tsv = simple_separated_format("\t")
-    #   tabulate([["foo", 1], ["spam", 23]], [], tsv) =>
-    #     "foo    1\nspam  23"
-    def tabulate(tabular_data, headers=[], tablefmt=TABLE_FORMATS[:orgmode],
-                 floatfmt="g", aligns=[], missingval='')
-        list_of_lists, headers = normalize_tabular_data(tabular_data, headers)
-
-        # optimization: look for ANSI control codes once,
-        # enable smart width functions only if a control code is found
-        plain_rows = [headers.map{|h| h.to_s}.join("\t")]
-        row_text = list_of_lists.map{|row|
-            row.map{|r| r.to_s}.join("\t")
-        }
-        plain_rows += row_text
-        plain_text = plain_rows.join("\n")
-
-        has_invisible = INVISIBILE_CODES.match(plain_text)
-        if has_invisible
-            width_fn = :visible_width
-        else
-            width_fn = :size
-        end
-
-        # format rows and columns, convert numeric values to strings
-        cols = list_of_lists[0].zip(*list_of_lists[1..-1]) if
-            list_of_lists.size > 1
-
-        coltypes = cols.map{|c| column_type(c)}
-
-        cols = cols.zip(coltypes).map do |c, ct|
-            c.map{|v| format(v, ct, floatfmt, missingval)}
-        end
-
-        # align columns
-        if aligns.empty?
-            # dynamic alignment by col type
-            aligns = coltypes.map do |ct|
-                [Fixnum, Float].member?(ct) ? 'decimal' : 'left'
-            end
-        end
-
-        minwidths =
-            if headers.empty?  then
-                [0] * cols.size
-            else
-                headers.map{|h| h.send(width_fn) + 2}
-            end
-
-        cols = cols.zip(aligns, minwidths).map do |c, a, minw|
-            align_column(c, a, minw, has_invisible)
-        end
-
-        if headers.empty?
-            minwidths = cols.map{|c| c[0].send(width_fn)}
-        else
-            # align headers and add headers
-            minwidths =
-                minwidths.zip(cols).map{|minw, c| [minw, c[0].send(width_fn)].max}
-            headers   =
-                headers.zip(aligns, minwidths).map{|h, a, minw| align_header(h, a, minw)}
-        end
-        rows = cols[0].zip(cols[1])
-
-        tablefmt = TABLE_FORMATS[:orgmode] unless
-            tablefmt.kind_of?(TableFormat)
-
-        # make sure values don't have newlines or tabs in them
-        rows = rows.each do |r|
-            r[1] = r[1].gsub("\n", '').gsub("\t", '')
-        end
-        return format_table(tablefmt, headers, rows, minwidths, aligns)
-    end
-end
-
-class Object
-
-    # "123.45".number? => true
-    # "123".number?    => true
-    # "spam".number?   => false
-    def number?
-        begin
-            Float(self)
-            return true
-        rescue
-            return false
-        end
-    end
-
-    # "123".int?    => true
-    # "123.45".int? => false
-    def int?
-        begin
-            Integer(self)
-            return true
-        rescue
-            return false
-        end
-    end
-end
-
-class String
-
-    # Symbols after a decimal point, -1 if the string lacks the decimal point.
-    #
-    #  "123.45".afterpoint =>  2
-    #  "1001".afterpoint   => -1
-    #  "eggs".afterpoint   => -1
-    #  "123e45".afterpoint =>  2
-    def afterpoint
-        if self.number?
-            if self.int?
-                return -1
-            else
-                pos = self.rindex('.') || -1
-                pos = self.downcase().rindex('e') if pos < 0
-                if pos >= 0
-                    return self.size - pos - 1
-                else
-                    return -1  # no point
-                end
-            end
-        else
-            return -1  # not a number
-        end
-    end
-
-    def adjusted_size(has_invisible)
-        return has_invisible ? self.strip_invisible.size : self.size
-    end
-
-    # Visible width of a printed string. ANSI color codes are removed.
-    #
-    #  ['\x1b[31mhello\x1b[0m' "world"].map{|s| s.visible_width} =>
-    #  [5, 5]
-    def visible_width
-        # if self.kind_of?(_text_type) or self.kind_of?(_binary_type)
-            return self.strip_invisible.size
-        # else
-        #    return _text_type(s).size
-        # end
-    end
-
-
-    # Flush right.
-    #
-    #    '\u044f\u0439\u0446\u0430'.padleft(6) =>
-    #    '  \u044f\u0439\u0446\u0430'
-    #    'abc'.padleft(2) => 'abc'
-    def padleft(width, has_invisible=true)
-        s_width = self.adjusted_size(has_invisible)
-        s_width < width ? (' ' * (width - s_width)) + self : self
-    end
-
-    # Flush left.
-    #
-    #   padright(6, '\u044f\u0439\u0446\u0430') => '\u044f\u0439\u0446\u0430  '
-    #   padright(2, 'abc') => 'abc'
-    def padright(width, has_invisible=true)
-        s_width = self.adjusted_size(has_invisible)
-        s_width < width ? self + (' ' * (width - s_width)) : self
-    end
-
-
-    # Center string with uneven space on the right
-    #
-    #  '\u044f\u0439\u0446\u0430'.padboth(6) => ' \u044f\u0439\u0446\u0430 '
-    #  'abc'.padboth(2) => 'abc'
-    #  'abc'.padboth(6) => ' abc  '
-    def padboth(width, has_invisible=true)
-        s_width = self.adjusted_size(has_invisible)
-        return self if s_width >= width
-        pad_size   = width - s_width
-        pad_left   = ' ' * (pad_size/2)
-        pad_right  = ' ' * ((pad_size + 1)/ 2)
-        pad_left + self + pad_right
-    end
-
-
-    # Remove invisible ANSI color codes.
-    def strip_invisible
-        return self.gsub(SolveBio::Tabulate::INVISIBILE_CODES, '')
-    end
-
-end
-
-if __FILE__ == $0
-    include SolveBio::Tabulate
-    # puts '" 123.45".num? %s'    % "123.45".number?() # true
-    # puts "'123'.num?: %s"       % '123'.number?      # true
-    # puts "'spam'.num? spam: %s" % "spam".number?     # false
-    # puts "'123'.int? %s"        %  "123".int?        # true
-    # puts "'123.45'int?: %s"     % '124.45'.int?      # false
-
-    # puts "_type(nil) %s = %s" % [_type(nil), NilClass]
-    # puts "_type('foo') %s = %s" % [_type('foo'), String]
-    # puts "_type('1') %s = %s" % [_type('1'), Fixnum]
-    # puts "_type(''\x1b[31m42\x1b[0m') %s = %s" % [_type('\x1b[31m42\x1b[0m'), Fixnum]
-
-    # puts "'123.45'.afterpoint:   2 == %d" % '123.45'.afterpoint
-    # puts "'1001'afterpoint   :  -1 == %d" % '1001'.afterpoint
-    # puts "'eggs'.afterpoint  :  -1 == %d" % 'eggs'.afterpoint
-    # puts "'123e45'.afterpoint:   2 == %d" % "123e45".afterpoint
-
-    # puts("'\u044f\u0439\u0446\u0430'.padleft(6) = '%s' == '%s'" %
-    #      ["\u044f\u0439\u0446\u0430".padleft(6),
-    #      "  \u044f\u0439\u0446\u0430"])
-    # puts("'abc'.padleft(2) = '%s' == '%s'" %
-    #      ['abc'.padleft(2), 'abc'])
-    # puts("padright(2, 'abc') = '%s' == '%s'" %
-    #      ['abc'.padright(2), 'abc'])
-    # puts("'abc'.padboth(2) = '%s' == '%s'" %
-    #      ['abc'.padboth(2), 'abc'])
-    # puts("'abc'.padboth(6) = '%s' == '%s'" %
-    #      ['abc'.padboth(6), ' abc  '])
-
-    # puts align_column(
-    #                   ["12.345", "-1234.5", "1.23", "1234.5",
-    #                    "1e+234", "1.0e234"], "decimal")
-
-    # puts '=' * 30
-    # puts ['   12.345  ', '-1234.5    ', '    1.23   ',
-    #      ' 1234.5    ', '    1e+234 ', '    1.0e234']
-
-    # puts('column_type(["1", "2"]) is Fixnum == %s ' %
-    #      column_type(["1", "2"]))
-    # puts('column_type(["1", "2.3"]) is Float == %s ' %
-    #      column_type(["1", "2.3"]))
-    # puts('column_type(["1", "2.3", "four"]) is String => %s ' %
-    #      column_type(["1", "2.3", "four"]))
-    # puts('column_type(["four", "\u043f\u044f\u0442\u044c"]) is text => %s ' %
-    #      column_type(["four", "\u043f\u044f\u0442\u044c"]))
-    # puts('column_type([nil, "brux"]) is String => %s ' %
-    #      column_type([nil, "brux"]))
-    # puts('column_type([1, 2, nil]) is Fixnum => %s ' %
-    #      column_type([1, 2, nil]))
-    # tsv = simple_separated_format("\t")
-    # puts tabulate([["foo", 1], ["spam", 23]], [], tsv)
-    # hrow = ["\u0431\u0443\u043a\u0432\u0430", "\u0446\u0438\u0444\u0440\u0430"]
-    # tbl = [["\u0430\u0437", 2], ["\u0431\u0443\u043a\u0438", 4]]
-    # puts SolveBio::Tabulate.tabulate(tbl, hrow)
-
-    hash = {
-        "rcvaccession_version"=>2,
-        "hg18_chromosome"=>"3",
-        "hg19_start"=>148562304,
-        "rcvaccession"=>"RCV000060731",
-        "hg38_start"=>148844517,
-        "reference_allele"=>"C",
-        "gene_symbols"=>["CPB1"],
-        "rsid"=>"rs150241322",
-        "hg19_chromosome"=>"3",
-        "hgvs"=>["NC_000003.12:g.148844517C>T"],
-        "clinical_significance"=>"other",
-        "alternate_alleles"=>["T"],
-        "clinical_origin"=>["somatic"],
-        "type"=>"SNV"}
-    puts SolveBio::Tabulate.tabulate(hash.to_a,
-                                     ['Fields', 'Data'],
-                                     ['right', 'left'])
-end