enm 0.1.0

data/lib/enm/namespace.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module ENM
+  # A namespace allows grouping multiple databases together for lookup,
+  # to be exposed in an atomic constant through {ENM.current}.
+  #
+  # It is not meant to be instantiated directly, instead, use {ENM.configure_current}
+  # to set it up for the gem. More advanced use cases can use {.build} for their own
+  # use cases, but the interface is not guaranteed to be stable.
+  class Namespace
+    include Dry::Initializer[undefined: false].define -> do
+      option :databases, ENM::Types::DatabaseMap
+      option :default, ENM::Types::DefaultDatabase, default: proc { databases.first[1] if databases.one? }
+    end
+
+    def initialize(...)
+      super
+
+      freeze
+    end
+
+    # @param [String, Symbol] name
+    # @return [ENM::Database, nil]
+    def [](name) = @databases[name.to_s]
+
+    # @param [String, Symbol] name
+    # @param [String, Symbol, nil] schema
+    # @param [String, Symbol, nil] on the name of the database to get the enum from.
+    #   If `nil`, the default database will be used.
+    # @param [String, Symbol, #to_s, #to_sym, nil] default whether to use a
+    #   certain value as dry-type's default, since it must be defined _before_
+    #   the enum call.
+    # @param [:string, :symbol] mode the underlying type of the enum values.
+    # @return [Dry::Types::Type]
+    def dry(name, schema: nil, on: nil, default: nil, mode: :string)
+      enum = get(name, schema:, on:)
+
+      enum.dry(default:, mode:)
+    end
+
+    def has_default? = !@default.nil?
+
+    # @see ENM::Database#get
+    # @param [String, Symbol] name
+    # @param [String, Symbol, nil] schema
+    # @param [String, Symbol, nil] on the name of the database to get the enum from.
+    #   If `nil`, the default database will be used.
+    # @return [ENM::Enum]
+    def get(name, schema: nil, on: nil)
+      database = database_for(on)
+
+      database.get(name, schema:)
+    end
+
+    private
+
+    # @param [#to_s, nil] name
+    # @raise [ENM::NoDefaultDatabaseError] if `name` is `nil` and no default database is configured
+    # @raise [ENM::DatabaseNotFoundError] if `name` is not
+    # @return [ENM::Database]
+    def database_for(name)
+      if name.nil?
+        if has_default?
+          @default
+        else
+          raise ENM::NoDefaultDatabaseError, "No default database configured for namespace"
+        end
+      else
+        @databases.fetch(name.to_s) do
+          raise ENM::DatabaseNotFoundError, "Database #{name} not found in namespace"
+        end
+      end
+    end
+
+    class << self
+      private_class_method :new
+
+      # @yieldparam [ENM::Namespace::Builder] builder
+      # @yieldreturn [void]
+      # @return [ENM::Namespace]
+      def build
+        builder = Builder.new
+
+        yield(builder)
+
+        new(**builder.to_h)
+      end
+    end
+
+    # A builder for {ENM::Namespace}.
+    # @see ENM::Namespace.build
+    # @api private
+    class Builder
+      def initialize
+        @databases = {}
+        @default = nil
+      end
+
+      # Add a {ENM::Database database} to the namespace from a RON string.
+      #
+      # @api public
+      # @see #from_ron_file!
+      # @param [String] ron
+      # @param [Integer] version
+      # @param [Boolean] default
+      # @return [void]
+      def from_ron!(ron, version: ENM::RON_VERSION, default: false)
+        add!(Database.from_ron(version, ron), default:)
+      end
+
+      # Add a {ENM::Database database} to the namespace from a RON file.
+      #
+      # @api public
+      # @see #from_ron!
+      # @param [String] path
+      # @param [Integer] version
+      # @param [Boolean] default
+      # @return [void]
+      def from_ron_file!(path, version: ENM::RON_VERSION, default: false)
+        add!(Database.from_ron_file(version, path), default:)
+      end
+
+      # Add a {ENM::Database database} to the namespace from a SQL string.
+      #
+      # @api public
+      # @see #from_sql_file!
+      # @param [String, Symbol] name
+      # @param [String] sql
+      # @param [Boolean] default
+      # @return [void]
+      def from_sql!(name, sql, default: false)
+        add!(Database.from_sql(name, sql), default:)
+      end
+
+      # Add a {ENM::Database database} to the namespace from a SQL string.
+      #
+      # @api public
+      # @see #from_sql!
+      # @param [String, Symbol] name
+      # @param [String] path
+      # @param [Boolean] default
+      # @return [void]
+      def from_sql_file!(name, path, default: false)
+        add!(Database.from_sql_file(name, path), default:)
+      end
+
+      # Set the default database for the namespace.
+      #
+      # @api public
+      # @param [String, Symbol] name
+      # @raise [ENM::DatabaseNotFoundError] if no database with the given name is found in the namespace
+      # @return [void]
+      def default!(name)
+        @default = @databases.fetch(name.to_s) do
+          raise ENM::DatabaseNotFoundError, "Default database #{name} not found in namespace"
+        end
+      end
+
+      # @api private
+      # @return [{ Symbol => Object }]
+      def to_h
+        { databases: @databases, default: @default }
+      end
+
+      private
+
+      # @param [ENM::Database] database
+      # @param [Boolean] default
+      # @return [void]
+      def add!(database, default: false)
+        @databases[database.name.to_s] = database
+        @default = database if default
+      end
+    end
+  end
+end

data/lib/enm/types.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ENM
+  # @api private
+  module Types
+    # @!parse [ruby]
+    #   include Dry::Types
+    __send__(:include, Dry.Types)
+
+    # @return [Dry::Types::Type(ENM::Database)]
+    Database = Instance(ENM::Database)
+
+    # @return [Dry::Types::Type(Hash{String => ENM::Database})]
+    DatabaseMap = Hash.map(String, Database)
+
+    # @return [Dry::Types::Type(ENM::Database, nil)]
+    DefaultDatabase = Database.optional
+
+    # @return [Dry::Types::Type(#to_s)]
+    DefaultValue = Coercible::String.constrained(filled: true)
+
+    # @return [Dry::Types::Type(ENM::Enum)]
+    Enum = Instance(ENM::Enum)
+
+    # @return [Dry::Types::Type(:string, :symbol)]
+    DryMode = Coercible::Symbol.default(:string).enum(:string, :symbol)
+  end
+end

data/lib/enm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ENM
+  VERSION = "0.1.0"
+end

data/lib/enm.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+require "dry/types"
+require "pathname"
+
+require_relative "enm/version"
+require "enm/enm"
+require "enm/types"
+require "enm/database"
+require "enm/enum"
+require "enm/namespace"
+
+# A parser and introspecter for PostgreSQL enums, made to be used
+# within Rails or other Ruby applications.
+module ENM
+  # @abstract The base error class for `ENM`.
+  class Error < StandardError; end
+
+  class AlreadyConfiguredError < Error; end
+
+  class DatabaseNotFoundError < Error; end
+
+  class DuplicatedTypeError < Error; end
+
+  class DuplicatedValueError < Error; end
+
+  class EnumConflictError < Error; end
+
+  class EnumNotFoundError < Error; end
+
+  # An error that is raised when trying to specify a default value that
+  # is not present in the enum.
+  class InvalidDefaultError < Error; end
+
+  # An error that is raised when there is some sort of IO error during
+  # file reading / writing operations.
+  class IOError < Error; end
+
+  # An error that is raised when trying to access the current namespace when
+  # it has yet to be initialized.
+  class NoCurrentNamespaceError < Error; end
+
+  # An error that is raised when trying to look up an enum without
+  # specifying the database, and no default database has been set.
+  class NoDefaultDatabaseError < Error; end
+
+  # An error that is raised when there is an issue during parsing of SQL input.
+  class ParseError < Error; end
+
+  # An error that is raised when there is an issue with RON serialization or deserialization.
+  class SerializationError < Error; end
+
+  # An error that is raised when specifying an unknown version during RON deserialization.
+  class UnknownVersionError < Error; end
+
+  class << self
+    # Configure {.current} namespace for the gem.
+    #
+    # @param [Boolean] force
+    # @raise [ENM::AlreadyConfiguredError] if a current namespace is already configured and `force` is not set to `true`
+    # @yieldparam [ENM::Namespace::Builder] builder
+    # @yieldreturn [void]
+    # @return [void]
+    def configure_current(force: false, &block)
+      namespace = Namespace.build(&block)
+
+      raise AlreadyConfiguredError, "Current namespace is already configured" if current? && !force
+
+      Thread.current.thread_variable_set(:enm_current_namespace, namespace)
+    end
+
+    # @!attribute [r] current
+    # @raise [ENM::NoCurrentNamespaceError] if no current namespace is set
+    # @return [ENM::Namespace]
+    def current
+      Thread.current.thread_variable_get(:enm_current_namespace) || raise(ENM::NoCurrentNamespaceError, "No current namespace set")
+    end
+
+    # Whether a current namespace is set.
+    def current? = Thread.current.thread_variable?(:enm_current_namespace)
+
+    # @see ENM::Namespace#[]
+    # @param [String, Symbol] name
+    # @return [ENM::Database, nil]
+    def [](name) = current[name]
+
+    # @see ENM::Namespace#dry
+    # @return [Dry::Types::Type]
+    def dry(...) = current.dry(...)
+
+    # @see ENM::Namespace#get
+    # @return [ENM::Enum]
+    def get(...) = current.get(...)
+
+    # Reset the current namespace, caches, etc.
+    #
+    # @api private
+    # @return [void]
+    def reset!
+      Thread.current.thread_variable_set(:enm_current_namespace, nil)
+
+      ENM::Enum.cache.clear
+    end
+  end
+end

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "4.0.1"

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: enm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexa Grey
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Parse and serialize PostgreSQL enum sets in Ruby, powered by Rust.
+email:
+- devel@mouse.vc
+executables: []
+extensions:
+- ext/enm/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/enm/Cargo.toml
+- ext/enm/build.rs
+- ext/enm/extconf.rb
+- ext/enm/src/lib.rs
+- lib/enm.rb
+- lib/enm/database.rb
+- lib/enm/enum.rb
+- lib/enm/namespace.rb
+- lib/enm/types.rb
+- lib/enm/version.rb
+- mise.toml
+homepage: https://github.com/scryptmouse/enm
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/scryptmouse/enm
+  source_code_uri: https://github.com/scryptmouse/enm
+  changelog_uri: https://github.com/scryptmouse/enm/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Parse and serialize PostgreSQL enum sets in Ruby, powered by Rust.
+test_files: []