go_dbscan_filter_binary 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ad0debca08e183d3253a52f7df2694b383eb95036978a538357c6e486cdabae
+  data.tar.gz: 2fca6e1bdf9cb4fd1bfaa5a6458000476abbd40971078732faa35d414cf84ab1
+SHA512:
+  metadata.gz: 11347d45885b847ee2da87edc51d0f9602928b50f17da6a5a95534170868de64afa7890bc825caa8a3b91504764baac0367954c061e015889e69282423098a3c
+  data.tar.gz: ddfec33d952a6fb5429532af6299505068cbf45749a89fc7bd5e8501745ff88a3b70c7ab058e9f3d726f676e6291e07d6e2ef41cc05eaf9a47a15814c432a833

data/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Sergey Kovalev
+
+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,61 @@
+# GoDbscanFilterBinary
+
+A Ruby gem that provides the `go_dbscan_filter` binary for DBSCAN geo point clustering. The gem automatically downloads the correct platform-specific binary during installation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'go_dbscan_filter_binary'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install go_dbscan_filter_binary
+```
+
+## Usage
+
+After installation, you can access the binary path:
+
+```ruby
+require 'go_dbscan_filter_binary'
+
+# Get the binary path
+binary_path = GoDbscanFilterBinary.binary_path
+
+# Check if binary exists
+if GoDbscanFilterBinary.binary_exists?
+  system("#{GoDbscanFilterBinary.binary!} -input points.csv -output filtered.csv")
+end
+
+# Or use the executable directly
+system("go_dbscan_filter -input points.csv -output filtered.csv")
+```
+
+## Supported Platforms
+
+- Linux (amd64, arm64)
+- macOS (darwin) (amd64, arm64)
+- Windows (amd64, arm64)
+
+The gem automatically detects your platform and downloads the appropriate binary from GitHub releases.
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake build` to build the gem.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE).
+

data/bin/go_dbscan_filter

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'go_dbscan_filter_binary'
+
+binary_path = GoDbscanFilterBinary.binary!
+
+exec(binary_path, *ARGV)
+

data/ext/go_dbscan_filter_binary/extconf.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'zlib'
+require 'stringio'
+require 'tempfile'
+require 'open-uri'
+
+# Determine platform
+def detect_platform
+  os = case RbConfig::CONFIG['host_os']
+  when /linux/i
+    'linux'
+  when /darwin|mac os/i
+    'darwin'
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/i
+    'windows'
+  else
+    raise "Unsupported OS: #{RbConfig::CONFIG['host_os']}"
+  end
+
+  arch = case RbConfig::CONFIG['host_cpu']
+  when /x86_64|amd64/i
+    'amd64'
+  when /arm64|aarch64/i
+    'arm64'
+  else
+    raise "Unsupported architecture: #{RbConfig::CONFIG['host_cpu']}"
+  end
+
+  [os, arch]
+end
+
+# Get the gem version (should match the release version)
+def get_gem_version
+  # When installed, extconf.rb runs in: gem_dir/ext/go_dbscan_filter_binary/extconf.rb
+  # We need to find: gem_dir/lib/go_dbscan_filter_binary/version.rb
+
+  # Calculate gem root: go up two directory levels from extconf.rb
+  # Use expand_path to ensure we get absolute path
+  extconf_dir = File.expand_path(File.dirname(__FILE__))
+  # extconf_dir = gem_dir/ext/go_dbscan_filter_binary
+  ext_dir = File.expand_path('..', extconf_dir)
+  # ext_dir = gem_dir/ext
+  gem_root = File.expand_path('..', ext_dir)
+  # gem_root = gem_dir
+
+  version_file = File.join(gem_root, 'lib', 'go_dbscan_filter_binary', 'version.rb')
+
+  # Try to load the version file directly
+  if File.exist?(version_file)
+    version_content = File.read(version_file)
+    if version_content =~ /VERSION\s*=\s*['"]([^'"]+)['"]/
+      return $1
+    end
+  end
+
+  # Fallback: try to require it
+  begin
+    $LOAD_PATH.unshift(File.join(gem_root, 'lib'))
+    require 'go_dbscan_filter_binary/version'
+    return GoDbscanFilterBinary::VERSION
+  rescue LoadError => e
+    raise "Could not determine gem version. Tried: #{version_file} (gem_root: #{gem_root}, extconf_dir: #{extconf_dir})"
+  end
+end
+
+# Extract tar.gz using system tar command (more reliable)
+def extract_tar_gz(data, binary_name, output_path)
+  require 'tempfile'
+  temp_tar = Tempfile.new(['binary', '.tar.gz'])
+  temp_tar.binmode
+  temp_tar.write(data)
+  temp_tar.close
+
+  # Create temp directory for extraction
+  temp_dir = Dir.mktmpdir('go_dbscan_filter_extract')
+  begin
+    # Extract entire archive to temp directory
+    if system("tar -xzf '#{temp_tar.path}' -C '#{temp_dir}' 2>/dev/null")
+      # Find the binary in the extracted files (could be at root or in subdirectory)
+      found_binary = nil
+      Dir.glob(File.join(temp_dir, '**', binary_name)).each do |file|
+        if File.file?(file) && File.executable?(file) || true # Accept any file matching the name
+          found_binary = file
+          break
+        end
+      end
+
+      # Also check root level
+      root_binary = File.join(temp_dir, binary_name)
+      found_binary = root_binary if File.exist?(root_binary) && !found_binary
+
+      if found_binary && File.exist?(found_binary)
+        FileUtils.cp(found_binary, output_path)
+        File.chmod(0o755, output_path)
+        temp_tar.unlink
+        return true
+      end
+    end
+  ensure
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+  end
+
+  # Fallback: manual extraction
+  io = StringIO.new(data)
+  gz = Zlib::GzipReader.new(io)
+  tar_data = gz.read
+  gz.close
+
+  # Simple tar extraction
+  pos = 0
+  while pos < tar_data.length
+    header = tar_data[pos, 512]
+    break if header.nil? || header.empty? || header[0] == "\0"
+
+    name = header[0, 100].strip
+    size_str = header[124, 12].strip
+    size = size_str.oct rescue 0
+
+    pos += 512
+
+    if name.end_with?(binary_name) && size > 0
+      binary_data = tar_data[pos, size]
+      File.open(output_path, 'wb') do |f|
+        f.write(binary_data)
+      end
+      File.chmod(0o755, output_path)
+      temp_tar.unlink
+      return true
+    end
+
+    pos += (size + 511) / 512 * 512
+  end
+
+  temp_tar.unlink
+  false
+end
+
+# Extract zip using system unzip command (more reliable)
+def extract_zip(data, binary_name, output_path)
+  require 'tempfile'
+  temp_zip = Tempfile.new(['binary', '.zip'])
+  temp_zip.binmode
+  temp_zip.write(data)
+  temp_zip.close
+
+  # Create temp directory for extraction
+  temp_dir = Dir.mktmpdir('go_dbscan_filter_extract')
+  begin
+    # Extract entire archive to temp directory
+    if system("unzip -q '#{temp_zip.path}' -d '#{temp_dir}' 2>/dev/null")
+      # Find the binary in the extracted files
+      found_binary = nil
+      Dir.glob(File.join(temp_dir, '**', binary_name)).each do |file|
+        if File.file?(file)
+          found_binary = file
+          break
+        end
+      end
+
+      # Also check root level
+      root_binary = File.join(temp_dir, binary_name)
+      found_binary = root_binary if File.exist?(root_binary) && !found_binary
+
+      if found_binary && File.exist?(found_binary)
+        FileUtils.cp(found_binary, output_path)
+        temp_zip.unlink
+        return true
+      end
+    end
+
+    # Fallback: try direct extraction to output directory
+    if system("unzip -q -j '#{temp_zip.path}' '*#{binary_name}' -d '#{File.dirname(output_path)}' 2>/dev/null")
+      result = File.exist?(output_path)
+      temp_zip.unlink
+      return result
+    end
+  ensure
+    FileUtils.rm_rf(temp_dir) if Dir.exist?(temp_dir)
+  end
+
+  temp_zip.unlink
+  false
+end
+
+# Download and extract the binary
+def download_binary(os, arch, version)
+  puts "Downloading go_dbscan_filter binary for #{os}/#{arch}..."
+
+  # Construct download URL
+  archive_name = "go-dbscan-filter_#{os}_#{arch}"
+  archive_name += '.zip' if os == 'windows'
+  archive_name += '.tar.gz' unless os == 'windows'
+
+  url = "https://github.com/serg-kovalev/go-dbscan-filter/releases/download/v#{version}/#{archive_name}"
+
+  puts "Downloading from: #{url}"
+
+  # Download the archive (open-uri handles redirects automatically)
+  begin
+    response_body = URI.open(url, 'User-Agent' => 'go_dbscan_filter_binary-gem', &:read)
+  rescue OpenURI::HTTPError => e
+    raise "Failed to download binary: HTTP #{e.io.status[0]} #{e.io.status[1]}"
+  rescue => e
+    raise "Failed to download binary: #{e.message}"
+  end
+
+  # Determine binary name
+  binary_name = 'go_dbscan_filter'
+  binary_name += '.exe' if os == 'windows'
+
+  # Download binary to lib/go_dbscan_filter_binary/bin/ (wrapper script stays in bin/)
+  # From ext/go_dbscan_filter_binary/extconf.rb, go up to gem root
+  gem_root = File.expand_path('../..', File.dirname(__FILE__))
+  bin_dir = File.join(gem_root, 'lib', 'go_dbscan_filter_binary', 'bin')
+  FileUtils.mkdir_p(bin_dir)
+  output_path = File.join(bin_dir, binary_name)
+
+  # Extract binary
+  success = if os == 'windows'
+    extract_zip(response_body, binary_name, output_path)
+  else
+    extract_tar_gz(response_body, binary_name, output_path)
+  end
+
+  unless success && File.exist?(output_path)
+    raise "Binary #{binary_name} was not extracted correctly"
+  end
+
+  puts "Binary downloaded successfully to #{output_path}"
+  output_path
+end
+
+# Main installation logic
+begin
+  os, arch = detect_platform
+  version = get_gem_version
+
+  puts "Installing go_dbscan_filter binary for platform: #{os}/#{arch}"
+  puts "Gem version: #{version} (will download matching release v#{version})"
+
+  binary_path = download_binary(os, arch, version)
+
+  # Determine binary name for Makefile
+  binary_name = 'go_dbscan_filter'
+  binary_name += '.exe' if os == 'windows'
+
+  # Get bin directory path (actual binary is in lib/go_dbscan_filter_binary/bin/)
+  gem_root = File.expand_path('../..', File.dirname(__FILE__))
+  bin_dir = File.join(gem_root, 'lib', 'go_dbscan_filter_binary', 'bin')
+  bin_path = File.join(bin_dir, binary_name)
+
+  # Create Makefile (required by RubyGems)
+  File.open('Makefile', 'w') do |f|
+    f.puts <<~MAKEFILE
+      # Makefile for go_dbscan_filter_binary extension
+      # The binary is already downloaded by extconf.rb
+
+      .PHONY: all install clean
+
+      all:
+      \t@echo "Binary already prepared by extconf.rb"
+      \t@test -f "#{bin_path}" || (echo "Error: Binary not found at #{bin_path}" && exit 1)
+      \t@echo "Binary verified: #{bin_path}"
+
+      install: all
+      \t@echo "Installing go_dbscan_filter binary..."
+      \t@test -f "#{bin_path}" || (echo "Error: Binary not found at #{bin_path}" && exit 1)
+      \t@chmod +x "#{bin_path}" 2>/dev/null || true
+      \t@echo "Binary installed successfully: #{bin_path}"
+
+      clean:
+      \t@echo "Cleaning up..."
+      \t@# Don't remove Makefile - it's needed for make install
+    MAKEFILE
+  end
+
+rescue => e
+  $stderr.puts "Error installing binary: #{e.message}"
+  $stderr.puts e.backtrace.join("\n")
+  exit 1
+end
+

data/go_dbscan_filter_binary.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/go_dbscan_filter_binary/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'go_dbscan_filter_binary'
+  spec.version       = GoDbscanFilterBinary::VERSION
+  spec.authors       = ['Sergey Kovalev']
+  spec.email         = ['serg-kovalev@users.noreply.github.com>']
+
+  spec.summary       = 'DBSCAN geo point clustering binary'
+  spec.description   = 'Provides the go-dbscan-filter binary to be used by other gems'
+  spec.homepage      = 'https://github.com/serg-kovalev/go-dbscan-filter'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['lib/**/*', 'ext/**/*', 'bin/**/*', '*.md', 'LICENSE', '*.gemspec']
+  # Note: bin/go_dbscan_filter is a Ruby wrapper script that calls the actual Go binary
+  # The actual Go binary is downloaded to lib/go_dbscan_filter_binary/bin/ during installation via extconf.rb
+  spec.bindir        = 'bin'
+  spec.executables   = ['go_dbscan_filter']
+  # The executable is the actual Go binary downloaded during installation
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/go_dbscan_filter_binary/extconf.rb']
+
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+end
+

data/lib/go_dbscan_filter_binary/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module GoDbscanFilterBinary
+  VERSION = '0.1.2'
+end
+

data/lib/go_dbscan_filter_binary.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'go_dbscan_filter_binary/version'
+
+module GoDbscanFilterBinary
+  class Error < StandardError; end
+
+  # Returns the path to the go_dbscan_filter binary
+  def self.binary_path
+    @binary_path ||= begin
+      # Find the gem's root directory
+      # __dir__ points to lib/go_dbscan_filter_binary, so go up two levels to gem root
+      gem_root = File.expand_path('../..', __dir__)
+
+      # Construct binary path (actual binary is in lib/go_dbscan_filter_binary/bin/)
+      binary_name = 'go_dbscan_filter'
+      binary_name += '.exe' if Gem.win_platform?
+      bin_path = File.join(__dir__, 'bin', binary_name)
+
+      # Verify the path exists, if not try alternative methods
+      unless File.exist?(bin_path)
+        # Try using Gem to find the gem path (works for installed gems)
+        begin
+          spec = Gem::Specification.find_by_name('go_dbscan_filter_binary')
+          if spec
+            bin_path = File.join(spec.gem_dir, 'lib', 'go_dbscan_filter_binary', 'bin', binary_name)
+          end
+        rescue Gem::LoadError
+          # Gem not found via Gem, try Bundler
+          begin
+            require 'bundler'
+            if defined?(Bundler)
+              spec = Bundler.rubygems.find_name('go_dbscan_filter_binary').first
+              if spec
+                bin_path = File.join(spec.full_gem_path, 'lib', 'go_dbscan_filter_binary', 'bin', binary_name)
+              end
+            end
+          rescue
+            # Fallback to original calculation
+          end
+        end
+      end
+
+      bin_path
+    end
+  end
+
+  # Returns true if the binary exists
+  def self.binary_exists?
+    File.exist?(binary_path) && File.executable?(binary_path)
+  end
+
+  # Returns the binary path or raises an error if it doesn't exist
+  def self.binary!
+    raise Error, "go_dbscan_filter binary not found at #{binary_path}" unless binary_exists?
+    binary_path
+  end
+end
+

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: go_dbscan_filter_binary
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Sergey Kovalev
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Provides the go-dbscan-filter binary to be used by other gems
+email:
+- serg-kovalev@users.noreply.github.com>
+executables:
+- go_dbscan_filter
+extensions:
+- ext/go_dbscan_filter_binary/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/go_dbscan_filter
+- ext/go_dbscan_filter_binary/extconf.rb
+- go_dbscan_filter_binary.gemspec
+- lib/go_dbscan_filter_binary.rb
+- lib/go_dbscan_filter_binary/version.rb
+homepage: https://github.com/serg-kovalev/go-dbscan-filter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: DBSCAN geo point clustering binary
+test_files: []