bioinform 0.1.17 → 0.2.0

data/lib/bioinform/support/third_part/active_support/core_ext/string/access.rb

@@ -1,99 +0,0 @@
-require_relative "../../multibyte"
-
-class String
-  unless '1.9'.respond_to?(:force_encoding)
-    # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".at(0)  # => "h"
-    #   "hello".at(4)  # => "o"
-    #   "hello".at(10) # => ERROR if < 1.9, nil in 1.9
-    def at(position)
-      mb_chars[position, 1].to_s
-    end
-
-    # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".from(0)  # => "hello"
-    #   "hello".from(2)  # => "llo"
-    #   "hello".from(10) # => "" if < 1.9, nil in 1.9
-    def from(position)
-      mb_chars[position..-1].to_s
-    end
-
-    # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
-    #
-    # Examples:
-    #   "hello".to(0)  # => "h"
-    #   "hello".to(2)  # => "hel"
-    #   "hello".to(10) # => "hello"
-    def to(position)
-      mb_chars[0..position].to_s
-    end
-
-    # Returns the first character of the string or the first +limit+ characters.
-    #
-    # Examples:
-    #   "hello".first     # => "h"
-    #   "hello".first(2)  # => "he"
-    #   "hello".first(10) # => "hello"
-    def first(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        mb_chars[0...limit].to_s
-      end
-    end
-
-    # Returns the last character of the string or the last +limit+ characters.
-    #
-    # Examples:
-    #   "hello".last     # => "o"
-    #   "hello".last(2)  # => "lo"
-    #   "hello".last(10) # => "hello"
-    def last(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        mb_chars[(-limit)..-1].to_s
-      end
-    end
-  else
-    def at(position)
-      self[position]
-    end
-
-    def from(position)
-      self[position..-1]
-    end
-
-    def to(position)
-      self[0..position]
-    end
-
-    def first(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        to(limit - 1)
-      end
-    end
-
-    def last(limit = 1)
-      if limit == 0
-        ''
-      elsif limit >= size
-        self
-      else
-        from(-limit)
-      end
-    end
-  end
-end

data/lib/bioinform/support/third_part/active_support/core_ext/string/behavior.rb

@@ -1,6 +0,0 @@
-class String
-  # Enable more predictable duck-typing on String-like classes. See <tt>Object#acts_like?</tt>.
-  def acts_like_string?
-    true
-  end
-end

data/lib/bioinform/support/third_part/active_support/core_ext/string/filters.rb

@@ -1,49 +0,0 @@
-require_relative 'multibyte'
-
-class String
-  # Returns the string, first removing all whitespace on both ends of
-  # the string, and then changing remaining consecutive whitespace
-  # groups into one space each.
-  #
-  # Examples:
-  #   %{ Multi-line
-  #      string }.squish                   # => "Multi-line string"
-  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
-  def squish
-    dup.squish!
-  end
-
-  # Performs a destructive squish. See String#squish.
-  def squish!
-    strip!
-    gsub!(/\s+/, ' ')
-    self
-  end
-
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
-  #
-  #   "Once upon a time in a world far far away".truncate(27)
-  #   # => "Once upon a time in a wo..."
-  #
-  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
-  #
-  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
-  #   # => "Once upon a time in a..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>:length</tt>:
-  #
-  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
-  #   # => "And they f... (continued)"
-  def truncate(length, options = {})
-    text = self.dup
-    options[:omission] ||= "..."
-
-    length_with_room_for_omission = length - options[:omission].mb_chars.length
-    chars = text.mb_chars
-    stop = options[:separator] ?
-      (chars.rindex(options[:separator].mb_chars, length_with_room_for_omission) || length_with_room_for_omission) : length_with_room_for_omission
-
-    (chars.length > length ? chars[0...stop] + options[:omission] : text).to_s
-  end
-end

data/lib/bioinform/support/third_part/active_support/core_ext/string/multibyte.rb

@@ -1,72 +0,0 @@
-# encoding: utf-8
-require_relative '../../multibyte'
-
-class String
-  if RUBY_VERSION >= "1.9"
-    # == Multibyte proxy
-    #
-    # +mb_chars+ is a multibyte safe proxy for string methods.
-    #
-    # In Ruby 1.8 and older it creates and returns an instance of the ActiveSupport::Multibyte::Chars class which
-    # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
-    # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
-    #
-    #   name = 'Claus Müller'
-    #   name.reverse # => "rell??M sualC"
-    #   name.length  # => 13
-    #
-    #   name.mb_chars.reverse.to_s # => "rellüM sualC"
-    #   name.mb_chars.length       # => 12
-    #
-    # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
-    # it becomes easy to run one version of your code on multiple Ruby versions.
-    #
-    # == Method chaining
-    #
-    # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
-    # method chaining on the result of any of these methods.
-    #
-    #   name.mb_chars.reverse.length # => 12
-    #
-    # == Interoperability and configuration
-    #
-    # The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between
-    # String and Char work like expected. The bang! methods change the internal string representation in the Chars
-    # object. Interoperability problems can be resolved easily with a +to_s+ call.
-    #
-    # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
-    # information about how to change the default Multibyte behavior see ActiveSupport::Multibyte.
-    def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.consumes?(self)
-        ActiveSupport::Multibyte.proxy_class.new(self)
-      else
-        self
-      end
-    end
-
-    def is_utf8?
-      case encoding
-      when Encoding::UTF_8
-        valid_encoding?
-      when Encoding::ASCII_8BIT, Encoding::US_ASCII
-        dup.force_encoding(Encoding::UTF_8).valid_encoding?
-      else
-        false
-      end
-    end
-  else
-    def mb_chars
-      if ActiveSupport::Multibyte.proxy_class.wants?(self)
-        ActiveSupport::Multibyte.proxy_class.new(self)
-      else
-        self
-      end
-    end
-
-    # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
-    # them), returns false otherwise.
-    def is_utf8?
-      ActiveSupport::Multibyte::Chars.consumes?(self)
-    end
-  end
-end

data/lib/bioinform/support/third_part/active_support/hash_with_indifferent_access.rb

@@ -1,181 +0,0 @@
-require_relative 'core_ext/hash/keys'
-
-# This class has dubious semantics and we only have it so that
-# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
-# and they get the same value for both keys.
-unless defined? ActiveSupport::HashWithIndifferentAccess
-
-module ActiveSupport
-  class HashWithIndifferentAccess < Hash
-
-    # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
-    def extractable_options?
-      true
-    end
-
-    def with_indifferent_access
-      dup
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
-      else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      end
-    end
-
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
-    #
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
-    end
-
-    alias_method :store, :[]=
-
-    # Updates the instantized hash with values from the second:
-    #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
-    #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New Value!"
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
-      else
-        other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-        self
-      end
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash["key"] = "value"
-    #   hash.key? :key  # => true
-    #   hash.key? "key" # => true
-    #
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.fetch("foo")          # => 1
-    #   counters.fetch(:bar, 0)        # => 0
-    #   counters.fetch(:bar) {|key| 0} # => 0
-    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-    #
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:a] = "x"
-    #   hash[:b] = "y"
-    #   hash.values_at("a", "b") # => ["x", "y"]
-    #
-    def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
-    end
-
-    # Returns an exact copy of the hash.
-    def dup
-      self.class.new(self).tap do |new_hash|
-        new_hash.default = default
-      end
-    end
-
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
-    def reverse_merge(other_hash)
-      super self.class.new_from_hash_copying_default(other_hash)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    undef :symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a Hash with String keys.
-    def to_hash
-      Hash.new(default).merge!(self)
-    end
-
-    protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value)
-        if value.is_a? Hash
-          value.nested_under_indifferent_access
-        elsif value.is_a?(Array)
-          value.dup.replace(value.map { |e| convert_value(e) })
-        else
-          value
-        end
-      end
-  end
-end
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
-
-end

data/lib/bioinform/support/third_part/active_support/multibyte.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-require_relative 'core_ext/module/attribute_accessors'
-
-module ActiveSupport #:nodoc:
-  module Multibyte
-    autoload :EncodingError, 'bioinform/support/third_part/active_support/multibyte/exceptions'
-    autoload :Chars, 'bioinform/support/third_part/active_support/multibyte/chars'
-    autoload :Unicode, 'bioinform/support/third_part/active_support/multibyte/unicode'
-
-    # The proxy class returned when calling mb_chars. You can use this accessor to configure your own proxy
-    # class so you can support other encodings. See the ActiveSupport::Multibyte::Chars implementation for
-    # an example how to do this.
-    #
-    # Example:
-    #   ActiveSupport::Multibyte.proxy_class = CharsForUTF32
-    def self.proxy_class=(klass)
-      @proxy_class = klass
-    end
-
-    # Returns the current proxy class
-    def self.proxy_class
-      @proxy_class ||= ActiveSupport::Multibyte::Chars
-    end
-
-    # Regular expressions that describe valid byte sequences for a character
-    VALID_CHARACTER = {
-      # Borrowed from the Kconv library by Shinji KONO - (also as seen on the W3C site)
-      'UTF-8' => /\A(?:
-                  [\x00-\x7f]                                         |
-                  [\xc2-\xdf] [\x80-\xbf]                             |
-                  \xe0        [\xa0-\xbf] [\x80-\xbf]                 |
-                  [\xe1-\xef] [\x80-\xbf] [\x80-\xbf]                 |
-                  \xf0        [\x90-\xbf] [\x80-\xbf] [\x80-\xbf]     |
-                  [\xf1-\xf3] [\x80-\xbf] [\x80-\xbf] [\x80-\xbf]     |
-                  \xf4        [\x80-\x8f] [\x80-\xbf] [\x80-\xbf])\z /xn,
-      # Quick check for valid Shift-JIS characters, disregards the odd-even pairing
-      'Shift_JIS' => /\A(?:
-                  [\x00-\x7e\xa1-\xdf]                                     |
-                  [\x81-\x9f\xe0-\xef] [\x40-\x7e\x80-\x9e\x9f-\xfc])\z /xn
-    }
-  end
-end
-
-require_relative 'multibyte/utils'