dms-parser 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c14f1d20d52d7187a1d070cd97a73489c7ecf26d33f36e1b7caec2800e5ebf7
-  data.tar.gz: c23cd13f0f751281b72245f2ae5c4193b705c44ffc7154208146d2af06535bfd
+  metadata.gz: 356dcaecf022100fac1eeae5350a76ecfc417f831f64084ffe912cd4da486a80
+  data.tar.gz: 74e4bd7721ac3f5c7325ada5145c98ad5eccb7723c6e0eed45fcd99dd0a61b9e
 SHA512:
-  metadata.gz: e54215e05be86f064095579e879b0a45518b2b221dfea42d0c2314bce3f45863ba2be8098f460ebd82acd5e1387339b280ddb7718271f3f3fd0e61c42fec2999
-  data.tar.gz: aa9925ba49da2e63580c171a6d08f91db92ad5b4a6a5623fcca75ac8a26ef21102935ebed7323069f16cc3d03f01493f98a4cc5636fb7625ed492d402c7523a5
+  metadata.gz: 39ef8d91e5fdb82746a03ddc8e3b367970b60ff2291021b7a33ed922d3fc93a377f6e0a4c4ddd9093d52f9c7aae87bf3d674ca089bd18c6d6a42fcde2c58358a
+  data.tar.gz: d95fec6634f7049576d56e93195eb47f772e54daa49e270ea7afeace93c2ea3021747c9b8e4a8baa17e54779e1d687198f58462da5a7fd1531d6baf05f521cc8

data/README.md

@@ -7,16 +7,88 @@ multi-line heredocs, and front-matter metadata.
 
 Two gems live in this repo, both with the same Ruby API and value shape:
 
-| gem    | implementation                       | when to use                          |
-| ------ | ------------------------------------ | ------------------------------------ |
-| `dms`  | pure Ruby                            | portable; no C toolchain required    |
-| `dms-c`| C extension wrapping the dms-c decoder | hot paths; ~2× faster than pure Ruby |
+| gem          | implementation                            | when to use                          |
+| ------------ | ----------------------------------------- | ------------------------------------ |
+| `dms-parser` | pure Ruby (`require "dms"`)               | portable; no C toolchain required    |
+| `dms-c`      | C extension wrapping the dms-c decoder    | hot paths; ~2× faster than pure Ruby |
+
+> **Gem naming.** The plain `dms` name on RubyGems is taken by an unrelated
+> project, so the pure-Ruby gem ships as `dms-parser`. The require path is
+> still `"dms"` (the install command and the `require` line don't match —
+> a one-time gotcha when adding the dependency).
+
+## What DMS looks like
+
+A medium-size tier-0 document, exercising every feature you'd touch in a
+real config — front matter, comments (line + trailing), nested tables,
+list-of-tables with the `+` marker, flow forms, distinct types, and a
+heredoc with a trim modifier:
+
+```dms
++++
+title:    "DMS feature tour"
+version:  "1.0.0"
+updated:  2026-04-24T09:30:00-04:00
++++
+
+# Hash and // line comments both work.
+// Bare keys allow full Unicode; quoted keys take any string.
+
+database:
+  host:    "db.internal"
+  port:    5432            # bumped after the LB change
+  pool:    { size: 10, idle_timeout_s: 30 }   # flow table
+
+servers:
+  + name: "web1"
+    disks:
+      + mount: "/"
+        size_gb: 100
+      + mount: "/var"
+        size_gb: 500
+  + name: "web2"
+
+regions: ["us-east-1", "eu-west-1", "ap-south-1"]
+
+sql: """SQL _trim("\n", ">")
+    SELECT id, email
+      FROM users
+     WHERE active = true
+    SQL
+```
+
+Tier 1 layers structured decorators on top of the value tree. Sigils bind
+to families published by a dialect; here is `dms+html` carrying an HTML
+fragment as a DMS document:
+
+```dms
++++
+_dms_tier: 1
+_dms_imports:
+  + dialect: "html"
+    version: "1.0.0"
++++
+
++ |html(lang: "en")
+  + |head
+    + |title "DMS feature tour"
+    + |meta(charset: "UTF-8")
+  + |body(class: "main")
+    + |h1 "Welcome to DMS"
+    + |p(class: "lede")
+      + "Click "
+      + |a(href: "/spec.html") "here"
+      + " to read the spec."
+```
+
+Full feature tour, format comparison, and dialect index on the
+**[DMS website](https://flo-labs.gitlab.io/pub/dms-webpage/)**.
 
 ## Install
 
 ```sh
-gem install dms          # pure Ruby
-gem install dms-c        # native (C) extension, same API
+gem install dms-parser   # pure Ruby
+gem install dms-c        # native (C) extension, same API (not yet published)
 ```
 
 ## Usage

data/bin/dms-encoder

@@ -5,10 +5,22 @@
 # Reads DMS source from stdin, writes tagged JSON to stdout.
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+$LOAD_PATH.unshift(File.expand_path("../dms-c/lib", __dir__))
 
 require "json"
 require "dms"
 
+# Feature-detect the native dms-c gem for tier-1 acceleration.
+# Falls back silently to pure-Ruby Dms::Tier1 if unavailable or
+# if the build hasn't been compiled yet.
+DMS_C_AVAILABLE =
+  begin
+    require "dms_c"
+    DmsC.respond_to?(:decode_t1_to_json)
+  rescue LoadError
+    false
+  end
+
 # Force UTF-8 output: tagged JSON uses ensure_ascii=False equivalent
 # (we write raw UTF-8) so stdout must accept it. Disable CRLF translation.
 $stdout.set_encoding("UTF-8")
@@ -188,9 +200,16 @@ end
 begin
   # Tier-1 decode path: parse with decorator awareness, emit wrapper JSON.
   if tier_flag == 1
-    doc_t1 = Dms::Tier1.parse(src)
-    out = Dms::Tier1.emit_t1_json(doc_t1, method(:tag))
-    $stdout.write(JSON.pretty_generate(out, indent: "  ") + "\n")
+    if DMS_C_AVAILABLE
+      # Native path: dms-c tier1.c returns ready-to-print JSON; pretty-print it.
+      raw_hash = DmsC.decode_t1(src)
+      $stdout.write(JSON.pretty_generate(raw_hash, indent: "  ") + "\n")
+    else
+      # Pure-Ruby fallback.
+      doc_t1 = Dms::Tier1.parse(src)
+      out = Dms::Tier1.emit_t1_json(doc_t1, method(:tag))
+      $stdout.write(JSON.pretty_generate(out, indent: "  ") + "\n")
+    end
     exit 0
   end
 

data/lib/dms/tier1.rb

@@ -217,7 +217,7 @@ module Dms
     # params: Array of ParamGroup
     # params_dec: Array (always empty in this implementation)
     # sigil: String (the literal sigil string)
-    DecoratorCall = Struct.new(:sigil, :family, :fn_name, :ns, :position, :params, :params_dec)
+    DecoratorCall = Struct.new(:sigil, :family, :fn_name, :ns, :position, :params, :params_dec, :call_style)
 
     # kind: :named or :positional
     # value: Hash (for named) or Array (for positional)
@@ -463,7 +463,8 @@ module Dms
     # Resolve a decorator call's family from imports.
     # Returns [family_name, canonical_fn_name] or raises.
     # Also applies deny-list check.
-    def self.resolve_family(sigil, fn_name, ns, imports)
+    # call_style: :named or :nameless
+    def self.resolve_family(sigil, fn_name, ns, imports, call_style: :named)
       # Filter imports by ns if specified
       candidate_imports = if ns
                             filtered = imports.select { |imp| imp.ns == ns }
@@ -475,6 +476,24 @@ module Dms
                             imports
                           end
 
+      # Nameless call: fn_name is empty; resolve to the single bound family name
+      if call_style == :nameless
+        bound_families = []
+        candidate_imports.each do |imp|
+          (imp.bind[sigil] || []).each { |fam| bound_families << fam }
+        end
+        if bound_families.empty?
+          raise DecodeError.new(0, 0, "unbound sigil '#{sigil}'")
+        end
+        if bound_families.size > 1
+          raise DecodeError.new(0, 0,
+            "nameless call on sigil '#{sigil}' is ambiguous between families " \
+            + bound_families.map { |f| "'#{f}'" }.join(", "))
+        end
+        family = bound_families.first
+        return [family, family]
+      end
+
       # For each import, check families bound to this sigil
       # Apply aliases and allow/deny rules
       accepted = []  # [family_name, canonical_fn_name]
@@ -773,8 +792,8 @@ module Dms
       # But we don't know the next key yet — so we store them as pending.
       def collect_leading_decorators(path_prefix)
         while !eof? && sigil_at?(@pos)
-          sigil, fn_name, ns, params = parse_decorator_call
-          @pending_leading << { sigil: sigil, fn_name: fn_name, ns: ns, params: params }
+          sigil, fn_name, ns, params, cs = parse_decorator_call
+          @pending_leading << { sigil: sigil, fn_name: fn_name, ns: ns, params: params, call_style: cs }
           skip_trivia_no_consume_leading
           break if eof?
           # Check if next line also starts with a sigil
@@ -824,8 +843,8 @@ module Dms
           if sigil_at?(@pos)
             # Collect leading decorators for next value
             loop do
-              sigil, fn_name, ns, params = parse_decorator_call
-              @pending_leading << { sigil: sigil, fn_name: fn_name, ns: ns, params: params }
+              sigil, fn_name, ns, params, cs = parse_decorator_call
+              @pending_leading << { sigil: sigil, fn_name: fn_name, ns: ns, params: params, call_style: cs }
               # After decorator call, consume rest of line
               skip_inline_ws
               if consume_eol || eof?
@@ -860,8 +879,8 @@ module Dms
             pending = @pending_leading.dup
             @pending_leading.clear
             pending.each do |dec|
-              family, canonical_fn = resolve_call(dec[:sigil], dec[:fn_name], dec[:ns])
-              add_decorator_call(current_path, dec[:sigil], family, canonical_fn, dec[:ns], :leading, dec[:params])
+              family, canonical_fn = resolve_call(dec[:sigil], dec[:fn_name], dec[:ns], call_style: dec[:call_style] || :named)
+              add_decorator_call(current_path, dec[:sigil], family, canonical_fn, dec[:ns], :leading, dec[:params], call_style: dec[:call_style] || :named)
             end
           end
 
@@ -1029,9 +1048,9 @@ module Dms
       def parse_t1_inner_and_value(path)
         # Collect all consecutive inner decorator calls
         while !eof? && sigil_at?(@pos)
-          sigil, fn_name, ns, params = parse_decorator_call
-          family, canonical_fn = resolve_call(sigil, fn_name, ns)
-          add_decorator_call(path, sigil, family, canonical_fn, ns, :inner, params)
+          sigil, fn_name, ns, params, cs = parse_decorator_call
+          family, canonical_fn = resolve_call(sigil, fn_name, ns, call_style: cs || :named)
+          add_decorator_call(path, sigil, family, canonical_fn, ns, :inner, params, call_style: cs || :named)
           skip_inline_ws
         end
 
@@ -1059,9 +1078,9 @@ module Dms
 
       def parse_t1_trailing_decorators(path)
         while !eof? && sigil_at?(@pos)
-          sigil, fn_name, ns, params = parse_decorator_call
-          family, canonical_fn = resolve_call(sigil, fn_name, ns)
-          add_decorator_call(path, sigil, family, canonical_fn, ns, :trailing, params)
+          sigil, fn_name, ns, params, cs = parse_decorator_call
+          family, canonical_fn = resolve_call(sigil, fn_name, ns, call_style: cs || :named)
+          add_decorator_call(path, sigil, family, canonical_fn, ns, :trailing, params, call_style: cs || :named)
           skip_inline_ws
         end
       end
@@ -1081,15 +1100,28 @@ module Dms
 
         raise DecodeError.new(@line, col, "empty decorator sigil") if sigil.empty?
 
-        # Parse name (bare identifier)
-        # Could be: name  OR  ns.name
-        name1 = parse_bare_ident
-        raise DecodeError.new(@line, col, "expected decorator name after sigil '#{sigil}'") if name1.empty?
+        # Parse name (bare identifier) — may be empty for nameless calls
+        # Nameless: sigil followed by '(', whitespace, EOL, ',', ']', '}'
+        # Error: sigil followed by '.' (dotted form requires name before '.')
+        next_byte = @src.getbyte(@pos)
+        call_style = :named
+        if next_byte == DOT
+          raise DecodeError.new(@line, col, "dotted form requires a name before '.'")
+        elsif next_byte == LPAREN || next_byte == SP || next_byte == TAB ||
+              next_byte == LF || next_byte == CR || next_byte == COMMA ||
+              next_byte == RBRACK || next_byte == RBRACE || next_byte.nil? || @pos >= @src.bytesize
+          # Nameless call
+          call_style = :nameless
+          name1 = ""
+        else
+          name1 = parse_bare_ident
+          raise DecodeError.new(@line, col, "expected decorator name after sigil '#{sigil}'") if name1.empty?
+        end
 
         # Check for '.' => namespace qualifier
         ns = nil
         fn_name = name1
-        if @src.getbyte(@pos) == DOT
+        if call_style == :named && @src.getbyte(@pos) == DOT
           @pos += 1  # consume '.'
           name2 = parse_bare_ident
           if name2.empty?
@@ -1122,7 +1154,7 @@ module Dms
         # If no params at all, treat as one empty named group
         params << ParamGroup.new(:named, {}) if params.empty?
 
-        [sigil, fn_name, ns, params]
+        [sigil, fn_name, ns, params, call_style]
       end
 
       # Parse a param group (between parens, after '(' was consumed).
@@ -1244,9 +1276,9 @@ module Dms
             # Inner decorator in flow array
             loop do
               break unless sigil_at?(@pos)
-              sigil, fn_name, ns, params = parse_decorator_call
-              family, canonical_fn = resolve_call(sigil, fn_name, ns)
-              add_decorator_call(current_path, sigil, family, canonical_fn, ns, :inner, params)
+              sigil, fn_name, ns, params, cs = parse_decorator_call
+              family, canonical_fn = resolve_call(sigil, fn_name, ns, call_style: cs || :named)
+              add_decorator_call(current_path, sigil, family, canonical_fn, ns, :inner, params, call_style: cs || :named)
               skip_inline_ws
             end
             # Now parse the actual value
@@ -1326,20 +1358,20 @@ module Dms
         val
       end
 
-      def add_decorator_call(path, sigil, family, fn_name, ns, position, params)
+      def add_decorator_call(path, sigil, family, fn_name, ns, position, params, call_style: :named)
         path_key = path_to_key(path)
         entry = @dec_entries[path_key]
         if entry.nil?
           entry = DecoratorEntry.new(path.dup, {}, [])
           @dec_entries[path_key] = entry
         end
-        call = DecoratorCall.new(sigil, family, fn_name, ns, position, params, [])
+        call = DecoratorCall.new(sigil, family, fn_name, ns, position, params, [], call_style)
         entry.calls[sigil] ||= []
         entry.calls[sigil] << call
       end
 
-      def resolve_call(sigil, fn_name, ns)
-        Tier1.resolve_family(sigil, fn_name, ns, @imports)
+      def resolve_call(sigil, fn_name, ns, call_style: :named)
+        Tier1.resolve_family(sigil, fn_name, ns, @imports, call_style: call_style)
       end
 
       def path_to_key(path)
@@ -1732,7 +1764,8 @@ module Dms
         "ns"         => call.ns,
         "position"   => call.position.to_s,
         "params"     => params_json,
-        "params_dec" => []
+        "params_dec" => [],
+        "call_style" => (call.call_style || :named).to_s
       }
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dms-parser
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Filip Lopes
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-05 00:00:00.000000000 Z
+date: 2026-05-06 00:00:00.000000000 Z
 dependencies: []
 description: Ruby parser for DMS, a data syntax with strong typing, ordered maps,
   multi-line heredocs, and front-matter metadata.