segment_tree 0.1.0 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59ea55a8bf39f04d9d5d8fc248c8d8eaa5cb2c65692fd25c22ccc3b5a5ac14d0
+  data.tar.gz: a9b683819704f99d933a04bbf89272dcb00e87908a2a876aebd798268ee1c35d
+SHA512:
+  metadata.gz: 5bf8d0dbbad097d1e9f2ea887eaa71f02f253c27ee2d27bed792781ebc858a9e7e116cb42176939a10bc30a670ce820ad2eeb26be67ad40b752ce31f2d1eb455
+  data.tar.gz: 1cd80e31aaf356a599dea612fb6b0e21bb6551b02205a02eb982eb47a9ce6ea6d61336c17060c8b0444bc3764f8c6eb0a8fc0d0fa272c7ab90ce530605cbf1f1

data/lib/segment_tree/version.rb

@@ -1,3 +1,3 @@
 class SegmentTree
-  VERSION = "0.1.0"
-end
+  VERSION = '0.2.0'
+end

data/lib/segment_tree.rb

@@ -31,8 +31,38 @@ class SegmentTree
         else cmp
       end
     end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        @range == other.range &&
+        @value == other.value
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        @range.eql?(other.range) &&
+        @value.eql?(other.value)
+    end
+
+    def hash
+      [@range, @value].hash
+    end
+
+    def marshal_dump
+      {
+        range: @range,
+        value: @value,
+      }
+    end
+
+    def marshal_load(serialized_tree)
+      @range = serialized_tree[:range]
+      @value = serialized_tree[:value]
+    end
   end
 
+  attr_reader :segments
+
   # Build a segment tree from +data+.
   #
   # Data can be one of the following:
@@ -83,6 +113,28 @@ class SegmentTree
     end
   end
 
+  def ==(other)
+    other.is_a?(self.class) && @segments == other.segments
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) && @segments.eql?(other.segments)
+  end
+
+  def hash
+    @segments.hash
+  end
+
+  def marshal_dump
+    {
+      segments: @segments,
+    }
+  end
+
+  def marshal_load(serialized_tree)
+    @segments = serialized_tree[:segments]
+  end
+
   private
   def matches?(x, low_idx, high_idx, idx) #:nodoc:
     low, high = @segments[low_idx], @segments[high_idx]
@@ -91,9 +143,9 @@ class SegmentTree
     right     = idx < @segments.size - 1 && @segments[idx + 1]
 
     case
-      when left && (low.range.begin..left.range.end).include?(x) then -1
-      when segment.range.include?(x) then 0
-      when right && (right.range.begin..high.range.end).include?(x) then 1
+      when left && low.range.begin <= x && x <= left.range.end then -1
+      when segment.range.begin <=x && x <= segment.range.end then 0
+      when right && right.range.begin <=x && x <= high.range.end then 1
       else nil
     end
   end

data/segment_tree.gemspec

@@ -2,18 +2,19 @@
 require File.expand_path('../lib/segment_tree/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.author        = "Alexei Mikhailov"
-  gem.email         = "amikhailov83@gmail.com"
+  gem.author        = 'Alexei Mikhailov'
+  gem.email         = 'amikhailov83@gmail.com'
   gem.description   = %q{Tree data structure for storing segments. It allows querying which of the stored segments contain a given point.}
   gem.summary       = %q{Tree data structure for storing segments. It allows querying which of the stored segments contain a given point.}
-  gem.homepage      = "https://github.com/take-five/segment_tree"
+  gem.homepage      = 'https://github.com/take-five/segment_tree'
 
   gem.files         = `git ls-files`.split($\).grep(/lib|spec/)
   gem.test_files    = gem.files.grep(/spec/)
-  gem.name          = "segment_tree"
+  gem.name          = 'segment_tree'
   gem.require_paths = %W(lib)
   gem.version       = SegmentTree::VERSION
 
-  gem.add_development_dependency "bundler", ">= 1.0"
-  gem.add_development_dependency "rspec", ">= 2.11"
+  gem.add_development_dependency 'bundler', '>= 1.0'
+  gem.add_development_dependency 'rspec', '>= 3.1.0'
+  gem.add_development_dependency 'rake'
 end

data/spec/segment_tree_spec.rb

@@ -1,5 +1,5 @@
-require "spec_helper"
-require "segment_tree"
+require 'spec_helper'
+require 'segment_tree'
 
 # subject { tree }
 # it { should query(12).and_return("b") }
@@ -13,10 +13,10 @@ RSpec::Matchers.define :query do |key|
     result = tree.find(key)
     result &&= result.value
 
-    result.should eq @expected
+    expect(result).to eq @expected
   end
 
-  failure_message_for_should do |tree|
+  failure_message do |tree|
     result = tree.find(key)
     result &&= result.value
 
@@ -28,15 +28,15 @@ end
 describe SegmentTree do
   # some fixtures
   # [[0..9, "a"], [10..19, "b"], ..., [90..99, "j"]] - spanned intervals
-  let(:sample_spanned) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 1, letter] }.shuffle }
+  let(:sample_spanned) { (0..9).zip('a'..'j').map { |num, letter| [(num * 10)..(num + 1) * 10 - 1, letter] }.shuffle }
   # [[0..10, "a"], [10..20, "b"], ..., [90..100, "j"]] - partially overlapping intervals
-  let(:sample_overlapping) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 + 2, letter] }.shuffle }
+  let(:sample_overlapping) { (0..9).zip('a'..'j').map { |num, letter| [(num * 10)..(num + 1) * 10 + 2, letter] }.shuffle }
   # [[0..5, "a"], [10..15, "b"], ..., [90..95, "j"]] - sparsed intervals
-  let(:sample_sparsed) { (0..9).zip("a".."j").map { |num, letter| [(num * 10)..(num + 1) * 10 - 5, letter] }.shuffle }
+  let(:sample_sparsed) { (0..9).zip('a'..'j').map { |num, letter| [(num * 10)..(num + 1) * 10 - 5, letter] }.shuffle }
 
   # [[0..5, "a"], [0..7, "aa"], [10..15, "b"], [10..17, "bb"], ..., [90..97, "jj"]]
   let(:sample_overlapping2) do
-    (0..9).zip("a".."j").map do |num, letter|
+    (0..9).zip('a'..'j').map do |num, letter|
       [(num * 10)..(num + 1) * 10 - 5, letter,
        (num * 10)..(num + 1) * 10 - 3, letter * 2]
     end.
@@ -46,89 +46,167 @@ describe SegmentTree do
     shuffle
   end
 
-  describe ".new" do
-    context "given a hash with ranges as keys" do
+  describe '.new' do
+    context 'given a hash with ranges as keys' do
       let :data do
-        {7..9 => "a",
-         4..6 => "b",
-         0..3 => "c",
-         10..12 => "d"}
+        {7..9 => 'a',
+         4..6 => 'b',
+         0..3 => 'c',
+         10..12 => 'd'}
       end
 
       subject(:tree) { SegmentTree.new(data) }
 
-      it { should be_a SegmentTree }
+      it { is_expected.to be_a SegmentTree }
     end
 
-    context "given an array of arrays" do
+    context 'given an array of arrays' do
       let :data do
-        [[0..3, "a"],
-         [4..6, "b"],
-         [7..9, "c"],
-         [10..12, "d"]].shuffle
+        [[0..3, 'a'],
+         [4..6, 'b'],
+         [7..9, 'c'],
+         [10..12, 'd']].shuffle
       end
 
       subject(:tree) { SegmentTree.new(data) }
 
-      it { should be_a SegmentTree }
+      it { is_expected.to be_a SegmentTree }
     end
 
-    context "given preordered data" do
+    context 'given preordered data' do
       let :data do
-        [[0..3, "a"],
-         [4..6, "b"],
-         [7..9, "c"],
-         [10..12, "d"]]
+        [[0..3, 'a'],
+         [4..6, 'b'],
+         [7..9, 'c'],
+         [10..12, 'd']]
       end
 
       subject(:tree) { SegmentTree.new(data, true) }
 
-      it { should be_a SegmentTree }
-      it { should query(8).and_return("c") }
+      it { is_expected.to be_a SegmentTree }
+      it { is_expected.to query(8).and_return('c') }
     end
 
-    context "given nor hash neither array" do
+    context 'given nor hash neither array' do
       it { expect{ SegmentTree.new(Object.new) }.to raise_error(ArgumentError) }
     end
 
-    context "given 1-dimensional array" do
+    context 'given 1-dimensional array' do
       let :data do
-        [0..3, "a",
-         4..6, "b",
-         7..9, "c",
-         10..12, "d"]
+        [0..3, 'a',
+         4..6, 'b',
+         7..9, 'c',
+         10..12, 'd']
       end
 
       it { expect{ SegmentTree.new(data) }.to raise_error(ArgumentError) }
     end
   end
 
-  describe "querying" do
-    context "given spanned intervals" do
+  describe 'querying' do
+    context 'given spanned intervals' do
       subject { SegmentTree.new(sample_spanned) }
 
-      it { should query(12).and_return('b') }
-      it { should query(101).and_return(:nothing) }
+      it { is_expected.to query(12).and_return('b') }
+      it { is_expected.to query(101).and_return(:nothing) }
     end
 
-    context "given partially overlapping intervals" do
+    context 'given partially overlapping intervals' do
       subject { SegmentTree.new(sample_overlapping) }
 
-      it { should query(11).and_return('a') }
+      it { is_expected.to query(11).and_return('a') }
     end
 
-    context "given sparsed intervals" do
+    context 'given sparsed intervals' do
       subject { SegmentTree.new(sample_sparsed) }
 
-      it { should query(12).and_return('b') }
-      it { should query(8).and_return(:nothing) }
+      it { is_expected.to query(12).and_return('b') }
+      it { is_expected.to query(8).and_return(:nothing) }
     end
 
-    context "given hardly overlapping intervals" do
+    context 'given hardly overlapping intervals' do
       subject { SegmentTree.new(sample_overlapping2) }
 
-      it { should query(12).and_return('b') }
-      it { should query(8).and_return(:nothing) }
+      it { is_expected.to query(12).and_return('b') }
+      it { is_expected.to query(8).and_return(:nothing) }
     end
   end
-end
+
+  describe '#==' do
+    subject { SegmentTree.new(sample_overlapping) }
+
+    it { is_expected.to eq(SegmentTree.new(sample_overlapping)) }
+    it { is_expected.not_to eq(SegmentTree.new(sample_overlapping2)) }
+
+    it 'is equal when a range coerces' do
+      expect(SegmentTree.new((1..2) => "a")).to eq(SegmentTree.new(((1.0)..(2.0)) => "a"))
+    end
+
+    it 'is equal when a value coerces' do
+      expect(SegmentTree.new((1..2) => 1)).to eq(SegmentTree.new((1..2) => 1.0))
+    end
+
+    it "isn't equal when only a range is different" do
+      expect(SegmentTree.new((1..2) => "a")).not_to eq(SegmentTree.new((1..3) => "a"))
+    end
+
+    it "isn't equal when only a value is different" do
+      expect(SegmentTree.new((1..2) => "a")).not_to eq(SegmentTree.new((1..2) => "b"))
+    end
+  end
+
+  describe '#eql?' do
+    subject { SegmentTree.new(sample_overlapping) }
+
+    it { is_expected.to be_eql(SegmentTree.new(sample_overlapping)) }
+    it { is_expected.not_to be_eql(SegmentTree.new(sample_overlapping2)) }
+
+    it "isn't equal when a range coerces" do
+      expect(SegmentTree.new((1..2) => "a")).not_to be_eql(SegmentTree.new(((1.0)..(2.0)) => "a"))
+    end
+
+    it "isn't equal when a value coerces" do
+      expect(SegmentTree.new((1..2) => 1)).not_to be_eql(SegmentTree.new((1..2) => 1.0))
+    end
+
+    it "isn't equal when only a range is different" do
+      expect(SegmentTree.new((1..2) => "a")).not_to be_eql(SegmentTree.new((1..3) => "a"))
+    end
+
+    it "isn't equal when only a value is different" do
+      expect(SegmentTree.new((1..2) => "a")).not_to be_eql(SegmentTree.new((1..2) => "b"))
+    end
+  end
+
+  describe '#hash' do
+    subject { SegmentTree.new(sample_overlapping).hash }
+
+    it { is_expected.to eq(SegmentTree.new(sample_overlapping).hash) }
+    it { is_expected.not_to eq(SegmentTree.new(sample_overlapping2).hash) }
+
+    it "isn't equal when only a range is different" do
+      expect(SegmentTree.new((1..2) => "a").hash).not_to eq(SegmentTree.new((1..3) => "a").hash)
+    end
+
+    it "isn't equal when only a value is different" do
+      expect(SegmentTree.new((1..2) => "a").hash).not_to eq(SegmentTree.new((1..2) => "b").hash)
+    end
+  end
+
+  describe 'marshaling' do
+    it 'dumps and loads successfully' do
+      aggregate_failures do
+        [
+          sample_spanned,
+          sample_sparsed,
+          sample_overlapping,
+          sample_overlapping2,
+        ].each do |sample|
+          tree = SegmentTree.new(sample)
+          dumped = Marshal.dump(tree)
+          expect(Marshal.load(dumped)).to eq(tree)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require "bundler/setup"
+require 'bundler/setup'
 
 RSpec.configure do |config|
   # Run specs in random order to surface order dependencies. If you find an
@@ -9,8 +9,8 @@ RSpec.configure do |config|
 end
 
 if defined?(RUBY_ENGINE) &&
-    RUBY_ENGINE == "ruby" &&
-    RUBY_VERSION > "1.9"
-  require "simplecov"
+    RUBY_ENGINE == 'ruby' &&
+    RUBY_VERSION > '1.9'
+  require 'simplecov'
   SimpleCov.start
 end

metadata

@@ -1,48 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: segment_tree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
-  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors:
 - Alexei Mikhailov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-08-06 00:00:00.000000000 Z
+date: 2023-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: Tree data structure for storing segments. It allows querying which of
   the stored segments contain a given point.
 email: amikhailov83@gmail.com
@@ -50,7 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .rspec
+- ".rspec"
 - lib/segment_tree.rb
 - lib/segment_tree/version.rb
 - segment_tree.gemspec
@@ -58,31 +67,29 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/take-five/segment_tree
 licenses: []
-post_install_message: 
+metadata: {}
+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.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
 summary: Tree data structure for storing segments. It allows querying which of the
   stored segments contain a given point.
 test_files:
-- .rspec
+- ".rspec"
 - segment_tree.gemspec
 - spec/segment_tree_spec.rb
 - spec/spec_helper.rb