tina4ruby 3.13.47 → 3.13.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '008f9200b3c67bd44a13fba5bbfeb6895792ff8844ca01815fcb116adf1cf526'
-  data.tar.gz: ff713e6d0bcefb5795d8a8f10eb5de37893bd8f24fb026bcff2b13128236467d
+  metadata.gz: 9a325d3de2855893935edf93852d2ebc796def59bbb68dd668420da07de78f28
+  data.tar.gz: be1f417f6fe10f8e68c038a16839eb0a036bb8b1a15b58f67764ef1e1d31988d
 SHA512:
-  metadata.gz: b8f63842da92b8084f4adec4920cf4d969d7c344f0d7db43bdea734f513f3eade99be7ffc63af89176f071c7fc411b9d3e083f96b79859415986a855967deb75
-  data.tar.gz: 1aa428df186321c9640cf4b790a9657619ba5c96c8de14016b4f805ba64fe19440ba7ffe8ec60104a7505f81b6d8c1a5cb7677489c844edbf54e9e82ced042f5
+  metadata.gz: 9c5da9a717c386c9e36a5fd5cb1d347d7bf5baa660c8efaee3f564dc37acadb3398f98a81c73d90885b71e1571e9edc93896cf1921584953b80372ccd3dca02d
+  data.tar.gz: 5ccc156283bcdb8fc2e176b7342358cc43adde6c68191bf605e2e8e7774fd8d7c574798a589d14647ea75fb82d7a9d81ab01e1ed0ed9d8bf07e7bb60340e8317

data/lib/tina4/localization.rb

@@ -24,38 +24,19 @@ module Tina4
         @current_locale = locale.to_s
       end
 
-      def load(root_dir = Dir.pwd)
-        locale_dir_override = ENV["TINA4_LOCALE_DIR"]
-        search_dirs = locale_dir_override && !locale_dir_override.empty? ? [locale_dir_override] : LOCALE_DIRS
-
-        search_dirs.each do |dir|
-          locale_dir = File.expand_path(dir, root_dir)
-          next unless Dir.exist?(locale_dir)
+      # The fallback locale used when a key is missing in the current locale.
+      # Mirrors the Python master (TINA4_LOCALE, else "en").
+      def default_locale
+        ENV["TINA4_LOCALE"] || "en"
+      end
 
+      def load(root_dir = Dir.pwd)
+        locale_search_dirs(root_dir).each do |locale_dir|
           Dir.glob(File.join(locale_dir, "*.json")).each do |file|
-            locale = File.basename(file, ".json")
-            data = JSON.parse(File.read(file))
-            translations[locale] ||= {}
-            translations[locale].merge!(data)
-            # Build leaf-key aliases from the loaded data
-            build_leaf_aliases(locale, data)
-            Tina4::Log.debug("Loaded locale: #{locale} from #{file}")
+            ingest_json_file(File.basename(file, ".json"), file)
           end
-
-          # Also support YAML
           Dir.glob(File.join(locale_dir, "*.{yml,yaml}")).each do |file|
-            begin
-              require "yaml"
-              locale = File.basename(file, File.extname(file))
-              data = YAML.safe_load(File.read(file))
-              if data.is_a?(Hash)
-                translations[locale] ||= {}
-                translations[locale].merge!(data)
-                build_leaf_aliases(locale, data)
-              end
-            rescue LoadError
-              Tina4::Log.warning("YAML support requires the 'yaml' gem")
-            end
+            ingest_yaml_file(File.basename(file, File.extname(file)), file)
           end
         end
       end
@@ -64,22 +45,53 @@ module Tina4
         lang = locale || current_locale
         value = lookup(lang, key)
 
-        if value.nil? && lang != "en"
-          value = lookup("en", key)
+        # Fallback: current locale -> default/fallback locale -> the key itself.
+        if value.nil? && lang != default_locale
+          value = lookup(default_locale, key)
         end
 
         value = default || key if value.nil?
 
-        # Interpolation: "Hello %{name}" => "Hello World"
-        interpolations.each do |k, v|
-          value = value.gsub("%{#{k}}", v.to_s)
-        end
-
-        value
+        # Interpolation: "Hello {name}" => "Hello World". PARTIAL — each {name}
+        # token present in interpolations is replaced; a missing param's
+        # placeholder is left literal, and a malformed placeholder ({x.y} with a
+        # dot, {n:d} with a spec, a lone unmatched brace) is left literal too.
+        # Never raises — a bad template must not crash t().
+        interpolate(value, interpolations)
       end
 
       def set_locale(locale)
         self.current_locale = locale.to_s
+        # Lazily load the new locale's file if it hasn't been loaded yet, so a
+        # switch to an unloaded locale resolves its keys (parity with Python/PHP/
+        # Node, where setting the locale triggers a per-locale load).
+        load_locale(locale.to_s) unless translations.key?(locale.to_s)
+        current_locale
+      end
+
+      # Load a SINGLE locale's file (JSON, then YAML) from the configured search
+      # dirs if it is not already loaded. Boot-safe (a malformed file is skipped,
+      # never raised) — mirrors Python's _load_locale.
+      def load_locale(locale, root_dir = Dir.pwd)
+        locale = locale.to_s
+        return if translations.key?(locale)
+
+        locale_search_dirs(root_dir).each do |locale_dir|
+          json = File.join(locale_dir, "#{locale}.json")
+          if File.file?(json)
+            ingest_json_file(locale, json)
+            return
+          end
+          %w[yml yaml].each do |ext|
+            yaml = File.join(locale_dir, "#{locale}.#{ext}")
+            if File.file?(yaml)
+              ingest_yaml_file(locale, yaml)
+              return
+            end
+          end
+        end
+        # No file found — cache an empty table so lookups fall back to the key.
+        translations[locale] ||= {}
       end
 
       def get_locale
@@ -117,12 +129,102 @@ module Tina4
         end
       end
 
-      def available_locales
-        translations.keys
+      # List available locale codes by scanning the configured locale dir(s) for
+      # *.json / *.yml / *.yaml file stems, sorted. When no dir exists/has files,
+      # returns a [default_locale] floor (parity with Python/PHP/Node — never an
+      # empty list when a default locale is known).
+      def available_locales(root_dir = Dir.pwd)
+        stems = []
+        locale_search_dirs(root_dir).each do |locale_dir|
+          %w[*.json *.yml *.yaml].each do |pattern|
+            Dir.glob(File.join(locale_dir, pattern)).each do |file|
+              stems << File.basename(file, File.extname(file))
+            end
+          end
+        end
+        stems.uniq!
+        stems.empty? ? [default_locale] : stems.sort
       end
 
       private
 
+      # The locale directories to scan, in order: TINA4_LOCALE_DIR override (when
+      # set) else the built-in LOCALE_DIRS list, each resolved against root_dir,
+      # filtered to those that actually exist.
+      def locale_search_dirs(root_dir = Dir.pwd)
+        override = ENV["TINA4_LOCALE_DIR"]
+        dirs = override && !override.empty? ? [override] : LOCALE_DIRS
+        dirs.map { |dir| File.expand_path(dir, root_dir) }.select { |d| Dir.exist?(d) }
+      end
+
+      # Parse one JSON locale file into translations + leaf aliases. Boot-safe:
+      # a malformed/unreadable file is logged, skipped, and cached empty so a
+      # bad file never crashes boot and is never retried into a partial state.
+      def ingest_json_file(locale, file)
+        data = JSON.parse(File.read(file))
+        translations[locale] ||= {}
+        translations[locale].merge!(data)
+        build_leaf_aliases(locale, data)
+        Tina4::Log.debug("Loaded locale: #{locale} from #{file}")
+      rescue JSON::ParserError, IOError, SystemCallError, StandardError => e
+        Tina4::Log.error("Skipping malformed locale file #{file}: #{e.class}: #{e.message}")
+        translations[locale] ||= {}
+      end
+
+      # Parse one YAML locale file into translations + leaf aliases. Same
+      # boot-safe policy as ingest_json_file (Psych::SyntaxError is the YAML
+      # parse error; the broad StandardError is a final safety net).
+      def ingest_yaml_file(locale, file)
+        require "yaml"
+        data = YAML.safe_load(File.read(file))
+        if data.is_a?(Hash)
+          translations[locale] ||= {}
+          translations[locale].merge!(data)
+          build_leaf_aliases(locale, data)
+        end
+      rescue LoadError
+        Tina4::Log.warning("YAML support requires the 'yaml' gem")
+      rescue Psych::SyntaxError, IOError, SystemCallError, StandardError => e
+        Tina4::Log.error("Skipping malformed locale file #{file}: #{e.class}: #{e.message}")
+        translations[locale] ||= {}
+      end
+
+      # {name} placeholder. Matches Python's _PLACEHOLDER = \{(\w+)\}, so only a
+      # bare word inside braces is a candidate — {x.y} (a dot) and {n:d} (a spec)
+      # never match and are left literal, and a lone unmatched brace is untouched.
+      PLACEHOLDER = /\{(\w+)\}/.freeze
+
+      # Substitute {name} placeholders from params. PARTIAL + literal-leftover:
+      # a placeholder present in params is replaced; a missing or malformed
+      # placeholder is left untouched. Never raises (a bad template must not
+      # crash t()). Params may be keyed by symbol (kwargs) or string.
+      def interpolate(template, params)
+        return template unless template.is_a?(String)
+        return template if params.nil? || params.empty?
+
+        template.gsub(PLACEHOLDER) do
+          name = Regexp.last_match(1)
+          if params.key?(name.to_sym)
+            params[name.to_sym].to_s
+          elsif params.key?(name)
+            params[name].to_s
+          else
+            Regexp.last_match(0)
+          end
+        end
+      end
+
+      # Render a non-string locale scalar JSON-natively: boolean true/false ->
+      # "true"/"false", null/nil -> "null", numbers as their plain form ("42").
+      def coerce_scalar(value)
+        case value
+        when true then "true"
+        when false then "false"
+        when nil then "null"
+        else value.to_s
+        end
+      end
+
       # Recursively walk a nested hash and register leaf-key aliases.
       # First-wins: if a leaf key already exists, it is NOT overwritten.
       def build_leaf_aliases(locale, hash, prefix = nil)
@@ -132,30 +234,34 @@ module Tina4
           if value.is_a?(Hash)
             build_leaf_aliases(locale, value, full_key)
           else
-            # Store the leaf key as an alias (first-wins)
-            flat_aliases[locale.to_s][key.to_s] ||= value
+            # Store the leaf key as an alias (first-wins). Coerce non-string
+            # JSON-native scalars (true/false/null/number) to their string form.
+            flat_aliases[locale.to_s][key.to_s] ||= coerce_scalar(value)
           end
         end
       end
 
       def lookup(locale, key)
         keys = key.to_s.split(".")
-        result = translations[locale]
-        return nil unless result
+        node = translations[locale]
+        return nil unless node
 
-        # Try dot-path traversal first
-        dot_result = result
+        # Try dot-path traversal first. Track found-ness explicitly so a leaf
+        # whose value is false/nil is still recognised as resolved.
+        found = true
         keys.each do |k|
-          if dot_result.is_a?(Hash)
-            dot_result = dot_result[k] || dot_result[k.to_sym]
+          if node.is_a?(Hash) && (node.key?(k) || node.key?(k.to_sym))
+            node = node.key?(k) ? node[k] : node[k.to_sym]
           else
-            dot_result = nil
+            found = false
             break
           end
         end
-        return dot_result if dot_result.is_a?(String)
+        # A resolved leaf (string OR JSON-native scalar) wins. An intermediate
+        # Hash is not a value — fall through to the leaf alias instead.
+        return coerce_scalar(node) if found && !node.is_a?(Hash)
 
-        # Fall back to leaf-key alias (only for simple keys without dots)
+        # Fall back to leaf-key alias (stored already-coerced as a string).
         if flat_aliases[locale]
           alias_val = flat_aliases[locale][key.to_s]
           return alias_val if alias_val.is_a?(String)

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.47"
+  VERSION = "3.13.48"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.47
+  version: 3.13.48
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-25 00:00:00.000000000 Z
+date: 2026-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack