enm 0.1.0

data/ext/enm/src/lib.rs

@@ -0,0 +1,543 @@
+use magnus::{
+    block::Yield, function, method, prelude::*, Error, ExceptionClass, RModule, Ruby, TryConvert,
+    Value,
+};
+
+use pgenum_parser::{Database, EnumType, PGEnumError, RON_VERSION};
+
+/// Convert an `anyhow::Error` into a `magnus::Error` with the appropriate
+/// Ruby exception class based on the `PGEnumError` variant.
+fn to_ruby_err(err: anyhow::Error) -> Error {
+    let ruby = Ruby::get().expect("called outside Ruby");
+    let module: RModule = ruby.class_object().const_get("ENM").expect("ENM module not defined");
+
+    let (class_name, message) = match err.downcast_ref::<PGEnumError>() {
+        Some(PGEnumError::DuplicatedType { .. }) => ("DuplicatedTypeError", err.to_string()),
+        Some(PGEnumError::DuplicatedValue { .. }) => ("DuplicatedValueError", err.to_string()),
+        Some(PGEnumError::EnumConflict { .. }) => ("EnumConflictError", err.to_string()),
+        Some(PGEnumError::EnumNotFound { .. }) => ("EnumNotFoundError", err.to_string()),
+        Some(PGEnumError::InvalidRepresentation(_)) => ("SerializationError", err.to_string()),
+        Some(PGEnumError::IOError { .. }) => ("IOError", err.to_string()),
+        Some(PGEnumError::SQLParseError(_)) => ("ParseError", err.to_string()),
+        Some(PGEnumError::UnknownVersion(_)) => ("UnknownVersionError", err.to_string()),
+        None => ("Error", err.to_string()),
+    };
+
+    let exception_class: ExceptionClass = module
+        .const_get(class_name)
+        .expect("exception class not defined");
+
+    Error::new(exception_class, message)
+}
+
+/// A wrapper around `pgenum_parser::Database`. It provides
+/// ruby bindings to the underlying Rust implementation.
+#[magnus::wrap(class = "ENM::Database", free_immediately, size)]
+struct DatabaseWrapper {
+    inner: Database,
+}
+
+impl DatabaseWrapper {
+    fn new(inner: Database) -> Self {
+        Self { inner }
+    }
+
+    fn empty(&self) -> bool {
+        self.inner.enums().is_empty()
+    }
+
+    fn from_ron(version: u32, ron: String) -> Result<Self, Error> {
+        let inner = Database::from_ron(version, &ron).map_err(to_ruby_err)?;
+
+        Ok(Self::new(inner))
+    }
+
+    fn value_to_string(value: Value) -> Result<String, Error> {
+        String::try_convert(value).or_else(|_| value.funcall("to_s", ()))
+    }
+
+    fn from_ron_file(version: u32, path: Value) -> Result<Self, Error> {
+        let path = Self::value_to_string(path)?;
+        let inner = Database::from_ron_file(version, &path).map_err(to_ruby_err)?;
+        Ok(Self::new(inner))
+    }
+
+    fn from_sql(name: String, sql: String) -> Result<Self, Error> {
+        let inner = Database::from_sql(&name, &sql).map_err(to_ruby_err)?;
+
+        Ok(Self::new(inner))
+    }
+
+    fn from_sql_file(name: String, path: Value) -> Result<Self, Error> {
+        let path = Self::value_to_string(path)?;
+        let inner = Database::from_sql_file(&name, &path).map_err(to_ruby_err)?;
+
+        Ok(Self::new(inner))
+    }
+
+    fn get(&self, name: String, schema: Option<String>) -> Result<Enum, Error> {
+        let enum_type = self
+            .inner
+            .get(schema.as_deref(), &name)
+            .map_err(to_ruby_err)?;
+
+        Ok(Enum {
+            inner: enum_type.clone(),
+        })
+    }
+
+    fn lazy_get(&self, key: Value) -> Result<Enum, Error> {
+        let s: String = String::try_convert(key)
+            .or_else(|_| key.funcall("to_s", ()))?;
+
+        if let Some((schema, name)) = s.split_once('.') {
+            self.get(name.to_string(), Some(schema.to_string()))
+        } else {
+            self.get(s, None)
+        }
+    }
+
+    fn name(&self) -> String {
+        self.inner.name().to_string()
+    }
+
+    fn to_ron(&self) -> Result<String, Error> {
+        self.inner.to_ron().map_err(to_ruby_err)
+    }
+
+    fn to_ron_file(&self, path: Value) -> Result<(), Error> {
+        let path = Self::value_to_string(path)?;
+        self.inner.to_ron_file(&path).map_err(to_ruby_err)
+    }
+}
+
+#[magnus::wrap(class = "ENM::Enum", free_immediately, size)]
+struct Enum {
+    inner: EnumType,
+}
+
+impl Enum {
+    fn comment(&self) -> Option<String> {
+        self.inner.comment().map(|s| s.to_string())
+    }
+
+    fn digest(&self) -> String {
+        self.inner.digest().to_string()
+    }
+
+    fn each(ruby: &Ruby, rb_self: Value) -> Yield<std::vec::IntoIter<String>> {
+        if ruby.block_given() {
+            let wrapper = <&Enum>::try_convert(rb_self).expect("self is Enum");
+
+            Yield::Iter(wrapper.into_iter().cloned().collect::<Vec<_>>().into_iter())
+        } else {
+            Yield::Enumerator(rb_self.enumeratorize("each", ()))
+        }
+    }
+
+    fn name(&self) -> String {
+        self.inner.name().to_string()
+    }
+
+    fn schema(&self) -> String {
+        self.inner.schema().to_string()
+    }
+
+    fn values(&self) -> Vec<String> {
+        self.inner.values().to_vec()
+    }
+}
+
+impl<'a> IntoIterator for &'a Enum {
+    type Item = &'a String;
+    type IntoIter = std::slice::Iter<'a, String>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.inner).into_iter()
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module: RModule = ruby.define_module("ENM")?;
+
+    let error_class = module.define_error("Error", ruby.exception_standard_error())?;
+
+    module.define_error("DuplicatedTypeError", error_class)?;
+    module.define_error("DuplicatedValueError", error_class)?;
+    module.define_error("EnumConflictError", error_class)?;
+    module.define_error("EnumNotFoundError", error_class)?;
+    module.define_error("IOError", error_class)?;
+    module.define_error("ParseError", error_class)?;
+    module.define_error("SerializationError", error_class)?;
+    module.define_error("UnknownVersionError", error_class)?;
+
+    // Database class
+    let database_klass = module.define_class("Database", ruby.class_object())?;
+
+    database_klass.define_singleton_method("from_ron", function!(DatabaseWrapper::from_ron, 2))?;
+    database_klass.define_singleton_method("from_ron_file", function!(DatabaseWrapper::from_ron_file, 2))?;
+    database_klass.define_singleton_method("from_sql", function!(DatabaseWrapper::from_sql, 2))?;
+    database_klass.define_singleton_method("from_sql_file", function!(DatabaseWrapper::from_sql_file, 2))?;
+    database_klass.define_method("[]", method!(DatabaseWrapper::lazy_get, 1))?;
+    database_klass.define_method("name", method!(DatabaseWrapper::name, 0))?;
+    database_klass.define_method("empty?", method!(DatabaseWrapper::empty, 0))?;
+    database_klass.define_method("to_ron", method!(DatabaseWrapper::to_ron, 0))?;
+    database_klass.define_method("to_ron_file", method!(DatabaseWrapper::to_ron_file, 1))?;
+    database_klass.define_private_method("_get", method!(DatabaseWrapper::get, 2))?;
+
+    // Enum class with Enumerable
+    let enum_klass = module.define_class("Enum", ruby.class_object())?;
+    let enumerable: RModule = ruby.class_object().const_get("Enumerable")?;
+
+    enum_klass.include_module(enumerable)?;
+
+    enum_klass.define_method("comment", method!(Enum::comment, 0))?;
+    enum_klass.define_method("digest", method!(Enum::digest, 0))?;
+    enum_klass.define_method("each", method!(Enum::each, 0))?;
+    enum_klass.define_method("name", method!(Enum::name, 0))?;
+    enum_klass.define_method("schema", method!(Enum::schema, 0))?;
+    enum_klass.define_method("values", method!(Enum::values, 0))?;
+
+    if module.const_get::<_, Value>("RON_VERSION").is_err() {
+        module.const_set("RON_VERSION", RON_VERSION)?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use magnus::eval;
+    use rb_sys_test_helpers::ruby_test;
+
+    const VALID_SQL: &str = r#"
+        CREATE TYPE public.access_management AS ENUM ('global', 'contextual', 'forbidden');
+        COMMENT ON TYPE public.access_management IS 'Represents access management levels.';
+        CREATE TYPE public.analytics_context AS ENUM ('admin', 'frontend');
+        CREATE TYPE asset_kind AS ENUM ('unknown', 'image', 'video');
+    "#;
+
+    fn setup(ruby: &Ruby) {
+        init(ruby).expect("init failed");
+    }
+
+    fn ruby_string_value(ruby: &Ruby, s: &str) -> Value {
+        ruby.str_new(s).as_value()
+    }
+
+    #[ruby_test]
+    fn test_init_defines_enm_module() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        let result: bool = eval("defined?(ENM) == 'constant'").unwrap();
+
+        assert!(result);
+    }
+
+    #[ruby_test]
+    fn test_init_defines_error_classes() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        for class_name in &[
+            "ENM::Error",
+            "ENM::DuplicatedTypeError",
+            "ENM::DuplicatedValueError",
+            "ENM::EnumConflictError",
+            "ENM::EnumNotFoundError",
+            "ENM::IOError",
+            "ENM::ParseError",
+            "ENM::SerializationError",
+            "ENM::UnknownVersionError",
+        ] {
+            let result: bool = eval(&format!("defined?({class_name}) == 'constant'")).unwrap();
+
+            assert!(result, "{class_name} should be defined");
+        }
+    }
+
+    #[ruby_test]
+    fn test_init_sets_ron_version_constant() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        let version: u32 = eval("ENM::RON_VERSION").unwrap();
+        assert_eq!(version, RON_VERSION);
+    }
+
+    #[ruby_test]
+    fn test_database_from_sql() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test_db".to_string(), VALID_SQL.to_string()).unwrap();
+        assert_eq!(db.name(), "test_db");
+        assert!(!db.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_from_sql_empty() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql(
+            "empty_db".to_string(),
+            "CREATE TABLE t (id int);".to_string(),
+        )
+        .unwrap();
+        assert!(db.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_from_sql_invalid() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let result = DatabaseWrapper::from_sql("bad".to_string(), "not valid sql".to_string());
+        assert!(result.is_err());
+    }
+
+    #[ruby_test]
+    fn test_database_ron_round_trip() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("rt".to_string(), VALID_SQL.to_string()).unwrap();
+        let ron = db.to_ron().unwrap();
+
+        let db2 = DatabaseWrapper::from_ron(RON_VERSION, ron).unwrap();
+
+        assert_eq!(db2.name(), "rt");
+        assert!(!db2.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_get_enum_by_name_and_schema() {
+        let ruby = Ruby::get().unwrap();
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let e = db
+            .get("access_management".to_string(), Some("public".to_string()))
+            .unwrap();
+
+        assert_eq!(e.name(), "access_management");
+        assert_eq!(e.schema(), "public");
+    }
+
+    #[ruby_test]
+    fn test_database_get_enum_not_found() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let result = db.get("nonexistent".to_string(), None);
+
+        assert!(result.is_err());
+    }
+
+    #[ruby_test]
+    fn test_lazy_get_with_symbol() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let key: Value = eval(":access_management").unwrap();
+        let e = db.lazy_get(key).unwrap();
+
+        assert_eq!(e.name(), "access_management");
+    }
+
+    #[ruby_test]
+    fn test_lazy_get_with_schema_dot_notation() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let key: Value = eval("'public.access_management'").unwrap();
+        let e = db.lazy_get(key).unwrap();
+
+        assert_eq!(e.name(), "access_management");
+        assert_eq!(e.schema(), "public");
+    }
+
+    #[ruby_test]
+    fn test_lazy_get_with_string_no_schema() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let key: Value = eval("'access_management'").unwrap();
+        let e = db.lazy_get(key).unwrap();
+
+        assert_eq!(e.name(), "access_management");
+    }
+
+    #[ruby_test]
+    fn test_enum_comment() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+
+        let with_comment = db
+            .get("access_management".to_string(), Some("public".to_string()))
+            .unwrap();
+        assert_eq!(
+            with_comment.comment(),
+            Some("Represents access management levels.".to_string())
+        );
+
+        let without_comment = db
+            .get("analytics_context".to_string(), Some("public".to_string()))
+            .unwrap();
+
+        assert_eq!(without_comment.comment(), None);
+    }
+
+    #[ruby_test]
+    fn test_enum_each_with_block() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let e = db
+            .get("analytics_context".to_string(), Some("public".to_string()))
+            .unwrap();
+
+        let values: Vec<String> = e.values();
+
+        assert_eq!(values, vec!["admin", "frontend"]);
+    }
+
+    #[ruby_test]
+    fn test_database_from_ron_rejects_bad_version() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let ron = db.to_ron().unwrap();
+
+        let result = DatabaseWrapper::from_ron(999, ron);
+
+        assert!(result.is_err());
+    }
+
+    #[ruby_test]
+    fn test_database_from_sql_file() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let path = std::env::temp_dir().join("enm_test_from_sql_file.sql");
+        let path_str = path.to_str().unwrap();
+
+        std::fs::write(&path, VALID_SQL).unwrap();
+
+        let db = DatabaseWrapper::from_sql_file(
+            "test_db".to_string(),
+            ruby_string_value(&ruby, path_str),
+        )
+        .unwrap();
+
+        assert_eq!(db.name(), "test_db");
+        assert!(!db.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_from_sql_file_not_found() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let result = DatabaseWrapper::from_sql_file(
+            "test".to_string(),
+            ruby_string_value(&ruby, "/nonexistent/path/enm_test.sql"),
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[ruby_test]
+    fn test_database_from_ron_file() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("rt".to_string(), VALID_SQL.to_string()).unwrap();
+        let ron = db.to_ron().unwrap();
+        let path = std::env::temp_dir().join("enm_test_from_ron_file.ron");
+        let path_str = path.to_str().unwrap();
+
+        std::fs::write(&path, &ron).unwrap();
+
+        let db2 = DatabaseWrapper::from_ron_file(RON_VERSION, ruby_string_value(&ruby, path_str))
+            .unwrap();
+
+        assert_eq!(db2.name(), "rt");
+        assert!(!db2.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_from_ron_file_not_found() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let result = DatabaseWrapper::from_ron_file(
+            RON_VERSION,
+            ruby_string_value(&ruby, "/nonexistent/path/enm_test.ron"),
+        );
+
+        assert!(result.is_err());
+    }
+
+    #[ruby_test]
+    fn test_database_to_ron_file() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("test".to_string(), VALID_SQL.to_string()).unwrap();
+        let path = std::env::temp_dir().join("enm_test_to_ron_file.ron");
+        let path_str = path.to_str().unwrap();
+
+        db.to_ron_file(ruby_string_value(&ruby, path_str)).unwrap();
+
+        let db2 = DatabaseWrapper::from_ron_file(RON_VERSION, ruby_string_value(&ruby, path_str))
+            .unwrap();
+
+        assert_eq!(db2.name(), "test");
+        assert!(!db2.empty());
+    }
+
+    #[ruby_test]
+    fn test_database_to_ron_file_round_trip() {
+        let ruby = Ruby::get().unwrap();
+
+        setup(&ruby);
+
+        let db = DatabaseWrapper::from_sql("rt".to_string(), VALID_SQL.to_string()).unwrap();
+        let expected_ron = db.to_ron().unwrap();
+        let path = std::env::temp_dir().join("enm_test_to_ron_file_rt.ron");
+        let path_str = path.to_str().unwrap();
+
+        db.to_ron_file(ruby_string_value(&ruby, path_str)).unwrap();
+        let db2 = DatabaseWrapper::from_ron_file(RON_VERSION, ruby_string_value(&ruby, path_str))
+            .unwrap();
+
+        assert_eq!(db2.to_ron().unwrap(), expected_ron);
+    }
+}

data/lib/enm/database.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ENM
+  class Database
+    # @param [String, Symbol] name
+    # @param [String, Symbol, nil] schema
+    # @return [ENM::Enum, nil]
+    def get(name, schema: nil)
+      _get(name, schema)
+    end
+  end
+end

data/lib/enm/enum.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ENM
+  # An enum type from the database.
+  class Enum
+    extend Dry::Core::Cache
+
+    # @!parse [ruby]
+    #   include Enumerable
+
+    # @!attribute [r] comment
+    #   @return [String, nil] comment associated with the enum type
+
+    # @!attribute [r] digest
+    #   @api private
+    #   @return [String] a digest representing the enum values, for caching purposes
+
+    # @!attribute [r] name
+    #   @return [String] the name of the enum type
+
+    # @!attribute [r] schema
+    #   @return [String] the schema of the enum type
+
+    # @see ENM::Enum::DryTypeBuilder
+    # @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(default: nil, mode: :string)
+      fetch_or_store([digest, default, mode]) do
+        DryTypeBuilder.new(self, mode:, default:).()
+      end
+    end
+
+    # Builds a `Dry::Types::Type` for an {ENM::Enum}.
+    #
+    # @api private
+    # @see ENM::Enum#dry
+    class DryTypeBuilder
+      include Dry::Initializer[undefined: false].define -> do
+        param :enum, ENM::Types::Enum
+
+        option :mode, ENM::Types::DryMode
+
+        option :default, ENM::Types::DefaultValue.optional, as: :default_value, optional: true
+      end
+
+      # @return [String, Symbol, nil]
+      attr_reader :default
+
+      def initialize(...)
+        super
+
+        @default = derive_real_default
+      end
+
+      # @return [Dry::Types::Type]
+      def call
+        base = build_base
+
+        type = default? ? base.default(default.freeze) : base
+
+        enum_values = symbol? ? enum.map(&:to_sym) : enum.to_a
+
+        type.enum(*enum_values)
+      end
+
+      def default? = !default_value.nil?
+
+      def symbol? = mode == :symbol
+
+      private
+
+      # @return [Dry::Types::Type]
+      def build_base = symbol? ? ENM::Types::Coercible::Symbol : ENM::Types::Coercible::String
+
+      # @return [String, Symbol, nil]
+      def derive_real_default
+        return unless default?
+
+        unless enum.include?(default_value)
+          raise ENM::InvalidDefaultError, "Default #{default_value.inspect} not present in #{enum.inspect}"
+        end
+
+        symbol? ? default_value.to_sym : default_value
+      end
+    end
+  end
+end