basic-rope 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6643ff0ca0cec28bee1440332fc9d71c3ce7f67f
+  data.tar.gz: c7563f1d28ee7587b850ed0cc7d4d454b2e29288
+SHA512:
+  metadata.gz: 27581ca183715f80cc38c1b358ff9356f478d589c40bbf0ff7e0fb4c91002058423e32b9089bd304d6df6aa215f52e22fa5d2b88992e7d496d56afac0ba23579
+  data.tar.gz: 6e7031ddabc83fc06940f147e155ab8a14dacac15f6f0b67d2b53e58bba206ef2f5aaf21b4d16f0e438ecf185d70b74eb0fab5acdfe7598a50a6c800ff6ebe7d

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+*.swp
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rope.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Andy Lindeman
+
+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.textile

@@ -0,0 +1,69 @@
+p{color:red}. *rope* is still under early development.  Check it out if you wish to follow my progress or help, but do not use it in your applications (yet!).
+
+*rope* is a pure Ruby implementation of the "Rope data structure":http://en.wikipedia.org/wiki/Rope_%28computer_science%29.
+
+For many applications, the *Rope* class can be a drop-in replacement for *String* that is optimized for certain use cases.
+
+Using a *Rope* instance over a *String* may be desirable in applications that manipulate large amounts of text.
+
+*rope* currently offers:
+* Fast string concatenation and substring operations involving large strings
+* Immutability, which is desirable for functional programming techniques or multithreaded applications
+
+Planned features for *rope*:
+* Ability to view a function producing characters as a Rope (including I/O operations).  For instance, a piece of a Rope may be a 100MB file, but is only read when that section of the string is examined.  Concatenating to the end of that Rope does not involve reading the entire file.
+* Implement a *Rope* counterpart to every immutable method available on the *String* class.
+
+Disadvantages of *rope*:
+* Single character replacements are expensive
+* Iterating character-by-character is slightly more expensive than in a String (TODO: how much? .. haven't implemented iterators yet)
+
+h1. Installation
+
+*rope* is hosted on "rubygems":http://www.rubygems.org/
+
+<pre>
+gem install rope
+</pre>
+
+... or in your Gemfile
+
+<pre>
+gem 'rope'
+</pre>
+
+*rope* is tested against MRI 1.8.7 and 1.9.2.
+
+h1. Usage
+
+h2. Creating a Rope
+
+<pre>
+rope = "123456789".to_rope # Rope::Rope.new("123456789") also works
+
+puts rope # "123456789"
+</pre>
+
+h2. Concatenation
+
+A *Rope* instance can be concatenated with another *Rope* or *String* instance.
+
+<pre>
+rope = "12345"
+string = "6789"
+
+rope += string
+puts rope # "123456789"
+</pre>
+
+h2. Slices/Substrings
+
+A *Rope* instance offers efficient substring operations.  The *slice* and *[]* methods are synonymous with their "String counterparts (Ruby API documentation)":http://ruby-doc.org/core-1.9/classes/String.html#M000293.
+
+<pre>
+rope = "123456789".to_rope
+
+puts rope.slice(3, 4) # 4567
+puts rope.slice(-6, 4) # 4567
+# TODO: More examples when they are implemented
+</pre>

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/basic-rope.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rope/version"
+
+Gem::Specification.new do |s|
+  s.name        = "basic-rope"
+  s.version     = Rope::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andy Lindeman", "Logan Bowers"]
+  s.email       = ["alindeman@gmail.com", "logan@datacurrent.com"]
+  s.homepage    = "http://rubygems.org/gems/basic-rope"
+  s.summary     = %q{Pure Ruby implementation of a Rope data structure}
+  s.description = %q{A Rope is a convenient data structure for manipulating large amounts of text.  This implementation is inspired by http://www.rubyquiz.com/quiz137.html and https://rubygems.org/gems/cord. Basic-rope is a fork of Andy Lindeman's original rope gem to generalize the rope data structure to work with any data type that has a length and supports slice(). }
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rdoc"
+end

data/benchmark.rb

@@ -0,0 +1,53 @@
+# Benchmarking code from
+# http://www.rubyquiz.com/quiz137.html
+
+# Compare:
+# ruby benchmark.rb
+# ruby -r lib/rope.rb -I lib benchmark.rb Rope::Rope
+
+require 'benchmark'
+
+#This code make a String/Rope of CHUNCKS chunks of text
+#each chunck is SIZE bytes long. Each chunck starts with
+#an 8 byte number. Initially the chuncks are shuffled the
+#qsort method sorts them into ascending order.
+
+puts 'preparing data...'
+TextClass = eval(ARGV.shift || "String")
+
+def qsort(text)
+  return TextClass.new if text.length == 0
+  pivot = text.slice(0,8).to_s.to_i
+  less = TextClass.new
+  more = TextClass.new
+  offset = 8+SIZE
+  while (offset < text.length)
+    i = text.slice(offset,8).to_s.to_i
+    (i < pivot ? less : more) << text.slice(offset,8+SIZE)
+    offset = offset + 8+SIZE
+  end
+  print "*"
+  return qsort(less) << text.slice(0,8+SIZE) << qsort(more)
+end
+
+SIZE = 512 * 1024
+CHUNCKS = 128
+CHARS = %w[R O P E]
+data = TextClass.new
+bulk_string =
+  TextClass.new(Array.new(SIZE) { CHARS[rand(4)] }.join)
+puts 'Building Text...'
+build = Benchmark.measure do
+  (0..CHUNCKS).sort_by { rand }.each do |n|
+    data<< sprintf("%08i",n) << bulk_string
+  end
+  data.normalize if data.respond_to? :normalize
+end
+GC.start
+sort = Benchmark.measure do
+  puts "Sorting Text..."
+  qsort(data)
+  puts"\nEND"
+end
+
+puts "Build: #{build}Sort: #{sort}"

data/lib/rope.rb

@@ -0,0 +1,16 @@
+require 'forwardable'
+
+require 'rope/basic_rope'
+
+require 'rope/string_methods'
+
+module Rope
+  Rope = BasicRope.rope_for_type(String) do
+    #
+    # Special case for string Ropes since to_s is universal
+    #
+    def to_s
+      to_primitive
+    end
+  end
+end

data/lib/rope/basic_node.rb

@@ -0,0 +1,36 @@
+module Rope
+	class BasicNode
+    # Length of the underlying data in the tree and its descendants
+    attr_reader :length
+
+    # Depth of the tree
+    attr_reader :depth
+
+    # Concatenates this tree with another tree (non-destructive to either
+    # tree)
+    def +(other)
+      InteriorNode.new(self, other)
+    end
+
+    # Gets the string representation of the underlying data in the tree
+    def to_primitive
+      data
+    end
+
+    # Returns the Node that contains this index or nil if the index is out of bounds
+    def segment(index)
+    	raise NotImplementedError
+    end
+
+    # Rebalances this tree
+    def rebalance!
+    	raise NotImplementedError
+    end
+
+    #Swaps out the data in this node to be rhs. Must be same length
+    def replace!(index, length, rhs)
+    	raise NotImplementedError
+    end
+
+	end
+end

data/lib/rope/basic_rope.rb

@@ -0,0 +1,109 @@
+require 'rope/leaf_node'
+require 'rope/interior_node'
+
+module Rope
+	# BasicRope is a data-type-agnostic Rope data structure. The data type is
+	# typically a string but can be anything that implements the following
+	# methods:
+	#
+	# * length - integer length of a unit of the data type
+	# * slice - break a unit of the data type into two pieces on an index boundary
+	# * + - join two pieces of the data type together
+	# * [] - alias for slice
+	#
+	class BasicRope
+    extend Forwardable
+
+    def self.rope_for_type(type, &block)
+    	Class.new(self) do
+    		define_method :primitive_type do
+    			type
+    		end
+    		
+    		class_eval &block if block_given?
+    	end
+    end
+
+    # Initializes a new rope
+    def initialize(arg=nil)
+      case arg
+      when BasicNode
+        @root = arg
+      when NilClass
+        @root = LeafNode.new(primitive_type.new)
+      when primitive_type
+      	@root = LeafNode.new(arg)
+      when self.class, InteriorNode
+      	@root = LeafNode.new(arg.to_primitive)
+      else
+        raise ArgumentError, "#{arg} is not a #{primitive_type}"
+      end
+    end
+
+    def_delegators :@root, :to_primitive, :length, :rebalance!, :segment
+
+    # Concatenates this rope with another rope or string
+    def +(other)
+      self.class.new(concatenate(other))
+    end
+
+    # Tests whether this rope is equal to another rope
+    def ==(other)
+      to_primitive == (BasicRope === other ? other.to_primitive : other)
+    end
+
+    # Creates a copy of this rope
+    def dup
+      root.freeze #Prevents errors when 
+      self.class.new(root)
+    end
+
+    # Gets a slice of this rope
+    def slice(*args)
+      slice = root.slice(*args)
+
+      case slice
+      when Fixnum # slice(Fixnum) returns a plain Fixnum
+        slice
+      when BasicNode, primitive_type # create a new Rope with the returned tree as the root
+        self.class.new(slice)
+      else
+        nil
+      end
+    end
+    alias :[] :slice
+
+    def []=(index, length=1, rhs)
+    	@root = @root.replace!(index, length, rhs)
+    	self
+    end
+
+
+    def <<(rhs)
+      self[length] = rhs
+    end
+    protected
+
+    # Root node (could either be a LeafNode or some child of LeafNode)
+    attr_reader :root
+
+    private
+
+    # Generate a concatenation node to combine this rope and another rope
+    # or string
+    def concatenate(other)
+      # TODO: Automatically balance the tree if needed
+      case other
+      when primitive_type
+        InteriorNode.new(root, LeafNode.new(other))
+      when BasicRope
+        InteriorNode.new(root, other.root)
+      end
+    end
+
+    def primitive_type
+    	raise NotImplementedError, "This method must return the data type stored in the rope"
+    end
+
+	end
+end

data/lib/rope/interior_node.rb

@@ -0,0 +1,170 @@
+require 'rope/basic_node'
+
+module Rope
+  # Specifies an interior node.  Its underlying data is retrieved by combining
+  # its children recursively.
+	class InteriorNode < BasicNode
+    # Left and right nodes
+    attr_reader :left, :right
+
+    # Initializes a new concatenation node.
+    def initialize(left, right)
+      @left = left
+      @right = right
+
+      @length = left.length + right.length
+      @depth = [left.depth, right.depth].max + 1
+    end
+
+    # Gets the underlying data in the tree
+    def data
+      left.data + right.data
+    end
+
+    # Gets a slice of the underlying data in the tree
+    def slice(arg0, *args)
+      if args.length == 0
+        if arg0.is_a?(Fixnum)
+          slice(arg0, 1)
+        elsif arg0.is_a?(Range)
+          from, to = arg0.minmax
+
+          # Special case when the range doesn't actually describe a valid range
+          return nil if from.nil? || to.nil?
+
+          # Normalize so both from and to are positive indices
+          if from < 0
+            from += @length
+          end
+          if to < 0
+            to += @length
+          end
+
+          if from <= to
+            subtree(from, (to - from) + 1)
+          else
+            # Range first is greater than range last
+            # Return empty string to match what String does
+            raise "TODO"
+          end
+        end
+
+        # TODO: arg0.is_a?(Range)
+        # TODO: arg0.is_a?(Regexp)
+        # TODO: arg0.is_a?(String)
+      else
+        arg1 = args[0] # may be slightly confusing; refer to method definition
+        if arg0.is_a?(Fixnum) && arg1.is_a?(Fixnum) # Fixnum, Fixnum
+          if arg1 >= 0
+            subtree(arg0, arg1)
+          else
+            # Negative length, return nil to match what String does
+            nil
+          end
+        end
+
+        # TODO: arg0.is_a?(Regexp) && arg1.is_a?(Fixnum)
+      end
+    end
+
+    #
+    # Freeze is redefined to freeze the subtree; used when dup'ing a Rope to protect against aliasing
+    #
+    def freeze
+      unless frozen?
+        super
+        @left.freeze  unless @left.frozen?
+        @right.freeze unless @right.frozen?
+      end
+      self
+    end
+
+    # Rebalances this tree
+    def rebalance!
+      # TODO
+    end
+
+    # Returns a node that represents a slice of this tree
+    def subtree(from, length)
+      # Translate to positive index if given a negative one
+      if from < 0
+        from += @length
+      end
+
+      # If more than @length characters are requested, truncate
+      length = [(@length - from), length].min
+
+      # Entire length requested
+      return self if length == @length
+
+      # Check if the requested subtree is entirely in the right subtree
+      rfrom = from - @left.length
+      return @right.subtree(rfrom, length) if rfrom >= 0
+
+      llen = @left.length - from
+      rlen = length - llen
+      if rlen > 0
+        # Requested subtree overlaps both the left and the right subtree
+        @left.subtree(from, llen) + @right.subtree(0, rlen)
+      else
+        # Requested subtree is entirely in the left subtree
+        @left.subtree(from, length)
+      end
+    end
+
+    #
+    # Overwrites data at index with substr
+    #
+    # Returns self, however leaf nodes may return a new interior node if the replace! causes a leaf to be split
+    #
+    def replace!(index, length, substr)
+      # We may be frozen, so this all gets reified into a new node or overwrites on ourselves 
+      new_left  = @left
+      new_right = @right
+
+      # Translate to positive index if given a negative one
+      if index < 0
+        index += @length
+      end
+
+      rindex = index - @left.length
+      if(index == 0 && length == @left.length)
+      	#substr exactly replaces left sub-tree
+      	new_left = LeafNode.new(substr)
+      elsif(index == @left.length && length == @right.length)
+      	#substr exactly replaces right sub-tree
+      	new_right = LeafNode.new(substr)
+      elsif rindex < 0
+      	if(index + length <= @left.length)
+      		#Replacement segment is a subsection of the left tree
+	        
+	        #Requested index is in the left subtree, and a split may occur
+	        new_left = @left.replace!(index, length, substr)
+      	else
+	      	#Replacement segement is a subsection of left tree along with a subsection of the right tree
+	      	left_count = @left.length - index
+
+	      	new_left = InteriorNode.new(
+	      		@left.subtree(0, index),
+	      		LeafNode.new(substr)
+	      	)
+	      	new_right = @right.subtree(rindex + length, @right.length - (rindex + length))
+	      end
+      else
+        # Requested index is in the right subtree, and a split may occur
+        new_right = @right.replace!(rindex, length, substr)
+      end
+
+      if(frozen?)
+        InteriorNode.new(new_left, new_right)
+      else
+        #Length could have changed if the substr replaced a section of a different size or there was an append
+        @left   = new_left
+        @right  = new_right
+        @length = @left.length + @right.length
+        @depth  = [left.depth, right.depth].max + 1
+        self
+      end
+    end
+  end
+end

data/lib/rope/leaf_node.rb

@@ -0,0 +1,48 @@
+require 'rope/basic_node'
+
+module Rope
+  # Specifies a leaf node that contains a basic string
+	class LeafNode < BasicNode
+    extend Forwardable
+
+    # The underlying data in the tree
+    attr_reader :data
+
+    def_delegator :@data, :slice
+
+    # Initializes a node that contains a basic string
+    def initialize(data)
+      @data = data.freeze #Freezes the data to protect against aliasing errors
+      @length = data.length
+      @depth = 0
+    end
+
+    def subtree(from, length)
+      if length == @data.length
+        self
+      else
+        self.class.new(@data.slice(from, length))
+      end
+    end
+
+    def replace!(index, length, substr)
+      left = if(index == 0)
+        LeafNode.new(substr)
+      else
+        InteriorNode.new(
+          LeafNode.new(@data.slice(0,index)),
+          LeafNode.new(substr)
+        )
+      end
+
+      if((index + length) < @data.length)
+        InteriorNode.new(
+          left,
+          LeafNode.new(@data.slice(index + length, @data.length - (index + length)))
+        )
+      else
+        left
+      end
+    end
+	end
+end

data/lib/rope/node.rb

@@ -0,0 +1,27 @@
+module Rope
+  class Node
+    # Length of the underlying data in the tree and its descendants
+    attr_reader :length
+
+    # Depth of the tree
+    attr_reader :depth
+
+    # The underlying data in the tree
+    attr_reader :data
+
+    # Concatenates this tree with another tree (non-destructive to either
+    # tree)
+    def +(other)
+      ConcatenationNode.new(self, other)
+    end
+
+    # Gets the string representation of the underlying data in the tree
+    def to_s
+      data.to_s
+    end
+
+    # Rebalances this tree
+    def rebalance!
+    end
+  end
+end

data/lib/rope/string_methods.rb

@@ -0,0 +1,6 @@
+class String
+  # Converts the String to a Rope
+  def to_rope
+    Rope::Rope.new(self)
+  end
+end

data/lib/rope/version.rb

@@ -0,0 +1,3 @@
+module Rope
+  VERSION = "0.0.2"
+end

data/spec/concatenation_spec.rb

@@ -0,0 +1,35 @@
+
+require 'rope'
+
+describe "rope" do
+  describe "#+" do
+    it "should allow concatenation of two Rope instances" do
+      rope1 = "123".to_rope
+      rope2 = "456".to_rope
+
+      rope3 = rope1 + rope2
+      rope3.to_s.should == "123456"
+
+      # rope1 and rope2 should not have been affected
+      rope1.to_s.should == "123"
+      rope2.to_s.should == "456"
+    end
+
+    it "should allow concatenation of a Rope and a String" do
+      rope = "123".to_rope
+      string = "456"
+
+      rope_concat = rope + string
+      rope_concat.to_s.should == "123456"
+
+      # rope and string should not have been affected
+      rope.to_s.should == "123"
+      string.should == "456"
+    end
+
+    it "should allow concatenation of many Rope instances" do
+      rope_concat = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+      rope_concat.to_s.should == "123456789012"
+    end
+  end
+end

data/spec/dup_spec.rb

@@ -0,0 +1,14 @@
+
+require 'rope'
+
+describe "rope" do
+  describe "#dup" do
+    it "should create a shallow copy" do
+      rope = "123".to_rope
+      rope_dupped = rope.dup
+
+      rope.should == rope_dupped
+      rope.should_not equal(rope_dupped)
+    end
+  end
+end

data/spec/initialization_spec.rb

@@ -0,0 +1,15 @@
+require 'rope'
+
+describe "rope" do
+  describe "#initialize" do
+    it "can be constructed using the Rope constructor" do
+      rope = Rope::Rope.new("testing123")
+      rope.to_s.should == "testing123"
+    end
+
+    it "can be constructed using the to_rope method on a string" do
+      rope = "testing123".to_rope
+      rope.to_s.should == "testing123"
+    end
+  end
+end

data/spec/replace_spec.rb

@@ -0,0 +1,62 @@
+require 'rope'
+
+describe Rope::Rope do
+	describe "[<Fixnum>]=" do
+		(1..4).each do |segments|
+			rope_len = segments.times.collect { |i| i + 1 }.reduce(0, :+)
+
+			context "a #{segments} segment rope (length #{rope_len})" do
+				#Makes a rope of successive pieces, each one longer than the previous
+				subject {
+					segments.times.collect { |i| i + 1 }.reduce("".freeze.to_rope) do |rope, i|
+						rope += (rope.length..(rope.length + i)).collect { |x| (x.to_i % 10).to_s.freeze }.join
+					end
+				}
+
+				(0..2).each do |replacement_len|
+					context "a #{replacement_len} length replacement str" do
+						let(:replacement) { ('a'..'z').to_a[0,replacement_len].join }
+
+						(0..rope_len).each do |offset|
+							(0..2).each do |replace_len|
+								it "replaces a substring of length #{replace_len} at offset #{offset} with a string" do
+									as_string = subject.to_s.dup
+
+									as_string[offset, replace_len] = replacement
+									subject[offset, replace_len]   = replacement
+
+									expect(subject.to_s).to eq(as_string)
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+
+		it "doesn't alias" do
+			r1 = "foo".to_rope + "bar" + "baz"
+			r2 = r1.dup
+
+			r2[0,3] = "baz"
+
+			expect(r2).not_to eq(r1)
+		end
+	end
+
+	subject { "foo".to_rope }
+
+	describe "[self.length]=" do		
+		it "appends to the end of the rope" do
+			subject[subject.length] = "bar"
+			should eq "foobar"
+		end
+	end
+
+	describe "<<" do
+		it "appends to the end of the rope" do
+			subject <<  "bar"
+			should eq "foobar"
+		end
+	end
+end

data/spec/slice_spec.rb

@@ -0,0 +1,83 @@
+
+require 'rope'
+
+describe Rope::Rope do
+  describe "#slice" do
+    context "Fixnum, Fixnum" do # slice(Fixnum, Fixnum)
+      it "should return a slice for a Rope instance created with a String" do
+        rope = "12345".to_rope
+        rope_slice = rope.slice(0, 2)
+
+        rope_slice.to_s.should == "12"
+        rope_slice.class.should == Rope::Rope
+      end
+
+      it "should return a slice for a Rope instance created by concatenating other Rope instances" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+        rope_slice = rope.slice(2, 6)
+
+        rope_slice.to_s.should == "345678"
+        rope_slice.class.should == Rope::Rope
+      end
+
+      it "should return a slice when given a negative index" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+        rope_slice = rope.slice(-8, 6)
+
+        rope_slice.to_s.should == "567890"
+        rope_slice.class.should == Rope::Rope
+      end
+
+      it "should return nil when given a negative length" do
+        "1234567".to_rope.slice(2, -1).should be_nil
+      end
+
+      it "should return an empty string when given a 0 length" do
+        "1234567".to_rope.slice(2, 0).to_s.should be_empty
+      end
+    end
+
+    context "Fixnum" do # slice(Fixnum)
+      it "should return the character value of the character at the given position" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+
+        rope.slice(0).should == ?1
+        rope.slice(3).should == ?4
+        rope.slice(7).should == ?8
+      end
+
+      it "should return a single character string" do
+        "12345".slice(0).should == "1"
+      end
+    end
+
+    context "Range" do # slice(Range)
+      it "should return a slice for a Rope when given a Range" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+
+        rope.slice(0..2).to_s.should == "123"
+        rope.slice(0...2).to_s.should == "12"
+      end
+
+      it "should return a slice for a Rope when given a Range that exercises edge cases" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+
+        rope.slice(5..5).to_s.should == "6"
+        rope.slice(5...5).to_s.should == ""
+        rope.slice(0...0).to_s.should == ""
+      end
+
+      it "should return a slice for a Rope when given a Range that contains negative indices" do
+        rope = ["123", "456", "789", "012"].inject(Rope::Rope.new) { |combined, str| combined += str.to_rope }
+
+        rope.slice(-4..-2).to_s.should == "901"
+        rope.slice(-4...-2).to_s.should == "90"
+      end
+
+      it "should return an empty Rope when given a Range where the first index is greater than the last index" do
+        "1234567".slice(4..2).to_s.should be_empty
+        "1234567".slice(-2..-4).to_s.should be_empty
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: basic-rope
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andy Lindeman
+- Logan Bowers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 'A Rope is a convenient data structure for manipulating large amounts
+  of text.  This implementation is inspired by http://www.rubyquiz.com/quiz137.html
+  and https://rubygems.org/gems/cord. Basic-rope is a fork of Andy Lindeman''s original
+  rope gem to generalize the rope data structure to work with any data type that has
+  a length and supports slice(). '
+email:
+- alindeman@gmail.com
+- logan@datacurrent.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.textile
+- Rakefile
+- basic-rope.gemspec
+- benchmark.rb
+- lib/rope.rb
+- lib/rope/basic_node.rb
+- lib/rope/basic_rope.rb
+- lib/rope/interior_node.rb
+- lib/rope/leaf_node.rb
+- lib/rope/node.rb
+- lib/rope/string_methods.rb
+- lib/rope/version.rb
+- spec/concatenation_spec.rb
+- spec/dup_spec.rb
+- spec/initialization_spec.rb
+- spec/replace_spec.rb
+- spec/slice_spec.rb
+homepage: http://rubygems.org/gems/basic-rope
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Pure Ruby implementation of a Rope data structure
+test_files:
+- spec/concatenation_spec.rb
+- spec/dup_spec.rb
+- spec/initialization_spec.rb
+- spec/replace_spec.rb
+- spec/slice_spec.rb