jade-lang 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1bbeb934a5bbbeb19cfeddeb18f59798c37380a34d514110f42e07dab206525
-  data.tar.gz: 1f68a227a953fa57f875274f409bf93aa7269bbadfc4b3abc7634ea1d6b283c2
+  metadata.gz: ec12f8f9ca54c6ac59b3d8d521a9ad192eb87dd5a2a5e62620f3abe00b636cee
+  data.tar.gz: 940c0c3e78b8dcbd013050b298508323e5c0f60f8ddcb4749ede2416b14d9e16
 SHA512:
-  metadata.gz: 87f7c7e84b193ee2dba6e989f493ca36cf4bc6a58ba7d4c38519aedf5052908263cea802e917b11555396edce72c1ae4af5ff687676f13e123d37858c9643e8f
-  data.tar.gz: 0d2f3e20d4e1863a567310355a04bc7eb0fb73c49b629db3f0f6162ce2a009ddf821420558962e35052f0a5859d035b196483ead990659f0c73700ad97b4abfb
+  metadata.gz: e2f05e1f66e7b893e547a2ccb4d31a9678705daecd35c4c806a94f65c47444ad8b69b334c14b18a3a67417963870debdc4f28530ac334c0106699ee278c1f199
+  data.tar.gz: 5711c4a232e7728699e89ddcf168e7dc5b1b86913e34579c7b0b1b2d3df6e069f2f4a12aeb35a800619fdb945169c142a2434f322ce582b1415c524259ab2646

data/CHANGELOG.md

@@ -6,6 +6,42 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.6.0]
+
+### Fixed
+
+- **A `Maybe` return encodes its element.** A function returning `Maybe(T)`
+  handed Ruby the internal `Data` object whenever `T` was a union, or a struct
+  holding one — no error, just an un-encoded value across the boundary. The
+  specialized encoder fell back to emitting the raw element when it couldn't
+  specialize it, instead of declining so the generic encoder could take over;
+  `decode`, five lines above it, already declined correctly. `Maybe(Int)` and
+  `Maybe(SomeStruct)` were unaffected, which is why it stayed hidden — identity
+  happens to be right for primitives. Both derived and hand-written
+  `Encodable` instances are now applied, and a `Maybe` field of a struct
+  unwraps the same way a `Maybe` return does.
+- **Boundary decode errors name the right side.** `DecodeError` reported
+  "Port returned a value that failed to decode" for every failure, including
+  values Ruby passed *into* an exposed function, where no port is involved —
+  sending you to look for a `uses` block that may not exist. Argument failures
+  now read "Ruby passed a value that failed to decode"; port returns are
+  unchanged.
+- **A symbol-keyed Hash says so.** Structs cross the boundary as a Hash with
+  string keys, so `Person.birthday(name: "Ada", age: 40)` used to fail with
+  `expected String, got null` — each field independently reading `nil`, naming
+  neither the cause nor the fix. It is now caught where the whole hash is in
+  scope, listing the offending keys and the correction. Hashes mixing string
+  and symbol keys are left alone; that is a real shape mismatch, and the
+  per-field errors describe it better than a guess would.
+- **A module declared under the wrong file name is now a compile error.** A
+  module is keyed by the name its file implies — imports resolve `Shop.Cart`
+  to `shop/cart.jd` and back — but nothing checked that against what the file
+  declared. `module Cart` in `orders.jd` compiled clean and emitted a `Cart`
+  module whose own type references pointed at `Orders`, so the first call
+  raised `NameError: uninitialized constant Cart::Internal::Orders` far from
+  the cause. It now fails at compile time, pointing at the declared name and
+  offering both the rename and the move.
+
 ## [0.5.0]
 
 ### Added
@@ -328,7 +364,9 @@ Initial release.
 - `jade` CLI dispatcher: `fmt`, `lsp`, `q`.
 - Language server and headless query interface for editor/agent tooling.
 
-[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/agustinrhcp/jade/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/agustinrhcp/jade/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/agustinrhcp/jade/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/agustinrhcp/jade/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/agustinrhcp/jade/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/agustinrhcp/jade/compare/v0.2.0...v0.3.0

data/lib/jade/codegen/boundary/cache.rb

@@ -36,8 +36,7 @@ module Jade
               Boundary::Specialized.decode_expr(t, '_', registry)
             },
             encoders: cache_map(per_fn.flat_map { it[:encoders] }, 'ENC') { |t|
-              Boundary::Specialized.identity_encoder?(t) ||
-                Boundary::Specialized.encode_expr(t, '_', registry)
+              Boundary::Specialized.encode_expr(t, '_', registry)
             },
           }
         end

data/lib/jade/codegen/boundary/specialized/list.rb

@@ -19,11 +19,16 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            return nil if Specialized.identity_encoder?(inner)
+            inner_of(type)
+              &.then { Specialized.encode_expr(it, '_1', registry) }
+              &.then { map_expr(it, value_expr) }
+          end
 
-            elem = Specialized.encode_expr(inner, '_1', registry) or return nil
-            "#{value_expr}.map { #{elem} }"
+          def map_expr(elem, value_expr)
+            case elem
+            in ::String then "#{value_expr}.map { #{elem} }"
+            in :identity then nil
+            end
           end
 
           def identity_encoder?(type)

data/lib/jade/codegen/boundary/specialized/maybe.rb

@@ -17,10 +17,22 @@ module Jade
           end
 
           def encode(type, value_expr, registry)
-            inner = inner_of(type) or return nil
-            inner_enc = Specialized.encode_expr(inner, 'it._1', registry) || 'it._1'
+            inner_of(type)
+              &.then { element_encoder(it, registry) }
+              &.then { unwrap_expr(it, value_expr) }
+          end
+
+          def unwrap_expr(elem, value_expr)
+            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{elem} : nil }"
+          end
 
-            "#{value_expr}.then { it.is_a?(::Jade::Maybe::Just) ? #{inner_enc} : nil }"
+          # Never identity even when the element is: the Just still unwraps.
+          def element_encoder(inner, registry)
+            case Specialized.encode_expr(inner, 'it._1', registry)
+            in :identity then 'it._1'
+            in ::String => expr then expr
+            in nil then nil
+            end
           end
 
           def specializable?(type, registry, seen)

data/lib/jade/codegen/boundary/specialized/record.rb

@@ -138,7 +138,7 @@ module Jade
 
           def encode_helper(struct, registry)
             struct.record_type.fields
-              .map { |k, t| "#{k.inspect} => #{field_encode_value(t, "p.#{k}", registry)}" }
+              .map { |k, t| "#{k.inspect} => #{field_encode(k, t, "p.#{k}", registry)}" }
               .then { "{ #{it.join(', ')} }" }
               .then { Pretty.block("def self.#{encode_helper_name(struct)}(p)", it) }
           end
@@ -148,8 +148,12 @@ module Jade
               fail("non-specializable field type for #{key}: #{type}")
           end
 
-          def field_encode_value(type, accessor, registry)
-            Specialized.encode_expr(type, accessor, registry) || accessor
+          def field_encode(key, type, accessor, registry)
+            case Specialized.encode_expr(type, accessor, registry)
+            in :identity then accessor
+            in ::String => expr then expr
+            in nil then fail("non-encodable field type for #{key}: #{type}")
+            end
           end
 
           def snake(name)

data/lib/jade/codegen/boundary/specialized.rb

@@ -28,10 +28,14 @@ module Jade
             Record.decode(type, input, registry)
         end
 
-        # Ruby expression that encodes `value_expr` to the wire form, or
-        # `nil` if the encoder is identity (caller skips the wrap) or the
-        # type isn't specializable (caller falls back to the cache).
+        # How to encode `value_expr` to the wire form:
+        #
+        #   String    inline expression
+        #   :identity the value is already wire-shaped; emit it unchanged
+        #   nil       not specializable; fall back to the cached encoder
         def encode_expr(type, value_expr, registry)
+          return :identity if identity_encoder?(type)
+
           Record.encode(type, value_expr, registry) ||
             List.encode(type, value_expr, registry) ||
             Maybe.encode(type, value_expr, registry)

data/lib/jade/codegen/function_declaration.rb

@@ -80,14 +80,15 @@ module Jade
       end
 
       def encode_return(return_type, call_expr, registry)
-        if Codegen::Boundary::Specialized.identity_encoder?(return_type)
-          call_expr
-        elsif (expr = Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry))
-          expr
-        else
+        case Codegen::Boundary::Specialized.encode_expr(return_type, call_expr, registry)
+        in :identity then call_expr
+
+        in ::String => expr then expr
+
+        in nil
           Codegen::Boundary::Cache
             .encoder_for(return_type, registry)
-            .then { |encoder| "#{encoder}.call(#{call_expr})" }
+            .then { "#{it}.call(#{call_expr})" }
         end
       end
 

data/lib/jade/interop/boundary.rb

@@ -50,12 +50,21 @@ module Jade
 
       def hash(label, v)
         case v
-        when ::Hash then v
+        when ::Hash then string_keyed!(label, v)
         when ::Data then v.to_h.transform_keys(&:to_s)
         else type_error!(label, v)
         end
       end
 
+      # Mixed keys are a real shape mismatch; the per-field errors say more
+      # than a guess about intent would.
+      def string_keyed!(label, v)
+        return v if v.empty? || v.keys.any?(::String)
+
+        v.keys.grep(::Symbol)
+          .then { it.empty? ? v : raise(Jade::Interop::SymbolKeys.new(label, it)) }
+      end
+
       def type_error!(label, v)
         raise Jade::Interop::DecodeError.new(
           Jade::Decode::WrongType[label, Jade::Decode.type_name(v)],

data/lib/jade/interop/error.rb

@@ -40,12 +40,31 @@ module Jade
       end
     end
 
+    # Caught where the whole hash is in scope; downstream each field just
+    # reads nil and blames its own type.
+    class SymbolKeys < Error
+      def initialize(label, keys)
+        super(
+          "#{label} expects a Hash with string keys, got symbol keys " \
+            "(#{keys.take(4).map(&:inspect).join(', ')}). " \
+            "Values cross the boundary as wire data — " \
+            "try #{keys.first.to_s.inspect} rather than #{keys.first.inspect}."
+        )
+      end
+    end
+
     class DecodeError < Error
-      attr_reader :decode_error, :value
+      attr_reader :decode_error, :value, :source
+
+      SUBJECTS = {
+        argument: 'Ruby passed a value that failed to decode',
+        port_return: 'Port returned a value that failed to decode',
+      }.freeze
 
-      def initialize(decode_error, value)
+      def initialize(decode_error, value, source: :argument)
         @decode_error = decode_error
         @value = value
+        @source = source
         super(format(decode_error, value))
       end
 
@@ -54,16 +73,17 @@ module Jade
       def format(error, value)
         path, leaf = unwind(error)
         location = path.empty? ? "value" : path.join
+        subject = SUBJECTS.fetch(@source)
 
         case leaf
         in Jade::Decode::WrongType[expected, got]
-          "Port returned a value that failed to decode at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
+          "#{subject} at #{location}: expected #{expected}, got #{got} (#{value.inspect})"
 
         in Jade::Decode::MissingField[key]
-          "Port returned a value that failed to decode at #{location}: missing field `#{key}` (#{value.inspect})"
+          "#{subject} at #{location}: missing field `#{key}` (#{value.inspect})"
 
         in Jade::Decode::Custom[msg]
-          "Port returned a value that failed to decode at #{location}: #{msg} (#{value.inspect})"
+          "#{subject} at #{location}: #{msg} (#{value.inspect})"
 
         in Jade::Decode::Multiple[errors]
           errors

data/lib/jade/module_loader/module_name.rb

@@ -0,0 +1,46 @@
+module Jade
+  module ModuleLoader
+    # A module is keyed by the name its file implies — imports resolve
+    # `Shop.Cart` to `shop/cart.jd` and back. The wrapper takes the declared
+    # name while every type reference inside takes the file's, so a mismatch
+    # emits Ruby referring to a constant that was never defined.
+    module ModuleName
+      extend self
+
+      def check(ast, source)
+        return Ok[ast] unless ast.is_a?(AST::Module)
+
+        source.to_module_name.then do |expected|
+          ast.name == expected ? Ok[ast] : Err[mismatch(ast, source, expected)]
+        end
+      end
+
+      private
+
+      def mismatch(ast, source, expected)
+        Diagnostics::List
+          .empty
+          .error(
+            "Module is declared as `#{ast.name}` but `#{source.uri}` defines `#{expected}`.",
+            source:,
+            span: name_span(ast),
+            label: "expected `#{expected}`",
+          )
+          .help("Rename it to `#{expected}`, or move the file to `#{path_for(ast.name)}`.")
+      end
+
+      # `module` is skipped during parsing, so the node starts at the name.
+      def name_span(ast)
+        ast.range.begin...(ast.range.begin + ast.name.length)
+      end
+
+      def path_for(module_name)
+        module_name
+          .split('.')
+          .map { Source.snake_case(it) }
+          .join('/')
+          .then { "#{it}.jd" }
+      end
+    end
+  end
+end

data/lib/jade/module_loader.rb

@@ -9,6 +9,7 @@ require 'jade/codegen'
 require 'jade/module_loader/cache'
 require 'jade/module_loader/dependency_resolver'
 require 'jade/module_loader/dependency_graph'
+require 'jade/module_loader/module_name'
 require 'jade/module_loader/normalize'
 require 'jade/module_loader/topological_sort'
 require 'jade/diagnostics'
@@ -132,6 +133,10 @@ module Jade
             .then { raise CompilationError.new(it) }
         end => Ok([raw_ast, comments])
 
+      ModuleName
+        .check(raw_ast, source)
+        .on_err { raise CompilationError.new(it) }
+
       Frontend::CommentAttacher
         .attach(raw_ast, comments, source)
         .then { Registry.entry(source.to_module_name).with(ast: it, source:, entry:) }

data/lib/jade/task.rb

@@ -93,7 +93,7 @@ module Jade
 
       def decode(decoder, value)
         Jade::Decode::Runner.run!(decoder, value) do |error|
-          fail Jade::Interop::DecodeError.new(error, value)
+          fail Jade::Interop::DecodeError.new(error, value, source: :port_return)
         end
       end
     end

data/lib/jade/version.rb

@@ -1,3 +1,3 @@
 module Jade
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: jade-lang
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Agustin Cornu
 bindir: exe
 cert_chain: []
-date: 2026-08-11 00:00:00.000000000 Z
+date: 2026-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -303,6 +303,7 @@ files:
 - lib/jade/module_loader/cache.rb
 - lib/jade/module_loader/dependency_graph.rb
 - lib/jade/module_loader/dependency_resolver.rb
+- lib/jade/module_loader/module_name.rb
 - lib/jade/module_loader/normalize.rb
 - lib/jade/module_loader/topological_sort.rb
 - lib/jade/parsing.rb