bioinform 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 981be4ea2c5a07809303b9d4ac6a43f5d816e2f9
-  data.tar.gz: 84aa6ce722f015b357c1ac87cbb0151c8f37a3d2
+  metadata.gz: bce1095da9311ea0d77479899064e74e5979c516
+  data.tar.gz: 3cdd8b774e7ad7cb930965bb5112c9046552f924
 SHA512:
-  metadata.gz: 6b60eaa7651a2880354673d0e9f40e11407c76e76cb8ce526b60283049ca1e9e6dafdf16d258f77146987c507adfcc8d252485a38130278204015cbaaa31c4c3
-  data.tar.gz: 45d806ad0a1befd381da35381f42d0cfcc1acd361bc35efa7ce9dacb203ab820e38564f8d93134ede8f5c380b1efc34ccc70ab1ee60ff7b3291c5ecc8d4e6c60
+  metadata.gz: 40c7a5191db1b2137de61d5e4b038fca9bb2ec14289ef3010a012a1fd1adb8f47d0b650bcd66b04ecfdac44104754a699ff8cf9b3e004e21834c8aeedddf521c
+  data.tar.gz: 9c2c7ce0367b030b318117f6fc7b597ed9886312e26c64f0bea32157485896f836cb7f30e91777b5f6df1944ac6cc2d53cf1b5c96019a236036fe306d4b86c9c

data/Gemfile

@@ -13,4 +13,4 @@ group :development do
   gem 'fakefs', '~> 0.4.2'
   gem 'wdm', :require => false
   gem 'guard-rspec', '>=2.1.0'
-end
+end

data/TODO.txt

@@ -1,3 +1,5 @@
+! Make matrices immutable  - it will allow more safe interface and better caching 
+
 Collection contain Motif-s, each Motif can contain any of list: pcm,pwm,ppm.
 Name, background, tags and any other parameters should be removed from PM class to be placed in Motif
 

data/bioinform.gemspec

@@ -15,11 +15,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Bioinform::VERSION
 
-  gem.add_dependency('activesupport', '>= 3.0.0')
   gem.add_dependency('docopt', '= 0.5.0')
-
-  gem.add_development_dependency('fakefs', '~> 0.4.2')
-  gem.add_development_dependency('fabrication', '~> 2.5.0')
-  gem.add_development_dependency('rspec', '>= 2.0')
-  gem.add_development_dependency('rspec-given', '>= 2.0.0')
 end

data/lib/bioinform/data_models/motif.rb

@@ -1,5 +1,5 @@
 require 'ostruct'
-require 'active_support/core_ext/object/try'
+require_relative '../support/third_part/active_support/core_ext/object/try'
 require_relative '../support/parameters'
 module Bioinform
   class Motif

data/lib/bioinform/data_models/pm.rb

@@ -4,7 +4,8 @@ require_relative '../parsers'
 require_relative '../formatters'
 
 module Bioinform
-  IndexByLetter = {'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3, A: 0, C: 1, G: 2, T: 3}
+  IndexByLetter = { 'A' => 0, 'C' => 1, 'G' => 2, 'T' => 3, A: 0, C: 1, G: 2, T: 3,
+                    'a' => 0, 'c' => 1, 'g' => 2, 't' => 3, a: 0, c: 1, g: 2, t: 3}
   LetterByIndex = {0 => :A, 1 => :C, 2 => :G, 3 => :T}
 
   class PM

data/lib/bioinform/data_models/pwm.rb

@@ -19,7 +19,6 @@ module Bioinform
     end
 
     def score(word)
-      word = word.upcase
       raise ArgumentError, 'word in PWM#score(word) should have the same length as matrix'  unless word.length == length
       #raise ArgumentError, 'word in PWM#score(word) should have only ACGT-letters'  unless word.each_char.all?{|letter| %w{A C G T}.include? letter}
       (0...length).map do |pos|
@@ -27,11 +26,11 @@ module Bioinform
         if IndexByLetter[letter]
           matrix[pos][IndexByLetter[letter]]
         elsif letter == 'N'
-          matrix[pos].zip(probability).map{|el, p| el * p}.inject(0.0, &:+)
+          matrix[pos].zip(probability).map{|el, p| el * p}.inject(0, &:+)
         else
           raise ArgumentError, "word in PWM#score(#{word}) should have only ACGT or N letters"
         end
-      end.inject(0.0, &:+)
+      end.inject(0, &:+).to_f
     end
 
     def to_pwm
@@ -39,10 +38,10 @@ module Bioinform
     end
 
     def best_score
-      @matrix.inject(0.0){|sum, col| sum + col.max}
+      best_suffix(0)
     end
     def worst_score
-      @matrix.inject(0.0){|sum, col| sum + col.min}
+      worst_suffix(0)
     end
 
     # best score of suffix s[i..l]

data/lib/bioinform/support/multiline_squish.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/filters'
+require_relative 'third_part/active_support/core_ext/string/filters'
 class String
   def multiline_squish
     split("\n").map(&:squish).join("\n").gsub(/\A\n+/,'').gsub(/\n+\z/,'')

data/lib/bioinform/support/third_part/active_support/core_ext/array/extract_options.rb

@@ -0,0 +1,29 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/bioinform/support/third_part/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,23 @@
+require_relative '../../hash_with_indifferent_access'
+
+class Hash
+  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method will be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # desirable.
+  #
+  #   b = {:b => 1}
+  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
+  #
+  alias nested_under_indifferent_access with_indifferent_access
+end

data/lib/bioinform/support/third_part/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,54 @@
+class Hash
+  # Return a new hash with all keys converted to strings.
+  #
+  #   { :name => 'Rob', :years => '28' }.stringify_keys
+  #   #=> { "name" => "Rob", "years" => "28" }
+  def stringify_keys
+    dup.stringify_keys!
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   { 'name' => 'Rob', 'years' => '28' }.symbolize_keys
+  #   #=> { :name => "Rob", :years => "28" }
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  alias_method :to_options,  :symbolize_keys
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key: name"
+  #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise(ArgumentError, "Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+end

data/lib/bioinform/support/third_part/active_support/core_ext/module/attribute_accessors.rb

@@ -0,0 +1,64 @@
+require_relative '../array/extract_options'
+
+class Module
+  def mattr_reader(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{sym} = nil unless defined? @@#{sym}
+
+        def self.#{sym}
+          @@#{sym}
+        end
+      EOS
+
+      unless options[:instance_reader] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
+    end
+  end
+
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+
+      unless options[:instance_writer] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+      end
+    end
+  end
+
+  # Extends the module object with module and instance accessors for class attributes,
+  # just like the native attr* accessors for instance attributes.
+  #
+  #  module AppConfiguration
+  #    mattr_accessor :google_api_key
+  #    self.google_api_key = "123456789"
+  #
+  #    mattr_accessor :paypal_url
+  #    self.paypal_url = "www.sandbox.paypal.com"
+  #  end
+  #
+  #  AppConfiguration.google_api_key = "overriding the api key!"
+  #
+  # To opt out of the instance writer method, pass :instance_writer => false.
+  # To opt out of the instance reader method, pass :instance_reader => false.
+  # To opt out of both instance methods, pass :instance_accessor => false.
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/bioinform/support/third_part/active_support/core_ext/object/try.rb

@@ -0,0 +1,57 @@
+class Object
+  # Invokes the method identified by the symbol +method+, passing it any arguments
+  # and/or the block specified, just like the regular Ruby <tt>Object#send</tt> does.
+  #
+  # *Unlike* that method however, a +NoMethodError+ exception will *not* be raised
+  # and +nil+ will be returned instead, if the receiving object is a +nil+ object or NilClass.
+  #
+  # If try is called without a method to call, it will yield any given block with the object.
+  #
+  # Please also note that +try+ is defined on +Object+, therefore it won't work with
+  # subclasses of +BasicObject+. For example, using try with +SimpleDelegator+ will
+  # delegate +try+ to target instead of calling it on delegator itself.
+  #
+  # ==== Examples
+  #
+  # Without +try+
+  #   @person && @person.name
+  # or
+  #   @person ? @person.name : nil
+  #
+  # With +try+
+  #   @person.try(:name)
+  #
+  # +try+ also accepts arguments and/or a block, for the method it is trying
+  #   Person.try(:find, 1)
+  #   @people.try(:collect) {|p| p.name}
+  #
+  # Without a method argument try will yield to the block unless the receiver is nil.
+  #   @person.try { |p| "#{p.first_name} #{p.last_name}" }
+  #--
+  # +try+ behaves like +Object#send+, unless called on +NilClass+.
+  def try(*a, &b)
+    if a.empty? && block_given?
+      yield self
+    else
+      __send__(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes specially helpful when navigating through associations that may return +nil+.
+  #
+  # === Examples
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && !@person.children.blank? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+end

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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,72 @@
+# 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