hashery 1.4.0 → 1.5.0

data/LICENSE

@@ -1,206 +0,0 @@
-.
-
-                             Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-.
-

data/NOTICE

@@ -1,11 +0,0 @@
-= COPYRIGHT NOTICES
-
-== BasicObject
-
-BasicObject class is a variation of Jim Weirich's BlankSlate class.
-
-  BlankSlate
-  Copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-  All rights reserved.
-
-

data/lib/hashery/sparse_array.rb

@@ -1 +0,0 @@
-require 'hashery/sparsearray'

data/lib/hashery/sparsearray.rb

@@ -1,577 +0,0 @@
-# = SparseArray
-#
-# SparseArray is an implemenation of the Array class using only Hashes.
-# Regular Arrays are never used except once to delegate the #pack method,
-# (and *args parameters of course). SparseArray is almost fully compatible
-# with Array. There are still a few missing methods that came in with
-# Ruby 1.9 that need to be added, and negative indexes are not quite fully
-# supported yet.
-#
-# Benchmarks comparing Ruby 1.6 circa 2004 compared to Ruby 1.8.7 
-# circa 2010, show that Ruby's Array implementation has improved quite
-# a bit. Where as Array was about 2-4 times faster than SparseArray in 2004,
-# it is now over 10x faster, and able to handle large sparse arrays quite
-# easily. Though surely SparseArray could still be improved, <b>SparseArray
-# is little more than an interesting novelty at this point</b>, as opposed
-# to a useful class, but we will keep her nonetheless for simple interests
-# sake.
-# 
-# NOTE: SparseArray is also the first piece of code I used TDD to create.
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-#--
-# TODO: Add auto-array features if needed (see work/autoarray).
-#++
-
-class SparseArray < Hash
-
-  def self.[](*args)
-    s = new
-    args.each{ |e| s << e }
-    s
-  end
-
-  def self.new_h(hsh)
-    nha = new
-    nha.replace(hsh)
-    #nha.reindex!
-  end
-
-  def initialize(i=0,e=nil)
-    if i > 0
-      i.times { set(self.length,e) }
-    end
-  end
-
-  def &(ha)
-    nha = self.class.new
-    (0..self.length-1).each do |i|
-      if ha.has_value?(self.fetch(i)) and !nha.has_value?(self.fetch(i))
-        nha.set(nha.length,self.fetch(i))
-      end
-    end
-    nha
-  end
-
-  def *(j)
-    if j.kind_of?(String)
-      return self.join(j)
-    else
-      nha = self.class.new
-      j.times { (0...self.length).each { |i| nha.set(nha.length,self.fetch(i)) } }
-      return nha
-    end
-  end
-
-  def +(ha)
-    nha = self.dup
-    (0..ha.length-1).each { |i| nha.set(nha.length,ha.fetch(i)) }
-    nha
-  end
-
-  def -(ha)
-    nha = self.class.new
-    self.each { |v| nha << v if !ha.has_value?(v) }
-    #ha.each { |v| nha << i if !self.include?(v) }
-    nha
-  end
-
-  def <<(e)
-    set(length,e)
-    self
-  end
-
-  def <=>(ha)
-    (0..self.length-1).each do |i|
-      ieq = (self.fetch(i) <=> ha.fetch(i))
-      return ieq if ieq != 0
-    end
-    self.length <=> ha.length
-  end
-
-  def ===(ha)
-    self.==(ha)
-  end
-
-  alias_method :get, :[]
-  private :get
-
-  # TODO: Ranges with negative indexes not yet supported.
-  def [](i,l=nil)
-    if l
-      i = size + i if i < 0
-      i = i...i+l
-    elsif ! i.kind_of?(Range)
-      return self.at(i)
-    end
-    nha = self.class.new
-    i.each { |j| nha.set(nha.length,get(j)) if has_key?(j) }
-    nha
-  end
-
-  alias set []=
-  protected :set
-
-  def []=(i,b,c=nil)
-    if c
-      rng = (Integer(i)..Integer(i+b))
-      b = c
-    elsif i.kind_of? Range
-      rng = i
-    else
-      self.set(Integer(i),b)
-      return b
-    end
-    if b == nil
-      rng.each { |i| qdelete(i) }
-      self.reindex!
-    elsif b.kind_of?(Array) or b.kind_of?(self.class)
-      j = 0
-      rng.each { |i| self[i] = b[j]; j+=1 }
-    else
-      rng.each { |i| qdelete(i) }
-      self[rng.fist] = b
-      self.reindex!
-    end
-  end
-
-  def |(ha)
-    nha = self.dup
-    ha.each { |v| nha << v if !nha.has_value?(v) }
-    nha
-  end
-
-  def assoc(k)
-    (0...self.length).each { |i| return self.fetch(i) if self.fetch(i)[0] == k }
-    return nil
-  end
-
-  def at(i)
-    i = self.length + i if i <= -1
-    get(i)
-    #return nil if i < 0 or i >= self.length
-    #return self.fetch(i)
-  end
-
-  #def choice
-  #end
-
-  # clear okay
-
-  #
-  def collect
-    nha = self.class.new
-    (0...self.length).each { |i| nha << yield(self.fetch(i)) }
-    nha
-  end
-
-  def collect!
-    nha = self.class.new
-    (0...self.length).each { |i| nha << yield(self.fetch(i)) }
-    self.replace(nha)
-  end
-
-  #def combination
-  #end
-
-  #
-  def compact
-    nha, j = self.class.new, 0
-    (0..self.length-1).each do |i|
-      if self.fetch(i) != nil
-        nha.set(j,self.fetch(i))
-        j+=1
-      end
-    end
-    nha
-  end
-
-  def compact!
-    if self.has_value?(nil)
-      nha, j = self.class.new, 0
-      (0..self.length-1).each do |i|
-        if self.fetch(i) != nil
-          nha.set(j,self.fetch(i))
-          j+=1
-        end
-      end
-      return self.replace(nha)
-    else
-      return nil
-    end
-  end
-
-  #
-  def concat(ha)
-    (0...ha.length).each { |i| self.set(self.length,ha.fetch(i)) }
-    self
-  end
-
-  def count(e=nil)
-    if block_given?
-      cnt = 0
-      (0...self.length).each { |i| cnt += 1 if yield(self.fetch(i)) }
-      return cnt
-    else
-      cnt = 0
-      (0...self.length).each { |i| cnt += 1 if self.fetch(i) == e }
-      return cnt
-    end
-  end
-
-  #
-  alias qdelete delete
-  private :qdelete
-
-  #
-  def delete(e)
-    if has_value?(e)
-      qdelete_if { |i,v| v == e }
-      reindex!
-      return e
-    else
-      return yield if block_given?
-      return nil
-    end
-  end
-
-  #
-  def delete_at(i)
-    if self.has_key?(i)
-      e = self.fetch(i)
-      qdelete(i)
-      reindex!
-      return e
-    else
-      return nil
-    end
-  end
-
-  alias qdelete_if delete_if
-  private :qdelete_if
-
-  #
-  def delete_if
-    qdelete_if { |i,v| yield(v) }
-    reindex!
-  end
-
-  def each
-    (0...self.length).each{ |i| yield(get(i)) }
-  end
-
-  def each_index
-    (0...self.length).each{ |i| yield(i) }
-  end
-
-  # empty? okay as is
-
-  def eql?(ha)
-    return false if self.length != ha.length
-    return true if (0...self.length).all? { |i| self.fetch(i).eql?(ha.fetch(i)) }
-    return false
-  end
-
-  def fill(f,s=nil,l=nil)
-    if s.kind_of?(Range)
-      r = s
-    else
-      s = 0 if !s
-      l = self.length - s if !l
-      r = s...(s+l)
-    end
-    r.each{ |i| self.set(i,f) }
-    self
-  end
-
-  def first
-    return nil if self.empty?
-    self.fetch(0)
-  end
-
-  def flatten
-    nha = self.class.new
-    (0...self.length).each do |i|
-      sfi = self.fetch(i)
-      if sfi.kind_of?(self.class) or sfi.kind_of?(Array)
-        nha.concat(sfi.flatten)
-      else
-        nha.set(nha.length,sfi)
-      end
-    end
-    nha
-  end
-
-  def flatten!
-    return nil if !self.any? { |e| e.kind_of?(self.class) or e.kind_of?(Array) }
-    self.replace(self.flatten)
-  end
-
-  def include?(v)
-    self.has_value?(v)
-  end
-
-  #
-  def insert(index, *objs)
-    index = size + index + 1 if index < 0
-    tail = self[index...size]
-    objs.each_with_index do |obj, i|
-      set(index + i, obj)
-    end
-    tail.each_with_index do |obj, i|
-      set(objs.size + index + i, obj)
-    end
-    self
-  end
-
-  # index okay
-
-  #
-  def join(sep='')
-    s = ''
-    (0...self.length).each { |i| s << "#{self.fetch(i)}#{sep}" }
-    return s.chomp(sep)
-  end
-
-  #
-  def last
-    self[self.length-1]
-  end
-
-  # length okay
-
-  #
-  alias map! collect!
-
-  #
-  def nitems
-    cnt = 0
-    (0...self.length).each { |i| cnt += 1 if self.fetch(i) != nil }
-    cnt
-  end
-
-  def pack(*args)
-    self.to_a.pack(*args)
-  end
-
-  #def permutation
-  #end
-
-  #
-  def pop
-    self.delete_at(self.length-1)
-  end
-
-  #def product
-  #end
-
-  #
-  def push(*e)
-    self.concat(e)
-  end
-
-  def rassoc(k)
-    (0...self.length).each { |i| return self.fetch(i) if self.fetch(i)[1] == k }
-    return nil
-  end
-
-  def reindex
-    nha, j, k, tl = self.class.new, 0, 0, self.length
-    while k < tl
-      if self.has_key?(j)
-        nha.set(k,self.fetch(j))
-        j+=1; k+=1
-      else
-        j+=1
-      end
-    end
-    nha
-  end
-
-  def reindex!
-    self.replace(self.reindex)
-  end
-
-  def reject!
-    chg=nil
-    qdelete_if { |i,v| r=yield(v); chg=true if r; r }
-    return nil if !chg
-    reindex!
-  end
-
-  #def replace(ha)
-  #  if ha.length < self.length
-  #    (ha.length..self.length-1).each { |i| self.delete(i) }
-  #    (0..ha.length-1).each { |i| self.set(i,ha[i]) }
-  #  end
-  #end
-
-  def reverse
-    nha = self.class.new
-    (0...self.length).each { |i| nha.set(self.length-1-i,self.fetch(i)) }
-    nha
-  end
-
-  def reverse!
-    (0...self.length/2).each do |i|
-      ri = self.length-1-i
-      tmp = self.fetch(ri)
-      self.set(ri,self.fetch(i))
-      self.set(i,tmp)
-    end
-    self
-  end
-
-  def reverse_each
-    i = self.length - 1
-    while i >= 0
-      yield(self.fetch(i))
-      i -= 1
-    end
-  end
-
-  def rindex(e)
-    i = self.length - 1
-    while i >= 0
-      return i if self.fetch(i) == e
-      i -= 1
-    end
-    return nil
-  end
-
-  def shift
-    e1 = self[0]
-    tl = self.length - 1
-    (1..tl).each { |i| self.set(i-1,self.fetch(i)) }
-    self.delete_at(tl)
-    e1
-  end
-
-  #
-  def shuffle
-    dup.shuffle!
-  end
-
-  #
-  def shuffle!
-    size.times do
-      a = rand(size).to_i
-      b = rand(size).to_i
-      self[a], self[b] = self[b], self[a]
-    end 
-  end
-
-  # size okay
-
-  #
-  def slice(*args)
-    self[*args]
-  end
-
-  def slice!(*args)
-    result = self[*args]
-    self[*args] = nil
-    result
-  end
-
-  def sort
-    raise "SparseArray does not currently support sorting with blocks" if block_given?
-    nha = self.dup
-    qsort(nha,0,nha.length-1)
-  end
-
-  def qsort(ha, l, r)
-    l_hold = l
-    r_hold = r
-    pivot = ha[l]
-    while l < r
-      r -= 1 while (ha[r] <=> pivot) >= 0 and l < r
-      if l != r
-        ha[l] = ha[r]
-        l += 1
-      end
-      l += 1 while (ha[l] <=> pivot) <= 0 and l < r
-      if l != r
-        ha[r] = ha[l]
-        r -= 1
-      end
-    end
-    ha[l] = pivot
-    pivot = l
-    l = l_hold
-    r = r_hold
-    qsort(ha,l,pivot-1) if l < pivot
-    qsort(ha,pivot+1,r) if r > pivot
-    ha
-  end
-
-  def sort!
-    raise "SparseArray does not currently support sorting with blocks" if block_given?
-    qsort(self,0,self.length-1)
-  end
-
-  def to_a
-    a = []
-    (0..self.length-1).each { |i| a << self.fetch(i) }
-    a
-  end
-
-  def to_ary
-    self
-  end
-
-  def to_h
-   h = Hash.new
-   self.each { |k,v| h[k] = v }
-   h
-  end
-
-  def to_s
-    self.join
-  end
-
-  #
-  #def transpose
-  #end
-
-  #
-  def uniq
-    nha = self.class.new
-    (0..self.length-1).each do |i|
-      nha[nha.length] = self[i] if !nha.has_value?(self[i])
-    end
-    nha
-  end
-
-  #
-  def uniq!
-    j = 0
-    (1..self.length-1).each do |i|
-      if !self[0..j].has_value?(self[i])
-        self[j+1] = self[i]
-        j+=1
-      end
-    end
-    (j+1..self.length-1).each { |i| qdelete(i) }
-  end
-
-  def unshift(e)
-    i = self.length - 1
-    while i >= 0
-      self.set(i+1,self.fetch(i))
-      return i if self.fetch(i) == e
-      i -= 1
-    end
-    self.set(0,e)
-    self
-  end
-
-  def values_at(*ix)
-    nha = self.class.new
-    ix.each {|i| nha[nha.length] = self.at(i)}
-    nha
-  end
-
-end
-