odin-foundation 1.0.4 → 1.2.0

data/lib/odin/transform/transform_parser.rb

@@ -71,6 +71,20 @@ module Odin
         "has" => 2, "merge" => 2, "jsonPath" => 2,
         "assert" => 2,
         "formatPhone" => 2, "movingAvg" => 2, "businessDays" => 2,
+        "fromEntries" => 1, "invert" => 1, "defaults" => 2, "renameKeys" => 2,
+        "compactObject" => 1,
+        "intersection" => 2, "union" => 2, "difference" => 2,
+        "symmetricDifference" => 2, "countBy" => 2, "keyBy" => 2,
+        "explode" => 2, "window" => 2,
+        "base64urlEncode" => 1, "base64urlDecode" => 1, "hmac" => 3,
+        "parseUrl" => 1, "buildUrl" => 1, "parseQuery" => 1, "buildQuery" => 1,
+        "stableStringify" => 1, "canonicalHash" => 1,
+        "escapeHtml" => 1, "unescapeHtml" => 1, "escapeXml" => 1, "stripTags" => 1,
+        "template" => 2,
+        "gcd" => 2, "lcm" => 2, "factorial" => 1,
+        "expr" => 2,
+        "countIf" => 4, "sumIf" => 5, "avgIf" => 5,
+        "xnpv" => 3, "xirr" => 3,
 
         # Arity 3
         "ifElse" => 3, "between" => 3,
@@ -100,14 +114,14 @@ module Odin
       }.freeze
 
       VARIADIC_VERBS = %w[
-        concat coalesce cond switch lookup lookupDefault minOf maxOf
+        concat coalesce cond switch lookup lookupDefault minOf maxOf pick omit
       ].freeze
 
       ALL_DIRECTIVES = %w[
         pos len field trim type date time timestamp boolean integer number
         currency percent binary duration reference leftPad rightPad truncate
         upper lower default decimals currencyCode required confidential
-        deprecated attr if unless omitNull omitEmpty
+        deprecated attr ns if unless omitNull omitEmpty
       ].freeze
 
       class ParseError < StandardError
@@ -156,14 +170,56 @@ module Odin
         accumulator_sections = {} # section_name -> [assignments]
         table_sections = {} # table_name -> { columns: [...], rows: [...] }
         source_section_fields = {} # {$source} section fields
-
-        lines.each do |line|
+        target_section_fields = {} # {$target} section fields
+        target_namespaces = {} # {$target.namespace} prefix -> URI (insertion order)
+        imports = [] # @import paths, in order
+
+        li = 0
+        while li < lines.length
+          line = lines[li]
+          li += 1
           stripped = line.strip
 
+          # A triple-quoted body under a :literal segment is captured verbatim,
+          # spanning lines until the closing """. Interior blank lines are kept.
+          if current_section_type == :segment && current_section &&
+             sections[current_section][:assignments].any? { |a| a[:key] == "_literal" } &&
+             sections[current_section][:assignments].none? { |a| a[:key] == "_literalBody" } &&
+             stripped.start_with?('"""')
+            body_lines = []
+            after = line.sub(/\A\s*"""/, "")
+            if after.end_with?('"""') && !after.strip.empty?
+              body_lines << after[0...-3]
+            else
+              body_lines << after unless after.empty?
+              loop do
+                break if li >= lines.length
+                l = lines[li]
+                li += 1
+                if l.strip == '"""' || l.rstrip.end_with?('"""')
+                  trimmed = l.rstrip.sub(/"""\z/, "")
+                  body_lines << trimmed unless trimmed.empty? && l.strip == '"""'
+                  break
+                end
+                body_lines << l
+              end
+            end
+            sections[current_section][:assignments] << { key: "_literalBody", value: body_lines.join("\n") }
+            next
+          end
+
           # Skip empty lines and comments
           next if stripped.empty?
           next if stripped.start_with?(";")
 
+          # Import directive: @import <path>
+          if stripped.start_with?("@import")
+            path = stripped.sub(/\A@import\s+/, "").strip
+            path = unquote(path) || path
+            imports << path unless path.empty?
+            next
+          end
+
           # Section header: {SectionName}
           if stripped =~ /\A\{(.*)\}\s*\z/
             section_name = $1
@@ -178,6 +234,12 @@ module Odin
             elsif section_name == "$source"
               current_section = section_name
               current_section_type = :source
+            elsif section_name == "$target"
+              current_section = section_name
+              current_section_type = :target
+            elsif section_name == "$target.namespace"
+              current_section = section_name
+              current_section_type = :target_namespace
             elsif section_name == "$accumulator" || section_name == "$accumulators"
               current_section = section_name
               current_section_type = :accumulator
@@ -209,6 +271,19 @@ module Odin
             next
           end
 
+          # Bare segment-directive line (e.g. ":loop items", ":counter n", ":from path").
+          # Parsed like "_<name> = \"rest\"", reusing the existing directive handling.
+          if current_section_type == :segment && current_section &&
+             (bare = parse_bare_directive(stripped))
+            # Repeated :loop lines stack as _loop, _loop2, _loop3, … (cross-product).
+            if bare[:key] == "_loop"
+              existing = sections[current_section][:assignments].count { |a| a[:key].to_s.match?(/\A_loop\d*\z/) }
+              bare = { key: "_loop#{existing + 1}", value: bare[:value] } if existing.positive?
+            end
+            sections[current_section][:assignments] << bare
+            next
+          end
+
           # Assignment: key = value
           if stripped =~ /\A([^=]+?)\s*=\s*(.*)\z/
             key = $1.strip
@@ -216,11 +291,18 @@ module Odin
             # Strip trailing comments
             raw_value = strip_comment(raw_value)
 
+            # Section-as-target: {path} = expr assigns to that path's section.
+            key = key[1...-1].strip if key.start_with?("{") && key.end_with?("}")
+
             case current_section_type
             when :header
               header_fields[key] = raw_value
             when :source
               source_section_fields[key] = raw_value
+            when :target
+              target_section_fields[key] = raw_value
+            when :target_namespace
+              target_namespaces[key] = unquote(raw_value) || raw_value
             when :const
               const_sections[current_section] << { key: key, value: raw_value }
             when :accumulator
@@ -234,8 +316,8 @@ module Odin
           end
         end
 
-        # Parse header (merge source section into source_options)
-        header = parse_header(header_fields, source_section_fields)
+        # Parse header (merge source/target sections into options)
+        header = parse_header(header_fields, source_section_fields, target_namespaces, target_section_fields)
 
         # Parse constants from header fields and {$const} sections
         constants = parse_constants(header_fields, sections)
@@ -296,10 +378,28 @@ module Odin
           constants: constants,
           tables: tables,
           accumulators: accumulators,
-          passes: passes
+          passes: passes,
+          imports: imports
         )
       end
 
+      # Segment directives that may be written as a bare ":name args" body line.
+      BARE_DIRECTIVES = %w[loop counter from if elif else literal].freeze
+
+      # Convert ":name rest-of-line" into a synthetic "_name = \"rest\"" assignment.
+      # Returns nil when the line is not a bare directive.
+      def parse_bare_directive(stripped)
+        return nil unless stripped.start_with?(":")
+        return nil unless stripped =~ /\A:(\w+)(?:\s+(.*))?\z/
+
+        name = $1
+        return nil unless BARE_DIRECTIVES.include?(name)
+
+        value = ($2 || "").strip
+        value = "true" if value.empty?
+        { key: "_#{name}", value: value }
+      end
+
       def parse_table_csv_line(line)
         # Remove trailing comment
         line = strip_comment(line)
@@ -352,7 +452,7 @@ module Odin
 
       # ── Header Parsing ──
 
-      def parse_header(fields, source_section_fields = {})
+      def parse_header(fields, source_section_fields = {}, target_namespaces = {}, target_section_fields = {})
         direction = unquote(fields["direction"])
         target_format = unquote(fields["target.format"])
         odin_version = unquote(fields["odin"]) || "1.0.0"
@@ -367,7 +467,7 @@ module Odin
                                else ConfidentialMode::NONE
                                end
 
-        strict_types = unquote(fields["strictTypes"]) == "true"
+        strict_types = unquote(fields["strictTypes"]).to_s.delete_prefix("?") == "true"
 
         source_options = {}
         target_options = {}
@@ -379,11 +479,21 @@ module Odin
           end
         end
 
+        # Root-level emitTypeHints is an alias for target.emitTypeHints.
+        if fields.key?("emitTypeHints") && !target_options.key?("emitTypeHints")
+          target_options["emitTypeHints"] = unquote(fields["emitTypeHints"])
+        end
+
         # Merge {$source} section fields into source_options
         source_section_fields.each do |key, val|
           source_options[key] = unquote(val) || val
         end
 
+        # Merge {$target} section fields into target_options
+        target_section_fields.each do |key, val|
+          target_options[key] = unquote(val) || val
+        end
+
         target_format ||= Direction.target_format(direction) if direction
 
         TransformHeader.new(
@@ -394,6 +504,7 @@ module Odin
           enforce_confidential: enforce_confidential,
           source_options: source_options,
           target_options: target_options,
+          target_namespaces: target_namespaces,
           strict_types: strict_types,
           id: id,
           name: name
@@ -510,6 +621,49 @@ module Odin
         array_index = nil
         is_array = false
 
+        inline_discriminator_value = nil
+        inline_if_condition = nil
+        inline_elif_condition = nil
+        inline_is_else = false
+        inline_loop = nil
+        inline_counter = nil
+        inline_from = nil
+
+        # Capture header-inline ":loop"/":counter"/":from"; each value runs to the
+        # next inline directive or the end of the header.
+        terminator = '(?=\s+:loop\s|\s+:counter\s|\s+:from\s|\z)'
+        if name =~ /\A(.+?)\s+:loop\s+(.+?)#{terminator}/
+          inline_loop = $2.strip
+        end
+        if name =~ /\A(.+?)\s+:counter\s+(.+?)#{terminator}/
+          inline_counter = $2.strip
+        end
+        if name =~ /\A(.+?)\s+:from\s+(.+?)#{terminator}/
+          inline_from = $2.strip
+        end
+        name = $1 if name =~ /\A(.+?)\s+:(?:loop|counter|from)\s/
+
+        # Strip inline header directive: ":type "value"" keeps the quoted value;
+        # ":if"/":elif" capture the unquoted expression; ":else" is a bare flag.
+        if name =~ /\A(.+?)\s+:type\s+"((?:[^"\\]|\\.)*)"\s*\z/
+          name = $1
+          inline_discriminator_value = unescape_string($2)
+        elsif name =~ /\A(.+?)\s+:(if|elif)\s+(.+?)\s*\z/
+          name = $1
+          expr = $3.strip
+          # A fully-quoted expression is the legacy infix form; strip the quotes.
+          if expr.length >= 2 && expr.start_with?('"') && expr.end_with?('"')
+            expr = unescape_string(expr[1...-1])
+          end
+          case $2
+          when "if" then inline_if_condition = expr
+          when "elif" then inline_elif_condition = expr
+          end
+        elsif name =~ /\A(.+?)\s+:else\s*\z/
+          name = $1
+          inline_is_else = true
+        end
+
         # Strip tabular column spec: "Items[] : col1, col2" -> "Items[]"
         name = $1 if name =~ /\A(.+\[\d*\])\s*:.*\z/
 
@@ -522,12 +676,20 @@ module Odin
 
         field_mappings = []
         discriminator = nil
-        discriminator_value = nil
+        discriminator_value = inline_discriminator_value
         when_condition = nil
-        each_source = nil
-        if_condition = nil
+        each_source = inline_loop || inline_from
+        is_array = true if each_source
+        if_condition = inline_if_condition
+        elif_condition = inline_elif_condition
+        is_else = inline_is_else
         pass = nil
-        counter_name = nil
+        counter_name = inline_counter
+        loops = []
+        loops << parse_loop_directive(inline_loop) if inline_loop
+        from_source = inline_from
+        is_literal = false
+        literal_body = nil
 
         assignments.each do |a|
           key = a[:key]
@@ -542,23 +704,51 @@ module Odin
             discriminator_value = unquote_or_raw(raw_val)
           when "_when"
             when_condition = unquote_or_raw(raw_val)
-          when "_each", "_loop", "_from"
+          when "_each"
             each_source = unquote_or_raw(raw_val)
             is_array = true
+          when "_from"
+            from_source = unquote_or_raw(raw_val)
+            each_source = from_source
+            is_array = true
+          when /\A_loop\d*\z/
+            spec = parse_loop_directive(unquote_or_raw(raw_val))
+            loops << spec
+            each_source ||= spec[:source]
+            is_array = true
           when "_if"
             if_condition = unquote_or_raw(raw_val)
+          when "_elif"
+            elif_condition = unquote_or_raw(raw_val)
+          when "_else"
+            is_else = true
           when "_pass"
             pass = parse_int_literal(raw_val)
           when "_counter"
             counter_name = unquote_or_raw(raw_val)
+          when "_literal"
+            is_literal = true
+          when "_literalBody"
+            literal_body = raw_val
           else
-            next if key.start_with?("_") && key != "_"
-
+            # An unrecognized `_`-prefixed field is a computation-only sink:
+            # it runs for side effects but is not emitted. Recognized loop
+            # directives are handled above; these flow through as mappings.
             mapping = parse_field_mapping(key, raw_val)
             field_mappings << mapping
           end
         end
 
+        # A :from directive supplies the array path for a self-referential
+        # (@ / empty) :loop source.
+        if from_source && !loops.empty?
+          loops.each do |spec|
+            src = spec[:source].to_s
+            spec[:source] = from_source if src.empty? || src == "@"
+          end
+          each_source = loops.first[:source]
+        end
+
         SegmentDef.new(
           name: name,
           path: section_name,
@@ -569,16 +759,38 @@ module Odin
           when_condition: when_condition,
           each_source: each_source,
           if_condition: if_condition,
+          elif_condition: elif_condition,
+          is_else: is_else,
           pass: pass,
           counter_name: counter_name,
-          is_array: is_array
+          is_array: is_array,
+          loops: loops,
+          is_literal: is_literal,
+          literal_body: literal_body
         )
       end
 
+      # Split a loop directive value into its source path and optional ":as" alias.
+      def parse_loop_directive(value)
+        v = value.to_s.strip
+        if v.include?(":as")
+          parts = v.split(":as", 2).map(&:strip)
+          { source: parts[0], alias: (parts[1].nil? || parts[1].empty? ? nil : parts[1]) }
+        else
+          { source: v, alias: nil }
+        end
+      end
+
       # ── Field Mapping ──
 
       def parse_field_mapping(target_field, raw_value)
+        # Pull out multi-token trailing directives the expression tokenizer can't carry:
+        #   :if/:unless  -> rest-of-line comparison expression
+        #   :object      -> brace-delimited inline-object spec
+        raw_value, captured = extract_capturing_directives(raw_value)
+
         expr, directives = parse_expression_with_directives(raw_value)
+        directives = captured + directives
 
         modifiers = []
         remaining_directives = []
@@ -593,7 +805,7 @@ module Odin
         end
 
         # Collect extraction directives from CopyExpr into field mapping directives
-        # (TypeScript parity: directives appear on BOTH CopyExpr and FieldMapping)
+        # (directives appear on BOTH CopyExpr and FieldMapping)
         collect_expr_directives(expr, remaining_directives)
 
         FieldMapping.new(
@@ -604,6 +816,75 @@ module Odin
         )
       end
 
+      # Strip trailing ":if"/":unless"/":object" directives whose values span multiple
+      # expression tokens, returning the remaining value text and the captured directives.
+      def extract_capturing_directives(raw_value)
+        return [raw_value, []] if raw_value.nil?
+
+        # Determine the directive-bearing body: unwrap a fully-quoted RHS so the
+        # capturing scan sees the raw ":if"/":object" tokens.
+        prefix = +""
+        suffix = +""
+        body = raw_value
+        stripped = raw_value.strip
+        if stripped.start_with?('"') && stripped.end_with?('"') && stripped.length >= 2
+          inner = unescape_string(stripped[1...-1])
+          if find_directive(inner, "if") || find_directive(inner, "unless") || find_directive(inner, "object")
+            body = inner
+            if inner.start_with?("@") || inner.start_with?("%")
+              prefix = '"'
+              suffix = '"'
+            end
+          end
+        elsif !(find_directive(body, "if") || find_directive(body, "unless") || find_directive(body, "object"))
+          return [raw_value, []]
+        end
+
+        captured = []
+
+        # :object {…} — capture the brace-delimited spec.
+        if (idx = find_directive(body, "object"))
+          brace = body.index("{", idx)
+          if brace
+            close = matching_brace(body, brace)
+            if close
+              captured << OdinDirective.new("object", body[brace..close])
+              body = body[0...idx].rstrip
+            end
+          end
+        end
+
+        # :if / :unless — capture the rest of the line as the condition expression.
+        %w[if unless].each do |kw|
+          next unless (idx = find_directive(body, kw))
+
+          cond = body[(idx + kw.length + 1)..].to_s.strip
+          captured << OdinDirective.new(kw, cond)
+          body = body[0...idx].rstrip
+        end
+
+        ["#{prefix}#{body}#{suffix}", captured]
+      end
+
+      # Index of a " :name" directive token in str, or nil.
+      def find_directive(str, name)
+        m = str.match(/(?:\A|\s):#{Regexp.escape(name)}(?=\s|\z|\{)/)
+        m ? m.begin(0) + (m[0].start_with?(":") ? 0 : 1) : nil
+      end
+
+      # Index of the brace matching the "{" at open, or nil.
+      def matching_brace(str, open)
+        depth = 0
+        i = open
+        while i < str.length
+          depth += 1 if str[i] == "{"
+          depth -= 1 if str[i] == "}"
+          return i if depth.zero?
+          i += 1
+        end
+        nil
+      end
+
       # Recursively collect extraction directives from expression tree into the field mapping
       def collect_expr_directives(expr, directives)
         case expr
@@ -739,6 +1020,9 @@ module Odin
           parse_verb_expr(tokens)
         elsif token.start_with?("@")
           parse_copy_expr(tokens)
+        elsif (prefixed = parse_prefixed_reference(token))
+          tokens.shift
+          [prefixed, tokens]
         elsif token.start_with?(":")
           [LiteralExpr.new(Types::DynValue.of_null), tokens]
         else
@@ -746,6 +1030,27 @@ module Odin
         end
       end
 
+      PREFIX_REF_TYPES = {
+        "##" => "integer",
+        '#$' => "currency",
+        '#%' => "percent",
+        "#"  => "number"
+      }.freeze
+
+      # A typed prefix on a reference (##@.x, #$@.x, #%@.x, #@.x) copies the
+      # source value and coerces it to the prefix type on output.
+      def parse_prefixed_reference(token)
+        ["##", '#$', '#%', "#"].each do |prefix|
+          next unless token.start_with?(prefix)
+          rest = token[prefix.length..]
+          next unless rest.start_with?("@")
+
+          path = rest == "@" ? "" : rest[1..]
+          return CopyExpr.new(path, directives: [OdinDirective.new("type", PREFIX_REF_TYPES[prefix])])
+        end
+        nil
+      end
+
       def parse_verb_expr(tokens)
         verb_token = tokens.shift
         custom = false
@@ -757,6 +1062,11 @@ module Odin
           verb_name = verb_token[1..]
         end
 
+        # %expr is a parse-time macro: compile the formula string into a verb tree.
+        if verb_name == "expr" && !custom
+          return compile_expr_macro(tokens)
+        end
+
         arity = VERB_ARITY[verb_name]
 
         if arity.nil?
@@ -780,6 +1090,27 @@ module Odin
         end
       end
 
+      # Compile a %expr formula from the remaining tokens. arg0 is a quoted
+      # formula string; arg1, if present, is an @-reference bindings object.
+      def compile_expr_macro(tokens)
+        formula_token = tokens.shift
+        unless formula_token&.match?(/\A".*"\z/m)
+          raise Expr::ExprSyntaxError, "expected a quoted formula string"
+        end
+        formula = unescape_string(formula_token[1...-1])
+
+        binding_path = nil
+        if !tokens.empty? && !tokens.first.start_with?(":")
+          ref_token = tokens.shift
+          unless ref_token.start_with?("@")
+            raise Expr::ExprSyntaxError, "the bindings argument must be a reference such as @.vars"
+          end
+          binding_path = ref_token == "@" ? "" : ref_token[1..]
+        end
+
+        [Expr.compile(formula, binding_path), tokens]
+      end
+
       EXTRACTION_DIRECTIVES = %w[pos len field trim].freeze
       # Directives that take a value argument (not boolean flags)
       VALUE_DIRECTIVES = %w[pos len field].freeze
@@ -893,7 +1224,34 @@ module Odin
       # ── Helpers ──
 
       def unescape_string(s)
-        s.gsub("\\n", "\n").gsub("\\r", "\r").gsub("\\t", "\t").gsub('\\"', '"').gsub("\\\\", "\\")
+        result = +""
+        i = 0
+        len = s.length
+        while i < len
+          ch = s[i]
+          if ch == "\\" && i + 1 < len
+            nxt = s[i + 1]
+            case nxt
+            when "n" then result << "\n"; i += 2
+            when "r" then result << "\r"; i += 2
+            when "t" then result << "\t"; i += 2
+            when '"' then result << '"'; i += 2
+            when "\\" then result << "\\"; i += 2
+            when "$"
+              # Literal dollar; keep the backslash before `${` so the
+              # interpolation layer treats it as an escaped marker.
+              result << (s[i + 2] == "{" ? "\\$" : "$")
+              i += 2
+            else
+              result << ch << nxt
+              i += 2
+            end
+          else
+            result << ch
+            i += 1
+          end
+        end
+        result
       end
 
       def unquote(val)