slippy_tiles_scorer 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3535ebc0ef81b4b9096043ac739f65877a793c82e9f115f4faa16339184c359c
-  data.tar.gz: f0375a478ee6603038e12fc15f55ecf320c161d2764d30fbd362908bfaf763b9
+  metadata.gz: ce623fd11c56fc5615043d62fd196810c7c0caccd5f9d9789dfaa864954ed2ee
+  data.tar.gz: 0b7296978405915b2ee53d79da2a8e8c0cc15445f2b71ce5e396ca5fc7af5a39
 SHA512:
-  metadata.gz: 0df4fbebb75b3f9b3a4019490695d6ae81e9d59498a1479f72f63f92de17ad756b1e1776787025e06cebeff2770aab067faff79aa6f6a2053757daf7972d5a34
-  data.tar.gz: 1c5b8bc92a68023c2fb8fbd84f9bba559eeb1b5eec26b757b7310c22a0aacbf316700736f4c814b31e2871a57b279f26d951d576d8861104c5b2460e10771a6e
+  metadata.gz: 746ffc5f6d06857aec00c471b3c671612debe31c22a2cdb1d73b1da3583ba253008cbea5e886addf44961019cd2435db6eccb7f70086f182e3cfa3440247a88a
+  data.tar.gz: 7e6bacaaab5a06b40d0fee46a3494f436a96b04e042a90bae45ae567ab1860b99499999e66089a372be84d733ae4f15683316748ee1835604c3358acdb3b2da8

data/.rubocop.yml

@@ -1,10 +1,19 @@
+require:
+  - rubocop-rake
+  - rubocop-performance
+
 AllCops:
   TargetRubyVersion: 3.0
+  NewCops: enable
   Exclude:
-    '*.gemspec'
+    - "*.gemspec"
+    - "./vendor/bundle/**/*"
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 Style/StringLiteralsInInterpolation:
   EnforcedStyle: double_quotes
+
+Naming/MethodParameterName:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
-## [0.1.0] - 2024-11-25
+## [0.0.3] - 2024-11-26
+
+- More tests, like a json file with test data.
+- The `Rakefile` can be used to run the tests and check the code style.
+- A CI pipeline runs the test suite and checks the code style for multiple Ruby versions >= v3.
+- Rubocop was configured and some plugins were added to the `.rubocop.yml` file.
+
+## [0.0.2] - 2024-11-26
+
+- The result `Hash` of `#clusters` under the key `:clusters` is now an array of `[x, y]` and `x` and `y` being integer values.
+
+## [0.0.1] - 2024-11-25
 
 - Initial release

data/README.md

@@ -1,5 +1,12 @@
 # SlippyTilesScorer
 
+> [!NOTE]  
+> This gem's API is not considered stable yet.
+> Things might change in the future.
+
+[![Gem Version](https://badge.fury.io/rb/slippy_tiles_scorer.svg)](https://badge.fury.io/rb/slippy_tiles_scorer) \
+[![Ruby](https://github.com/simonneutert/slippy_tiles_scorer/actions/workflows/main.yml/badge.svg)](https://github.com/simonneutert/slippy_tiles_scorer/actions/workflows/main.yml)
+
 Calculate scores of map tiles (x, y) on a map. The scores are total, (max)
 clusters, and max squares.
 
@@ -7,18 +14,16 @@ To experiment with that code, run `bin/console` for an interactive prompt.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
 
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add slippy_tiles_scorer
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install slippy_tiles_scorer
 ```
 
 ## Usage
@@ -43,7 +48,7 @@ collection_of_tiles.add([2, 0])
 collection_of_tiles.add([2, 1])
 collection_of_tiles.add([2, 2])
 
-tile_scorer = SlippyTilesScorer::Scorer.new(tiles_x_y: collection_of_tiles)
+tile_scorer = SlippyTilesScorer::Score.new(tiles_x_y: collection_of_tiles)
 tile_scorer.valid? # => true
 
 # the collection_of_tiles is a 3x3 map and will be used to calculate scores,
@@ -55,15 +60,17 @@ tile_scorer.visited # => 9
 tile_scorer.clusters # => 
     #   {
     #       :clusters=>[
-    #           <Set: {[0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [2, 2], [2, 1], [2, 0]}>
+    #           [
+    #             [0, 0], [1, 0], [0, 1], [1, 1], [0, 2], [1, 2], [2, 2], [2, 1], [2, 0]
+    #           ]
     #       ],
     #       :cluster_tiles=>#<Set: {[1, 1]}>,
-    #       :clusters_of_cluster_tiles=>[]
+    #       :clusters_of_cluster_tiles=>[[[1, 1]]]
     #   }
 
 # calculate max squares
-tile_scorer.max_squares # => {:size=>3, top_left_tile_x_y=>#<Set: {[0, 0]}>}
-tile_scorer.max_squares(min_size: 4) # => {:size=>4, top_left_tile_x_y=>#<Set: {}>}
+tile_scorer.max_squares # => {:size=>0, top_left_tile_x_y=>#<Set: {[0, 0]}>}
+tile_scorer.max_squares(min_size: 4) # => {:size=>0, top_left_tile_x_y=>#<Set: {}>}
 ```
 
 ### Optimized
@@ -72,7 +79,7 @@ An more computationally optimized example of how to use the `TileScorer` class,
 
 ```ruby
 ### OPTIMIZE COMPUTATION ###
-tile_scorer = SlippyTilesScorer::Scorer.new(tiles_x_y: collection_of_tiles)
+tile_scorer = SlippyTilesScorer::Score.new(tiles_x_y: collection_of_tiles)
 # Optimize computation by calculating clusters first,
 result_clusters = tile_scorer.clusters
 clusters = result_clusters[:clusters]

data/Rakefile

@@ -6,4 +6,7 @@ RuboCop::RakeTask.new
 
 task default: %i[test rubocop]
 
-# TODO: add more tasks here
+desc "Run tests"
+task :test do
+  sh "ruby test_runner.rb"
+end

data/lib/slippy_tiles_scorer/cluster.rb

@@ -1,68 +1,86 @@
 # frozen_string_literal: true
 
+require "set"
+
 module SlippyTilesScorer
   # finds clusters in a collection/tiles_x_y of points (x, y)
   class Cluster
     attr_accessor :tiles_x_y
 
     def initialize(tiles_x_y: Set.new)
-      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+      @tiles_x_y = tiles_x_y
       @cluster_tiles = Set.new
-      @visited = Set.new
+      @visited = {}
       @clusters = []
     end
 
+    # @return [Hash] The clusters and the tiles in the clusters.
     def clusters
-      while @tiles_x_y.any?
-        start = @tiles_x_y.first
-        @tiles_x_y.delete(start)
-        @visited.add(start)
-        find_cluster_around(start)
+      @tiles_x_y.each do |i|
+        next if visited?(i[0], i[1])
+
+        visit!(i[0], i[1])
+        find_cluster_around(i)
       end
       { clusters: @clusters, cluster_tiles: @cluster_tiles }
     end
 
     private
 
+    # @param start [Array] The x and y coordinate of the start point.
+    # @return [Array<Array<Integer, Integer>>] The cluster of points.
     def find_cluster_around(start)
-      cluster = Set.new
-      cluster.add(start)
+      cluster = []
+      cluster.push(start)
       todo = [start]
+      broad_search!(todo, cluster)
 
-      cluster = broad_search(todo, cluster)
-
-      @clusters.push(cluster) if cluster.size > 1
+      @clusters.push(cluster) if cluster.size.positive?
       cluster
     end
 
-    def neighbors_up_down_left_right?(neighbors)
-      neighbors.all? { |n| @tiles_x_y.include?(n) || @visited.include?(n) }
-    end
-
-    def broad_search(todo, cluster) # rubocop:disable Metrics/MethodLength
+    # @param todo [Array] The points to visit.
+    # @param cluster [Array] The cluster of points.
+    def broad_search!(todo, cluster) # rubocop:disable Metrics/CyclomaticComplexity
       until todo.empty?
         point = todo.pop
         neighbors = neighbor_points(*point)
-
-        next if neighbors.empty?
-
-        @cluster_tiles.add(point) if neighbors_up_down_left_right?(neighbors)
+        neighbors_up_down_left_right?(neighbors) && @cluster_tiles.add(point)
         neighbors.each do |neighbor|
+          next if visited?(neighbor[0], neighbor[1])
           next unless @tiles_x_y.include?(neighbor)
-          next if @visited.include?(neighbor)
 
-          @visited.add(neighbor)
-          cluster.add(neighbor)
-          todo.push(neighbor)
+          visit!(*neighbor) && todo.push(neighbor) && cluster.push(neighbor)
         end
       end
-      cluster
     end
 
-    def neighbor_points(x, y) # rubocop:disable Naming/MethodParameterName
-      res = Set.new
-      [[x - 1, y], [x + 1, y], [x, y + 1], [x, y - 1]].each { |point| res.add(point) }
-      res
+    # @param x [Integer] The x coordinate of the point.
+    # @param y [Integer] The y coordinate of the point.
+    # @return [Boolean] True if the point is visited.
+    def visit!(x, y)
+      @visited[x] ||= {}
+      @visited[x][y] = true
+    end
+
+    # @param x [Integer] The x coordinate of the point.
+    # @param y [Integer] The y coordinate of the point.
+    # @return [Boolean|Nil] True if the point is visited.
+    def visited?(x, y)
+      @visited.dig(x, y)
+    end
+
+    # @param neighbors [Array] The neighbors of the point.
+    # @return [Boolean] True if all neighbors are in the tiles_x_y.
+    def neighbors_up_down_left_right?(neighbors)
+      neighbors.all? { |n| @tiles_x_y.include?(n) }
+    end
+
+    # @param x [Integer] The x coordinate of the point.
+    # @param y [Integer] The y coordinate of the point.
+    # @return [Array<Array<Integer, Integer>>] The neighbors of the point.
+    def neighbor_points(x, y)
+      [[x - 1, y], [x + 1, y], [x, y + 1], [x, y - 1]]
     end
   end
 end

data/lib/slippy_tiles_scorer/max_square.rb

@@ -1,54 +1,106 @@
 # frozen_string_literal: true
 
+require "set"
+
 module SlippyTilesScorer
   # finds the maximum square in a collection/tiles_x_y of points (x, y)
   class MaxSquare
     attr_accessor :tiles_x_y
 
     def initialize(tiles_x_y: Set.new)
-      @tiles_x_y = Marshal.load(Marshal.dump(tiles_x_y))
+      @tiles_x_y = tiles_x_y
+      @tiles_lut = nil
     end
 
     # @param min_size [Integer] The minimum size of the square, should be 3 or greater.
     #   As the smallest square is 3x3 and therefor a cluster tile needs to be the center.
     # @return [Hash] The size of the square and the points of the square.
     def max_squares(min_size: 3)
-      raise ArgumentError, 'min_size must be 2 or greater' if min_size < 2
+      @max_size_found = 0
+      raise ArgumentError, "min_size must be 2 or greater" if min_size < 2
+
+      result = max_square_result(min_size: min_size)
+      @max_size_found = 0
+      @tiles_lut = nil
+      result
+    end
 
-      result = { size: min_size, top_left_tile_x_y: Set.new }
+    # @param min_size [Integer] The minimum size of the square, should be 3 or greater.
+    # @return [Hash] The size of the square and the points of the square.
+    def max_square_result(min_size: 3)
+      result = { size: @max_size_found, top_left_tile_x_y: Set.new }
       @tiles_x_y.each do |(x, y)|
-        raise ArgumentError, 'x and y must be greater than or equal to 0' if x.negative? || y.negative?
+        raise ArgumentError, "x and y must be greater than or equal to 0" if x.negative? || y.negative?
 
         steps = max_square(x: x, y: y)
-        track_result(result: result, steps: steps, x: x, y: y) if steps >= min_size
+        result = track_result(result: result, steps: steps, x: x, y: y) if steps >= min_size
       end
       result
     end
 
-    def max_square(x:, y:) # rubocop:disable Naming/MethodParameterName
+    # @param x [Integer] The x coordinate of the top left tile.
+    # @param y [Integer] The y coordinate of the top left tile.
+    # @return [Integer] The size of the square.
+    def max_square(x:, y:)
       steps = 1
       steps += 1 while steps_fulfilled?(x: x, y: y, steps: steps)
       steps
     end
 
-    def steps_fulfilled?(x:, y:, steps:) # rubocop:disable Naming/MethodParameterName
-      @tiles_x_y.include?([x + steps, y + steps]) &&
+    # @param x [Integer] The x coordinate of the top left tile.
+    # @param y [Integer] The y coordinate of the top left tile.
+    # @param steps [Integer] The size of the square.
+    # @return [Boolean] True if all steps are fulfilled.
+    def steps_fulfilled?(x:, y:, steps:)
+      in_lut?(x: x + steps, y: y + steps) &&
         (0...steps).all? do |i|
-          @tiles_x_y.include?([x + steps, y + i]) &&
-            @tiles_x_y.include?([x + i, y + steps])
+          in_lut?(x: x + steps, y: y + i) &&
+            in_lut?(x: x + i, y: y + steps)
         end
     end
 
     private
 
-    def track_result(result:, steps:, x:, y:) # rubocop:disable Naming/MethodParameterName
-      if steps > result[:size]
-        result[:size] = steps
-        result[:top_left_tile_x_y] = Set.new
-        result[:top_left_tile_x_y] << [x, y]
-      elsif steps == result[:size]
-        result[:top_left_tile_x_y] << [x, y]
+    # This is as fast as it gets! Do not implement `#nil?
+    #
+    # @param x [Integer] The x coordinate of the top left tile.
+    # @param y [Integer] The y coordinate of the top left tile.
+    # @return [Boolean|Nil] True if the tile is in the tiles_lut.
+    def in_lut?(x:, y:)
+      unless @tiles_lut
+        @tiles_lut = {}
+        @tiles_x_y.each do |(x, y)|
+          @tiles_lut[x] ||= {}
+          @tiles_lut[x][y] = true
+        end
       end
+      @tiles_lut.dig(x, y)
+    end
+
+    # @param result [Hash] The result hash.
+    # @param steps [Integer] The size of the square.
+    # @param x [Integer] The x coordinate of the top left tile.
+    # @param y [Integer] The y coordinate of the top left tile.
+    # @return [Hash] The updated result hash.
+    def track_result(result:, steps:, x:, y:)
+      if steps > @max_size_found
+        @max_size_found = steps
+        result = { size: @max_size_found, top_left_tile_x_y: Set.new }
+        update_result!(result: result, steps: steps, x: x, y: y)
+      elsif steps == @max_size_found
+        update_result!(result: result, steps: steps, x: x, y: y)
+      end
+      result
+    end
+
+    # @param result [Hash] The result hash.
+    # @param steps [Integer] The size of the square.
+    # @param x [Integer] The x coordinate of the top left tile.
+    # @param y [Integer] The y coordinate of the top left tile.
+    # @return [Hash] The updated result hash.
+    def update_result!(result:, steps:, x:, y:)
+      result[:size] = steps
+      result[:top_left_tile_x_y] << [x, y]
       result
     end
   end

data/lib/slippy_tiles_scorer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SlippyTilesScorer
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/slippy_tiles_scorer.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
+require "set"
 require_relative "slippy_tiles_scorer/version"
-require_relative "./slippy_tiles_scorer/cluster"
-require_relative "./slippy_tiles_scorer/max_square"
+require_relative "slippy_tiles_scorer/cluster"
+require_relative "slippy_tiles_scorer/max_square"
 
 module SlippyTilesScorer
   class Error < StandardError; end
@@ -17,11 +18,9 @@ module SlippyTilesScorer
 
     def valid?
       return true if @tiles_x_y.empty?
-
       raise ArgumentError, "@tiles_x_y must be a Set" unless @tiles_x_y.is_a?(Set)
 
-      set_of_arrays?
-      set_of_arrays_of_integers?
+      set_of_arrays? && set_of_arrays_of_integers?
     end
 
     def clusters(tiles_x_y: @tiles_x_y)
@@ -32,7 +31,7 @@ module SlippyTilesScorer
       result
     end
 
-    def max_square(x:, y:, tiles_x_y: @tiles_x_y) # rubocop:disable Naming/MethodParameterName
+    def max_square(x:, y:, tiles_x_y: @tiles_x_y)
       SlippyTilesScorer::MaxSquare.new(tiles_x_y: tiles_x_y).max_square(x: x, y: y)
     end
 
@@ -40,7 +39,7 @@ module SlippyTilesScorer
       SlippyTilesScorer::MaxSquare.new(tiles_x_y: tiles_x_y).max_squares(min_size: min_size)
     end
 
-    def steps_fulfilled?(x:, y:, steps:) # rubocop:disable Naming/MethodParameterName
+    def steps_fulfilled?(x:, y:, steps:)
       SlippyTilesScorer::MaxSquare.new(tiles_x_y: @tiles_x_y).steps_fulfilled?(x: x, y: y, steps: steps)
     end
 
@@ -51,13 +50,13 @@ module SlippyTilesScorer
     private
 
     def set_of_arrays?
-      return if @tiles_x_y.all? { |point| point.is_a?(Array) && point.size == 2 }
+      return true if @tiles_x_y.all? { |point| point.is_a?(Array) && point.size == 2 }
 
       raise ArgumentError, "each point must be an array with two elements"
     end
 
     def set_of_arrays_of_integers?
-      return if @tiles_x_y.all? { |point| point.all? { |coord| coord.is_a?(Integer) } }
+      return true if @tiles_x_y.all? { |point| point.all?(Integer) }
 
       raise ArgumentError, "each point must be an array with two integers"
     end

data/test_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SlippyTilesScorer
+  # TestHelper class to help with testing
+  class TestHelper
+    class << self
+      def stub_tiles_x_y(service:, size: 50)
+        service.tiles_x_y = Set.new
+        (0...size).each do |i|
+          (0...size).each do |j|
+            service.tiles_x_y.add([i, j])
+          end
+        end
+        service
+      end
+    end
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: slippy_tiles_scorer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Simon Neutert
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-25 00:00:00.000000000 Z
-dependencies: []
+date: 2024-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 description: For a given set of slippy tiles, this gem calculates the score of the
   tiles, like total tiles, clusters and max squares.
 email:
@@ -27,6 +41,7 @@ files:
 - lib/slippy_tiles_scorer/max_square.rb
 - lib/slippy_tiles_scorer/version.rb
 - sig/slippy_tiles_scorer.rbs
+- test_helper.rb
 homepage: https://github.com/simonneutert/slippy_tiles_scorer
 licenses: []
 metadata: