limitable 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e90558c6154eec0d84bc96b53b16feb809a6dfab2135a054e5d59a6714c49cfc
-  data.tar.gz: 5a2ac5366290ab0fe20904dd80166ca76a7d7f9aa0d1591d43a5d850312dd652
+  metadata.gz: fa345bff02b1a03c0ef3b2515de75383f9e1f55d2cf397fcd2660fe0a66b0746
+  data.tar.gz: 3f467cd6b86b8b97b1d7b9d749d0a507b943d9395c4691503cd051360d6ce557
 SHA512:
-  metadata.gz: f575314e180d4b218aaea9a062acaaa6aa26ac5193ae9a37d699f9bf0f4ed352bdd3960de99526b7d21a8ce1f5ea2a247e80b60ce565dd899ed50a229d8fe367
-  data.tar.gz: d08094e1249af6b703cd84c255d1e0b8fcfd23c0d7fe7c7f5c3d67fca369860ece3bcad070af83c1856ec639dabbf9a26d08bfa7aae848f62a054707f01f0bca
+  metadata.gz: 6f3d2b2a5ba1904d1a6537bf635cc5ba1c8c374d381ae92fab53b44895e0df3c961ecfbd5bb6dd9440622bb256c5c994cf29a73f416fbea96d0974ea16fa5d46
+  data.tar.gz: e14012f9cb14604324304088be9cb9cd6dc620e40b2e5233f0d2964386ebccbd4fe755e12859cd95be2a73d3d60bb5c6c3c78bb5d747aca65aa8ff26120d35ea

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# [2.0.0](https://github.com/benmelz/limitable/compare/v1.1.0...v2.0.0) (2023-07-30)
+
+
+* feat!: custom translations (#15) ([bacc785](https://github.com/benmelz/limitable/commit/bacc7858d7d506bba60bad2f1d39c32732136aa3)), closes [#15](https://github.com/benmelz/limitable/issues/15) [#12](https://github.com/benmelz/limitable/issues/12)
+
+
+### BREAKING CHANGES
+
+* reword default validation error messages
+
+# [1.1.0](https://github.com/benmelz/limitable/compare/v1.0.1...v1.1.0) (2023-07-17)
+
+
+### Features
+
+* support for binary column limits ([#14](https://github.com/benmelz/limitable/issues/14)) ([43224d1](https://github.com/benmelz/limitable/commit/43224d1351052833246b94666b7aca76f8c89aa5)), closes [#3](https://github.com/benmelz/limitable/issues/3)
+
 ## [1.0.1](https://github.com/benmelz/limitable/compare/v1.0.0...v1.0.1) (2023-06-09)
 
 

data/README.md

@@ -34,8 +34,8 @@ gem install limitable
 
 ## Usage
 
-Once included in a model, `Limitable` will scan `integer`, `string` and `text` columns for size limits
-and define byte size validations accordingly. Limits are configurable through `ActiveRecord` migrations.
+Once included in a model, `Limitable` will scan `integer`, `string`, `text` and `binary` columns for size limits,
+defining byte size validations accordingly. Limits are configurable through `ActiveRecord` migrations.
 
 ### Quick Start
 
@@ -59,6 +59,22 @@ class MyModel < ApplicationRecord
 end
 ```
 
+### Translations
+
+`Limitable` ships with i18n support for its validation error messages. Each column type has its own translation key,
+outlined alongside their default values in `lib/limitable/locale/en.yml`.
+
+Each validator will pass a `limit` parameter (min/max integer for integer columns, bytes for string/text/binary),
+which can be used to make the messages less ambiguous if desired.
+
+e.g.
+
+```yaml
+en:
+  limitable:
+    string_limit_exceeded: "may not exceed %{limit} characters"
+```
+
 ### SQL Adapters
 
 `Limitable` is designed to be SQL adapter agnostic, however different adapters have different default behaviors that
@@ -72,7 +88,7 @@ limits in your database migrations/schema unless you want to change them from th
 #### `pg`
 
 PostgreSQL has and reports hard limits on its integer columns, however it supports and defaults to unlimited
-string/text columns. If you wish for limits to be validated on those columns, they must be explicitly set in your
+string/text/binary columns. If you wish for limits to be validated on those columns, they must be explicitly set in your
 database migrations/schema.
 
 #### `sqlite3`

data/lib/limitable/locale/en.yml

@@ -0,0 +1,8 @@
+en:
+  limitable:
+    integer_limit_exceeded:
+      upper: "is too large"
+      lower: "is too small"
+    string_limit_exceeded: "is too long"
+    text_limit_exceeded: "is too long"
+    binary_limit_exceeded: "is too large"

data/lib/limitable/locale.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+module Limitable
+  # == Limitable::Locale
+  #
+  # Loads the default limitable custom translations into i18n.
+  #
+  module Locale
+    I18n.load_path << File.expand_path('locale/en.yml', __dir__)
+  end
+end

data/lib/limitable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Limitable
-  VERSION = '1.0.1'
+  VERSION = '2.0.0'
 end

data/lib/limitable.rb

@@ -3,18 +3,19 @@
 require 'active_record'
 require 'i18n'
 require_relative 'limitable/base'
+require_relative 'limitable/locale'
 require_relative 'limitable/version'
 
 # == Limitable
 #
 # Module that declares database limit validations when included in an ActiveRecord model class. Supports limit
-# inferences on integer, string and text columns.
+# inferences on integer, string, text and binary columns.
 #
 module Limitable
   class << self
     def included(klass)
-      safe_column_names(klass)&.each do |column_name|
-        add_limit_validation klass, column_name
+      safe_column_names(klass).each do |column_name|
+        attach_limit_validator_if_needed klass, column_name
       end
     end
 
@@ -23,53 +24,66 @@ module Limitable
     def safe_column_names(klass)
       klass.column_names
     rescue ActiveRecord::ActiveRecordError, ArgumentError
-      nil
+      []
     end
 
-    def add_limit_validation(klass, column_name)
+    def attach_limit_validator_if_needed(klass, column_name)
       column = klass.column_for_attribute column_name
       limit = column.sql_type_metadata.limit
       return if limit.blank?
 
       case column.type
-      when :integer
-        add_integer_limit_validation klass, column_name, limit
-      when :string, :text
-        add_string_limit_validation klass, column_name, limit
+      when :integer, :string, :text, :binary
+        klass.validate(&send(:"build_#{column.type}_limit_validator", column_name, limit))
       end
     end
 
-    def add_integer_limit_validation(klass, column_name, limit)
+    def build_integer_limit_validator(column_name, limit)
       min, max = integer_limit_range limit
-      integer_type_normalizer = method :integer_type_normalizer
-      klass.validate do
-        value = integer_type_normalizer.call klass, column_name, self[column_name]
-        next unless value.is_a?(Integer)
+      lambda do
+        value = begin
+          self.class.type_for_attribute(column_name).serialize self[column_name]
+        rescue ActiveModel::RangeError => e
+          e.message.match(/(?<number>\d+) is out of range/)[:number].to_i
+        end
+        next unless value.is_a? Integer
 
-        errors.add column_name, I18n.t('errors.messages.greater_than_or_equal_to', count: min) if value < min
-        errors.add column_name, I18n.t('errors.messages.less_than_or_equal_to', count: max) if value > max
+        errors.add column_name, I18n.t('limitable.integer_limit_exceeded.lower', limit: min) if value < min
+        errors.add column_name, I18n.t('limitable.integer_limit_exceeded.upper', limit: max) if value > max
       end
     end
 
-    def integer_limit_range(limit)
-      max = (1 << ((limit * 8) - 1)) - 1
-      min = -max
-      [min, max]
-    end
+    def build_string_limit_validator(column_name, limit)
+      lambda do
+        value = self.class.type_for_attribute(column_name).serialize self[column_name]
+        next unless value.is_a?(String) && value.bytesize > limit
 
-    def integer_type_normalizer(klass, column_name, value)
-      klass.type_for_attribute(column_name).serialize value
-    rescue ActiveModel::RangeError => e
-      e.message.match(/(?<number>\d+) is out of range/)[:number].to_i
+        errors.add column_name, I18n.t('limitable.string_limit_exceeded', limit: limit)
+      end
     end
 
-    def add_string_limit_validation(klass, column_name, limit)
-      klass.validate do
-        value = klass.type_for_attribute(column_name).serialize self[column_name]
+    def build_text_limit_validator(column_name, limit)
+      lambda do
+        value = self.class.type_for_attribute(column_name).serialize self[column_name]
         next unless value.is_a?(String) && value.bytesize > limit
 
-        errors.add column_name, I18n.t('errors.messages.too_long.other', count: limit)
+        errors.add column_name, I18n.t('limitable.text_limit_exceeded', limit: limit)
       end
     end
+
+    def build_binary_limit_validator(column_name, limit)
+      lambda do
+        value = self.class.type_for_attribute(column_name).serialize self[column_name]
+        next unless value.is_a?(ActiveModel::Type::Binary::Data) && value.to_s.bytesize > limit
+
+        errors.add column_name, I18n.t('limitable.binary_limit_exceeded', limit: limit)
+      end
+    end
+
+    def integer_limit_range(limit)
+      max = (1 << ((limit * 8) - 1)) - 1
+      min = -max
+      [min, max]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: limitable
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Benjamin Melz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-09 00:00:00.000000000 Z
+date: 2023-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -63,6 +63,8 @@ files:
 - README.md
 - lib/limitable.rb
 - lib/limitable/base.rb
+- lib/limitable/locale.rb
+- lib/limitable/locale/en.yml
 - lib/limitable/version.rb
 homepage: https://github.com/benmelz/limitable
 licenses:
@@ -70,7 +72,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/benmelz/limitable
   source_code_uri: https://github.com/benmelz/limitable
-  changelog_uri: https://github.com/benmelz/limitable/blob/v1.0.1/CHANGELOG.md
+  changelog_uri: https://github.com/benmelz/limitable/blob/v2.0.0/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []