tina4ruby 3.13.46 → 3.13.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46946847036ae1f2e6a3fede0084ffe84ab4144b7ec7a16570048b70994a7bee
-  data.tar.gz: db9caef85f32313bf13190f4ed5c3501c7783e82a155b5e59b7f21a6f87bd2f9
+  metadata.gz: 9a325d3de2855893935edf93852d2ebc796def59bbb68dd668420da07de78f28
+  data.tar.gz: be1f417f6fe10f8e68c038a16839eb0a036bb8b1a15b58f67764ef1e1d31988d
 SHA512:
-  metadata.gz: decedd4ef3df3a7ee7243e64975ecc76471c763ec18fe2f8d024e683e02e3329c016baeff41c680cc75747c90cda61b4581fd7370ce34629a141f3fd6faf8489
-  data.tar.gz: fd1c3e6b602d540388a56b2a0288d903adafc4e137b232645e7ee3e871c20885edadc531528ce443bd800045c175734666db312efed827cb8cef4c550dcd9cb1
+  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/migration.rb

@@ -366,59 +366,134 @@ module Tina4
       sql.gsub(SMART_QUOTE_RE, SMART_QUOTES)
     end
 
-    # Split SQL into individual statements, handling:
-    # - $$ delimited stored procedure blocks
-    # - // delimited blocks
-    # - Block comments /* ... */
-    # - Line comments -- ...
-    # Matches the Python/Node.js approach: extract blocks first, split on ;, restore blocks.
+    # Split SQL into individual statements with a single-pass, quote- and
+    # comment-aware scanner. The split decision is made character by character so
+    # the delimiter only ever fires in real statement position.
+    #
+    # This is the fix for issue #54: the old implementation split on +delimiter+
+    # BEFORE stripping +-- …+ line comments, so a +;+ inside a line comment
+    # fragmented one statement into several broken pieces. A scanner that knows
+    # where it is (code / comment / string) cannot make that mistake.
+    #
+    # Handled, in priority order, only when NOT already inside a stored-proc block:
+    # - $$ … $$ and // … // stored-proc blocks are kept intact (inner ; never
+    #   splits). A // preceded by ':' is a URL scheme (https://…), not a delimiter.
+    # - /* … */ block comments are stripped.
+    # - -- … line comments are stripped to end of line (the newline is kept).
+    # - '…' single-quoted strings and "…" double-quoted identifiers are copied
+    #   verbatim, honouring the SQL doubled-quote escape ('' / ""); a ;, -- or /*
+    #   inside a literal is data, not a delimiter or comment.
+    # Mirrors the tina4-python _split_statements / tina4-php scanner (parity).
     def split_sql_statements(sql, delimiter = ";")
       # Normalize smart/curly quotes to straight ASCII first, so SQL pasted from
       # an editor/doc (which converts " → “ ” and ' → ‘ ’) actually runs.
       sql = normalize_quotes(sql)
 
-      blocks = []
+      statements = []
+      current = +""
+      n = sql.length
+      dlen = delimiter.length
+      i = 0
+      in_dollar_block = false
+      in_slash_block = false
+
+      while i < n
+        ch = sql[i]
+
+        # $$ … $$ stored-proc block (toggle).
+        if !in_slash_block && ch == "$" && i + 1 < n && sql[i + 1] == "$"
+          current << "$$"
+          i += 2
+          in_dollar_block = !in_dollar_block
+          next
+        end
 
-      # Extract $$ ... $$ blocks (stored procedures, triggers, etc.)
-      processed = sql.gsub(/\$\$(.*?)\$\$/m) do
-        blocks << $~.to_s
-        "__BLOCK_#{blocks.length - 1}__"
-      end
+        # // … // stored-proc block (toggle) — but NOT a `://` URL scheme.
+        if !in_dollar_block && ch == "/" && i + 1 < n && sql[i + 1] == "/" &&
+           !(i.positive? && sql[i - 1] == ":")
+          current << "//"
+          i += 2
+          in_slash_block = !in_slash_block
+          next
+        end
 
-      # Extract // ... // blocks (stored procedures, triggers, etc.). The `//`
-      # delimiters must NOT be preceded by a colon, so a URL scheme
-      # (`https://…`) or other `://` literal inside a migration is never
-      # captured as an opaque stored-proc block (it would otherwise swallow
-      # everything between two `//` occurrences and skip statement splitting).
-      processed = processed.gsub(/(?<!:)\/\/(.*?)(?<!:)\/\//m) do
-        blocks << $~.to_s
-        "__BLOCK_#{blocks.length - 1}__"
-      end
+        # Inside a stored-proc block: consume verbatim (inner ; never splits).
+        if in_dollar_block || in_slash_block
+          current << ch
+          i += 1
+          next
+        end
+
+        # Block comment /* … */ — stripped.
+        if ch == "/" && i + 1 < n && sql[i + 1] == "*"
+          endpos = sql.index("*/", i + 2)
+          i = endpos ? endpos + 2 : n
+          next
+        end
 
-      # Remove block comments (/* ... */) but not inside stored proc blocks (already extracted)
-      clean = processed.gsub(/\/\*.*?\*\//m, "")
+        # Line comment -- … — stripped to end of line; the newline is left for the
+        # next iteration so line structure (and NEXT-line boundaries) survive.
+        if ch == "-" && i + 1 < n && sql[i + 1] == "-"
+          endpos = sql.index("\n", i + 2)
+          i = endpos || n
+          next
+        end
 
-      statements = []
-      clean.split(delimiter).each do |stmt|
-        lines = []
-        stmt.split("\n").each do |line|
-          stripped = line.strip
-          next if stripped.empty? || stripped.start_with?("--")
-          # Remove inline comments (-- after SQL)
-          comment_pos = line.index("--")
-          line = line[0...comment_pos] if comment_pos && comment_pos >= 0
-          lines << line
+        # Single-quoted string literal — '' escapes a quote. Copied verbatim.
+        if ch == "'"
+          current << "'"
+          i += 1
+          while i < n
+            if sql[i] == "'" && i + 1 < n && sql[i + 1] == "'"
+              current << "''"
+              i += 2
+            elsif sql[i] == "'"
+              current << "'"
+              i += 1
+              break
+            else
+              current << sql[i]
+              i += 1
+            end
+          end
+          next
         end
-        cleaned = lines.join("\n").strip
 
-        # Restore block placeholders
-        blocks.each_with_index do |block, i|
-          cleaned = cleaned.gsub("__BLOCK_#{i}__", block)
+        # Double-quoted identifier — "" escapes a quote. Same verbatim handling.
+        if ch == '"'
+          current << '"'
+          i += 1
+          while i < n
+            if sql[i] == '"' && i + 1 < n && sql[i + 1] == '"'
+              current << '""'
+              i += 2
+            elsif sql[i] == '"'
+              current << '"'
+              i += 1
+              break
+            else
+              current << sql[i]
+              i += 1
+            end
+          end
+          next
+        end
+
+        # Statement delimiter — only reached outside blocks/comments/strings.
+        if !delimiter.empty? && sql[i, dlen] == delimiter
+          stmt = current.strip
+          statements << stmt unless stmt.empty?
+          current = +""
+          i += dlen
+          next
         end
 
-        statements << cleaned unless cleaned.empty?
+        current << ch
+        i += 1
       end
 
+      stmt = current.strip
+      statements << stmt unless stmt.empty?
       statements
     end
 

data/lib/tina4/scss_compiler.rb

@@ -103,6 +103,9 @@ module Tina4
           ""
         end
 
+        # Resolve #{ ... } interpolation (before $var substitution + nesting).
+        content = resolve_interpolation(content, variables)
+
         # Replace variable references
         variables.each do |name, value|
           content = content.gsub("$#{name}", value)
@@ -117,6 +120,22 @@ module Tina4
         content
       end
 
+      # Resolve SCSS #{ ... } interpolation. Each #{ expr } is replaced by its
+      # resolved inner text: a $variable inside the braces resolves to its value,
+      # anything else is inlined verbatim (trimmed). Lets a value carry a
+      # variable inside a string context plain $var substitution can't reach --
+      # e.g. calc(100% - #{$gap}) -> calc(100% - 20px) -- and lets a variable
+      # appear in a selector (.icon-#{$name} -> .icon-home). Run BEFORE nesting
+      # flatten so the literal braces never confuse the block matcher.
+      def resolve_interpolation(content, variables)
+        names = variables.keys.sort_by { |k| -k.length }
+        content.gsub(/#\{([^{}]*)\}/) do
+          inner = Regexp.last_match(1).strip
+          names.each { |name| inner = inner.gsub("$#{name}", variables[name]) }
+          inner
+        end
+      end
+
       def process_imports(content, base_dir)
         content.gsub(/@import\s+["'](.+?)["']\s*;/) do
           import_path = Regexp.last_match(1)

data/lib/tina4/version.rb

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

metadata

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