sequel-sqlformat 0.1.0-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6100b4499e5dc52064a82ecb726f6c4e9e9004093dba75eff2effd40b10a1e2d
+  data.tar.gz: e187eb66070aa7bb530723117e9b748f56648f16adb4c6145c7e9705c08243bb
+SHA512:
+  metadata.gz: 61c899debff1f5d8610c5191ee8c1ec895a34cd66e4855235d412e861eebf9907130e1c431049b6c5bfc271c0230269f8160bb61d47fffb8dc4a1aa3067f05f2
+  data.tar.gz: 3f3e87e02dbd6982c235df0b4d9db3446201a7598e20626a3d838916d687b0b3addd4b84b9dca293620063249214d25b535f324e5dfe7ab13e8bfb6a7407b75b

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [0.1.0] - 2026-10-28
+
+### Added
+
+- The `sqlformat` Sequel extension: `Database#format_sql`, `Dataset#formatted_sql`, and `sqlformat_options` on a database or in the connect hash. The dialect comes from the database type.
+- `Sequel::SQLFormat.format(sql, indent:, uppercase:, lines_between_queries:, dialect:)` formats SQL with the Rust `sqlformat` crate 0.5, with no database. The defaults are the crate's defaults.
+
+[0.1.0]: https://github.com/outcomesinsights/sequel-sqlformat/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Outcomes Insights, Inc.
+
+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,81 @@
+# sequel-sqlformat
+
+A [Sequel](https://sequel.jeremyevans.net/) extension that formats SQL for reading. It adds
+`Dataset#formatted_sql` and `Database#format_sql`. Formatting runs inside the Ruby process,
+through a native extension built with [magnus](https://github.com/matsadler/magnus) that wraps
+the Rust [`sqlformat`](https://crates.io/crates/sqlformat) crate. No external process starts,
+so formatting many statements costs milliseconds, not seconds.
+
+```ruby
+DB.extension :sqlformat
+
+DB[:items].where(id: 1).formatted_sql(uppercase: true)
+# SELECT
+#   *
+# FROM
+#   "items"
+# WHERE
+#   ("id" = 1)
+
+DB.format_sql("select a, b from t where a = 1")   # any SQL string
+```
+
+To format one dataset only, load the extension into it: `DB[:items].extension(:sqlformat)`.
+
+Without a database:
+
+```ruby
+require "sequel/sqlformat"
+
+Sequel::SQLFormat.format("select a from t", dialect: :postgresql)
+```
+
+## Options
+
+| Option                  | Default    | Meaning                                                                           |
+| ----------------------- | ---------- | --------------------------------------------------------------------------------- |
+| `indent`                | `2`        | Spaces for each indentation level (0 to 255).                                     |
+| `uppercase`             | `nil`      | `true` uppercases keywords, `false` lowercases them, `nil` keeps them.            |
+| `lines_between_queries` | `1`        | Line breaks after each statement (0 to 255).                                      |
+| `dialect`               | `:generic` | `:postgresql` adds array syntax. `:sqlserver` adds `[brackets]` and `@variables`. |
+
+The defaults are the crate's defaults. Through the extension, the dialect comes from the
+database type: `:postgresql` for PostgreSQL, `:sqlserver` for Microsoft SQL Server, and
+`:generic` for every other database.
+
+Set options for a database when you connect, or before you freeze it, or for one call:
+
+```ruby
+DB = Sequel.connect(url, sqlformat: { uppercase: true, indent: 4 })
+DB.sqlformat_options = { uppercase: true }
+DB[:items].formatted_sql(uppercase: false)
+```
+
+An unknown option name raises `ArgumentError`.
+
+## What it does and does not do
+
+- The crate splits SQL into tokens and does not parse it. It accepts any dialect, including
+  DuckDB and Spark SQL, and it never fails on syntax that it does not know.
+- It changes only whitespace and, with `uppercase: true` or `false`, the case of keywords.
+- With `uppercase: true` or `false`, an unquoted identifier that is also a keyword (for
+  example `status`) changes case too. Sequel quotes identifiers by default, so this matters
+  only for SQL that you write yourself.
+
+## Installation
+
+Precompiled gems exist for x86_64 and ARM64 Linux, and for Intel and Apple Silicon macOS,
+for Ruby 3.3, 3.4 and 4.0. They need no Rust. Every other platform builds the source gem,
+which needs a Rust toolchain (rustc 1.84 or later) and libclang.
+
+## Development
+
+```sh
+just setup   # tools, bundle and the git hooks
+just test    # compile the extension and run the tests
+just ci      # everything CI runs
+```
+
+## License
+
+MIT. The `sqlformat` crate is MIT OR Apache-2.0.

data/lib/sequel/extensions/sqlformat.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+#
+# The sqlformat extension formats SQL for reading: one clause per line, indented
+# subqueries, and optionally uppercase keywords. It formats inside the Ruby process
+# with the Rust `sqlformat` crate, so no external process starts.
+#
+# Load it into a database:
+#
+#   DB.extension :sqlformat
+#
+#   DB[:items].where(id: 1).formatted_sql
+#   # => "SELECT\n  *\nFROM\n  \"items\"\nWHERE\n  (\"id\" = 1)"
+#
+#   DB.format_sql("select a from t")   # any SQL string
+#
+# Or into one dataset only:
+#
+#   DB[:items].extension(:sqlformat).formatted_sql
+#
+# The crate's SQL dialect comes from the database type: :postgresql for PostgreSQL,
+# :sqlserver for Microsoft SQL Server, and :generic for every other database.
+#
+# The default options are the crate's defaults (2 spaces, keyword case unchanged, one
+# line break between statements). Change them for a database, either when connecting
+# or before the database is frozen:
+#
+#   DB = Sequel.connect(url, sqlformat: { uppercase: true, indent: 4 })
+#   DB.sqlformat_options = { uppercase: true }
+#
+# or for one call:
+#
+#   DB[:items].formatted_sql(uppercase: false)
+#
+# The crate works on tokens and does not parse SQL. It changes only whitespace and,
+# with uppercase: true or false, the case of keywords. With uppercase: true or false,
+# an unquoted identifier that is also a keyword changes case too.
+#
+# Related module: Sequel::SQLFormat
+
+require_relative "../sqlformat"
+
+module Sequel
+  module SQLFormat
+    OPTION_KEYS = DEFAULTS.keys.freeze
+
+    # Checks option keys here, so a typo fails where it is written. The values are
+    # checked by SQLFormat.format.
+    def self.check_options!(opts)
+      raise TypeError, "sqlformat options must be a Hash, got #{opts.class}" unless opts.is_a?(Hash)
+
+      unknown = opts.keys - OPTION_KEYS
+      raise ArgumentError, "unknown sqlformat option(s) #{unknown.inspect}; expected #{OPTION_KEYS.inspect}" unless unknown.empty?
+
+      opts
+    end
+
+    module DatabaseMethods
+      def self.extended(db)
+        db.instance_exec do
+          @sqlformat_options = SQLFormat.check_options!(opts.fetch(:sqlformat, {})).dup.freeze
+        end
+        db.extend_datasets(DatasetMethods)
+      end
+
+      # The options this database passes to SQLFormat.format. Per-call options win.
+      attr_reader :sqlformat_options
+
+      def sqlformat_options=(opts)
+        @sqlformat_options = SQLFormat.check_options!(opts).dup.freeze
+      end
+
+      # Formats any SQL string with this database's dialect and options.
+      def format_sql(sql, **opts)
+        SQLFormat.check_options!(opts)
+        SQLFormat.format(sql, **{ dialect: SQLFormat.dialect_for(database_type) }.merge(sqlformat_options, opts))
+      end
+    end
+
+    module DatasetMethods
+      # The dataset's SQL (Dataset#sql), formatted.
+      def formatted_sql(**opts)
+        if db.respond_to?(:format_sql)
+          db.format_sql(sql, **opts)
+        else
+          SQLFormat.check_options!(opts)
+          SQLFormat.format(sql, **{ dialect: SQLFormat.dialect_for(db.database_type) }.merge(opts))
+        end
+      end
+    end
+  end
+
+  # Dataset first: Dataset.register_extension also registers a Database extension of the
+  # same name (one that only extends datasets), so the Database registration must come
+  # last to win.
+  Dataset.register_extension(:sqlformat, SQLFormat::DatasetMethods)
+  Database.register_extension(:sqlformat, SQLFormat::DatabaseMethods)
+end

data/lib/sequel/sqlformat/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sequel
+  module SQLFormat
+    VERSION = "0.1.0"
+  end
+end

data/lib/sequel/sqlformat.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "sqlformat/version"
+
+# A precompiled gem keeps one library per Ruby minor version under
+# lib/sequel/sqlformat/<major.minor>/. A gem built from source puts it in
+# lib/sequel/sqlformat/.
+begin
+  ruby_minor = RUBY_VERSION[/\A\d+\.\d+/]
+  require_relative "sqlformat/#{ruby_minor}/sequel_sqlformat"
+rescue LoadError
+  require_relative "sqlformat/sequel_sqlformat"
+end
+
+module Sequel
+  # Formats SQL inside the Ruby process with the Rust `sqlformat` crate. The crate
+  # splits SQL into tokens and does not parse it, so it accepts any dialect and never
+  # fails on unknown syntax. This needs no database; the `sqlformat` Sequel extension
+  # (lib/sequel/extensions/sqlformat.rb) adds it to databases and datasets.
+  module SQLFormat
+    DIALECTS = %i[generic postgresql sqlserver].freeze
+
+    # The crate's own defaults.
+    DEFAULTS = { indent: 2, uppercase: nil, lines_between_queries: 1, dialect: :generic }.freeze
+
+    # indent: spaces for each indentation level (0 to 255).
+    # uppercase: true uppercases keywords, false lowercases them, nil keeps them.
+    # lines_between_queries: line breaks after each statement (0 to 255).
+    # dialect: :postgresql adds array syntax. :sqlserver adds [brackets] and @variables.
+    def self.format(sql, indent: 2, uppercase: nil, lines_between_queries: 1, dialect: :generic)
+      raise TypeError, "sql must be a String, got #{sql.class}" unless sql.is_a?(String)
+      raise ArgumentError, "unknown dialect #{dialect.inspect}; expected one of #{DIALECTS.inspect}" unless DIALECTS.include?(dialect.to_sym)
+      raise ArgumentError, "indent must be an Integer from 0 to 255" unless indent.is_a?(Integer) && indent.between?(0, 255)
+      raise ArgumentError, "lines_between_queries must be an Integer from 0 to 255" unless lines_between_queries.is_a?(Integer) && lines_between_queries.between?(0, 255)
+      raise ArgumentError, "uppercase must be true, false or nil" unless [ true, false, nil ].include?(uppercase)
+
+      native_format(sql.encode(Encoding::UTF_8), indent, uppercase, lines_between_queries, dialect.to_s)
+    end
+
+    # The crate dialect for a Sequel database type. Every type the crate has no mode
+    # for, such as DuckDB, Spark, SQLite and MySQL, gets the generic mode.
+    def self.dialect_for(database_type)
+      case database_type
+      when :postgres then :postgresql
+      when :mssql then :sqlserver
+      else :generic
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: sequel-sqlformat
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: arm64-darwin
+authors:
+- Ryan Duryea
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Adds Database#format_sql and Dataset#formatted_sql to Sequel. Formatting
+  runs inside the Ruby process through a native extension (magnus) that wraps the
+  Rust sqlformat crate, so no external process starts and many statements format in
+  milliseconds.
+email:
+- aguynamedryan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/sequel/extensions/sqlformat.rb
+- lib/sequel/sqlformat.rb
+- lib/sequel/sqlformat/3.3/sequel_sqlformat.bundle
+- lib/sequel/sqlformat/3.4/sequel_sqlformat.bundle
+- lib/sequel/sqlformat/4.0/sequel_sqlformat.bundle
+- lib/sequel/sqlformat/version.rb
+homepage: https://github.com/outcomesinsights/sequel-sqlformat
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/outcomesinsights/sequel-sqlformat
+  source_code_uri: https://github.com/outcomesinsights/sequel-sqlformat
+  changelog_uri: https://github.com/outcomesinsights/sequel-sqlformat/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: A Sequel extension that formats SQL, fast, with the Rust sqlformat crate
+test_files: []