sorted_array_binary 0.0.1

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "jruby-19mode"

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'coveralls', :require => false

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Dmitry Maksyoma
+
+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/README.md

@@ -0,0 +1,42 @@
+sorted_array_binary
+===================
+
+[![Build Status](https://travis-ci.org/ledestin/sorted_array_binary.png)](https://travis-ci.org/ledestin/sorted_array_binary)
+[![Coverage Status] (https://coveralls.io/repos/ledestin/sorted_array_binary/badge.png)] (https://coveralls.io/r/ledestin/sorted_array_binary)
+[![Code Climate](https://codeclimate.com/github/ledestin/sorted_array_binary.png)](https://codeclimate.com/github/ledestin/sorted_array_binary)
+
+A sorted array using binary search
+
+## Why
+
+1. Neither of the existing sorted arrays gems use binary search (i.e. slow or
+   very slow).
+2. I don't like their source code, so I decided to roll my own, instead of
+   contributing.
+
+Existing sorted array gems as of Jan 2014:
+* sorted_array (0.0.5)
+* array-sorted (1.1.2)
+
+## Example
+
+```ruby
+require 'sorted_array_binary'
+
+# Use standard sorting via <=>.
+array = SortedArrayBinary.new
+array.push 'b', 'a' #=> ['a', 'b']
+
+# Use custom sorting block.
+array = SortedArrayBinary.new { |a, b| b <=> a }
+array.push 'a', 'b' #=> ['b', 'a']
+```
+
+## Performance
+
+When #push'ing 1000 random numbers into an array:
+```
+sorted_array (0.0.5)		1.179088
+array-sorted (1.1.2)		0.076348
+sorted_array_binary (0.0.1)     0.015969
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+task :default => :spec
+
+task :gem do
+  system 'gem build *.gemspec'
+end

data/lib/sorted_array_binary.rb

@@ -0,0 +1,216 @@
+# Copyright (C) 2014 by Dmitry Maksyoma <ledestin@gmail.com>
+
+# Automatically sorted array (by using binary search). Nils aren't allowed.
+# Methods that reorder elements are not implemented, as well as #[]= and #fill.
+#
+# = Example
+#   require 'sorted_array_binary'
+#
+#   # Use standard sorting via <=>.
+#   array = SortedArrayBinary.new
+#   array.push 'b', 'a' #=> ['a', 'b']
+#
+#   # Use custom sorting block.
+#   array = SortedArrayBinary.new { |a, b| b <=> a }
+#   array.push 'a', 'b' #=> ['b', 'a']
+class SortedArrayBinary < Array
+  # {{{2 ComparisonState
+  class ComparisonState #:nodoc:
+    def initialize state
+      raise ArgumentError, "invalid state: #{state.inspect}" \
+	unless state && state >= -1 && state <= 1
+
+      @state = state
+    end
+
+    def equal?
+      @state == 0
+    end
+
+    def greater?
+      @state == 1
+    end
+
+    def less?
+      @state == -1
+    end
+  end
+  # }}}2
+
+  class InvalidSortBlock < RuntimeError #:nodoc:
+  end
+
+  def self._check_for_nil *objs #:nodoc:
+    raise ArgumentError, "nils aren't allowed into sorted array" \
+      if objs.include?(nil)
+  end
+
+  alias :old_insert :insert
+  private :old_insert
+  alias :old_sort! :sort!
+  private :old_sort!
+
+  def initialize *args, &b
+    @sort_block = proc { |a, b| a <=> b }
+
+    # Passed sort block.
+    if args.size == 0 && block_given?
+      @sort_block = b
+      super()
+      return
+    end
+
+    if args.size == 1
+      # Passed initial array.
+      if args.first.respond_to? :each
+	self.class._check_for_nil *args.first
+	super *args
+	old_sort!
+	return
+      end
+
+      # Passed size and block.
+      if block_given?
+	super *args, &b
+	self.class._check_for_nil *self
+	old_sort!
+	return
+      end
+
+      # Passed size, but not obj, which means fill with nils.
+      raise ArgumentError, "can't fill array with nils" \
+	if args.first.is_a? Numeric
+    end
+
+    super
+  end
+
+  # Not implemented methods.
+  #
+  # The following methods are not implemented mostly because they change order
+  # of elements. The rest ([]= and fill) arguably aren't useful on a sorted
+  # array.
+  def _not_implemented *args #:nodoc:
+    raise NotImplementedError
+  end
+
+  [:[]=, :fill, :insert, :reverse!, :rotate!, :shuffle!, :sort!, :unshift].
+  each { |m|
+    alias_method m, :_not_implemented
+  }
+
+  # Same as Array#collect!, but:
+  # * Disallow nils in the resulting array.
+  # * The resulting array is sorted.
+  def collect! &b
+    replace(collect &b)
+  end
+  alias :map! :collect!
+
+  # Same as Array#concat, but:
+  # * Disallow nils in the passed array.
+  # * The resulting array is sorted.
+  def concat other_ary
+    _add *other_ary
+  end
+
+  # Same as Array#flatten!, but:
+  # * Disallow nils in the resulting array.
+  # * The resulting array is sorted.
+  def flatten! *args
+    replace(flatten *args)
+  end
+
+  # Add objects to array, automatically placing them according to sort order.
+  # Disallow nils.
+  def push *objs
+    _add *objs
+  end
+  alias :<< :push
+
+  # Same as Array#replace, but:
+  # * Disallow nils in @other_ary.
+  # * The resulting array is sorted.
+  def replace other_ary
+    self.class._check_for_nil *other_ary
+    super
+    old_sort!
+    self
+  end
+
+  #private
+  # Name the following methods starting with underscore so as not to pollute
+  # Array namespace. They are considered private, but for testing purposes are
+  # left public.
+
+  def _add *objs #:nodoc:
+    self.class._check_for_nil *objs
+    objs.each { |obj|
+      old_insert _find_insert_position(obj), obj
+    }
+    self
+  end
+
+  def _check_can_calc_boundary? #:nodoc:
+    raise "can't calc boundary on empty array" if empty?
+  end
+
+  def _compare a, b #:nodoc:
+    ComparisonState.new(ret = @sort_block.call(a, b))
+  rescue ArgumentError
+    raise InvalidSortBlock,
+      "sort block returned invalid value: #{ret.inspect}"
+  end
+
+  def _find_insert_position element_to_place #:nodoc:
+    return 0 if empty?
+
+    start_idx, end_idx = 0, size - 1
+    loop {
+      middle_idx = _middle_element_index(start_idx, end_idx)
+      middle_el = self[middle_idx]
+      after_middle_idx = middle_idx + 1
+
+      comparison_state = _compare(element_to_place, middle_el)
+
+      # 1. Equals to the middle element. Insert after el.
+      return after_middle_idx if comparison_state.equal?
+
+      # 2. Less than the middle element.
+      if comparison_state.less?
+	# There's nothing to the left. So insert it as the first element.
+	return 0 if _left_boundary? middle_idx
+
+	end_idx = middle_idx - 1
+	next
+      end
+
+      # 3. Greater than the middle element.
+      #
+      # Right boundary? Put element_to_place after the last (middle) element.
+      return after_middle_idx if _right_boundary? middle_idx
+
+      # Less than after middle element? Put it right before it!
+      after_middle_el = self[after_middle_idx]
+      ret = _compare(element_to_place, after_middle_el)
+      return after_middle_idx if ret.equal? || ret.less?
+
+      # Proceeed to divide the right part.
+      start_idx = after_middle_idx
+    }
+  end
+
+  def _left_boundary? idx #:nodoc:
+    _check_can_calc_boundary?
+    idx == 0
+  end
+
+  def _middle_element_index start, ending #:nodoc:
+    start + (ending - start)/2
+  end
+
+  def _right_boundary? idx #:nodoc:
+    _check_can_calc_boundary?
+    idx == size - 1
+  end
+end

data/perf-tests/common.rb

@@ -0,0 +1,13 @@
+require 'frugal_timeout'
+
+MonotonicTime = FrugalTimeout::MonotonicTime
+
+def say msg, sec
+  printf "%-24s %f\n", msg, sec
+end
+
+@ar = []
+COUNT = 1000
+COUNT.times {
+  @ar << rand(COUNT)
+}

data/perf-tests/perf-vs-sort

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+require './common'
+require '../lib/sorted_array_binary'
+
+sec = MonotonicTime.measure { @ar.sort }
+say 'sorting', sec
+
+sec = MonotonicTime.measure {
+  sa = SortedArrayBinary.new
+  sa.push *@ar
+}
+say 'pushing into SortedArray', sec
+
+sec = MonotonicTime.measure {
+  SortedArrayBinary.new @ar
+}
+say 'SortedArray.new', sec

data/perf-tests/perf-vs-sorted_array

@@ -0,0 +1,21 @@
+#!/usr/bin/ruby
+
+require 'frugal_timeout'
+require 'sorted_array'
+require 'array-sorted'
+require './common'
+require '../lib/sorted_array_binary'
+
+def measure sorted_array_name, sorted_array_instance
+  sec = MonotonicTime.measure {
+    @ar.each { |el|
+      sorted_array_instance.push el
+    }
+  }
+  say sorted_array_name, sec
+end
+
+measure 'sorted_array',
+  SortedArray::SortedArray.new(SortedArray::DefaultSorter.new(:to_i))
+measure 'array-sorted', Array::Sorted.new
+measure 'sorted_array_binary', SortedArrayBinary.new

data/sorted_array_binary.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name        = 'sorted_array_binary'
+  s.version     = '0.0.1'
+  s.date        = '2014-01-29'
+  s.summary     = 'Sorted array'
+  s.description = 'Sorted array using binary search'
+  s.authors     = ['Dmitry Maksyoma']
+  s.email       = 'ledestin@gmail.com'
+  s.files       = `git ls-files`.split($\)
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.homepage    = 'https://github.com/ledestin/sorted_array_binary'
+
+  s.add_development_dependency 'rspec', '>= 2.13'
+  s.add_development_dependency 'hitimes', '~> 1.2'
+end

data/spec/sorted_array_binary_spec.rb

@@ -0,0 +1,352 @@
+require 'rspec'
+require 'spec_helper'
+require 'sorted_array_binary'
+
+describe SortedArrayBinary do
+  before :each do
+    @ar = SortedArrayBinary.new
+  end
+
+  # {{{2 self._check_for_nil
+  context 'self._check_for_nil' do
+    it "raises exception if there's nil in passed objs" do
+      expect {
+	SortedArrayBinary._check_for_nil 'a', nil
+      }.to raise_error ArgumentError
+    end
+
+    it "doesn't raise exception if there's no nil in passed objs" do
+      expect {
+	SortedArrayBinary._check_for_nil 'a', 'b'
+      }.not_to raise_error
+    end
+  end
+
+  # {{{2 self.new
+  context 'self.new' do
+    it 'if passed size and obj, fills it' do
+      @ar = SortedArrayBinary.new 5, 'a'
+      @ar.should == ['a']*5
+    end
+
+    it 'if passed just size, raises exception' do
+      expect { SortedArrayBinary.new 5 }.to raise_error ArgumentError
+    end
+
+    it 'if passed single non-numeric argument, calls Array#new' do
+      expect { SortedArrayBinary.new 'a' }.to raise_error TypeError
+    end
+
+    context 'if passed array,' do
+      it 'sorts it' do
+	@ar = SortedArrayBinary.new ['b', 'a']
+	@ar.should == ['a', 'b']
+      end
+
+      it 'raises exception if nil found in passed array' do
+	expect { SortedArrayBinary.new [nil] }.to raise_error ArgumentError
+      end
+    end
+
+    it 'if passed size and block, fills it and sorts it' do
+      @ar = SortedArrayBinary.new(5) { |i| i == 0 ? 10 : i }
+      @ar.should == [1, 2, 3, 4, 10]
+    end
+
+    it 'if passed sorting block, resulting array is sorted using it' do
+      @ar = SortedArrayBinary.new { |a, b| b <=> a }
+      @ar.push 'a', 'b'
+      @ar.should == ['b', 'a']
+    end
+  end
+
+  # {{{2 Not implemented
+  context 'raises NotImplementedError exception when called' do
+    it '#[]=' do
+      expect { @ar[0] = 'a' }.to raise_error NotImplementedError
+    end
+
+    it '#fill' do
+      expect { @ar.fill nil }.to raise_error NotImplementedError
+    end
+
+    [:insert, :reverse!, :rotate!, :shuffle!, :sort!, :unshift].
+    each { |m|
+      it "##{m}" do
+	expect { @ar.send m }.to raise_error NotImplementedError
+      end
+    }
+  end
+
+  # {{{2 #collect!
+  [:collect!, :map!].each { |method|
+    context "##{method}" do
+      it 'after it, array is sorted' do
+	@ar.push 'a', 'b', 'c'
+	@ar.send(method) { |el|
+	  case el
+	  when 'a' then 9
+	  when 'b' then 3
+	  when 'c' then 1
+	  end
+	}
+	@ar.should == [1, 3, 9]
+      end
+
+      it 'raises exception if one of resulting elements is nil' do
+	@ar.push 'a'
+	expect { @ar.send(method) { nil } }.to raise_error ArgumentError
+	@ar.should == ['a']
+      end
+    end
+  }
+
+  # {{{2 #concat
+  it '#concat adds another array and everything is sorted' do
+    @ar.push 'c'
+    @ar.concat ['a', 'b']
+    @ar.should == ['a', 'b', 'c']
+  end
+
+  # {{{2 #flatten!
+  context '#flatten!' do
+    it 'flattens array' do
+      @ar.push [1, 2], [4, 3]
+      @ar.flatten!
+      @ar.should == [1, 2, 3, 4]
+    end
+
+    it 'raises exception if resulting array contains nil' do
+      @ar.push [nil, 1]
+      expect { @ar.flatten! }.to raise_error ArgumentError
+      @ar.should == [[nil, 1]]
+    end
+  end
+
+  # {{{2 #push
+  [:<<, :push].each { |method|
+    context "##{method}" do
+      it 'adds an element to array' do
+	@ar.send method, 'a'
+	@ar.should == ['a']
+      end
+
+      it 'adds 2 elements to array' do
+	@ar.send method, 'a', 'b'
+	@ar.should == ['a', 'b']
+      end
+
+      it 'adds elements in random order, but the result is sorted' do
+	@ar.send method, 'b', 'a', 'd', 'c'
+	@ar.should == ['a', 'b', 'c', 'd']
+	@ar.send method, 'e'
+	@ar.should == ['a', 'b', 'c', 'd', 'e']
+      end
+
+      it 'adds element in random order, but sorting is done via sort block' do
+	@ar = SortedArrayBinary.new { |a, b| b <=> a }
+	@ar.push 'c', 'd'
+	@ar.push 'a', 'b'
+	@ar.should == ['d', 'c', 'b', 'a']
+      end
+
+      it 'raises exception if nil is passed' do
+	expect { @ar.send method, nil }.to raise_error ArgumentError
+      end
+    end
+  }
+
+  # {{{2 #replace
+  context '#replace' do
+    it '#replace replaces array, the resulting array is sorted' do
+      @ar.push 'a'
+      @ar.replace ['c', 'b']
+      @ar.should == ['b', 'c']
+    end
+
+    it "doesn't allow nils" do
+      expect { @ar.replace [nil] }.to raise_error ArgumentError
+    end
+  end
+
+  # {{{2 #_compare
+  context '#_compare' do
+    context 'sort block not given' do
+      it 'returns :equal if arguments are equal' do
+	@ar._compare(1, 1).equal?.should be_true
+      end
+
+      it 'returns :less if arg1 < arg2' do
+	@ar._compare(1, 2).less?.should be_true
+      end
+
+      it 'returns :greater if arg1 > arg2' do
+	@ar._compare(2, 1).greater?.should be_true
+      end
+    end
+
+    context 'sort block given' do
+      before :each do
+	@ar = SortedArrayBinary.new { |a, b| b <=> a }
+      end
+
+      it 'returns :equal if arguments are equal' do
+	@ar._compare(1, 1).equal?.should be_true
+      end
+
+      it 'returns :less if arg1 < arg2' do
+	@ar._compare(2, 1).less?.should be_true
+      end
+
+      it 'returns :greater if arg1 > arg2' do
+	@ar._compare(1, 2).greater?.should be_true
+      end
+
+      it 'raises exception if block returns value outside of -1, 0, 1' do
+	@ar = SortedArrayBinary.new { 'a' }
+	expect {
+	  @ar.push 1, 2
+	}.to raise_error SortedArrayBinary::InvalidSortBlock
+      end
+    end
+  end
+
+  # {{{2 #_find_insert_position
+  context '#_find_insert_position' do
+    it 'returns 0 if array is empty' do
+      @ar._find_insert_position('a').should == 0
+    end
+
+    context 'and array contains single element,' do
+      it 'returns 1 if the first element is less than the passed elementt' do
+	@ar.push 'a'
+	@ar._find_insert_position('b').should == 1
+      end
+
+      it 'returns 0 if the first element is greater than the passed elementt' do
+	@ar.push 'b'
+	@ar._find_insert_position('a').should == 0
+      end
+
+      it 'returns 1 if the first element is equal to the passed elementt' do
+	@ar.push 'a'
+	@ar._find_insert_position('a').should == 1
+      end
+    end
+
+    context 'and array contains 2 elements,' do
+      it 'returns 2 if passed element is greater than 2nd element' do
+	@ar.push 'a', 'b'
+	@ar._find_insert_position('c').should == 2
+      end
+
+      it 'returns 1 if passed element is less than 2nd element' do
+	@ar.push 'a', 'c'
+	@ar._find_insert_position('b').should == 1
+      end
+
+      it 'returns 0 if passed element is less than 1st element' do
+	@ar.push 'b', 'c'
+	@ar._find_insert_position('a').should == 0
+      end
+    end
+
+    context 'and array context 4 elements,' do
+      it 'returns 1 if passed element is greater than 1st element' do
+	@ar.push 'a', 'c', 'd'
+	@ar._find_insert_position('b').should == 1
+      end
+    end
+  end
+
+  # {{{2 #_middle_element_index
+  context '_middle_element_index' do
+    it "returns first element index if there's one element" do
+      @ar._middle_element_index(0, 0).should == 0
+      @ar._middle_element_index(1, 1).should == 1
+    end
+
+    it 'returns 0 if there are 2 elements in the array' do
+      @ar._middle_element_index(0, 1).should == 0
+    end
+
+    it 'returns 1 if there are 3 elements in the array' do
+      @ar._middle_element_index(0, 2).should == 1
+    end
+
+    it 'returns 1 if there are 4 elements in the array' do
+      @ar._middle_element_index(0, 3).should == 1
+    end
+  end
+
+  # {{{2 #_left_boundary, #_right_boundary
+  context '#_left_boundary, #_right_boundary' do
+    context 'left' do
+      it "returns true if it's left boundary?" do
+	@ar.push 'a' 
+	@ar._left_boundary?(0).should == true
+      end
+
+      it "returns false if it's not left boundary?" do
+	@ar.push 'a' 
+	@ar._left_boundary?(1).should == false
+      end
+
+      it 'raises exception if array is empty' do
+	expect {
+	  @ar._left_boundary?(0)
+	}.to raise_error
+      end
+    end
+
+    context 'right' do
+      it "returns true if it's right boundary?" do
+	@ar.push 'a', 'b'
+	@ar._right_boundary?(1).should == true
+      end
+
+      it "returns false if it's not right boundary?" do
+	@ar.push 'a', 'b'
+	@ar._right_boundary?(0).should == false
+      end
+
+      it 'raises exception if array is empty' do
+	expect {
+	  @ar._right_boundary?(0)
+	}.to raise_error
+      end
+    end
+  end
+  # }}}2
+end
+
+describe SortedArrayBinary::ComparisonState do
+  [nil, -2, 2].each { |state|
+    it "allows only valid state in" do
+      expect {
+	SortedArrayBinary::ComparisonState.new state
+      }.to raise_error ArgumentError
+    end
+  }
+
+  it 'is equal? if state is 0' do
+    state = SortedArrayBinary::ComparisonState.new 0
+    state.equal?.should be_true
+    state.less?.should be_false
+    state.greater?.should be_false
+  end
+
+  it 'is greater? if state is 1' do
+    state = SortedArrayBinary::ComparisonState.new 1
+    state.greater?.should be_true
+    state.equal?.should be_false
+    state.less?.should be_false
+  end
+
+  it 'is less? if state is -1' do
+    state = SortedArrayBinary::ComparisonState.new -1
+    state.less?.should be_true
+    state.equal?.should be_false
+    state.greater?.should be_false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: sorted_array_binary
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dmitry Maksyoma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: hitimes
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Sorted array using binary search
+email: ledestin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .coveralls.yml
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/sorted_array_binary.rb
+- perf-tests/common.rb
+- perf-tests/perf-vs-sort
+- perf-tests/perf-vs-sorted_array
+- sorted_array_binary.gemspec
+- spec/sorted_array_binary_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ledestin/sorted_array_binary
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Sorted array
+test_files:
+- spec/sorted_array_binary_spec.rb
+- spec/spec_helper.rb
+has_rdoc: