bomp 1.0.5 → 1.0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 849824a0e41a0e0cb75915a9f509c877d1f9040a9cfc371ba17419d82204ce66
-  data.tar.gz: 0d45d271ea0ee59e11f9002f73eaafda275c2adaa89bded010bf777d4850fb43
+  metadata.gz: 06a8f25bf7a4ca659cf83abf8fba9cf4bb305ba64bef872964aa6fbbb8ce6ba7
+  data.tar.gz: 98290ff5312e27ceaae2347085c6b5b502e2cea716f3854a7a9782694a5aff15
 SHA512:
-  metadata.gz: b73a18265721e05347a5cf30ea5d3d6ce88c460ca2ad4d5c80005cd2c9bcfb954498190d7131db2263fa61b705ae14a4b5203c4cd84de0fa3fb595038284b47d
-  data.tar.gz: 5d2785ed6bd8a46f66713e2db01523c20741e33212ddc1518406385296729153830a8a0af173b3e659b56088caa426e4b72cd6f509df22490f292f34d50cd39f
+  metadata.gz: 3cd6bb90cd3d9d16662ebbc3eb1b05d62ae5bdf5f22826eedec0365c0032c8a3775ad00775cbaa788f7f3c736d39fad31c65d87838af1693c2f60e3dc113c96d
+  data.tar.gz: 584778eca57105a264de6331bcfefc36bf9203c707b892a7f5c71d966d6c6530672bcbde2bf4a7952c5d1d544955d51204e1f2a0dd5e006105af28b4ddf01c2f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 SealtielFreak
+
+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,74 @@
+# bomp.rb
+
+![Ruby](https://img.shields.io/badge/Ruby-CC342D?logo=ruby)
+![Gem Version](https://img.shields.io/gem/v/bomp)
+![Gem Downloads (for latest version)](https://img.shields.io/gem/dtv/bomp)
+![Gem download rank](https://img.shields.io/gem/rt/bomp)
+
+A collision detection library for Ruby, works in [Ruby2D](https://github.com/ruby2d/ruby2d), [Gosu](https://github.com/gosu/gosu) and [Tic-80](https://github.com/nesbox/TIC-80)
+
+## Introduction
+
+A collision detection library for Ruby that makes it easy to detect collisions between 2D objects in your game or application. The library implements two popular collision detection algorithms AABB and SAT.
+
+## Installation
+
+Ensure you have the latest versions of [Ruby](https://www.ruby-lang.org/) and [Gem](https://rubygems.org/pages/download) installed on your system to work with containerization.
+
+### Initial Setup
+
+1. **Clone the Repository**:
+```
+git clone https://github.com/sealtielfreak/bomp.rb.git
+cd bomp.rb
+```
+2. **Install Gemfile**:
+- Follow the instructions at [Install gems](https://www.bacancytechnology.com/blog/install-ruby-gems).
+
+## Contributing
+
+Contributions are what make the open-source community an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.
+
+### Setting Up Your Development Environment
+
+Before you start contributing, it's important to set up your development environment. This includes installing necessary tools and configuring pre-commit hooks to ensure code quality.
+
+#### Pre-Commit Hooks
+
+To maintain code quality and consistency, we use pre-commit hooks. Follow these steps to set up pre-commit hooks in your local development environment:
+
+1. **Install Pre-Commit**:
+    - Ensure you have Python installed on your system.
+    - Install pre-commit globally using pip:
+      ```
+      pip install pre-commit
+      ```
+
+2. **Clone the Repository** (if not already done):
+   ```
+   git clone https://github.com/sealtielfreak/bomp.rb.git
+   cd bomp.rb
+   ```
+
+3. **Set Up Pre-Commit Hooks**:
+    - In the root directory of the cloned repository, run:
+      ```
+      pre-commit install
+      ```
+    - The hook repository must have a `*.gemspec`. It will be installed via gem build `*.gemspec && gem install *.gem`. The installed package will produce an executable that will match the entry.
+
+4. **Usage**:
+    - Pre-commit hooks will now run automatically on the files you've staged whenever you commit.
+    - You can manually run the hooks on all files in the repository at any time with:
+      ```
+      pre-commit run --all-files
+      ```
+
+### Creating a Pull Request with your changes
+
+Now that you have done some changes and want to merge them in our repository, feel free to:
+
+1. Create your Feature Branch (`git checkout -b feature/amazing_feature`)
+2. Commit your Changes (`git commit -m "Add some AmazingFeature"`)
+3. Push to the Branch (`git push origin feature/amazing_feature`)
+4. Open a Pull Request

data/bomp.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s|
+  s.name        = 'bomp'
+  s.version     = '1.0.5.1'
+  s.summary     = 'A collision detection library for Ruby'
+  s.description = "Ruby collision-detection library for axis-aligned rectangles, inspired by 'bump.lua' but using native Ruby capabilities"
+  s.authors     = 'SealtielFreak'
+  s.email       = 'SealtielFreak@yandex.com'
+  s.files         = Dir['**/**'].grep_v(/.gem$/)
+  s.require_paths = %w[lib sample]
+  s.homepage    = 'https://github.com/SealtielFreak/bomp.rb'
+  s.license     = 'MIT'
+  s.required_ruby_version = '>= 2.5.0'
+end

data/lib/bomp.rb

@@ -0,0 +1,399 @@
+require_relative 'vector2'
+require_relative 'rect'
+require_relative 'collision/collision_aabb'
+require_relative 'collision/collision_sat'
+require_relative 'collision/collisions'
+
+module Bomp
+  class ColliderSystem
+    attr_reader :items
+
+    # Create collision system
+    def initialize
+      @items = []
+    end
+
+    # @param [Rect] item Add item
+    def add(item)
+      @items.push item unless @items.include? item
+    end
+
+    # @param [Rect] item Remove item
+    def remove(item)
+      @items -= [item]
+    end
+
+    # Sort all items
+    def sort(group = nil, reload = true)
+      raise NotImplementedError.new
+    end
+
+    # Clean
+    def clear!
+      @items&.clear
+    end
+
+    # Reload
+    def reload!
+      raise NotImplementedError.new
+    end
+
+    # Restart
+    def restart!
+      raise NotImplementedError.new
+    end
+
+    # Cast to array
+    # @return [Array]
+    def to_a
+      self.sort
+    end
+  end
+
+  class Lineal < ColliderSystem
+    # Initialize lineal collision system
+    def initialize
+      super
+    end
+
+    def sort(group = nil, reload = true)
+      [@items]
+    end
+
+    def clear!
+      @items&.clear
+    end
+
+    def reload!; end
+
+    def restart!; end
+  end
+
+  class QuadTree < ColliderSystem
+    class QuadNode < Rect
+      attr_reader :items
+
+      def initialize(x, y, w, h, args = {})
+        super(Vector2[x, y], Vector2[w, h])
+        limit = args[:limit_w] || 64, args[:limit_h] || 64
+        @limit_w = (limit[0]).to_f
+        @limit_h = (limit[1]).to_f
+        @limit = (args[:limit]) || 16
+
+        @items = []
+        @children = []
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def subdivided?
+        !@children.empty?
+      end
+
+      def insert(item)
+        return unless CollisionAABB.is_overlaps? self, item
+
+        subdivided unless subdivided?
+        @children.each { |child| child&.insert item }
+
+        @items << item unless subdivided? && @items.size <= @limit
+      end
+
+      def clear
+        @children.each { |child| child&.clear }
+        @items.clear
+      end
+
+      def release
+        @children.each { |child| child&.release }
+        @children.clear
+      end
+
+      def limit_size
+        [@limit_w, @limit_h]
+      end
+
+      def limit_size=(limit)
+        self.each { |c| c.limit_size = limit }
+      end
+
+      def each(&block)
+        @children.each { |c| c&.each(&block) }
+        block.call @items.clone unless @items.empty?
+      end
+
+      def each_children(&block)
+        @children.each { |c| c&.each_children(&block) }
+        block.call self unless @items.empty?
+      end
+
+      def each_children_by(item, &block)
+        @children.each { |c| c&.each_children_by(item, &block) }
+        block.call self if CollisionAABB.is_overlaps?(self, item) and not @items.empty?
+      end
+
+      def to_a
+        items = []
+
+        self.each { |item| items.push item }
+
+        items
+      end
+
+      def group_by(item)
+        children = []
+
+        self.each_children_by(item) { |c| children.push c.items }
+
+        children
+      end
+
+      private
+
+      def subdivided
+        x = self.x
+        y = self.y
+        w = self.width / 2
+        h = self.height / 2
+
+        return if self.width <= @limit_w || self.height <= @limit_h
+
+        @children = [
+          QuadNode.new(*config_child(x, y, w, h)),
+          QuadNode.new(*config_child(x + w, y, w, h)),
+          QuadNode.new(*config_child(x, y + h, w, h)),
+          QuadNode.new(*config_child(x + w, y + h, w, h))
+        ]
+      end
+
+      def config_child(x, y, w, h)
+        [x, y, w, h, {
+          limit_w: @limit_w, limit_h: @limit_h,
+          limit: @limit
+        }]
+      end
+    end
+
+    attr_reader :child
+
+    def initialize(width, height, **opts)
+      super()
+      @opts = opts
+      @child = QuadNode.new(0, 0, width, height, @opts)
+    end
+
+    def sort(group = nil, reload = true)
+      reload! if reload
+
+      if group.nil?
+        @child.to_a
+      else
+        @child.group_by group
+      end
+    end
+
+    def reload!
+      @child&.clear
+      @items.each { |item| @child.insert item }
+    end
+
+    def restart!
+      clear!
+      @child = QuadNode.new(0, 0, width, height, @opts)
+    end
+  end
+
+  class CollisionInfo
+    attr_reader :item, :other, :goal, :overlaps, :response
+
+    def initialize(item, other, goal, overlaps, response)
+      @item = item
+      @other = other
+      @goal = goal
+      @overlaps = overlaps
+      @response = response
+      @normal = Vector2[
+        goal[0] <=> 0,
+        goal[1] <=> 0
+      ]
+    end
+
+    def to_s
+      [@item, @other, @goal, @overlaps, @response, @normal].to_s
+    end
+
+    def self.[](*args)
+      CollisionInfo.new *args
+    end
+  end
+
+  class World
+    DEFAULT_FILTER = lambda { |a, b| :slide }
+
+    attr_reader :system_collision, :response
+
+    # Create world for collisions processing
+    # @param width [Integer] The first number
+    # @param height [Integer] The second number
+    def initialize(width, height, **opts)
+      @opts = opts
+      @system_collision = @opts[:system] || QuadTree.new(width, height, **opts)
+      @response = { 'bounce': lambda { |item, other, goal| CollisionAABB.bounce(item, other, goal) },
+                    'cross': lambda { |item, other, goal| CollisionAABB.cross(item, other, goal) },
+                    'touch': lambda { |item, other, goal| CollisionAABB.touch(item, other, goal) },
+                    'slide': lambda { |item, other, goal| CollisionAABB.slide(item, other, goal) },
+                    'push': lambda { |item, other, goal| CollisionAABB.push(item, other, goal) },
+                    'nothing': lambda { |item, other, goal| item } }
+    end
+
+    # Add item to world
+    # @param [Rect] item Add item to world
+    def add(item)
+      @system_collision&.add item
+    end
+
+    # Remove item from world
+    # @param [Rect] item Remove item from world
+    def remove(item)
+      @system_collision&.remove item
+    end
+
+    # Select item from world
+    # @param [Rect] index Index
+    def [](index)
+      @system_collision&.items[index]
+    end
+
+    # @param [Integer] index
+    # @param [Rect] item
+    def []=(index, item)
+      @system_collision&.items[index] = item
+    end
+
+    # @return [Array, nil]
+    def items
+      @system_collision&.items
+    end
+
+    # Cast to array
+    # @return [Array]
+    def to_a
+      @system_collision&.sort || []
+    end
+
+    # Check if item include in world
+    # @param [Rect] item Check if include item
+    def include?(item)
+      items.include? item
+    end
+
+    # At item
+    # @param [Rect] item
+    def at(item)
+      add item unless include? item
+    end
+
+    # Query point
+    # @param [Vector2] point
+    # @param [Proc] filter
+    def query_point(point, &filter)
+      _, cols = check Rect[point[0], point[1], 1, 1], &filter
+      cols
+    end
+
+    # Query rect
+    # @param [Rect] rect
+    # @param [Proc] filter
+    def query_rect(rect, &filter)
+      raise NotImplementedError.new
+    end
+
+    # Query segment
+    # @param [Vector2] p0
+    # @param [Vector2] p1
+    # @param [Proc] filter
+    def query_segment(p0, p1, &filter)
+      raise NotImplementedError.new
+    end
+
+    # Add response
+    # @param [String] name
+    def add_response(name, &block)
+      @response[name.to_sym] = block
+    end
+
+    # Move item in the world
+    # @param [Rect] item
+    # @param [Vector2] goal
+    # @param [Proc] filter
+    # @return [[Rect, Array]]
+    def move(item, goal, &filter)
+      filter = DEFAULT_FILTER if filter.nil?
+      item = self[item] if item.is_a? Integer
+      cols = []
+
+      all_sort_items = @system_collision&.sort
+
+      [Vector2[goal[0], 0], Vector2[0, goal[1]]].each do |g|
+        item.position += g
+
+        all_sort_items.each do |others|
+          next unless others.include? item
+
+          others -= [item]
+          cols += check_and_resolve item, g, others, filter
+        end
+      end
+
+      [item, cols]
+    end
+
+    # Check
+    # @param [Rect] item
+    # @param [Proc] filter
+    # @return [[Rect, Array]]
+    def check(item, &filter)
+      filter = DEFAULT_FILTER if filter.nil?
+      item = self[item] if item.is_a? Integer
+      cols = []
+
+      all_sort_items = @system_collision&.sort
+
+      all_sort_items.each do |others|
+        next unless others.include? item
+
+        others -= [item]
+        cols += check_and_resolve item, [0, 0], others, filter
+      end
+
+      [item, cols]
+    end
+
+    # Check and resolve
+    # @param [Rect] item
+    # @param [Vector2] goal
+    # @param [Array] others
+    # @param [Object] filter
+    # @return [Array]
+    private
+    def check_and_resolve(item, goal, others, filter)
+      cols = []
+
+      others.each do |other|
+        overlaps = CollisionAABB.is_overlaps? item, other
+        res = :nothing
+
+        if overlaps and goal.sum != 0
+          res = filter.call(item, other) || :nothing
+          @response[res]&.call item, other, goal
+        end
+
+        cols.push CollisionInfo[item, other, goal, overlaps, res]
+      end
+
+      cols
+    end
+  end
+end

data/lib/collision/collision_aabb.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module CollisionAABB
+  def self.was_horizontal_aligned?(a, b)
+    a.left < b.right && a.right > b.left
+  end
+
+  def self.was_vertical_aligned?(a, b)
+    a.top < b.bottom && a.bottom > b.top
+  end
+
+  def self.is_overlaps?(a, b)
+    was_vertical_aligned?(a, b) && was_horizontal_aligned?(a, b)
+  end
+
+  def self.bounce(item, other, goal) end
+
+  def self.cross(item, other, goal)
+    x, y = goal.to_a
+
+    if x != 0
+      goal.x *= -1
+      item.position.x += x
+    end
+
+    if y != 0
+      goal.y *= -1
+      item.position.y += y
+    end
+
+    item
+  end
+
+  def self.touch(item, other, goal) end
+
+  def self.slide(item, other, goal)
+    x, y = goal.to_a
+
+    if x != 0
+      item.position.x += x
+      if x > 0
+        item.right = other.left
+      elsif x < 0
+        item.left = other.right
+      end
+    end
+
+    if y != 0
+      item.position.y += y
+      if y > 0
+        item.bottom = other.top
+      elsif y < 0
+        item.top = other.bottom
+      end
+    end
+
+    item
+  end
+
+  def self.push(item, other, goal)
+    x, y = goal.to_a
+
+    if x != 0
+      if x > 0
+        other.right = item.left
+      elsif x < 0
+        other.left = item.right
+      end
+    end
+
+    if y != 0
+      if y > 0
+        other.bottom = item.top
+      elsif y < 0
+        other.top = item.bottom
+      end
+    end
+
+    item
+  end
+end

data/lib/collision/collision_sat.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module CollisionSAT
+  def self.is_overlaps?(a, b)
+    raise NotImplementedError.new
+  end
+end

data/lib/collision/collisions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Collisions
+  def self.is_overlaps?(a, b)
+    raise NotImplementedError.new
+  end
+end

data/lib/rect.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+class Rect
+  attr_accessor :position, :size
+
+  def initialize(pos, size)
+    @position = Vector2[*pos]
+    @size = Vector2[*size]
+  end
+
+  def x
+    @position.x
+  end
+
+  def y
+    @position.y
+  end
+
+  def width
+    @size.x
+  end
+
+  def width=(value)
+    @size.x = value
+  end
+
+  def height
+    @size.y
+  end
+
+  def height=(value)
+    @size.y = value
+  end
+
+  def top
+    @position.y
+  end
+
+  def top=(value)
+    @position.y = value
+  end
+
+  def bottom
+    @position.y + height
+  end
+
+  def bottom=(value)
+    @position.y += value - self.bottom
+  end
+
+  def left
+    @position.x
+  end
+
+  def left=(value)
+    @position.x = value
+  end
+
+  def right
+    @position.x + width
+  end
+
+  def right=(value)
+    @position.x += value - self.right
+  end
+
+  def to_s
+    self.to_a.to_s
+  end
+
+  def clone
+    Rect.new([@position.x, @position.y], [@size.x, @size.y])
+  end
+
+  def to_a
+    [@position.x, @position.y, @size.x, @size.y]
+  end
+
+  def self.[](x, y, w, h)
+    Rect.new([x, y], [w, h])
+  end
+end

data/lib/vector2.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Vector2
+  attr_accessor :x, :y
+
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+
+  def +(other)
+    Vector2[@x + other[0], @y + other[1]]
+  end
+
+  def -(other)
+    Vector2[@x - other[0], @y - other[1]]
+  end
+
+  def *(scalar)
+    Vector2[@x * scalar, @y * scalar]
+  end
+
+  def /(scalar)
+    Vector2[@x / scalar, @y / scalar]
+  end
+
+  def ==(other)
+    @x == other[0] && @y == other[1]
+  end
+
+  def [](index)
+    case index
+    when 0 then @x
+    when 1 then @y
+    else nil
+    end
+  end
+
+  def []=(index, value)
+    case index
+    when 0 then @x = value
+    when 1 then @y = value
+    end
+  end
+
+  def to_s
+    self.to_a.to_s
+  end
+
+  def to_a
+    [@x, @y]
+  end
+
+  def sum
+    @x + @y
+  end
+
+  def self.[](x, y)
+    Vector2.new(x, y)
+  end
+end

data/sample/hello_world.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../lib/bomp'
+
+include Bomp
+
+world = World.new 640, 480
+
+world.add(Rect[0, 0, 10, 10])
+world.add(Rect[2, 3, 10, 10])
+world.add(Rect[300, 300, 10, 10])
+
+puts 'Current position: ' + world[0].position.to_s
+cols = world.move(0, Vector2[3, -1]) do |item, other|
+	puts 'Other collision is ' + other.to_s
+	:push
+end
+
+puts 'Current position: ' + world[0].position.to_s
+
+cols.each do |col|
+	puts 'Collision: ' + col.to_s
+end

data/sample/sample_ruby2d.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'ruby2d'
+
+require_relative '../lib/bomp'
+include Bomp
+
+
+def normalize(vec)
+	x, y = vec.to_a
+
+	length = Math.sqrt(x ** 2 + y ** 2)
+
+	[x / length, y / length]
+end
+
+class MyRect < Rectangle
+	attr_reader :world, :rect
+
+	def initialize(world, **opts)
+		super **opts
+
+		@world = world
+		@rect = Rect.new Vector2[0, 0], Vector2[opts[:width] || 0, opts[:height] || 0]
+
+		@world.add rect
+	end
+
+	def position
+		[@rect.left, @rect.top]
+	end
+
+	def position=(pos)
+		x, y = pos.to_a
+
+		self.x = x
+		self.y = y
+
+		@rect.left = x
+		@rect.top = y
+	end
+
+	def size=(size)
+		w, h = size.to_a
+		self.width = w
+		self.height = h
+		@rect.width = w
+		@rect.height = h
+	end
+
+	def move(goal)
+		rect, col = @world.move @rect, normalize(goal)
+
+		@rect = rect
+		self.x = @rect.x
+		self.y = @rect.y
+		self.width = @rect.width
+		self.height = @rect.height
+
+		col
+	end
+end
+
+@world = World.new 640, 480
+
+@player = MyRect.new @world, color: 'red', width: 3, height: 3
+@walls = Array.new(5) { MyRect.new @world, color: 'random' }.map do |o|
+	o.position = [rand(0..640), rand(0..480)]
+	o.size = [rand(5...25), rand(5...25)]
+end
+
+on :key_held do |event|
+	goal = Vector2[0, 0]
+
+	case event.key
+	when 'w'
+		goal.y -= 5
+	when 's'
+		goal.y += 5
+	when 'a'
+		goal.x -= 5
+	when 'd'
+		goal.x += 5
+	end
+
+	@player.move goal
+end
+
+show

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bomp
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.5.1
 platform: ruby
 authors:
 - SealtielFreak
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-03-24 00:00:00.000000000 Z
 dependencies: []
 description: Ruby collision-detection library for axis-aligned rectangles, inspired
   by 'bump.lua' but using native Ruby capabilities
@@ -16,7 +16,18 @@ email: SealtielFreak@yandex.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- LICENSE
+- README.md
+- bomp.gemspec
+- lib/bomp.rb
+- lib/collision/collision_aabb.rb
+- lib/collision/collision_sat.rb
+- lib/collision/collisions.rb
+- lib/rect.rb
+- lib/vector2.rb
+- sample/hello_world.rb
+- sample/sample_ruby2d.rb
 homepage: https://github.com/SealtielFreak/bomp.rb
 licenses:
 - MIT
@@ -25,6 +36,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- sample
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="