json_translatable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1016e8df0b9e0934d8a9534ca2a9a5e03539fe14ba240b2c25b499a3b8e9edcf
+  data.tar.gz: 180b1f534a2c3895a4e722523aa1cdcb1727edaacf53b7581db19ec1abb6c00e
+SHA512:
+  metadata.gz: 1297496e70aef539c0e9ee423ec203c368cc5da9bce49dd135388cc2201894144b95938b3f8638eeef3a7e00c2400e29fcbcd0f65861ac3868d835463b882c7b
+  data.tar.gz: 8e776d74beef3b31a213922e161cdaa6e8c38203499f835ef14cd31e879ac8976532b0cbb43c7bb2c577ded263c87852786a1638fd146635290949540f18a476

data/lib/translatable/concern.rb

@@ -0,0 +1,215 @@
+module Translatable
+  module Concern
+    extend ActiveSupport::Concern
+
+    class Error < StandardError; end 
+    class MissingTranslationsColumnError < Error; end
+    class UndefinedTranslatableFieldsError < Error; end
+    class DatabaseColumnConflictError < Error; end
+
+    included do
+      class_attribute :translatable_fields, instance_writer: false, default: []
+      class_attribute :translatable_locales, instance_writer: false, default: []
+      class_attribute :translation_validations, instance_writer: false, default: []
+      class_attribute :translations_column_name, instance_writer: false, default: :translations
+
+      validate :validate_translations_structure
+      validate :validate_translation_fields
+
+      after_initialize :initialize_translations
+
+      def translate(locale = I18n.locale)
+        translation_class = self.class.translation_class
+        column_name = self.class.translations_column_name.to_s
+        translations_data = send(column_name) || {}
+        
+        translated_data = self.class.translatable_fields.index_with do |field|
+          translations_data.dig(locale.to_s, field.to_s)
+        end
+
+        translation_class.new(translated_data.merge(locale: locale.to_sym))
+      end
+
+      private
+
+      def validate_translations_structure
+        column_name = self.class.translations_column_name.to_s
+        translations_data = send(column_name)
+        return unless translations_data.present?
+        
+        translations_data.each do |locale, fields|
+          unless translatable_locales.map(&:to_s).include?(locale)
+            errors.add(column_name.to_sym, "contains invalid locale: #{locale}")
+          end
+          
+          next unless fields.is_a?(Hash)
+          
+          fields.each_key do |field|
+            unless translatable_fields.map(&:to_s).include?(field)
+              errors.add(column_name.to_sym, "contains invalid field: #{field} for locale #{locale}")
+            end
+          end
+        end
+      end
+
+      def validate_translation_fields
+        column_name = self.class.translations_column_name.to_s
+        translations_data = send(column_name) || {}
+        
+        self.class.translation_validations.each do |validation|
+          field = validation[:field]
+          options = validation[:options]
+          locales = validation[:locales] || self.class.translatable_locales
+          
+          locales.each do |locale|
+            field_value = translations_data.dig(locale.to_s, field.to_s)
+            error_key = "#{column_name}.#{locale}.#{field}"
+
+            if options[:custom]
+              options[:custom].call(self, locale, field, field_value)
+            end
+            
+            if options[:presence] && field_value.blank?
+              errors.add(column_name.to_sym, :blank, translation_key: error_key)
+            end
+            
+            if options[:length] && field_value.present?
+              length_options = options[:length]
+              if length_options[:minimum] && field_value.length < length_options[:minimum]
+                errors.add(column_name.to_sym, :too_short, count: length_options[:minimum], translation_key: error_key)
+              end
+              if length_options[:maximum] && field_value.length > length_options[:maximum]
+                errors.add(column_name.to_sym, :too_long, count: length_options[:maximum], translation_key: error_key)
+              end
+            end
+            
+            if options[:format] && field_value.present?
+              format_options = options[:format]
+              if format_options[:with] && !field_value.match?(format_options[:with])
+                errors.add(column_name.to_sym, :invalid, translation_key: error_key)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def initialize_translations
+      self.class.validate_translatable
+
+      column_name = self.class.translations_column_name.to_s
+      current_translations = send(column_name) || {}
+      
+      self.class.translatable_locales.map(&:to_s).uniq.each do |locale|
+        current_translations[locale] ||= {}
+        self.class.translatable_fields.map(&:to_s).uniq.each do |field|
+          unless current_translations[locale].key?(field)
+            current_translations[locale][field] = nil
+          end
+        end
+      end
+      
+      send("#{column_name}=", current_translations)
+    end
+
+    class_methods do
+      def translatable(*fields, locales: nil, column: nil)
+        resolved_locales = locales || Translatable.configuration.default_locales.call
+        resolved_column = column || Translatable.configuration.default_column_name
+        
+        self.translatable_fields = fields.map(&:to_sym)
+        self.translatable_locales = resolved_locales.map(&:to_sym)
+        self.translations_column_name = resolved_column.to_sym
+      end
+
+      def where_translations(attributes, locales: [], case_sensitive: false)
+        return none if attributes.blank?
+        
+        strategy = database_strategy
+        strategy.where_translations_scope(self, attributes, locales: locales, case_sensitive: case_sensitive)
+      end
+
+      def validates_translation(*fields, **options, &block)
+        fields.flatten.each do |field|
+          if !translatable_fields.include?(field.to_sym)
+            raise ArgumentError, "Field :#{field} is not defined as translatable. " \
+                                "Available translatable fields: #{translatable_fields.map(&:inspect).join(', ')}"
+          end
+
+          valid_options = [:presence, :length, :format, :locales]
+          invalid_options = options.keys - valid_options
+          if invalid_options.any?
+            raise ArgumentError, "Invalid validation option(s): #{invalid_options.map(&:inspect).join(', ')}. " \
+                                "Valid options are: #{valid_options.map(&:inspect).join(', ')}"
+          end
+
+          if options[:locales]
+            invalid_locales = options[:locales].map(&:to_sym) - translatable_locales
+            if invalid_locales.any?
+              raise ArgumentError, "Invalid locale(s): #{invalid_locales.map(&:inspect).join(', ')}. " \
+                                  "Available locales: #{translatable_locales.map(&:inspect).join(', ')}"
+            end
+          end
+          
+          if block_given?
+            validation_options = options.merge(custom: block)
+          else
+            validation_options = options
+          end
+          
+          locales = validation_options.delete(:locales)
+          
+          self.translation_validations = self.translation_validations + [{
+            field: field.to_sym,
+            options: validation_options,
+            locales: locales&.map(&:to_sym)
+          }]
+        end
+      end
+
+      def translations_permit_list
+        self.translatable_locales.map do |locale|
+          [locale.to_s, self.translatable_fields.map(&:to_s)]
+        end.to_h
+      end
+
+      def database_strategy
+        @database_strategy ||= DatabaseStrategies::Base.for_adapter(connection.adapter_name)
+      end
+
+      def translation_class
+        @translation_class ||= TranslationClassGenerator.generate_for(self.name)
+      end
+
+      def validate_translatable
+        column_name = translations_column_name.to_s
+        strategy = database_strategy
+        
+        unless self.column_names.include?(column_name) && 
+               self.columns_hash[column_name]&.type == strategy.column_type
+          raise MissingTranslationsColumnError, 
+                "Model #{self.name} is missing a '#{column_name}' #{strategy.column_type} column. " \
+                "Please add it via a migration:\n#{strategy.migration_example(self.table_name, column_name)}"
+        end
+    
+        unless self.respond_to?(:translatable_fields) && self.translatable_fields.present?
+          raise UndefinedTranslatableFieldsError,
+                "Model #{self.name} must call the class method `translatable` with field names. " \
+                "Example: \n" \
+                "class #{self.name} < ApplicationRecord\n" \
+                "  include Translatable\n" \
+                "  translatable :title, :content\n" \
+                "end"
+        end
+
+        conflicting_columns = self.column_names.select { |column| self.translatable_fields.include?(column.to_sym) }
+        if conflicting_columns.any?
+          raise DatabaseColumnConflictError,
+                "Model #{self.name} has database columns that conflict with translatable fields. " \
+                "Translatable fields should not exist as actual database columns." \
+                "\n\nConflicting columns: #{conflicting_columns.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/translatable/configuration.rb

@@ -0,0 +1,10 @@
+module Translatable
+  class Configuration
+    attr_accessor :default_column_name, :default_locales
+
+    def initialize
+      @default_column_name = :translations
+      @default_locales = -> { I18n.available_locales }
+    end
+  end
+end

data/lib/translatable/database_strategies/base.rb

@@ -0,0 +1,30 @@
+module Translatable
+  module DatabaseStrategies
+    class Base
+      def self.for_adapter(adapter_name)
+        case adapter_name.downcase
+        when /postgresql/
+          PostgreSQL.new
+        when /mysql/
+          MySQL.new
+        when /sqlite/
+          SQLite.new
+        else
+          raise ArgumentError, "Unsupported database adapter: #{adapter_name}"
+        end
+      end
+
+      def column_type
+        raise NotImplementedError, "Subclasses must implement column_type"
+      end
+
+      def migration_example(table_name, column_name)
+        raise NotImplementedError, "Subclasses must implement migration_example"
+      end
+
+      def where_translations_scope(model_class, attributes, locales: [], case_sensitive: false)
+        raise NotImplementedError, "#{self.class.name} does not support where_translations yet"
+      end
+    end
+  end
+end

data/lib/translatable/database_strategies/mysql.rb

@@ -0,0 +1,41 @@
+module Translatable
+  module DatabaseStrategies
+    class MySQL < Base
+      def column_type
+        :json
+      end
+
+      def migration_example(table_name, column_name)
+        "add_column :#{table_name}, :#{column_name}, :json, null: false"
+      end
+
+      def where_translations_scope(model_class, attributes, locales: [], case_sensitive: false)
+        column_name = model_class.translations_column_name
+        search_locales = locales.present? ? locales.map(&:to_s) : model_class.translatable_locales.map(&:to_s)
+        
+        return model_class.none if attributes.blank?
+        
+        conditions = []
+        bind_values = []
+        
+        if case_sensitive
+          search_locales.each do |locale|
+            locale_attributes = { locale => attributes }
+            conditions << "JSON_CONTAINS(#{column_name}, ?)"
+            bind_values << locale_attributes.to_json
+          end
+        else
+          search_locales.each do |locale|
+            attributes.each do |field, value|
+              conditions << "UPPER(JSON_UNQUOTE(JSON_EXTRACT(#{column_name}, ?))) LIKE UPPER(?)"
+              bind_values += ["$.#{locale}.#{field}", value.to_s]
+            end
+          end
+        end
+        
+        where_clause = conditions.join(' OR ')
+        model_class.where(where_clause, *bind_values)
+      end
+    end
+  end
+end

data/lib/translatable/database_strategies/postgresql.rb

@@ -0,0 +1,41 @@
+module Translatable
+  module DatabaseStrategies
+    class PostgreSQL < Base
+      def column_type
+        :jsonb
+      end
+
+      def migration_example(table_name, column_name)
+        "add_column :#{table_name}, :#{column_name}, :jsonb, default: {}, null: false"
+      end
+
+      def where_translations_scope(model_class, attributes, locales: [], case_sensitive: false)
+        column_name = model_class.translations_column_name
+        search_locales = locales.present? ? locales.map(&:to_s) : model_class.translatable_locales.map(&:to_s)
+        
+        return model_class.none if attributes.blank?
+        
+        conditions = []
+        bind_values = []
+        
+        if case_sensitive
+          search_locales.each do |locale|
+            locale_attributes = { locale => attributes }
+            conditions << "#{column_name} @> ?"
+            bind_values << locale_attributes.to_json
+          end
+        else
+          search_locales.each do |locale|
+            attributes.each do |field, value|
+              conditions << "(#{column_name} -> ? ->> ?) ILIKE ?"
+              bind_values += [locale, field.to_s, value.to_s]
+            end
+          end
+        end
+        
+        where_clause = conditions.join(' OR ')
+        model_class.where(where_clause, *bind_values)
+      end
+    end
+  end
+end

data/lib/translatable/database_strategies/sqlite.rb

@@ -0,0 +1,40 @@
+module Translatable
+  module DatabaseStrategies
+    class SQLite < Base
+      def column_type
+        :json
+      end
+
+      def migration_example(table_name, column_name)
+        "add_column :#{table_name}, :#{column_name}, :json, default: '{}', null: false"
+      end
+
+      def where_translations_scope(model_class, attributes, locales: [], case_sensitive: false)
+        column_name = model_class.translations_column_name
+        search_locales = locales.present? ? locales.map(&:to_s) : model_class.translatable_locales.map(&:to_s)
+        
+        return model_class.none if attributes.blank?
+        
+        conditions = []
+        bind_values = []
+        
+        search_locales.each do |locale|
+          attributes.each do |field, value|
+            json_path = "$.#{locale}.#{field}"
+            
+            if case_sensitive
+              conditions << "json_extract(#{column_name}, ?) = ?"
+              bind_values += [json_path, value.to_s]
+            else
+              conditions << "json_extract(#{column_name}, ?) LIKE ? COLLATE NOCASE"
+              bind_values += [json_path, value.to_s]
+            end
+          end
+        end
+        
+        where_clause = conditions.join(' OR ')
+        model_class.where(where_clause, *bind_values)
+      end
+    end
+  end
+end

data/lib/translatable/translation_class_generator.rb

@@ -0,0 +1,83 @@
+module Translatable
+  class TranslationClassGenerator
+    def self.generate_for(model_class_name)
+      class_name = "#{model_class_name}Translation"
+      
+      return Translatable.const_get(class_name) if Translatable.const_defined?(class_name)
+      
+      model_class = Object.const_get(model_class_name)
+      translatable_fields = model_class.translatable_fields
+      
+      translation_class = Class.new do
+        include Enumerable
+
+        translatable_fields.each do |field|
+          define_method(field) do
+            @attributes[field]
+          end
+        end
+        
+        def initialize(attributes = {})
+          @attributes = attributes.dup
+          @locale = attributes[:locale]
+        end
+        
+        def locale
+          @locale
+        end
+        
+        def [](key)
+          @attributes[key.to_sym] 
+        end
+        
+        def to_h
+          @attributes.dup
+        end
+
+        def each(&block)
+          return enum_for(:each) unless block_given?
+          
+          @attributes.each do |key, value|
+            next if key == :locale
+            yield(key, value)
+          end
+        end
+
+        def keys
+          @attributes.keys.reject { |k| k == :locale }
+        end
+        
+        def values
+          keys.map { |key| @attributes[key] }
+        end
+        
+        def empty?
+          keys.empty? || values.all?(&:blank?)
+        end
+        
+        def size
+          keys.size
+        end
+        
+        alias_method :length, :size
+        
+        def inspect
+          fields = @attributes.reject { |k, _| k == :locale }
+                              .map { |field, value| "#{field}: #{value.inspect.to_s[0, 30]}" }
+                              .append("locale: #{@locale.inspect}")
+                              .join(', ')
+          "#<#{self.class} #{fields}>"
+        end
+        
+        def to_s
+          inspect
+        end
+      end
+      
+      translation_class.define_singleton_method(:name) { class_name }
+      
+      Translatable.const_set(class_name, translation_class)
+      translation_class
+    end
+  end
+end

data/lib/translatable/version.rb

@@ -0,0 +1,3 @@
+module Translatable
+  VERSION = "1.0.0"
+end

data/lib/translatable.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+require_relative 'translatable/version'
+require_relative 'translatable/configuration'
+require_relative 'translatable/database_strategies/base'
+require_relative 'translatable/database_strategies/postgresql'
+require_relative 'translatable/database_strategies/mysql'
+require_relative 'translatable/database_strategies/sqlite'
+require_relative 'translatable/translation_class_generator'
+require_relative 'translatable/concern'
+
+module Translatable
+  extend ActiveSupport::Concern
+  include Translatable::Concern
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: json_translatable
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Luka Bak
+bindir: bin
+cert_chain: []
+date: 2025-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  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: I18n Rails gem that allows storing and querying translations for ActiveRecord
+  models in a single JSON/JSONB column.
+email: bakluka@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/translatable.rb
+- lib/translatable/concern.rb
+- lib/translatable/configuration.rb
+- lib/translatable/database_strategies/base.rb
+- lib/translatable/database_strategies/mysql.rb
+- lib/translatable/database_strategies/postgresql.rb
+- lib/translatable/database_strategies/sqlite.rb
+- lib/translatable/translation_class_generator.rb
+- lib/translatable/version.rb
+homepage: https://github.com/bakluka/json_translatable
+licenses:
+- MIT
+metadata: {}
+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.6.2
+specification_version: 4
+summary: I18n Rails gem that allows storing and querying translations for ActiveRecord
+  models in a single JSON/JSONB column.
+test_files: []