gui_geometry2 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5b1ce600043107151ce24dfa9b9ba280b69c45f807d6ede5460157e8d43b01c
+  data.tar.gz: 62651f258dabe0f1b435ec77f4342e3400b9ba01eddedd27112c2a9514a04ac9
+SHA512:
+  metadata.gz: a9a71af16a2383caf95ce5e77bc8555b0e332aad972c61a92f1fa91d174cf23e3dc89c3036088c93665e08c9d4ce0497bc4b1365f68934fcf7572dab79e9fd5b
+  data.tar.gz: a203e70a11d5ca3fc7892a05ca762b5f92f8b8012f0976a6705c0f00afaa8eb82ff03974b460c72053ec15e0cdca6eefd0c616da03645b9da20b84ef1067b4f0

data/.github/workflows/rake.yml

@@ -0,0 +1,22 @@
+# see also https://github.com/whitequark/parser/blob/master/.github/workflows/test.yml
+name: Rake
+
+on: [push]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby_version: [head, "4.0", "3.2"]
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby_version }}
+          bundler-cache: true # 'bundle install' and cache
+      - name: Run the default task
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,8 @@
+# ~/.gitignore included
+
+**/*.gem
+**/*.lock
+**/*.log
+
+.watchr
+coverage

data/.ruby-version

@@ -0,0 +1 @@
+ruby-4.0.6

data/.watchr

@@ -0,0 +1 @@
+/home/dk/shared/.watchr-gem

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in gui_geometry.gemspec
+gemspec
+
+group :test do
+  gem "benchmark"
+  gem "benchmark-ips"
+  gem "cuco"
+  gem "ricecream", require: false
+  gem "simplecov", require: false
+  gem "standard", require: false
+end

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Shane Brinkman-Davis
+Copyright (c) 2026 Dittmar Krall (www.matiq.com)
+
+MIT License
+
+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,106 @@
+# GuiGeo
+
+[![Gem Version](https://img.shields.io/gem/v/guigeo2?color=168AFE&logo=rubygems&logoColor=FE1616)](https://rubygems.org/gems/guigeo2)
+[![Downloads](https://img.shields.io/gem/dt/guigeo2?color=168AFE&logo=rubygems&logoColor=FE1616)](https://rubygems.org/gems/guigeo2)
+[![GitHub Build](https://img.shields.io/github/actions/workflow/status/matique/guigeo2/rake.yml?logo=github)](https://github.com/matique/guigeo2/actions/workflows/rake.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-168AFE.svg)](https://github.com/standardrb/standard)
+[![MIT License](https://img.shields.io/badge/license-MIT-168AFE.svg)](http://choosealicense.com/licenses/mit/)
+
+There are a few good geometry gems already available for
+Ruby (ruby-geometry and geometry),
+but I need one which is focused on the needs of creating 2D graphical
+user interfaces.
+
+# GuiGeo2
+
+## GuiGeo2 vs GuiGeo
+
+- Ruby 3+: minor changes
+- Added workflow: Github testing with multiple versions of Ruby
+- Added benchmarks
+- Removed method disjoint
+- Removed Guardfile
+- Linter: using gem standard
+- Restructuring
+- Rspec replaced by Minitest
+- Breaking change: rect & rect means intersection
+- Breaking change: rect | rect means union
+
+## Installation
+
+As usual:
+
+~~~~ruby
+# Gemfile
+...
+gem "guigeo2"
+...
+~~~~
+
+and run "bundle install".
+
+## Usage (copied from GuiGeo)
+
+Points are represented by X and Y coordinates:
+
+Rectangles consist of two point objects.
+One specifies the location of the rectangle - it's top-left corner.
+The other specifies its size in terms of width then height.
+
+``` ruby
+require "gui_geometry"
+include GuiGeo2
+
+# create point x == y == 0
+point
+# => point(0, 0)
+
+# create a point x=3, y=4
+my_point = point(3, 4)
+# => point(3, 4)
+
+[my_point.x, my_point.y]
+# => [3, 4]
+
+# create a rectangle - x, y, w, h form
+rect(4, 5, 100, 80)
+# => rect(4, 5, 100, 80)
+
+# create rectangle - location, size form
+my_rect = rect point(4, 5), point(100, 80)
+# => rect(4, 5, 100, 80)
+
+# create rectangle - size form (location defaults to 0,0
+rect point(30, 50)
+# => rect(0, 0, 30, 50)
+
+# get loc and size:
+[my_rect.loc, my_rect.size]
+# => [point(4, 5), point(100, 80)]
+
+# get x, y, width and height
+[my_rect.x, my_rect.y, my_rect.w, my_rect.h]
+# => [4, 5, 100, 80]
+
+# get the 4 corners:
+[my_rect.tl, my_rect.tr, my_rect.bl, my_rect.br]
+# => [point(4, 5), point(104, 5), point(4, 85), point(104, 85)]
+```
+
+To get access to min, max, bound, and minmax:
+
+```
+include GuiGeo2::Tools
+
+min(4, 5)
+# => 4
+
+max(4, 5)
+# => 5
+
+minmax(4, 5)
+# => [4, 5]
+
+bound(5, 4, 10)
+# => 5
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require "rake"
+require "rake/testtask"
+require "bundler/gem_tasks"
+
+Rake::TestTask.new do |t|
+  t.libs.push "test"
+  t.pattern = "test/*_test.rb"
+end
+
+desc "Default: run unit tests."
+task default: :test

data/gui_geometry.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "gui_geometry/version"
+
+Gem::Specification.new do |s|
+  s.name = "gui_geometry2"
+  s.version = GuiGeo2::VERSION
+  s.authors = ["Dittmar Krall", "Shane Brinkman-Davis"]
+  s.email = ["dittmar.krall@matiq.com", "shanebdavis@gmail.com"]
+  s.description = "2D geometry specificly designed to support graphical user interfaces and bitmaps currently focsued on Point and Rectangle classes"
+  s.summary = "2D geometry specificly designed to support graphical user interfaces and bitmaps"
+  s.homepage = "https://github.com/shanebdavis/gui_geometry"
+  s.license = "MIT"
+
+  s.files = `git ls-files`.split($/)
+  s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 3"
+
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "simplecov"
+end

data/lib/gui_geometry/alias.rb

@@ -0,0 +1,21 @@
+class GuiGeo2::Point
+  include GuiGeo2::Tools
+
+  alias_method :w, :x
+  alias_method :width, :x
+  alias_method :col, :x
+  alias_method :column, :x
+
+  alias_method :h, :y
+  # alias_method :height, :y # reserved?
+  alias_method :line, :y
+end
+
+class GuiGeo2::Rectangle
+  include GuiGeo2::Tools
+
+  alias_method :width, :w
+  alias_method :height, :h
+  alias_method :|, :union
+  alias_method :&, :intersection
+end

data/lib/gui_geometry/point.rb

@@ -0,0 +1,31 @@
+class GuiGeo2::Point < Struct.new(:x, :y)
+  include GuiGeo2::Tools
+
+  def initialize(*args)
+    self.x = self.y = 0
+    super if args.length != 0
+    raise ArgumentError unless valid?
+  end
+
+  def valid? = x.is_a?(Integer) && y.is_a?(Integer)
+
+  def +(other) = other.is_a?(Point) ? point(x + other.x, y + other.y) : point(x + other, y + other)
+  def -(other) = other.is_a?(Point) ? point(x - other.x, y - other.y) : point(x - other, y - other)
+  def *(other) = other.is_a?(Point) ? point(x * other.x, y * other.y) : point(x * other, y * other)
+  def /(other) = other.is_a?(Point) ? point(x / other.x, y / other.y) : point(x / other, y / other)
+
+  def >=(other) = x >= other.x && y >= other.y
+  def <=(other) = x <= other.x && y <= other.y
+  def >(other) = x > other.x && y > other.y
+  def <(other) = x < other.x && y < other.y
+
+  def min(b) = point(Tools.min(x, b.x), Tools.min(y, b.y))
+  def max(b) = point(Tools.max(x, b.x), Tools.max(y, b.y))
+  def bound(a, b) = point(Tools.bound(a.x, x, b.x), Tools.bound(a.y, y, b.y))
+
+  def area = x * y
+
+  def clone = point(clone_value(x), clone_value(y))
+  def inspect = "point(#{x}, #{y})"
+  def to_s = "(#{x}, #{y})"
+end

data/lib/gui_geometry/rectangle.rb

@@ -0,0 +1,33 @@
+class GuiGeo2::Rectangle < Struct.new(:loc, :size)
+  include GuiGeo2::Tools
+
+  def initialize(*args)
+    case args.length
+    when 0 then super(point, point)
+    when 1 then super(point, args[0])
+    when 2 then super(args[0], args[1])
+    when 4 then super(point(*args[0..1]), point(*args[2..3]))
+    else raise ArgumentError
+    end
+    raise ArgumentError unless valid?
+  end
+
+  def valid? = loc.valid? && size.valid?
+
+  def +(other)
+    other.is_a?(Point) ? rect(loc + other, size) : rect(loc + other.loc, size + other.size)
+  end
+
+  def -(other)
+    other.is_a?(Point) ? rect(loc - other, size) : rect(loc - other.loc, size - other.size)
+  end
+
+  def present? = w > 0 && h > 0
+  def blank? = !present?
+  def clone = rect loc.clone, size.clone
+
+  def area = size.area
+
+  def inspect = "rect" + to_s
+  def to_s = "(#{[loc.x, loc.y, size.x, size.y].join ", "})"
+end

data/lib/gui_geometry/rectangle2.rb

@@ -0,0 +1,57 @@
+# rectangle 2
+
+class GuiGeo2::Rectangle
+  include GuiGeo2::Tools
+
+  # val can be a Rectangle or Point
+  # returns a Rectangle or Point that is within this Rectangle
+  # For Rectangles, the size is only changed if it has to be
+  def bound(val)
+    case val
+    when Rectangle
+      r = val.clone
+      r.size = r.size.min(size)
+      r.loc = r.loc.bound(loc, loc + size - val.size)
+      r
+    when Point then (val - loc).bound(point, size) + loc
+    else raise ArgumentError, "wrong type: (#{val.class}) - Rectangle or Point expected"
+    end
+  end
+
+  def overlaps?(val)
+    case val
+    when nil then false
+    when Point
+      contains?(val)
+    when Rectangle
+      val.loc + val.size > loc && loc + size > val.loc
+    else raise ArgumentError, "wrong type: (#{val.class}) - Rectangle or Point expected"
+    end
+  end
+
+  def contains?(val)
+    case val
+    when nil then false
+    when Point
+      val >= loc && val < (loc + size)
+    when Rectangle
+      (self | val) == self
+    else raise ArgumentError, "wrong type: (#{val.class}) - Rectangle or Point expected"
+    end
+  end
+
+  def union(b)
+    return clone unless b
+    l = loc.min(b.loc)
+    s = br.max(b.br) - l
+    rect l, s
+  end
+
+  def intersection(b)
+    return self unless b
+    l = loc.max(b.loc)
+    s = br.min(b.br) - l
+    return rect unless s > point
+    rect l, s
+  end
+end

data/lib/gui_geometry/rectangle3.rb

@@ -0,0 +1,21 @@
+class GuiGeo2::Rectangle
+  include GuiGeo2::Tools
+
+  def x = loc.x
+  def y = loc.y
+  def w = size.w
+  def h = size.h
+
+  def x_range = x...(x + w)
+  def y_range = y...(y + h)
+
+  def tl = loc
+  def tr = point(x + w, y)
+  def bl = point(x, y + h)
+  def br = loc + size
+
+  def left = loc.x
+  def top = loc.y
+  def right = loc.x + size.x
+  def bottom = loc.y + size.y
+end

data/lib/gui_geometry/tools.rb

@@ -0,0 +1,23 @@
+module GuiGeo2
+  module Tools
+    include ::GuiGeo2
+
+    def min(a, b) = (a < b) ? a : b
+    def max(a, b) = (a > b) ? a : b
+    def bound(a, bounded, c) = max(a, min(bounded, c))
+
+    def minmax(a, b) = (a <= b) ? [a, b] : [b, a]
+
+    def clone_value(v) = v
+    # def clone_value(v)
+    #   case v
+    #   when Integer, Float then v
+    #   else v.clone
+    #   end
+    # end
+
+    class << self
+      include GuiGeo2::Tools
+    end
+  end
+end

data/lib/gui_geometry/version.rb

@@ -0,0 +1,4 @@
+module GuiGeo2
+  VERSION = "3.0.0" # 2026-08-20
+  # VERSION = "0.3.1"
+end

data/lib/gui_geometry.rb

@@ -0,0 +1,9 @@
+%w[tools point rectangle rectangle2 rectangle3
+  alias version].each do |file|
+  require File.join(File.dirname(__FILE__), "gui_geometry", file)
+end
+
+module GuiGeo2
+  def point(...) = GuiGeo2::Point.new(...)
+  def rect(...) = GuiGeo2::Rectangle.new(...)
+end

data/test/alias_test.rb

@@ -0,0 +1,29 @@
+require "test_helper"
+
+describe "Alias" do
+  include GuiGeo2::Tools
+
+  let(:p34) { point(3, 4) }
+  let(:r1234) { rect(1, 2, 3, 4) }
+  let(:r1235) { rect(1, 2, 3, 5) }
+
+  it "alias for Point x" do
+    assert_equal p34.x, p34.w
+    assert_equal p34.x, p34.width
+    assert_equal p34.x, p34.col
+    assert_equal p34.x, p34.column
+  end
+
+  it "alias for Point y" do
+    assert_equal p34.y, p34.h
+    # assert_equal p34.y, p34.height # reserved word?
+    assert_equal p34.y, p34.line
+  end
+
+  it "alias for rectanglex" do
+    assert_equal r1234.w, r1234.width
+    assert_equal r1234.h, r1234.height
+    assert_equal r1234 | r1235, r1234.union(r1235)
+    assert_equal r1234 & r1235, r1234.intersection(r1235)
+  end
+end

data/test/benchmark2_test.rb

@@ -0,0 +1,72 @@
+# Benchmark 2 (rectangle3 rectangle tools)
+
+require "test_helper"
+require "benchmark"
+require "benchmark/ips"
+
+# return # outcomment to disable all benchmarks
+
+describe "lib/gui_geometry" do
+  include GuiGeo2::Tools
+
+  let(:p1) { point(1, 2) }
+  let(:p3) { point(3, 5) }
+  let(:r0) { rect(0, 0, 0, 0) }
+  let(:rn) { rect(0, 1, 3, 5) }
+  let(:r10) { rect(0, 0, 10, 10) }
+
+  return # skip benchmarks; outcomment to run them
+  b_rectangle3 = 1 # outcomment to run this benchmark
+  b_rectangle = 1 # outcomment to run this benchmark
+  b_tools = 1 # outcomment to run this benchmark
+
+  it "runs" do
+    Benchmark.ips do |x|
+      if defined? b_rectangle3
+        x.report("rn.x") { rn.x }
+        x.report("rn.y") { rn.y }
+        x.report("rn.w") { rn.w }
+        x.report("rn.h") { rn.h }
+        x.report("rn.x_range") { rn.x_range }
+        x.report("rn.y_range") { rn.y_range }
+        x.report("r0.x_range") { r0.x_range }
+        x.report("r0.y_range") { r0.y_range }
+        x.report("rn.tl") { rn.tl }
+        x.report("rn.tr") { rn.tr }
+        x.report("rn.bl") { rn.bl }
+        x.report("rn.br") { rn.br }
+        x.report("rn.left") { rn.left }
+        x.report("rn.top") { rn.top }
+        x.report("rn.right") { rn.right }
+        x.report("rn.bottom") { rn.bottom }
+      end
+      if defined? b_rectangle
+        x.report("rect") { rect }
+        x.report("rect(p3)") { rect(p3) }
+        x.report("rect(point, point)") { rect(point, point) }
+        x.report("rect(0, 0, 0, 0)") { rect(0, 0, 0, 0) }
+        x.report("rn.valid?") { rn.valid? }
+        x.report("rn + p3") { rn + p3 }
+        x.report("rn + rn") { rn + rn }
+        x.report("rn - p3") { rn - p3 }
+        x.report("rn - r10") { rn - r10 }
+        x.report("rn.present?") { rn.present? }
+        x.report("rn.blank?") { rn.blank? }
+        x.report("rn.clone") { rn.clone }
+        x.report("rn.area") { rn.area }
+        x.report("rn.inspect") { rn.inspect }
+        x.report("rn.to_s") { rn.to_s }
+      end
+      if defined? b_tools
+        x.report("min(4, 5)") { min(4, 5) }
+        x.report("max(4, 5)") { max(4, 5) }
+        x.report("bound(2, 5, 7)") { bound(2, 5, 7) }
+        x.report("minmax(4, 5)") { minmax(4, 5) }
+        x.report("point") { point }
+        x.report("rect") { rect }
+      end
+
+      x.compare!
+    end
+  end
+end

data/test/benchmark_test.rb

@@ -0,0 +1,77 @@
+# Benchmark (alias point rectangle)
+
+require "test_helper"
+require "benchmark"
+require "benchmark/ips"
+
+# return # outcomment to disable all benchmarks
+
+describe "lib/gui_geometry" do
+  include GuiGeo2::Tools
+
+  let(:p1) { point(1, 2) }
+  let(:p3) { point(3, 5) }
+  let(:r0) { rect(0, 0, 0, 0) }
+  let(:rn) { rect(0, 1, 3, 5) }
+  let(:r10) { rect(0, 0, 10, 10) }
+
+  return # skip benchmarks; outcomment to run them
+  b_alias = 1 # outcomment to run this benchmark
+  b_point = 1 # outcomment to run this benchmark
+  b_rectangle2 = 1 # outcomment to run this benchmark
+
+  it "runs" do
+    Benchmark.ips do |x|
+      if defined? b_alias
+        x.report("p1.w") { p1.w }
+        x.report("p1.h") { p1.h }
+        x.report("p1.width") { p1.width }
+        # x.report("p1.height") { p1.heigth } # reserved?
+        x.report("p1.col") { p1.col }
+        x.report("p1.column") { p1.column }
+        x.report("p1.line") { p1.line }
+
+        x.report("rn.width") { rn.width }
+        x.report("rn.height") { rn.height }
+        x.report("r0 | rn") { r0 | rn }
+        x.report("r0 & rn") { r0 & rn }
+      end
+      if defined? b_point
+        x.report("point") { point }
+        x.report("point(1, 2)") { point(1, 2) }
+        x.report("valid?") { p1.valid? }
+        x.report("p1 + p3") { p1 + p3 }
+        x.report("p1 - p3") { p1 - p3 }
+        x.report("p1 * p3") { p1 * p3 }
+        x.report("p1 / p3") { p1 / p3 }
+        x.report("p1 >= p3") { p1 >= p3 }
+        x.report("p1 > p3") { p1 > p3 }
+        x.report("p1 <= p3") { p1 <= p3 }
+        x.report("p1 < p3") { p1 < p3 }
+        x.report("p1.min(p3)") { p1.min(p3) }
+        x.report("p1.max(p3)") { p1.max(p3) }
+        x.report("p1.bound(p1, p3)") { p1.bound(p1, p3) }
+        x.report("p1.area") { p1.area }
+        x.report("p1.clone") { p1.clone }
+        x.report("p1.inspect") { p1.inspect }
+        x.report("p1.to_s") { p1.to_s }
+      end
+      if defined? b_rectangle2
+        x.report("rn.bound(p1)") { rn.bound(p1) }
+        x.report("rn.bound(r10)") { rn.bound(r10) }
+        x.report("r10.overlaps?(nil)") { r10.overlaps?(nil) }
+        x.report("r10.overlaps?(p1)") { r10.overlaps?(p1) }
+        x.report("r10.overlaps?(rn)") { r10.overlaps?(rn) }
+        x.report("r10.contains?(nil)") { r10.contains?(nil) }
+        x.report("r10.contains?(p1)") { r10.contains?(p1) }
+        x.report("r10.contains?(rn)") { r10.contains?(rn) }
+        x.report("r10.union(nil)") { r10.union(nil) }
+        x.report("r10.union(rn)") { r10.union(rn) }
+        x.report("r10.intersection(nil)") { r10.intersection(nil) }
+        x.report("r10.intersection(rn)") { r10.intersection(rn) }
+      end
+
+      x.compare!
+    end
+  end
+end

data/test/point_test.rb

@@ -0,0 +1,124 @@
+require "test_helper"
+
+describe "Point" do
+  include GuiGeo2::Tools
+
+  let(:p34) { point(3, 4) }
+
+  it "init" do
+    assert_equal point(0, 0), point
+  end
+
+  it "invalid init" do
+    assert_raises(ArgumentError) { point("1", 2) }
+    assert_raises(ArgumentError) { point(1.1, 2) }
+    assert_raises(ArgumentError) { point(1, :Y2) }
+    assert_raises(ArgumentError) { point(1) }
+  end
+
+  it "valid?" do
+    assert p34.valid?
+  end
+
+  it "+" do
+    assert_equal point(4, 6), (point(1, 2) + point(3, 4))
+    assert_equal point(4, 5), (point(1, 2) + 3)
+  end
+
+  it "-" do
+    assert_equal point(6, 4), (point(9, 8) - point(3, 4))
+    assert_equal point(6, 5), (point(9, 8) - 3)
+  end
+
+  it "*" do
+    assert_equal point(27, 32), (point(9, 8) * point(3, 4))
+    assert_equal point(27, 24), (point(9, 8) * 3)
+  end
+
+  it "/" do
+    assert_equal point(9, 8), (point(36, 24) / point(4, 3))
+    assert_equal point(18, 12), (point(36, 24) / 2)
+  end
+
+  it "==" do
+    assert p34 == point(3, 4)
+    refute point(3, 4) == point(2, 4)
+    refute point(3, 4) == point(3, 3)
+  end
+
+  it ">=" do
+    assert p34 >= point(3, 4)
+    refute point(2, 4) >= point(3, 4)
+    refute point(3, 3) >= point(3, 4)
+    refute point(3, 4) >= point(4, 4)
+    refute point(3, 4) >= point(3, 5)
+  end
+
+  it "<=" do
+    assert p34 <= point(3, 4)
+    refute point(3, 4) <= point(2, 4)
+    refute point(3, 4) <= point(3, 3)
+    refute point(4, 4) <= point(3, 4)
+    refute point(3, 5) <= point(3, 4)
+  end
+
+  it ">" do
+    assert point(4, 5) > point(3, 4)
+    refute point(3, 5) > point(3, 4)
+    refute point(4, 4) > point(3, 4)
+    refute point(4, 5) > point(4, 4)
+    refute point(4, 5) > point(3, 5)
+  end
+
+  it "<" do
+    assert p34 < point(4, 5)
+    refute point(3, 4) < point(3, 5)
+    refute point(3, 4) < point(4, 4)
+    refute point(4, 4) < point(4, 5)
+    refute point(3, 5) < point(4, 5)
+  end
+
+  it "min" do
+    assert_equal point(5, 5), point(5, 5).min(point(9, 9))
+    assert_equal point(5, 5), point(9, 9).min(point(5, 5))
+    assert_equal point(5, 5), point(9, 5).min(point(5, 9))
+    assert_equal point(5, 5), point(5, 9).min(point(9, 5))
+  end
+
+  it "max" do
+    assert_equal point(9, 9), point(5, 5).max(point(9, 9))
+    assert_equal point(9, 9), point(9, 9).max(point(5, 5))
+    assert_equal point(9, 9), point(9, 5).max(point(5, 9))
+    assert_equal point(9, 9), point(5, 9).max(point(9, 5))
+  end
+
+  it "bound" do
+    assert_equal point(3, 4), point(3, 4).bound(point(1, 2), point(5, 6))
+    assert_equal point(3, 2), point(3, 0).bound(point(1, 2), point(5, 6))
+    assert_equal point(3, 6), point(3, 6).bound(point(1, 2), point(5, 6))
+    assert_equal point(1, 4), point(0, 4).bound(point(1, 2), point(5, 6))
+    assert_equal point(5, 4), point(6, 4).bound(point(1, 2), point(5, 6))
+  end
+
+  it ".area" do
+    assert_equal 12, p34.area
+    assert_equal 300, point(15, 20).area
+    assert_equal(-15, point(-5, 3).area)
+  end
+
+  it "clone basic point" do
+    p1 = point(1, 2)
+    p2 = p1.clone
+    assert_equal p2, p1
+    p2.x = 3
+    refute_equal p2, p1
+  end
+
+  it "inspect" do
+    assert_equal "point(3, 4)", p34.inspect
+  end
+
+  it "to_s" do
+    assert_equal "(3, 4)", p34.to_s
+  end
+end

data/test/rectangle2_test.rb

@@ -0,0 +1,110 @@
+require "test_helper"
+
+describe "Rectangle 2" do
+  include GuiGeo2::Tools
+
+  let(:r10) { rect(0, 0, 10, 10) }
+  let(:rn) { rect(0, 1, 3, 5) }
+  let(:p34) { point(3, 4) }
+  let(:p10) { point(10, 10) }
+
+  it "ArgumentError" do
+    assert_raises(ArgumentError) { rn.bound(1) }
+    assert_raises(ArgumentError) { rn.overlaps?(1.23) }
+    assert_raises(ArgumentError) { rn.contains?("abc") }
+  end
+
+  it "contains?" do
+    assert rect(0, 0, 10, 10).contains?(rect(2, 2, 5, 5))
+    refute rect(0, 0, 10, 10).contains?(rect(8, 2, 5, 5))
+  end
+
+  it ".overlap?" do
+    # solidly overlapping
+    assert rect(0, 0, 10, 10).overlaps?(rect(0, 0, 10, 10))
+    assert rect(0, 0, 10, 10).overlaps?(rect(0, 5, 10, 10))
+    assert rect(0, 0, 10, 10).overlaps?(rect(5, 0, 10, 10))
+
+    # just below, just to the right, just above, just to the left
+    refute rect(0, 0, 10, 10).overlaps?(rect(10, 0, 10, 10))
+    refute rect(0, 0, 10, 10).overlaps?(rect(0, 10, 10, 10))
+    refute rect(10, 0, 10, 10).overlaps?(rect(0, 0, 10, 10))
+    refute rect(0, 10, 10, 10).overlaps?(rect(0, 0, 10, 10))
+
+    # below, right, above, left
+    refute rect(0, 0, 10, 10).overlaps?(rect(11, 0, 10, 10))
+    refute rect(0, 0, 10, 10).overlaps?(rect(0, 11, 10, 10))
+    refute rect(11, 0, 10, 10).overlaps?(rect(0, 0, 10, 10))
+    refute rect(0, 11, 10, 10).overlaps?(rect(0, 0, 10, 10))
+
+    # just overlapping below, right, above, left
+    assert rect(0, 0, 10, 10).overlaps?(rect(9, 0, 10, 10))
+    assert rect(0, 0, 10, 10).overlaps?(rect(0, 9, 10, 10))
+    assert rect(9, 0, 10, 10).overlaps?(rect(0, 0, 10, 10))
+    assert rect(0, 9, 10, 10).overlaps?(rect(0, 0, 10, 10))
+  end
+
+  it ".union" do
+    assert_equal rect(0, 0, 10, 15), rect(0, 0, 10, 10) | rect(0, 5, 10, 10)
+    assert_equal rect(0, 0, 15, 10), rect(0, 0, 10, 10) | rect(5, 0, 10, 10)
+    assert_equal rect(0, 0, 30, 30), rect(20, 20, 10, 10) | rect(0, 0, 10, 10)
+  end
+
+  it ".intersection" do
+    r10 = rect(0, 0, 10, 10)
+    assert_equal rect(0, 0, 10, 10), r10 & rect(0, 0, 10, 10)
+    assert_equal rect(0, 5, 10, 5), r10 & rect(0, 5, 10, 10)
+    assert_equal rect(5, 0, 5, 10), r10 & rect(5, 0, 10, 10)
+    assert_equal rect(0, 0, 0, 0), r10 & rect(10, 0, 10, 10)
+    assert_equal rect(0, 0, 5, 5), r10 & rect(-5, -5, 10, 10)
+  end
+
+  it "default intersection and union" do
+    assert_equal rect(0, 0, 10, 10), rect(0, 0, 10, 10) | nil
+    assert_equal rect(0, 0, 10, 10), rect(0, 0, 10, 10) & nil
+  end
+
+  it ".bound(point)" do
+    r = rect(5, 10, 15, 20)
+    assert_equal point(5, 10), r.bound(point(5, 10))
+    assert_equal point(20, 30), r.bound(point(20, 30))
+    assert_equal point(5, 30), r.bound(point(5, 31))
+    assert_equal point(20, 10), r.bound(point(21, 10))
+    assert_equal point(5, 10), r.bound(point(5, 10))
+    assert_equal point(5, 10), r.bound(point(5, 9))
+    assert_equal point(5, 10), r.bound(point(4, 10))
+  end
+
+  it ".bound(smaller_rect)" do
+    r1 = rect(5, 10, 15, 20)
+    assert_equal rect(5, 10, 5, 5), r1.bound(rect(5, 0, 5, 5))
+    assert_equal rect(5, 10, 5, 5), r1.bound(rect(0, 10, 5, 5))
+    assert_equal rect(5, 25, 5, 5), r1.bound(rect(0, 30, 5, 5))
+    assert_equal rect(15, 10, 5, 5), r1.bound(rect(30, 0, 5, 5))
+    assert_equal rect(5, 10, 15, 5), r1.bound(rect(0, 0, 20, 5))
+  end
+
+  it ".overlaps? point" do
+    r1 = rect(5, 10, 15, 20)
+    assert r1.overlaps?(point(10, 10))
+    refute r1.overlaps?(point(20, 10))
+    refute r1.overlaps?(point(10, 30))
+    refute r1.overlaps?(point(5, 9))
+    refute r1.overlaps?(point(4, 10))
+  end
+
+  it ".contains? point" do
+    r1 = rect(5, 10, 15, 20)
+    assert r1.contains?(point(10, 10))
+    refute r1.contains?(point(20, 10))
+    refute r1.contains?(point(10, 30))
+    refute r1.contains?(point(5, 9))
+    refute r1.contains?(point(4, 10))
+  end
+
+  it ".contains? and .overlaps? with nil" do
+    r1 = rect(5, 10, 15, 20)
+    refute r1.overlaps?(nil)
+    refute r1.contains?(nil)
+  end
+end

data/test/rectangle3_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+describe "Rectangle 3" do
+  include GuiGeo2::Tools
+
+  let(:r0) { rect(0, 0, 0, 0) }
+  let(:rn) { rect(0, 1, 3, 5) }
+
+  it "x y w h" do
+    assert_equal 0, rn.x
+    assert_equal 1, rn.y
+    assert_equal 3, rn.w
+    assert_equal 5, rn.h
+  end
+
+  it ".y_range and .x_range" do
+    assert_equal (0...3), rn.x_range
+    assert_equal (1...6), rn.y_range
+    assert_equal (0...0), r0.x_range
+    assert_equal (0...0), r0.y_range
+  end
+
+  it "tl br bl tr" do
+    assert_equal point(0, 1), rn.tl
+    assert_equal point(3, 1), rn.tr
+    assert_equal point(0, 6), rn.bl
+    assert_equal point(3, 6), rn.br
+  end
+
+  it "left top right bottom" do
+    assert_equal 0, rn.left
+    assert_equal 1, rn.top
+    assert_equal 3, rn.right
+    assert_equal 6, rn.bottom
+  end
+end

data/test/rectangle_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+describe "Rectangle" do
+  include GuiGeo2::Tools
+
+  let(:r0) { rect(0, 0, 0, 0) }
+  let(:r10) { rect(0, 0, 10, 10) }
+  let(:rn) { rect(0, 1, 3, 5) }
+  let(:p34) { point(3, 4) }
+  let(:p10) { point(10, 10) }
+
+  it "init" do
+    assert_equal r0, rect
+    assert_equal r10, rect(p10)
+    assert_equal r0, rect(point, point)
+    assert_equal r0, rect(0, 0, 0, 0)
+  end
+
+  it "invalid init" do
+    assert_raises { rect(1) }
+    assert_raises { rect(1, 2) }
+    assert_raises { rect(1, 2, 3) }
+  end
+
+  it "valid?" do
+    assert rect.valid?
+    assert rn.valid?
+  end
+
+  it "+" do
+    assert_equal rect(3, 5, 3, 5), rn + p34
+    assert_equal rect(0, 2, 6, 10), rn + rn
+  end
+
+  it "-" do
+    assert_equal rect(-3, -3, 3, 5), rn - p34
+    assert_equal r0, rn - rn
+    assert_equal rect(0, 1, -7, -5), rn - r10
+  end
+
+  it ".present?" do
+    assert rect(0, 0, 1, 1).present?
+    refute rect(0, 0, 1, 0).present?
+    refute rect(0, 0, 0, 1).present?
+    refute rect(0, 0, 0, 0).present?
+  end
+
+  it ".blank?" do
+    refute rect(0, 0, 1, 1).blank?
+    assert rect(0, 0, 1, 0).blank?
+    assert rect(0, 0, 0, 1).blank?
+    assert rect(0, 0, 0, 0).blank?
+  end
+
+  it "clone" do
+    r1 = rect(1, 2, 3, 4)
+    r2 = r1.clone
+    assert_equal r2, r1
+    refute_equal r2.object_id, r1.object_id
+    refute_equal r2.loc.object_id, r1.loc.object_id
+    refute_equal r2.size.object_id, r1.size.object_id
+  end
+
+  it ".area" do
+    assert_equal 300, rect(5, 10, 15, 20).area
+  end
+
+  it "inspect" do
+    assert_equal "rect(0, 0, 0, 0)", rect.inspect
+  end
+
+  it "to_s" do
+    assert_equal "(0, 1, 3, 5)", rn.to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.start do
+    skip "/test/"
+  end
+end
+
+require "minitest/autorun"
+require File.join(File.dirname(__FILE__), "..", "lib", "gui_geometry")
+require "ricecream"

data/test/tools_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+describe "Tools" do
+  include GuiGeo2::Tools
+
+  it "min" do
+    assert_equal 4, min(4, 5)
+    assert_equal 4, min(5, 4)
+  end
+
+  it "max" do
+    assert_equal 5, max(4, 5)
+    assert_equal 5, max(5, 4)
+  end
+
+  it "bound" do
+    assert_equal 5, bound(2, 5, 7)
+    assert_equal 2, bound(2, 1, 7)
+    assert_equal 7, bound(2, 8, 7)
+    assert_equal 2, bound(2, 8, 1)
+  end
+
+  it "minmax" do
+    assert_equal [4, 5], minmax(4, 5)
+    assert_equal [4, 5], minmax(5, 4)
+  end
+
+  it "easy constructors" do
+    assert_kind_of GuiGeo2::Point, point
+    assert_kind_of GuiGeo2::Rectangle, rect
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: gui_geometry2
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Dittmar Krall
+- Shane Brinkman-Davis
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: simplecov
+  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: 2D geometry specificly designed to support graphical user interfaces
+  and bitmaps currently focsued on Point and Rectangle classes
+email:
+- dittmar.krall@matiq.com
+- shanebdavis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/rake.yml"
+- ".gitignore"
+- ".ruby-version"
+- ".watchr"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gui_geometry.gemspec
+- lib/gui_geometry.rb
+- lib/gui_geometry/alias.rb
+- lib/gui_geometry/point.rb
+- lib/gui_geometry/rectangle.rb
+- lib/gui_geometry/rectangle2.rb
+- lib/gui_geometry/rectangle3.rb
+- lib/gui_geometry/tools.rb
+- lib/gui_geometry/version.rb
+- test/alias_test.rb
+- test/benchmark2_test.rb
+- test/benchmark_test.rb
+- test/point_test.rb
+- test/rectangle2_test.rb
+- test/rectangle3_test.rb
+- test/rectangle_test.rb
+- test/test_helper.rb
+- test/tools_test.rb
+homepage: https://github.com/shanebdavis/gui_geometry
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: 2D geometry specificly designed to support graphical user interfaces and
+  bitmaps
+test_files: []