tina4ruby 3.13.46 → 3.13.47

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46946847036ae1f2e6a3fede0084ffe84ab4144b7ec7a16570048b70994a7bee
-  data.tar.gz: db9caef85f32313bf13190f4ed5c3501c7783e82a155b5e59b7f21a6f87bd2f9
+  metadata.gz: '008f9200b3c67bd44a13fba5bbfeb6895792ff8844ca01815fcb116adf1cf526'
+  data.tar.gz: ff713e6d0bcefb5795d8a8f10eb5de37893bd8f24fb026bcff2b13128236467d
 SHA512:
-  metadata.gz: decedd4ef3df3a7ee7243e64975ecc76471c763ec18fe2f8d024e683e02e3329c016baeff41c680cc75747c90cda61b4581fd7370ce34629a141f3fd6faf8489
-  data.tar.gz: fd1c3e6b602d540388a56b2a0288d903adafc4e137b232645e7ee3e871c20885edadc531528ce443bd800045c175734666db312efed827cb8cef4c550dcd9cb1
+  metadata.gz: b8f63842da92b8084f4adec4920cf4d969d7c344f0d7db43bdea734f513f3eade99be7ffc63af89176f071c7fc411b9d3e083f96b79859415986a855967deb75
+  data.tar.gz: 1aa428df186321c9640cf4b790a9657619ba5c96c8de14016b4f805ba64fe19440ba7ffe8ec60104a7505f81b6d8c1a5cb7677489c844edbf54e9e82ced042f5

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.47"
 end

metadata

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