array-sorted 1.0.0

data/CHANGELOG.rdoc

@@ -0,0 +1,12 @@
+
+== 6/14/2012
+
+Initial release - split from compositing-sorted-array. 
+
+== 6/15/2012
+
+fixed SortedArray::Interface to include Array::Sorted::ArrayInterface
+
+== 6/30/2012
+
+Renamed from sorted-array to array-sorted. File schema updated to reflect gem name.

data/README.md

@@ -0,0 +1,44 @@
+# Sorted Array #
+
+http://rubygems.org/gems/array-sorted
+
+# Description #
+
+Provides ::Array::Sorted and ::SortedArray.
+
+# Summary #
+
+A subclass of Array::Hooked that also keeps array sorted.
+
+# Install #
+
+* sudo gem install array-sorted
+
+# Usage #
+
+Just like Array or Array::Hooked (provided by hooked_array)! Provides additional support in :initialize to declare sorting block.
+
+# License #
+
+  (The MIT License)
+
+  Copyright (c) Asher
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+  'Software'), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/array-hooked-sorted.rb

@@ -0,0 +1,2 @@
+
+require_relative 'array/sorted.rb'

data/lib/array-sorted.rb

@@ -0,0 +1,2 @@
+
+require_relative 'array/sorted.rb'

data/lib/array/hooked/sorted.rb

@@ -0,0 +1,2 @@
+
+require_relative '../sorted.rb'

data/lib/array/namespaces.rb

@@ -0,0 +1,6 @@
+
+class ::Array::Sorted < ::Array::Hooked
+end
+
+class ::SortedArray < ::Array::Sorted
+end

data/lib/array/requires.rb

@@ -0,0 +1,27 @@
+
+basepath = 'sorted'
+
+files = [
+  
+  'array_interface'
+  
+]
+
+second_basepath = '../sorted_array'
+
+second_files = [
+  
+  'array_interface'
+  
+]
+
+files.each do |this_file|
+  require_relative( File.join( basepath, this_file ) + '.rb' )
+end
+second_files.each do |this_file|
+  require_relative( File.join( second_basepath, this_file ) + '.rb' )
+end
+
+require_relative( basepath + '.rb' )
+require_relative( second_basepath + '.rb' )
+

data/lib/array/sorted.rb

@@ -0,0 +1,14 @@
+
+require 'array/hooked'
+
+# namespaces that have to be declared ahead of time for proper load order
+require_relative './namespaces'
+
+# source file requires
+require_relative './requires.rb'
+
+class ::Array::Sorted < ::Array::Hooked
+  
+  include ::Array::Sorted::ArrayInterface
+    
+end

data/lib/array/sorted/array_interface.rb

@@ -0,0 +1,173 @@
+
+module ::Array::Sorted::ArrayInterface
+  
+  include ::Array::Hooked::ArrayInterface
+  
+  instances_identify_as!( ::Array::Sorted )
+  
+  ################
+  #  initialize  #
+  ################
+
+  # Adds optional block for retaining sort order.
+  # @yield Block to use to determine sort order.
+  def initialize( *args, & sort_object_block )
+    
+    super( *args )
+    
+    if block_given?
+      @sort_object_block = sort_object_block
+    end
+    
+  end
+  
+  ##############
+  #  reverse!  #
+  ##############
+
+  def reverse!
+    
+    @sort_order_reversed = ! @sort_order_reversed
+    
+    super
+        
+    return self
+    
+  end
+  
+  ##############
+  #  collect!  #
+  #  map!      #
+  ##############
+
+  def collect!
+    
+    return to_enum unless block_given?
+    
+    replacement_array = [ ]
+    self.each_with_index do |this_object, index|
+      replacement_object = yield( this_object )
+      replacement_array[ index ] = replacement_object
+    end
+    
+    replace( replacement_array )
+    
+    return self
+    
+  end
+  alias_method :map!, :collect!
+  
+  ###########
+  #  sort!  #
+  ###########
+
+  def sort!( & block )
+
+    if block_given?
+      self.each_with_index do |this_member, index|
+        unless index + 1 == count
+          sort_object = @sort_object_block ? @sort_object_block.call( this_member ) : this_member
+          yield( sort_object, self[ index + 1 ] )
+        end
+      end
+    end
+    
+    return self
+
+  end
+
+  ##############
+  #  sort_by!  #
+  ##############
+
+  def sort_by!( & block )
+
+    return to_enum unless block_given?
+  
+    self.each do |this_member|
+      sort_object = @sort_object_block ? @sort_object_block.call( this_member ) : this_member
+      yield( sort_object )
+    end
+    
+    return self
+    
+  end
+
+  ###############################
+  #  perform_set_between_hooks  #
+  ###############################
+
+  def perform_set_between_hooks( index, object )
+
+    unless index >= count
+      delete_at( index )
+    end
+    
+    return perform_insert_between_hooks( index, object )
+    
+  end
+  
+  ##################################
+  #  perform_insert_between_hooks  #
+  ##################################
+
+  def perform_insert_between_hooks( index, *objects )
+
+    # we ignore the index and insert in sorted order
+
+    # we have to have at least one member for comparison-based insert (to retain sorted order)
+
+    objects.each do |this_object|
+
+      insert_occurred = false
+
+      if this_object.nil?
+        if @sort_order_reversed
+          super( count, this_object )
+        else
+          super( 0, this_object )
+        end
+        next
+      end
+      
+      self.each_with_index do |this_member, this_index|
+        
+        insert_sort_object = this_object
+        existing_sort_object = this_member
+        
+        if @sort_object_block
+          insert_sort_object = @sort_object_block.call( this_object )
+          existing_sort_object = @sort_object_block.call( this_member )
+        end
+        
+        if @sort_order_reversed
+                    
+          case insert_sort_object <=> existing_sort_object
+            when 0, 1
+              super( this_index, this_object )
+              insert_occurred = true
+              break
+          end
+          
+        else
+          
+          case insert_sort_object <=> existing_sort_object
+            when 0, -1
+              super( this_index, this_object )
+              insert_occurred = true
+              break
+          end
+          
+        end
+        
+      end
+    
+      unless insert_occurred
+        super( count, this_object )
+      end
+      
+    end
+
+  end
+  
+end

data/lib/hooked/array/sorted.rb

@@ -0,0 +1,2 @@
+
+require_relative '../../array-sorted.rb'

data/lib/sorted_array.rb

@@ -0,0 +1,6 @@
+
+class ::SortedArray < ::Array::Sorted
+  
+  include ::SortedArray::Interface
+  
+end

data/lib/sorted_array/array_interface.rb

@@ -0,0 +1,23 @@
+
+module ::SortedArray::Interface
+
+  include ::Array::Sorted::ArrayInterface
+  include ::HookedArray::Interface
+  
+  instances_identify_as!( ::SortedArray )
+
+  ################
+  #  initialize  #
+  ################
+
+  def initialize( configuration_instance = nil, & sort_object_block )
+    
+    super( configuration_instance )
+    
+    if block_given?
+      @sort_object_block = sort_object_block
+    end
+    
+  end
+
+end

data/spec/array/sorted_spec.rb

@@ -0,0 +1,667 @@
+
+require_relative '../../lib/array-sorted.rb'
+
+describe ::Array::Sorted do
+
+  ################
+  #  initialize  #
+  ################
+
+  it 'can add initialize with an ancestor, inheriting its values and linking to it as a child' do
+  
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.should == [ ]
+
+  end
+
+  #########
+  #  []=  #
+  #########
+
+  it 'can add elements' do
+  
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array[ 0 ] = :A
+    sorted_array.should == [ :A ]
+
+    sorted_array[ 1 ] = :B
+    sorted_array.should == [ :A, :B ]
+
+    sorted_array[ 0 ] = :D
+    sorted_array.should == [ :B, :D ]
+
+  end
+  
+  ############
+  #  insert  #
+  ############
+
+  it 'can insert elements' do
+  
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.insert( 3, :D )
+    sorted_array.should == [ nil, nil, nil, :D ]
+
+    sorted_array.insert( 1, :B )
+    sorted_array.should == [ nil, nil, nil, :B, :D ]
+
+    sorted_array.insert( 2, :C )
+    sorted_array.should == [ nil, nil, nil, :B, :C, :D ]
+
+  end
+  
+  ##########
+  #  push  #
+  #  <<    #
+  ##########
+  
+  it 'can add elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array << :A
+    sorted_array.should == [ :A ]
+
+    sorted_array << :B
+    sorted_array.should == [ :A, :B ]
+
+  end
+  
+  ############
+  #  concat  #
+  #  +       #
+  ############
+
+  it 'can add elements' do
+
+    # NOTE: this breaks + by causing it to modify the array like +=
+    # The alternative was worse.
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.concat( [ :A ] )
+    sorted_array.should == [ :A ]
+
+    sorted_array += [ :B ]
+    sorted_array.should == [ :A, :B ]
+
+  end
+
+  ####################
+  #  delete_objects  #
+  ####################
+
+  it 'can delete multiple elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += [ :A, :B ]
+    sorted_array.should == [ :A, :B ]
+
+    sorted_array.delete_objects( :A, :B )
+    sorted_array.should == [ ]
+
+  end
+
+  #######
+  #  -  #
+  #######
+  
+  it 'can exclude elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A )
+    sorted_array.should == [ :A ]
+
+    sorted_array -= [ :A ]
+    sorted_array.should == [ ]
+
+    sorted_array.push( :B )
+    sorted_array.should == [ :B ]
+
+  end
+
+  ############
+  #  delete  #
+  ############
+  
+  it 'can delete elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A )
+    sorted_array.should == [ :A ]
+
+    sorted_array.delete( :A )
+    sorted_array.should == [ ]
+
+    sorted_array.push( :B )
+    sorted_array.should == [ :B ]
+
+  end
+
+  ###############
+  #  delete_at  #
+  ###############
+
+  it 'can delete by indexes' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A )
+    sorted_array.should == [ :A ]
+    
+    sorted_array.delete_at( 0 )
+    sorted_array.should == [ ]
+
+    sorted_array.push( :B )
+    sorted_array.should == [ :B ]
+
+  end
+
+  #######################
+  #  delete_at_indexes  #
+  #######################
+
+  it 'can delete by indexes' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+
+    sorted_array.delete_at_indexes( 0, 1 )
+    sorted_array.should == [ :C ]
+
+  end
+
+  ###############
+  #  delete_if  #
+  ###############
+
+  it 'can delete by block' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.delete_if do |object|
+      object != :C
+    end
+    sorted_array.should == [ :C ]
+
+    sorted_array.delete_if.is_a?( Enumerator ).should == true
+
+  end
+
+  #############
+  #  keep_if  #
+  #############
+
+  it 'can keep by block' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.keep_if do |object|
+      object == :C
+    end
+    sorted_array.should == [ :C ]
+
+  end
+
+  ##############
+  #  compact!  #
+  ##############
+
+  it 'can compact' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, nil, :B, nil, :C, nil )
+    sorted_array.should == [ nil, nil, nil, :A, :B, :C ]
+    sorted_array.compact!
+    sorted_array.should == [ :A, :B, :C ]
+
+  end
+
+  ##############
+  #  flatten!  #
+  ##############
+
+  it 'can flatten' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, [ :F_A, :F_B ], :B, [ :F_C ], :C, [ :F_D ], [ :F_E ] )
+    sorted_array.should == [ :A, [ :F_A, :F_B ], :B, [ :F_C ], :C, [ :F_D ], [ :F_E ] ]
+    sorted_array.flatten!
+    sorted_array.should == [ :A, :B, :C, :F_A, :F_B, :F_C, :F_D, :F_E ]
+
+  end
+
+  #############
+  #  reject!  #
+  #############
+
+  it 'can reject' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.reject! do |object|
+      object != :C
+    end
+    sorted_array.should == [ :C ]
+
+    sorted_array.reject!.is_a?( Enumerator ).should == true
+
+  end
+
+  #############
+  #  replace  #
+  #############
+
+  it 'can replace self' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.replace( [ :D, :E, :F ] )
+    sorted_array.should == [ :D, :E, :F ]
+
+  end
+
+  ##############
+  #  reverse!  #
+  ##############
+
+  it 'can reverse self' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.reverse!
+    sorted_array.should == [ :C, :B, :A ]
+
+  end
+
+  #############
+  #  rotate!  #
+  #############
+
+  it 'can rotate self' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+
+    sorted_array.rotate!
+    sorted_array.should == [ :A, :B, :C ]
+
+    sorted_array.rotate!( -1 )
+    sorted_array.should == [ :A, :B, :C ]
+
+  end
+
+  #############
+  #  select!  #
+  #############
+
+  it 'can keep by select' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.select! do |object|
+      object == :C
+    end
+    sorted_array.should == [ :C ]
+
+    sorted_array.select!.is_a?( Enumerator ).should == true
+
+  end
+
+  ##############
+  #  shuffle!  #
+  ##############
+
+  it 'can shuffle self' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+
+    first_shuffle_version = sorted_array.dup
+    sorted_array.shuffle!
+    sorted_array.should == first_shuffle_version
+
+  end
+
+  ##############
+  #  collect!  #
+  #  map!      #
+  ##############
+
+  it 'can replace by collect/map' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.collect! do |object|
+      :C
+    end
+    sorted_array.should == [ :C, :C, :C ]
+
+    sorted_array.collect!.is_a?( Enumerator ).should == true
+
+  end
+
+  ###########
+  #  sort!  #
+  ###########
+
+  it 'can replace by collect/map' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.sort! do |a, b|
+      if a < b
+        1
+      elsif a > b
+        -1
+      elsif a == b
+        0
+      end
+    end
+    sorted_array.should == [ :A, :B, :C ]
+
+    sorted_array.sort!
+    sorted_array.should == [ :A, :B, :C ]
+
+  end
+
+  ##############
+  #  sort_by!  #
+  ##############
+
+  it 'can replace by collect/map' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C )
+    sorted_array.should == [ :A, :B, :C ]
+    sorted_array.sort_by! do |object|
+      case object
+      when :A
+        :B
+      when :B
+        :A
+      when :C
+        :C
+      end
+    end
+    sorted_array.should == [ :A, :B, :C ]
+
+    sorted_array.sort_by!.is_a?( Enumerator ).should == true
+
+  end
+
+  ###########
+  #  uniq!  #
+  ###########
+
+  it 'can remove non-unique elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array.push( :A, :B, :C, :C, :C, :B, :A )
+    sorted_array.should == [ :A, :A, :B, :B, :C, :C, :C ]
+    sorted_array.uniq!
+    sorted_array.should == [ :A, :B, :C ]
+
+  end
+
+  #############
+  #  unshift  #
+  #############
+
+  it 'can unshift onto the first element' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += :A
+    sorted_array.should == [ :A ]
+
+    sorted_array.unshift( :B )
+    sorted_array.should == [ :A, :B ]
+
+  end
+
+  #########
+  #  pop  #
+  #########
+  
+  it 'can pop the final element' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += :A
+    sorted_array.should == [ :A ]
+
+    sorted_array.pop.should == :A
+    sorted_array.should == [ ]
+
+    sorted_array += :B
+    sorted_array.should == [ :B ]
+
+  end
+
+  ###########
+  #  shift  #
+  ###########
+  
+  it 'can shift the first element' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += :A
+    sorted_array.should == [ :A ]
+
+    sorted_array.shift.should == :A
+    sorted_array.should == [ ]
+
+    sorted_array += :B
+    sorted_array.should == [ :B ]
+
+  end
+
+  ############
+  #  slice!  #
+  ############
+  
+  it 'can slice elements' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += :A
+    sorted_array.should == [ :A ]
+
+    sorted_array.slice!( 0, 1 ).should == [ :A ]
+    sorted_array.should == [ ]
+
+    sorted_array += :B
+    sorted_array.should == [ :B ]
+
+  end
+  
+  ###########
+  #  clear  #
+  ###########
+
+  it 'can clear, causing present elements to be excluded' do
+
+    sorted_array = ::Array::Sorted.new
+
+    sorted_array += :A
+    sorted_array.should == [ :A ]
+
+    sorted_array.clear
+    sorted_array.should == [ ]
+
+    sorted_array += :B
+    sorted_array.should == [ :B ]
+
+  end
+
+  ##################
+  #  pre_set_hook  #
+  ##################
+
+  it 'has a hook that is called before setting a value; return value is used in place of object' do
+    
+    class ::Array::Sorted::SubMockPreSet < ::Array::Sorted
+      
+      def pre_set_hook( index, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPreSet.new
+
+    sorted_array.push( :some_value )
+    
+    sorted_array.should == [ :some_other_value ]
+    
+  end
+
+  ###################
+  #  post_set_hook  #
+  ###################
+
+  it 'has a hook that is called after setting a value' do
+
+    class ::Array::Sorted::SubMockPostSet < ::Array::Sorted
+      
+      def post_set_hook( index, object, is_insert = false )
+        return :some_other_value
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPostSet.new
+
+    sorted_array.push( :some_value ).should == [ :some_other_value ]
+    
+    sorted_array.should == [ :some_value ]
+    
+  end
+
+  ##################
+  #  pre_get_hook  #
+  ##################
+
+  it 'has a hook that is called before getting a value; if return value is false, get does not occur' do
+    
+    class ::Array::Sorted::SubMockPreGet < ::Array::Sorted
+      
+      def pre_get_hook( index )
+        return false
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPreGet.new
+    
+    sorted_array.push( :some_value )
+    sorted_array[ 0 ].should == nil
+    
+    sorted_array.should == [ :some_value ]
+    
+  end
+
+  ###################
+  #  post_get_hook  #
+  ###################
+
+  it 'has a hook that is called after getting a value' do
+
+    class ::Array::Sorted::SubMockPostGet < ::Array::Sorted
+      
+      def post_get_hook( index, object )
+        return :some_other_value
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPostGet.new
+    
+    sorted_array.push( :some_value )
+    sorted_array[ 0 ].should == :some_other_value
+    
+    sorted_array.should == [ :some_value ]
+    
+  end
+
+  #####################
+  #  pre_delete_hook  #
+  #####################
+
+  it 'has a hook that is called before deleting an index; if return value is false, delete does not occur' do
+    
+    class ::Array::Sorted::SubMockPreDelete < ::Array::Sorted
+      
+      def pre_delete_hook( index )
+        return false
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPreDelete.new
+    
+    sorted_array.push( :some_value )
+    sorted_array.delete_at( 0 )
+    
+    sorted_array.should == [ :some_value ]
+    
+  end
+
+  ######################
+  #  post_delete_hook  #
+  ######################
+
+  it 'has a hook that is called after deleting an index' do
+    
+    class ::Array::Sorted::SubMockPostDelete < ::Array::Sorted
+      
+      def post_delete_hook( index, object )
+        return :some_other_value
+      end
+      
+    end
+    
+    sorted_array = ::Array::Sorted::SubMockPostDelete.new
+    
+    sorted_array.push( :some_value )
+    sorted_array.delete_at( 0 ).should == :some_other_value
+    
+    sorted_array.should == [ ]
+    
+  end
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: array-sorted
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Asher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: array-hooked
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A subclass of Array::Hooked that also keeps array sorted.
+email: asher@ridiculouspower.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/array/hooked/sorted.rb
+- lib/array/namespaces.rb
+- lib/array/requires.rb
+- lib/array/sorted/array_interface.rb
+- lib/array/sorted.rb
+- lib/array-hooked-sorted.rb
+- lib/array-sorted.rb
+- lib/hooked/array/sorted.rb
+- lib/sorted_array/array_interface.rb
+- lib/sorted_array.rb
+- spec/array/sorted_spec.rb
+- README.md
+- CHANGELOG.rdoc
+homepage: http://rubygems.org/gems/array-sorted
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: array-sorted
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides Array::Sorted and SortedArray.
+test_files: []
+has_rdoc: