philiprehberger-interval 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32f7667847de4edfef6e6bed9ba746bb591406c692db772569d09d46d9bbc412
-  data.tar.gz: 8e4a1395612a8fe831f347425fc620d98199c203271477775174f9f1e12a97a6
+  metadata.gz: 6039cd1187d208aeb17ffae5d095d4dd9416fd8175f95084984600dc36c15b74
+  data.tar.gz: 4cb497c7a97490954a47568a6b024e517f71a680f040644073b60b316f6fe174
 SHA512:
-  metadata.gz: 15efa08d08720b493aa265bd88db732d235cbb8a88f6364ffd3f9aa5865c7a42ed2a5f33851e7a7e43f54f8a7b36ea5d4a0f5d6fb20f5ef885b7bb38a8d7ac6a
-  data.tar.gz: 0dd947ea52c1536545d019c2bef21288fefcb6d7650464ac406ec7ccdcd87d1f521229f601424066866b4ef710e401437a5740dbda5f0e2cc27e6ed763fae386
+  metadata.gz: 60355c282c23da5623dc104947363632290343db018701c800f0b10e65bb64d87e5c5e0a69b08ca309ee7241318d92381cca64a1f9fc0f5be036a139d2258b9a
+  data.tar.gz: 4c686abfd2318284ca810c87d25787804029ec3355039f56f3a859d3abdae8925704e0320a3ac6be192174dbe426fd28622ce73be36d514e0e18ae00b26117f1

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-04-03
+
+### Added
+- Open, half-open interval types via `type:` parameter (`:closed`, `:open`, `:left_open`, `:right_open`)
+- `shift` method for translating intervals
+- `scale` method for resizing around an anchor point
+- `split` method for dividing into equal sub-intervals
+- `clamp` method for constraining values to interval bounds
+
+## [0.1.6] - 2026-03-31
+
+### Added
+- Add GitHub issue templates, dependabot config, and PR template
+
+## [0.1.5] - 2026-03-31
+
+### Changed
+- Standardize README badges, support section, and license format
+
 ## [0.1.4] - 2026-03-26
 
 ### Changed

data/README.md

@@ -2,10 +2,9 @@
 
 [![Tests](https://github.com/philiprehberger/rb-interval/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-interval/actions/workflows/ci.yml)
 [![Gem Version](https://badge.fury.io/rb/philiprehberger-interval.svg)](https://rubygems.org/gems/philiprehberger-interval)
-[![License](https://img.shields.io/github/license/philiprehberger/rb-interval)](LICENSE)
-[![Sponsor](https://img.shields.io/badge/sponsor-GitHub%20Sponsors-ec6cb9)](https://github.com/sponsors/philiprehberger)
+[![Last updated](https://img.shields.io/github/last-commit/philiprehberger/rb-interval)](https://github.com/philiprehberger/rb-interval/commits/main)
 
-Interval data type with overlap detection, merging, and gap finding
+Interval data type with open/closed boundaries, arithmetic, merging, and gap finding
 
 ## Requirements
 
@@ -39,6 +38,32 @@ a.union(b)         # => [1, 8]
 a.include?(4)      # => true
 ```
 
+### Interval Types
+
+Supports closed, open, and half-open boundaries:
+
+```ruby
+closed     = Philiprehberger::Interval.new(1, 5, type: :closed)     # [1, 5] (default)
+open       = Philiprehberger::Interval.new(1, 5, type: :open)       # (1, 5)
+left_open  = Philiprehberger::Interval.new(1, 5, type: :left_open)  # (1, 5]
+right_open = Philiprehberger::Interval.new(1, 5, type: :right_open) # [1, 5)
+
+closed.include?(5)      # => true
+right_open.include?(5)  # => false
+```
+
+### Interval Arithmetic
+
+```ruby
+interval = Philiprehberger::Interval.new(2, 8)
+
+interval.shift(3)                    # => [5, 11]
+interval.scale(2, anchor: :left)     # => [2, 14]
+interval.scale(0.5, anchor: :center) # => [3.5, 6.5]
+interval.split(3)                    # => [[2, 4], [4, 6], [6, 8]]
+interval.clamp(10)                   # => 8
+```
+
 ### Merging Intervals
 
 ```ruby
@@ -69,15 +94,20 @@ shift.include?(Time.new(2026, 1, 1, 12))  # => true
 
 | Method | Description |
 |--------|-------------|
-| `.new(start, finish)` | Create a closed interval |
-| `#overlaps?(other)` | Check if two intervals overlap |
+| `.new(start, finish, type:)` | Create an interval (`:closed`, `:open`, `:left_open`, `:right_open`) |
+| `#type` | Return the interval boundary type |
+| `#overlaps?(other)` | Check if two intervals overlap (respects boundary types) |
 | `#contains?(other)` | Check if interval fully contains another |
 | `#adjacent?(other)` | Check if intervals are touching but not overlapping |
 | `#intersect(other)` | Return the overlap between two intervals |
 | `#union(other)` | Return the combined interval |
 | `#subtract(other)` | Remove another interval, returning remaining parts |
 | `#size` | Length of the interval |
-| `#include?(point)` | Check if a point falls within the interval |
+| `#include?(point)` | Check if a point falls within the interval (respects boundary types) |
+| `#shift(delta)` | Return new interval shifted by delta, preserving type |
+| `#scale(factor, anchor:)` | Scale width around anchor (`:center`, `:left`, `:right`) |
+| `#split(n)` | Split into n equal sub-intervals |
+| `#clamp(value)` | Clamp value to interval bounds |
 | `.merge(intervals)` | Merge overlapping intervals into non-overlapping set |
 | `.gaps(intervals)` | Find gaps between a set of intervals |
 
@@ -89,6 +119,24 @@ bundle exec rspec
 bundle exec rubocop
 ```
 
+## Support
+
+If you find this project useful:
+
+⭐ [Star the repo](https://github.com/philiprehberger/rb-interval)
+
+🐛 [Report issues](https://github.com/philiprehberger/rb-interval/issues?q=is%3Aissue+is%3Aopen+label%3Abug)
+
+💡 [Suggest features](https://github.com/philiprehberger/rb-interval/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement)
+
+❤️ [Sponsor development](https://github.com/sponsors/philiprehberger)
+
+🌐 [All Open Source Projects](https://philiprehberger.com/open-source-packages)
+
+💻 [GitHub Profile](https://github.com/philiprehberger)
+
+🔗 [LinkedIn Profile](https://www.linkedin.com/in/philiprehberger)
+
 ## License
 
 [MIT](LICENSE)

data/lib/philiprehberger/interval/range.rb

@@ -2,7 +2,10 @@
 
 module Philiprehberger
   module Interval
-    # Represents a closed interval [start, finish] over any Comparable type.
+    VALID_TYPES = %i[closed open left_open right_open].freeze
+
+    # Represents an interval over any Comparable type.
+    # Supports closed [a, b], open (a, b), left-open (a, b], and right-open [a, b) boundaries.
     class Range
       include Comparable
 
@@ -12,16 +15,23 @@ module Philiprehberger
       # @return [Comparable] the end of the interval
       attr_reader :finish
 
+      # @return [Symbol] the interval type (:closed, :open, :left_open, :right_open)
+      attr_reader :type
+
       # Create a new interval.
       #
       # @param start [Comparable] the start value
       # @param finish [Comparable] the end value
+      # @param type [Symbol] boundary type (:closed, :open, :left_open, :right_open)
       # @raise [Error] if start > finish
-      def initialize(start, finish)
+      # @raise [Error] if type is invalid
+      def initialize(start, finish, type: :closed)
         raise Error, 'start must be <= finish' if start > finish
+        raise Error, "invalid interval type: #{type}" unless VALID_TYPES.include?(type)
 
         @start = start
         @finish = finish
+        @type = type
       end
 
       # Check if this interval overlaps with another.
@@ -29,7 +39,21 @@ module Philiprehberger
       # @param other [Range] the other interval
       # @return [Boolean]
       def overlaps?(other)
-        @start <= other.finish && other.start <= @finish
+        return false if empty? || other.empty?
+
+        left_ok = if right_closed? && other.left_closed?
+                    @finish >= other.start
+                  else
+                    @finish > other.start
+                  end
+
+        right_ok = if other.right_closed? && left_closed?
+                     other.finish >= @start
+                   else
+                     other.finish > @start
+                   end
+
+        left_ok && right_ok
       end
 
       # Check if this interval fully contains another.
@@ -94,7 +118,66 @@ module Philiprehberger
       # @param point [Comparable] the point to check
       # @return [Boolean]
       def include?(point)
-        point >= @start && point <= @finish
+        left = left_closed? ? point >= @start : point > @start
+        right = right_closed? ? point <= @finish : point < @finish
+        left && right
+      end
+
+      # Return a new interval shifted by delta, preserving type.
+      #
+      # @param delta [Numeric] the amount to shift
+      # @return [Range] a new shifted interval
+      def shift(delta)
+        self.class.new(@start + delta, @finish + delta, type: @type)
+      end
+
+      # Scale interval width around an anchor point, preserving type.
+      #
+      # @param factor [Numeric] the scale factor
+      # @param anchor [Symbol] the anchor point (:center, :left, :right)
+      # @return [Range] a new scaled interval
+      def scale(factor, anchor: :center)
+        current_size = size
+        new_size = current_size * factor
+
+        case anchor
+        when :left
+          self.class.new(@start, @start + new_size, type: @type)
+        when :right
+          self.class.new(@finish - new_size, @finish, type: @type)
+        when :center
+          center = @start + (current_size / 2.0)
+          half = new_size / 2.0
+          self.class.new(center - half, center + half, type: @type)
+        else
+          raise Error, "invalid anchor: #{anchor}"
+        end
+      end
+
+      # Split interval into n equal sub-intervals, preserving type.
+      #
+      # @param n [Integer] number of sub-intervals
+      # @return [Array<Range>] array of n equal sub-intervals
+      def split(n)
+        raise Error, 'n must be positive' if n < 1
+
+        step = size.to_f / n
+        Array.new(n) do |i|
+          sub_start = @start + (step * i)
+          sub_finish = @start + (step * (i + 1))
+          self.class.new(sub_start, sub_finish, type: @type)
+        end
+      end
+
+      # Clamp a value to the interval bounds.
+      #
+      # @param value [Comparable] the value to clamp
+      # @return [Comparable] the clamped value
+      def clamp(value)
+        return @start if value < @start
+        return @finish if value > @finish
+
+        value
       end
 
       # Compare intervals by start then finish.
@@ -108,18 +191,37 @@ module Philiprehberger
 
       # @return [Boolean]
       def ==(other)
-        other.is_a?(self.class) && @start == other.start && @finish == other.finish
+        other.is_a?(self.class) && @start == other.start && @finish == other.finish && @type == other.type
       end
 
       # @return [String]
       def to_s
-        "[#{@start}, #{@finish}]"
+        left_bracket = left_closed? ? '[' : '('
+        right_bracket = right_closed? ? ']' : ')'
+        "#{left_bracket}#{@start}, #{@finish}#{right_bracket}"
       end
 
       # @return [String]
       def inspect
         "#<#{self.class} #{self}>"
       end
+
+      # @return [Boolean] true if the left endpoint is included
+      def left_closed?
+        @type == :closed || @type == :right_open
+      end
+
+      # @return [Boolean] true if the right endpoint is included
+      def right_closed?
+        @type == :closed || @type == :left_open
+      end
+
+      protected
+
+      # @return [Boolean] true if the interval contains no points
+      def empty?
+        @start == @finish && @type != :closed
+      end
     end
   end
 end

data/lib/philiprehberger/interval/version.rb

@@ -2,6 +2,6 @@
 
 module Philiprehberger
   module Interval
-    VERSION = "0.1.4"
+    VERSION = '0.2.0'
   end
 end

data/lib/philiprehberger/interval.rb

@@ -12,8 +12,8 @@ module Philiprehberger
     # @param start [Comparable] the start value
     # @param finish [Comparable] the end value
     # @return [Range] a new interval
-    def self.new(start, finish)
-      Range.new(start, finish)
+    def self.new(start, finish, type: :closed)
+      Range.new(start, finish, type: type)
     end
 
     # Merge a collection of overlapping or adjacent intervals into non-overlapping intervals.
@@ -44,7 +44,7 @@ module Philiprehberger
     # @param intervals [Array<Range>] the intervals to analyze
     # @return [Array<Range>] gaps between the merged intervals
     def self.gaps(intervals)
-      merged = self.merge(intervals)
+      merged = merge(intervals)
       return [] if merged.length < 2
 
       result = []

metadata

@@ -1,18 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: philiprehberger-interval
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Philip Rehberger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-27 00:00:00.000000000 Z
+date: 2026-04-03 00:00:00.000000000 Z
 dependencies: []
-description: Closed interval data type supporting overlap detection, containment,
-  intersection, union, subtraction, merging collections, and finding gaps. Works with
-  any Comparable type including Numeric and Time.
+description: Interval data type supporting closed, open, and half-open boundaries
+  with overlap detection, containment, intersection, union, subtraction, shift, scale,
+  split, clamp, merging collections, and finding gaps. Works with any Comparable type
+  including Numeric and Time.
 email:
 - me@philiprehberger.com
 executables: []
@@ -25,11 +26,11 @@ files:
 - lib/philiprehberger/interval.rb
 - lib/philiprehberger/interval/range.rb
 - lib/philiprehberger/interval/version.rb
-homepage: https://github.com/philiprehberger/rb-interval
+homepage: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-interval
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/philiprehberger/rb-interval
+  homepage_uri: https://philiprehberger.com/open-source-packages/ruby/philiprehberger-interval
   source_code_uri: https://github.com/philiprehberger/rb-interval
   changelog_uri: https://github.com/philiprehberger/rb-interval/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/philiprehberger/rb-interval/issues
@@ -52,5 +53,6 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Interval data type with overlap detection, merging, and gap finding
+summary: Interval data type with open/closed boundaries, arithmetic, merging, and
+  gap finding
 test_files: []