rangops 1.0.0.beta1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 485eb7acc54d2b3bbb164eba5bb8feb7740db3a0f0fbdeeaed3f0daa8e8e0c98
-  data.tar.gz: 074c8cc3f02759af90fd9319a82126a1be621ce626cac962c061018d76d2c175
+  metadata.gz: 5710c3163c9b9098afe8d67062eff72e52018d102c4d2eeb322038a73692b52c
+  data.tar.gz: 3a832f5d480caf10ec7dc687363d602134b3749d51531f9bc8b1967b32c2b18f
 SHA512:
-  metadata.gz: 7386938a537baa3226be2ac6f5f504acb46778c836422a809385c56acd3508b4e4a1fef6a44d2dd30fe784a1399a036a5e0804c6c0e8f3cf47e5b62f7a43e33a
-  data.tar.gz: 8b7da51eb22ee01822246af4e7fca799d10250b4b92574fef5339b850d1e709c3dcb456a5f0a562f9af9e5b6c80a4e51f36bb650c07d439c6bba96e063b71021
+  metadata.gz: d9afee6c9742f6903f5cea072e9061aa3eb5f16600a500fdd48b9c68642fe4c21d376acf64b021b19bea0a1e5e402f36cff23aae690181d295bde7774b0f1931
+  data.tar.gz: 0f06c047dd654d539c2aa93869dab696e8e32184cba8f4b30a37671d33b09159c62b11b0354b948e49b11b3ba6525afa78736e40cd82e2b2c42073503e1a29b0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rangops (1.0.0.beta1)
+    rangops (1.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,49 +1,90 @@
 # Rangops
 
-Rangops is a simple Ruby extension library that aims to treat Ranges as sets.
+Rangops is a tiny Ruby extension library that aims to treat Ranges as sets.
 
-It provides methods for elementary set related operations and predicates.
+Install it with `gem install rangops` or add `gem "rangops"` to your Gemfile.
 
-        class Range
-          include Rangops::Set
-        end
+It patches `Range` class with methods for basic set related operations
+and predicates, like:
 
 Union:
 
-        (1..5).union(3..10)
-        => 1..10
+    (1..5).union(3..10)
+    => 1..10
 
-        (11..19) | (16..23)
-        => 11..23
+    (1..5) + (3..10)
+    => 1..10
 
 Intersection:
 
-        (1..5).intersection(3..10)
-        => 3..5
+    (1..5).intersection(3..10)
+    => 3..5
 
-        (11..19) & (16..23)
-        => 16..19
+    (1..5) & (3..10)
+    => 3..5
 
 
-Complement, difference operations and subset/superset checking is also available.
-For full list of methods, check [API docs](https://bartpiet.github.io/rangops/).
+Symmetric difference:
 
-No mapping to arrays nor iterating on elements is performed, so operations
-on ranges of any size are possible without penalty on speed or memory usage.
-Ranges delimited with any type of Numerics can be operated.
+    (1..10).difference(5..15)
+    => [1..5, 10..15]
 
-        (1.0..10).union(Rational(20, 4)..Float::INFINITY)
-        => 1.0..Infinity 
+    (1..10) - (5..15)
+    => [1..5, 10..15]
 
-It works equally well on string and date ranges, although some operations may be
-not available if they only make sense for numbers.
+Relative complement:
 
-Library tries to adhere to conventions established in Ruby core and `Set` module
-from standard library. It only focuses on extending core Range class; only ranges or
-elements covered by them can be used as arguments. Due to the properties of Range class,
-most operations return meaningful results only for ranges of the same type.
+    (1..10).complement(5..15)
+    => 10..15
+
+Checking for subsets/supersets:
+
+    (2..3).subset?(0..10)
+    => true
+
+    (0..10).superset?(2..3)
+    => true
+
+
+Check [API docs](https://bartpiet.github.io/rangops/Rangops/Set.html) for full list of aliases
+and predicates.
+
+There is no mapping to arrays nor iteratons under the hood,
+just begin/end values comparison - so operations on ranges of any size are
+possible, with no penalty on speed or memory usage.
+Ranges delimited with any type of Numerics can be used.
+
+    (1.0..10).union(Rational(20, 4)..Float::INFINITY)
+    => 1.0..Infinity 
+
+Beginless and endless ranges are supported.
+
+    (nil..10).intersection(5..nil)
+    => 5..10
+
+    (nil..10).union(5..nil)
+    => nil..nil
+
+End exclusion is supported too.
+
+    (1...3).intersect?(3..10)
+    => false
+
+It works well on string and date ranges too.
+
+    ('2025-01-01'..'2026-12-31') & ('2026-01-01'..'2027-12-31')
+    => '2026-01-01'..'2026-12-31'
+
+    ('a'..'e') & ('c'..'g')
+    => "c".."e"
+
+
+Operations are supposed to return a `Range` result, so they only work on 
+arguments delimited with values of the same type.
+`(1..5) & ('c'..'g')` will just return `nil`.
 
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/docs/README_md.html

@@ -8,7 +8,7 @@
 <title>README - Rangops</title>
 
   <meta name="keywords" content="ruby,documentation,README">
-  <meta name="description" content="README: Rangops Rangops is a simple Ruby extension library that aims to treat Ranges as sets. It provides methods for elementary set related operations and p">
+  <meta name="description" content="README: Rangops Rangops is a tiny Ruby extension library that aims to treat Ranges as sets. Install it with `gem install rangops` or add `gem &quot;rangops&quot;` to y">
 
 
 <script type="text/javascript">
@@ -106,41 +106,78 @@
 
 <h1 id="label-Rangops"><a href="Rangops.html"><code>Rangops</code></a><span><a href="#label-Rangops">&para;</a> <a href="#top">&uarr;</a></span></h1>
 
-<p><a href="Rangops.html"><code>Rangops</code></a> is a simple Ruby extension library that aims to treat Ranges as sets.</p>
+<p><a href="Rangops.html"><code>Rangops</code></a> is a tiny Ruby extension library that aims to treat Ranges as sets.</p>
 
-<p>It provides methods for elementary set related operations and predicates.</p>
+<p>Install it with <code>gem install rangops</code> or add <code>gem &quot;rangops&quot;</code> to your Gemfile.</p>
 
-<pre class="ruby">    <span class="ruby-keyword">class</span> <span class="ruby-constant">Range</span>
-      <span class="ruby-identifier">include</span> <span class="ruby-constant">Rangops</span><span class="ruby-operator">::</span><span class="ruby-constant">Set</span>
-    <span class="ruby-keyword">end</span>
-</pre>
+<p>It patches <code>Range</code> class with methods for basic set related operations and predicates, like:</p>
 
 <p>Union:</p>
 
-<pre>    (1..5).union(3..10)
-    =&gt; 1..10
+<pre>(1..5).union(3..10)
+=&gt; 1..10
 
-    (11..19) | (16..23)
-    =&gt; 11..23</pre>
+(1..5) + (3..10)
+=&gt; 1..10</pre>
 
 <p>Intersection:</p>
 
-<pre>    (1..5).intersection(3..10)
-    =&gt; 3..5
+<pre>(1..5).intersection(3..10)
+=&gt; 3..5
 
-    (11..19) &amp; (16..23)
-    =&gt; 16..19</pre>
+(1..5) &amp; (3..10)
+=&gt; 3..5</pre>
 
-<p>Complement, difference operations and subset/superset checking is also available. For full list of methods, check <a href="https://bartpiet.github.io/rangops/">API docs</a>.</p>
+<p>Symmetric difference:</p>
 
-<p>No mapping to arrays nor iterating on elements is performed, so operations on ranges of any size are possible without penalty on speed or memory usage. Ranges delimited with any type of Numerics can be operated.</p>
+<pre>(1..10).difference(5..15)
+=&gt; [1..5, 10..15]
 
-<pre>    (1.0..10).union(Rational(20, 4)..Float::INFINITY)
-    =&gt; 1.0..Infinity</pre>
+(1..10) - (5..15)
+=&gt; [1..5, 10..15]</pre>
 
-<p>It works equally well on string and date ranges, although some operations may be not available if they only make sense for numbers.</p>
+<p>Relative complement:</p>
 
-<p>Library tries to adhere to conventions established in Ruby core and <code>Set</code> module from standard library. It only focuses on extending core Range class; only ranges or elements covered by them can be used as arguments. Due to the properties of Range class, most operations return meaningful results only for ranges of the same type.</p>
+<pre>(1..10).complement(5..15)
+=&gt; 10..15</pre>
+
+<p>Checking for subsets/supersets:</p>
+
+<pre>(2..3).subset?(0..10)
+=&gt; true
+
+(0..10).superset?(2..3)
+=&gt; true</pre>
+
+<p>Check <a href="https://bartpiet.github.io/rangops/Rangops/Set.html">API docs</a> for full list of aliases and predicates.</p>
+
+<p>There is no mapping to arrays nor iteratons under the hood, just begin/end values comparison - so operations on ranges of any size are possible, with no penalty on speed or memory usage. Ranges delimited with any type of Numerics can be used.</p>
+
+<pre>(1.0..10).union(Rational(20, 4)..Float::INFINITY)
+=&gt; 1.0..Infinity</pre>
+
+<p>Beginless and endless ranges are supported.</p>
+
+<pre>(nil..10).intersection(5..nil)
+=&gt; 5..10
+
+(nil..10).union(5..nil)
+=&gt; nil..nil</pre>
+
+<p>End exclusion is supported too.</p>
+
+<pre>(1...3).intersect?(3..10)
+=&gt; false</pre>
+
+<p>It works well on string and date ranges too.</p>
+
+<pre>(&#39;2025-01-01&#39;..&#39;2026-12-31&#39;) &amp; (&#39;2026-01-01&#39;..&#39;2027-12-31&#39;)
+=&gt; &#39;2026-01-01&#39;..&#39;2026-12-31&#39;
+
+(&#39;a&#39;..&#39;e&#39;) &amp; (&#39;c&#39;..&#39;g&#39;)
+=&gt; &quot;c&quot;..&quot;e&quot;</pre>
+
+<p>Operations are supposed to return a <code>Range</code> result, so they only work on arguments delimited with values of the same type. <code>(1..5) &amp; (&#39;c&#39;..&#39;g&#39;)</code> will just return <code>nil</code>.</p>
 
 <h2 id="label-License">License<span><a href="#label-License">&para;</a> <a href="#top">&uarr;</a></span></h2>
 

data/docs/Rangops/Set.html

@@ -183,7 +183,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="sort_by_boundaries-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 175</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 176</span>
 <span class="ruby-keyword">def</span> <span class="ruby-keyword">self</span>.<span class="ruby-identifier ruby-title">sort_by_boundaries</span>(<span class="ruby-identifier">a</span>, <span class="ruby-identifier">b</span>)
   <span class="ruby-identifier">ary</span> = [<span class="ruby-identifier">a</span>, <span class="ruby-identifier">b</span>]
   <span class="ruby-identifier">lower</span> = <span class="ruby-identifier">ary</span>.<span class="ruby-identifier">find</span>{ <span class="ruby-operator">|</span><span class="ruby-identifier">r</span><span class="ruby-operator">|</span> <span class="ruby-identifier">r</span>.<span class="ruby-identifier">begin</span>.<span class="ruby-identifier">nil?</span> } <span class="ruby-operator">||</span> <span class="ruby-identifier">ary</span>.<span class="ruby-identifier">sort_by</span>(<span class="ruby-operator">&amp;</span><span class="ruby-value">:begin</span>).<span class="ruby-identifier">first</span>
@@ -407,7 +407,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="disjoint-3F-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 104</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 105</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">disjoint?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-operator">!</span><span class="ruby-identifier">intersect?</span>(<span class="ruby-identifier">other</span>)
 <span class="ruby-keyword">end</span></pre>
@@ -439,7 +439,8 @@
             <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 97</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">intersect?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-identifier">lower</span>, <span class="ruby-identifier">upper</span> = <span class="ruby-constant">Set</span>.<span class="ruby-identifier">sort_by_boundaries</span>(<span class="ruby-keyword">self</span>, <span class="ruby-identifier">other</span>)
-  <span class="ruby-identifier">lower</span>.<span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">upper</span>.<span class="ruby-identifier">begin</span>) <span class="ruby-operator">||</span> <span class="ruby-identifier">upper</span>.<span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">lower</span>.<span class="ruby-identifier">end</span>)
+  <span class="ruby-identifier">lower</span>.<span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">upper</span>.<span class="ruby-identifier">begin</span>) <span class="ruby-operator">||</span>
+    (<span class="ruby-identifier">upper</span>.<span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">lower</span>.<span class="ruby-identifier">end</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-operator">!</span><span class="ruby-identifier">lower</span>.<span class="ruby-identifier">exclude_end?</span>)
 <span class="ruby-keyword">end</span></pre>
           </div>
           <p>Checks if 2 ranges have any common elements.</p>
@@ -535,7 +536,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="proper_subset-3F-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 162</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 163</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">proper_subset?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-identifier">subset?</span>(<span class="ruby-identifier">other</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-keyword">self</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">other</span>
 <span class="ruby-keyword">end</span></pre>
@@ -570,7 +571,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="proper_superset-3F-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 133</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 134</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">proper_superset?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-identifier">superset?</span>(<span class="ruby-identifier">other</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-keyword">self</span> <span class="ruby-operator">!=</span> <span class="ruby-identifier">other</span>
 <span class="ruby-keyword">end</span></pre>
@@ -605,7 +606,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="subset-3F-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 148</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 149</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">subset?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-identifier">other</span>.<span class="ruby-identifier">superset?</span>(<span class="ruby-keyword">self</span>)
 <span class="ruby-keyword">end</span></pre>
@@ -646,7 +647,7 @@
 
         <div class="method-description">
           <div class="method-source-code" id="superset-3F-source">
-            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 119</span>
+            <pre><span class="ruby-comment"># File lib/rangops/set.rb, line 120</span>
 <span class="ruby-keyword">def</span> <span class="ruby-identifier ruby-title">superset?</span>(<span class="ruby-identifier">other</span>)
   <span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">other</span>.<span class="ruby-identifier">begin</span>) <span class="ruby-operator">&amp;&amp;</span> <span class="ruby-identifier">cover?</span>(<span class="ruby-identifier">other</span>.<span class="ruby-identifier">end</span>)
 <span class="ruby-keyword">end</span></pre>

data/docs/created.rid

@@ -1,3 +1,3 @@
-Tue, 12 Aug 2025 22:43:46 +0200
-README.md	Wed, 11 Nov 2020 21:15:00 +0100
-lib/rangops/set.rb	Tue, 12 Aug 2025 22:43:14 +0200
+Thu, 14 Aug 2025 19:37:19 +0200
+README.md	Thu, 14 Aug 2025 19:34:50 +0200
+lib/rangops/set.rb	Wed, 13 Aug 2025 22:04:18 +0200

data/docs/index.html

@@ -10,7 +10,7 @@
   <meta name="keywords" content="ruby,documentation,Rangops">
 
 
-    <meta name="description" content="Rangops: Rangops Rangops is a simple Ruby extension library that aims to treat Ranges as sets. It provides methods for elementary set related operations and p">
+    <meta name="description" content="Rangops: Rangops Rangops is a tiny Ruby extension library that aims to treat Ranges as sets. Install it with `gem install rangops` or add `gem &quot;rangops&quot;` to y">
 
 
 <script type="text/javascript">
@@ -115,41 +115,78 @@
   
 <h1 id="label-Rangops"><a href="Rangops.html"><code>Rangops</code></a><span><a href="#label-Rangops">&para;</a> <a href="#top">&uarr;</a></span></h1>
 
-<p><a href="Rangops.html"><code>Rangops</code></a> is a simple Ruby extension library that aims to treat Ranges as sets.</p>
+<p><a href="Rangops.html"><code>Rangops</code></a> is a tiny Ruby extension library that aims to treat Ranges as sets.</p>
 
-<p>It provides methods for elementary set related operations and predicates.</p>
+<p>Install it with <code>gem install rangops</code> or add <code>gem &quot;rangops&quot;</code> to your Gemfile.</p>
 
-<pre class="ruby">    <span class="ruby-keyword">class</span> <span class="ruby-constant">Range</span>
-      <span class="ruby-identifier">include</span> <span class="ruby-constant">Rangops</span><span class="ruby-operator">::</span><span class="ruby-constant">Set</span>
-    <span class="ruby-keyword">end</span>
-</pre>
+<p>It patches <code>Range</code> class with methods for basic set related operations and predicates, like:</p>
 
 <p>Union:</p>
 
-<pre>    (1..5).union(3..10)
-    =&gt; 1..10
+<pre>(1..5).union(3..10)
+=&gt; 1..10
 
-    (11..19) | (16..23)
-    =&gt; 11..23</pre>
+(1..5) + (3..10)
+=&gt; 1..10</pre>
 
 <p>Intersection:</p>
 
-<pre>    (1..5).intersection(3..10)
-    =&gt; 3..5
+<pre>(1..5).intersection(3..10)
+=&gt; 3..5
 
-    (11..19) &amp; (16..23)
-    =&gt; 16..19</pre>
+(1..5) &amp; (3..10)
+=&gt; 3..5</pre>
 
-<p>Complement, difference operations and subset/superset checking is also available. For full list of methods, check <a href="https://bartpiet.github.io/rangops/">API docs</a>.</p>
+<p>Symmetric difference:</p>
 
-<p>No mapping to arrays nor iterating on elements is performed, so operations on ranges of any size are possible without penalty on speed or memory usage. Ranges delimited with any type of Numerics can be operated.</p>
+<pre>(1..10).difference(5..15)
+=&gt; [1..5, 10..15]
 
-<pre>    (1.0..10).union(Rational(20, 4)..Float::INFINITY)
-    =&gt; 1.0..Infinity</pre>
+(1..10) - (5..15)
+=&gt; [1..5, 10..15]</pre>
 
-<p>It works equally well on string and date ranges, although some operations may be not available if they only make sense for numbers.</p>
+<p>Relative complement:</p>
 
-<p>Library tries to adhere to conventions established in Ruby core and <code>Set</code> module from standard library. It only focuses on extending core Range class; only ranges or elements covered by them can be used as arguments. Due to the properties of Range class, most operations return meaningful results only for ranges of the same type.</p>
+<pre>(1..10).complement(5..15)
+=&gt; 10..15</pre>
+
+<p>Checking for subsets/supersets:</p>
+
+<pre>(2..3).subset?(0..10)
+=&gt; true
+
+(0..10).superset?(2..3)
+=&gt; true</pre>
+
+<p>Check <a href="https://bartpiet.github.io/rangops/Rangops/Set.html">API docs</a> for full list of aliases and predicates.</p>
+
+<p>There is no mapping to arrays nor iteratons under the hood, just begin/end values comparison - so operations on ranges of any size are possible, with no penalty on speed or memory usage. Ranges delimited with any type of Numerics can be used.</p>
+
+<pre>(1.0..10).union(Rational(20, 4)..Float::INFINITY)
+=&gt; 1.0..Infinity</pre>
+
+<p>Beginless and endless ranges are supported.</p>
+
+<pre>(nil..10).intersection(5..nil)
+=&gt; 5..10
+
+(nil..10).union(5..nil)
+=&gt; nil..nil</pre>
+
+<p>End exclusion is supported too.</p>
+
+<pre>(1...3).intersect?(3..10)
+=&gt; false</pre>
+
+<p>It works well on string and date ranges too.</p>
+
+<pre>(&#39;2025-01-01&#39;..&#39;2026-12-31&#39;) &amp; (&#39;2026-01-01&#39;..&#39;2027-12-31&#39;)
+=&gt; &#39;2026-01-01&#39;..&#39;2026-12-31&#39;
+
+(&#39;a&#39;..&#39;e&#39;) &amp; (&#39;c&#39;..&#39;g&#39;)
+=&gt; &quot;c&quot;..&quot;e&quot;</pre>
+
+<p>Operations are supposed to return a <code>Range</code> result, so they only work on arguments delimited with values of the same type. <code>(1..5) &amp; (&#39;c&#39;..&#39;g&#39;)</code> will just return <code>nil</code>.</p>
 
 <h2 id="label-License">License<span><a href="#label-License">&para;</a> <a href="#top">&uarr;</a></span></h2>
 

data/docs/js/search_index.js

@@ -1 +1 @@
-var search_data = {"index":{"searchIndex":["rangops","set","&()","+()","-()","complement()","contains?()","difference()","disjoint?()","intersect?()","intersection()","is_contained_by?()","proper_subset?()","proper_superset?()","sort_by_boundaries()","subset?()","superset?()","union()","|()","readme"],"longSearchIndex":["rangops","rangops::set","rangops::set#&()","rangops::set#+()","rangops::set#-()","rangops::set#complement()","rangops::set#contains?()","rangops::set#difference()","rangops::set#disjoint?()","rangops::set#intersect?()","rangops::set#intersection()","rangops::set#is_contained_by?()","rangops::set#proper_subset?()","rangops::set#proper_superset?()","rangops::set::sort_by_boundaries()","rangops::set#subset?()","rangops::set#superset?()","rangops::set#union()","rangops::set#|()",""],"info":[["Rangops","","Rangops.html","",""],["Rangops::Set","","Rangops/Set.html","","<p>Module defining basic set operations that can be performed\non ranges.\n<p>union\n<p>intersection\n"],["&","Rangops::Set","Rangops/Set.html#method-i-26","(other)",""],["+","Rangops::Set","Rangops/Set.html#method-i-2B","(other)",""],["-","Rangops::Set","Rangops/Set.html#method-i-2D","(other)",""],["complement","Rangops::Set","Rangops/Set.html#method-i-complement","(other)","<p>Relative complement of 2 ranges. Returns a range covering\nelements from <code>other</code> that are not covered by ...\n"],["contains?","Rangops::Set","Rangops/Set.html#method-i-contains-3F","(other)",""],["difference","Rangops::Set","Rangops/Set.html#method-i-difference","(other)","<p>Symmetric difference of 2 ranges. Returns ranges covering\nelements of both operands, excluding elements ...\n"],["disjoint?","Rangops::Set","Rangops/Set.html#method-i-disjoint-3F","(other)","<p>Opposite of ‘intersect?.\n"],["intersect?","Rangops::Set","Rangops/Set.html#method-i-intersect-3F","(other)","<p>Checks if 2 ranges have any common elements.\n\n<pre> (1..10).intersect?(8..15)\n =&gt; true\n\n (1..10).intersect?(11..15) ...</pre>\n"],["intersection","Rangops::Set","Rangops/Set.html#method-i-intersection","(other)","<p>Intersection of 2 ranges. Returns a range covering elements\ncommon to both ranges. Returns <code>nil</code> if ranges ...\n"],["is_contained_by?","Rangops::Set","Rangops/Set.html#method-i-is_contained_by-3F","(other)",""],["proper_subset?","Rangops::Set","Rangops/Set.html#method-i-proper_subset-3F","(other)","<p>Checks if <code>self</code> is proper subset of <code>other</code>,\ni.e. is subset and has elements not present\nin <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">proper_subset?</span>(<span class=\"ruby-value\">0</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">12</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["proper_superset?","Rangops::Set","Rangops/Set.html#method-i-proper_superset-3F","(other)","<p>Checks if <code>self</code> is proper superset of <code>other</code>,\ni.e. is superset and has elements not present\nin <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">proper_superset?</span>(<span class=\"ruby-value\">2</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["sort_by_boundaries","Rangops::Set","Rangops/Set.html#method-c-sort_by_boundaries","(a, b)","<p>Determine which range has lower begin, and which one higher end.\n"],["subset?","Rangops::Set","Rangops/Set.html#method-i-subset-3F","(other)","<p>Checks if <code>self</code> is subset of <code>other</code>, i.e. all\nelements of <code>self</code> fit within <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">subset?</span>(<span class=\"ruby-value\">0</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">12</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["superset?","Rangops::Set","Rangops/Set.html#method-i-superset-3F","(other)","<p>Checks if <code>self</code> is superset of <code>other</code>, i.e. all\nelements of <code>other</code> fit within <code>self</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">superset?</span>(<span class=\"ruby-value\">2</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["union","Rangops::Set","Rangops/Set.html#method-i-union","(other)","<p>Union of 2 ranges. Returns a range covering sum of all elements\nbelonging to both ranges. Returns <code>nil</code> ...\n"],["|","Rangops::Set","Rangops/Set.html#method-i-7C","(other)",""],["README","","README_md.html","","<p>Rangops\n<p>Rangops is a simple Ruby extension library that aims to treat Ranges as sets.\n<p>It provides methods …\n"]]}}
+var search_data = {"index":{"searchIndex":["rangops","set","&()","+()","-()","complement()","contains?()","difference()","disjoint?()","intersect?()","intersection()","is_contained_by?()","proper_subset?()","proper_superset?()","sort_by_boundaries()","subset?()","superset?()","union()","|()","readme"],"longSearchIndex":["rangops","rangops::set","rangops::set#&()","rangops::set#+()","rangops::set#-()","rangops::set#complement()","rangops::set#contains?()","rangops::set#difference()","rangops::set#disjoint?()","rangops::set#intersect?()","rangops::set#intersection()","rangops::set#is_contained_by?()","rangops::set#proper_subset?()","rangops::set#proper_superset?()","rangops::set::sort_by_boundaries()","rangops::set#subset?()","rangops::set#superset?()","rangops::set#union()","rangops::set#|()",""],"info":[["Rangops","","Rangops.html","",""],["Rangops::Set","","Rangops/Set.html","","<p>Module defining basic set operations that can be performed\non ranges.\n<p>union\n<p>intersection\n"],["&","Rangops::Set","Rangops/Set.html#method-i-26","(other)",""],["+","Rangops::Set","Rangops/Set.html#method-i-2B","(other)",""],["-","Rangops::Set","Rangops/Set.html#method-i-2D","(other)",""],["complement","Rangops::Set","Rangops/Set.html#method-i-complement","(other)","<p>Relative complement of 2 ranges. Returns a range covering\nelements from <code>other</code> that are not covered by ...\n"],["contains?","Rangops::Set","Rangops/Set.html#method-i-contains-3F","(other)",""],["difference","Rangops::Set","Rangops/Set.html#method-i-difference","(other)","<p>Symmetric difference of 2 ranges. Returns ranges covering\nelements of both operands, excluding elements ...\n"],["disjoint?","Rangops::Set","Rangops/Set.html#method-i-disjoint-3F","(other)","<p>Opposite of ‘intersect?.\n"],["intersect?","Rangops::Set","Rangops/Set.html#method-i-intersect-3F","(other)","<p>Checks if 2 ranges have any common elements.\n\n<pre> (1..10).intersect?(8..15)\n =&gt; true\n\n (1..10).intersect?(11..15) ...</pre>\n"],["intersection","Rangops::Set","Rangops/Set.html#method-i-intersection","(other)","<p>Intersection of 2 ranges. Returns a range covering elements\ncommon to both ranges. Returns <code>nil</code> if ranges ...\n"],["is_contained_by?","Rangops::Set","Rangops/Set.html#method-i-is_contained_by-3F","(other)",""],["proper_subset?","Rangops::Set","Rangops/Set.html#method-i-proper_subset-3F","(other)","<p>Checks if <code>self</code> is proper subset of <code>other</code>,\ni.e. is subset and has elements not present\nin <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">proper_subset?</span>(<span class=\"ruby-value\">0</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">12</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["proper_superset?","Rangops::Set","Rangops/Set.html#method-i-proper_superset-3F","(other)","<p>Checks if <code>self</code> is proper superset of <code>other</code>,\ni.e. is superset and has elements not present\nin <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">proper_superset?</span>(<span class=\"ruby-value\">2</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["sort_by_boundaries","Rangops::Set","Rangops/Set.html#method-c-sort_by_boundaries","(a, b)","<p>Determine which range has lower begin, and which one higher end.\n"],["subset?","Rangops::Set","Rangops/Set.html#method-i-subset-3F","(other)","<p>Checks if <code>self</code> is subset of <code>other</code>, i.e. all\nelements of <code>self</code> fit within <code>other</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">subset?</span>(<span class=\"ruby-value\">0</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">12</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["superset?","Rangops::Set","Rangops/Set.html#method-i-superset-3F","(other)","<p>Checks if <code>self</code> is superset of <code>other</code>, i.e. all\nelements of <code>other</code> fit within <code>self</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">superset?</span>(<span class=\"ruby-value\">2</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["union","Rangops::Set","Rangops/Set.html#method-i-union","(other)","<p>Union of 2 ranges. Returns a range covering sum of all elements\nbelonging to both ranges. Returns <code>nil</code> ...\n"],["|","Rangops::Set","Rangops/Set.html#method-i-7C","(other)",""],["README","","README_md.html","","<p>Rangops\n<p>Rangops is a tiny Ruby extension library that aims to treat Ranges as sets.\n<p>Install it with <code>gem</code> …\n"]]}}

data/docs/table_of_contents.html

@@ -10,7 +10,7 @@
   <meta name="keywords" content="ruby,documentation,Table of Contents - Rangops">
 
 
-    <meta name="description" content="Table of Contents - Rangops: Rangops Rangops is a simple Ruby extension library that aims to treat Ranges as sets. It provides methods for elementary set related operations and p">
+    <meta name="description" content="Table of Contents - Rangops: Rangops Rangops is a tiny Ruby extension library that aims to treat Ranges as sets. Install it with `gem install rangops` or add `gem &quot;rangops&quot;` to y">
 
 
 <script type="text/javascript">

data/lib/rangops/set.rb

@@ -96,7 +96,8 @@ module Rangops
     #      => false
     def intersect?(other)
       lower, upper = Set.sort_by_boundaries(self, other)
-      lower.cover?(upper.begin) || upper.cover?(lower.end)
+      lower.cover?(upper.begin) ||
+        (upper.cover?(lower.end) && !lower.exclude_end?)
     end
 
 

data/lib/rangops/version.rb

@@ -1,3 +1,3 @@
 module Rangops
-  VERSION = "1.0.0.beta1"
+  VERSION = "1.0.0"
 end

data/rangops.gemspec

@@ -13,6 +13,13 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://bartpiet.github.io/rangops/"
   spec.license       = "MIT"
 
+  spec.metadata = {
+    "bug_tracker_uri"   => "https://github.com/bartpiet/rangops/issues",
+    "documentation_uri" => "https://bartpiet.github.io/rangops/",
+    "homepage_uri"      => "https://github.com/bartpiet/rangops",
+    "source_code_uri"   => "https://github.com/bartpiet/rangops",
+  }
+
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rangops
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta1
+  version: 1.0.0
 platform: ruby
 authors:
 - Bartosz Pietraszko
 bindir: bin
 cert_chain: []
-date: 2025-08-13 00:00:00.000000000 Z
+date: 2025-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -120,6 +120,10 @@ homepage: https://bartpiet.github.io/rangops/
 licenses:
 - MIT
 metadata:
+  bug_tracker_uri: https://github.com/bartpiet/rangops/issues
+  documentation_uri: https://bartpiet.github.io/rangops/
+  homepage_uri: https://github.com/bartpiet/rangops
+  source_code_uri: https://github.com/bartpiet/rangops
   allowed_push_host: https://rubygems.org
 rdoc_options: []
 require_paths: