klenod-build 0.0.16 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6e40006fd1c7bfbe3441e5ae89f60b136a4fb6c6ca24da762346c785e61983c
-  data.tar.gz: 8927ec3112ab13d5ba3e936820f532528fae9f8556967c9bfaba352e9362898a
+  metadata.gz: b36ee8205987d239a6301d55da7f4ef92548303139d04b5bbc2246ba6e94e8e3
+  data.tar.gz: 8f6db6e13f72e4b290b91d115df9e38e8e907100db677baea5a5fec047bc6ae0
 SHA512:
-  metadata.gz: 31dedad665ee4b642d6b8517a9bb9fe2e9bf20a1a93c430a45c29c0ba9db497a40b06553be170965ba3e6a62adec01d0500fcfb3a7e370b6fc59ef6aa5c50ec7
-  data.tar.gz: 181a6b2156410d3fd6f5b33a5830a03c0b304e7a3eba1920fa4dc75b043cd14aa0ace57d7a275502c79c59267f89136a416b330a286591c66f0c26cb44dc385d
+  metadata.gz: d9572bdc8295bfa42c28a88057e6625d1b105cfb8b7c9f51bc7d426ffb0e090c472237f86f549258da64b1095931921e5259a78a41050590b4d67254c92590c5
+  data.tar.gz: e4b49528fe297b00c61d9f45bd8b780e88d485c9c3c4e1f37c1a28ce63ee128af0c64bccdaa68567197f0aa5beae51f568fd4371cb4d4a273c82ca7204a73b19

data/lib/klenod/build/graph.rb

@@ -374,6 +374,7 @@ module Klenod
           transform = loaded_source.transform || transform_module_source(module_id, source)
           resolved_dependencies = resolve_transform_dependencies(module_id, transform)
           dependency_records = load_eager_dependency_records(resolved_dependencies)
+          assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
           transform = finalize_transform_result(module_id, transform, resolved_dependencies, dependency_records)
           assert_supported_transform!(module_id, source, transform)
           assert_generated_ruby_parses!(module_id, transform)
@@ -430,6 +431,7 @@ module Klenod
           transform = loaded_source.transform || transform_module_source(module_id, source)
           resolved_dependencies = resolve_transform_dependencies(module_id, transform)
           dependency_records = collect_eager_dependency_records(resolved_dependencies)
+          assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
           transform = finalize_transform_result(module_id, transform, resolved_dependencies, dependency_records)
           assert_supported_transform!(module_id, source, transform)
           assert_generated_ruby_parses!(module_id, transform)
@@ -462,7 +464,7 @@ module Klenod
             Runtime::Mod.new(
               module_id.to_s,
               record.transformed_source,
-              imports: imports_for(record.resolved_dependencies, dependency_records),
+              imports: imports_for(module_id, record.source, record.resolved_dependencies, dependency_records),
               source_map: record.source_map,
               version: record.version,
               eval_path: eval_path_for(module_id),
@@ -554,7 +556,11 @@ module Klenod
           record
             .resolved_dependencies
             .reject { skip_asset_dependency?(it, type:) }
-            .map(&:module_id)
+        if type == :css
+          regular_dependencies, companion_styles = dependency_ids.partition { |dependency| dependency.dependency.kind != :companion_style }
+          dependency_ids = [*regular_dependencies, *companion_styles]
+        end
+        dependency_ids = dependency_ids.map(&:module_id)
 
         if module_id.extname == ".css"
           dependency_ids.flat_map { |dependency_id| ordered_module_ids_for_assets(dependency_id, seen, type: type) } + [module_id]
@@ -659,7 +665,7 @@ module Klenod
           Runtime::Mod.new(
             module_id.to_s,
             transform.code,
-            imports: imports_for(resolved_dependencies, dependency_records),
+            imports: imports_for(module_id, source, resolved_dependencies, dependency_records),
             source_map: transform.source_map,
             version: cached ? cached.version + 1 : 0,
             eval_path: eval_path_for(module_id),
@@ -690,7 +696,7 @@ module Klenod
         source_dir.join(module_id.path).to_s
       end
 
-      def imports_for(resolved_dependencies, dependency_records)
+      def imports_for(module_id, source, resolved_dependencies, dependency_records)
         resolved_dependencies.to_h do |resolved_dependency|
           value =
             if resolved_dependency.dependency.eager
@@ -702,6 +708,7 @@ module Klenod
                 evaluate_module(resolved_dependency.module_id)
                 record = @records.fetch(resolved_dependency.module_id)
                 raise_failed_module!(record)
+                assert_import_name!(module_id, source, resolved_dependency, record)
                 import_value(resolved_dependency, record)
               end
             end
@@ -898,10 +905,9 @@ module Klenod
         @records.to_h do |module_id, record|
           imports =
             record.resolved_dependencies.to_h do |resolved_dependency|
-              [
-                resolved_dependency.dependency.id,
-                runtime_import_spec(resolved_dependency, @records.fetch(resolved_dependency.module_id))
-              ]
+              target = @records.fetch(resolved_dependency.module_id)
+              assert_import_name!(module_id, record.source, resolved_dependency, target)
+              [resolved_dependency.dependency.id, runtime_import_spec(resolved_dependency, target)]
             end
 
           [
@@ -990,6 +996,35 @@ module Klenod
         end
       end
 
+      # Lazy targets are not collected until bundle or call time, so only the
+      # eager imports can be checked while the importer is collected.
+      def assert_eager_import_names!(module_id, source, resolved_dependencies, dependency_records)
+        resolved_dependencies.each do |resolved_dependency|
+          next unless resolved_dependency.dependency.eager
+
+          record = dependency_records.fetch(resolved_dependency.dependency.id)
+          assert_import_name!(module_id, source, resolved_dependency, record)
+        end
+      end
+
+      # A named import (`import("./x", :Bar)`) is checked against the constants
+      # the target defines statically, recorded by the Ruby plugin as
+      # metadata[:ruby_constants]. A missing Default is not an error: the
+      # import then returns the Exports module.
+      def assert_import_name!(module_id, source, resolved_dependency, record)
+        name = resolved_dependency.dependency.metadata[:import_name]
+        return unless name
+
+        constants = record.metadata[:ruby_constants]
+        return if constants&.include?(name)
+
+        raise MissingExportError.new(
+          MissingExportError::Report.new(resolved_dependency.dependency, record.id, name, constants),
+          source: source,
+          module_id: module_id
+        )
+      end
+
       def import_value(resolved_dependency, record)
         raise_failed_module!(record)
 

data/lib/klenod/build/plugins/class_names_runtime.rb

@@ -22,7 +22,7 @@ module Klenod
           return nil unless module_id.scheme == :virtual && module_id == CLASS_NAMES_MODULE_ID
 
           source = class_names_runtime_source
-          LoadResult.new(source, nil, TransformResult.new(source, [], nil, [], [], {}))
+          LoadResult.new(source, nil, TransformResult.new(source, [], nil, [], [], {ruby_constants: [:Default]}))
         end
 
         def class_names_runtime_dependency(module_id)

data/lib/klenod/build/plugins/haml_plugin/helper_source.rb

@@ -12,7 +12,8 @@ module Klenod
               .create(
                 specifier: HAML_HELPER_SPECIFIER,
                 importer_id: module_id,
-                kind: :haml_helper
+                kind: :haml_helper,
+                metadata: {import_name: :Default}
               )
               .with(id: "#{module_id}:haml_helper")
           end

data/lib/klenod/build/plugins/haml_plugin/parser.rb

@@ -35,6 +35,20 @@ module Klenod
             result
           end
 
+          # Haml's parenthesized-attribute parser accepts only a bare variable
+          # after `=`. For example, it reads `video_id=video.id` as the value
+          # `video` plus a `.id` class. Extend that form to ordinary Ruby
+          # member and index expressions while leaving all other attributes on
+          # Haml's native parsing path.
+          def parse_new_attributes(text)
+            balanced, rest = ::Haml::Util.balance(text, "(", ")")
+            pairs = balanced && extended_attribute_pairs(balanced[1...-1])
+            return super unless pairs&.any? { |_name, value| value.match?(/[.\[]/) }
+
+            dynamic = pairs.reduce("{") { |source, (name, value)| "#{source}#{::Haml::Util.inspect_obj(name)} => #{value}," } << "}"
+            [[{}, dynamic], rest, @line.index + 1]
+          end
+
           def annotate_tag_nodes(root)
             queue = root.children.dup
             until queue.empty?
@@ -62,6 +76,59 @@ module Klenod
             {shorthand: shorthand, literal: literal}
           end
 
+          def extended_attribute_pairs(source)
+            pairs = []
+            index = 0
+
+            loop do
+              index += 1 while source[index]&.match?(/\s/)
+              break if index >= source.length
+
+              name = source[index..].match(/\A[-:@#\w.]+/)&.to_s
+              return nil unless name
+
+              index += name.length
+              index += 1 while source[index]&.match?(/\s/)
+              return nil unless source[index] == "="
+
+              index += 1
+              index += 1 while source[index]&.match?(/\s/)
+              value_start = index
+              depth = 0
+              quote = nil
+              escaped = false
+
+              while index < source.length
+                character = source[index]
+                if quote
+                  if escaped
+                    escaped = false
+                  elsif character == "\\"
+                    escaped = true
+                  elsif character == quote
+                    quote = nil
+                  end
+                else
+                  case character
+                  when "'", '"' then quote = character
+                  when "(", "[", "{" then depth += 1
+                  when ")", "]", "}" then depth -= 1
+                  when " ", "\t"
+                    break if depth.zero? && source[index..].match?(/\A\s+[-:@#\w.]+\s*=/)
+                  end
+                end
+                index += 1
+              end
+
+              value = source[value_start...index].strip
+              return nil if value.empty? || depth.negative? || quote
+
+              pairs << [name, value]
+            end
+
+            pairs
+          end
+
           def literal_class_names_from_old_attributes(source)
             parsed = ::Haml::AttributeParser.parse(source)
             return [] unless parsed&.key?("class")

data/lib/klenod/build/plugins/haml_plugin/transformer/ruby_builder.rb

@@ -489,7 +489,9 @@ module Klenod
             def render_ruby_filter(node)
               source = to_source(node)
               parsed = (node if node.is_a?(Fragment) && node.node?) || statements(source)
-              return statements("begin\n#{indent(source, 2)}\n  nil\nend") unless parsed
+              unless parsed&.node?
+                raise_ruby_parse_error(source, line_no: nil, context: "Could not parse Ruby filter")
+              end
 
               fragment(
                 ast_begin([
@@ -497,8 +499,6 @@ module Klenod
                   nil_node
                 ])
               )
-            rescue SyntaxTree::Parser::ParseError
-              statements("begin\n#{indent(source, 2)}\n  nil\nend")
             end
 
             def format_node(node)
@@ -575,16 +575,20 @@ module Klenod
               line_offsets = [0]
               source.each_line(chomp: false) { |line| line_offsets << line_offsets.last + line.length }
 
-              Ripper
-                .lex(source)
-                .filter_map do |(line, column), type, token, _state|
+              tokens = Ripper.lex(source)
+
+              tokens
+                .each_with_index
+                .filter_map do |((line, column), type, token, _state), index|
                   kind, prefix, pattern = VARIABLE_TOKEN_KINDS[type]
                   receiver = @variables[kind]
                   if type == :on_gvar && token == "$*" && receiver
                     [offset_for(line_offsets, line, column), token.length, receiver]
                   elsif receiver && token.match?(pattern)
                     name = token.delete_prefix(prefix)
-                    [offset_for(line_offsets, line, column), token.length, "(#{receiver})[#{symbol_source(name)}]"]
+                    replacement = "(#{receiver})[#{symbol_source(name)}]"
+                    replacement = "{#{replacement}}" if tokens[index - 1]&.fetch(1) == :on_embvar
+                    [offset_for(line_offsets, line, column), token.length, replacement]
                   end
                 end
                 .reverse_each

data/lib/klenod/build/plugins/haml_plugin/transformer.rb

@@ -549,6 +549,9 @@ module Klenod
               source_column_offset = source.lines.fetch(node.line, "").match(/\A\s*/).to_s.length
               text = import_rewriter.call(text, source_line_offset: node.line, source_column_offset: source_column_offset)
             end
+            unless builder.statements(text).node?
+              builder.ruby_parse_error(text, line_no: node.line + 1, context: "Could not parse Ruby filter")
+            end
             heredoc_body_lines = ruby_heredoc_body_lines(text)
             source = +""
             text.each_line.with_index(node.line + 1) do |line, line_no|

data/lib/klenod/build/plugins/haml_plugin.rb

@@ -97,7 +97,9 @@ module Klenod
 
             return nil unless module_id.scheme == :virtual && module_id == HAML_HELPER_MODULE_ID
 
-            LoadResult.new(haml_helper_source, nil, TransformResult.new(haml_helper_source, [], nil, [], [], {}))
+            # Loaded with a ready transform, so the Ruby plugin never scans it: declare
+            # the Default export it defines.
+            LoadResult.new(haml_helper_source, nil, TransformResult.new(haml_helper_source, [], nil, [], [], {ruby_constants: [:Default]}))
           end
 
           def transform(module_id, code, context)
@@ -136,7 +138,7 @@ module Klenod
                       specifier: "/markdown-components",
                       importer_id: module_id,
                       kind: :markdown_components,
-                      metadata: {optional: true}
+                      metadata: {optional: true, import_name: :Default}
                     )
                     .with(id: "#{module_id}:markdown_components")
                 dependencies << markdown_components_dependency
@@ -205,11 +207,11 @@ module Klenod
                 styles_source: styles_source,
                 translations_source: translations_source,
                 i18n_source: i18n_source_for(builder),
-                haml_helper_source: haml_helper_dependency && builder.constant_assignment("HamlHelper", "#{builder.import_call(haml_helper_dependency.id).source}::Default"),
+                haml_helper_source: haml_helper_dependency && builder.constant_assignment("HamlHelper", builder.import_call(haml_helper_dependency.id).source),
                 styleable: !style_dependencies.empty?,
                 profiler: context.profiler,
                 import_rewriter: import_rewriter,
-                markdown_components_source: markdown_components_dependency ? "__klenod_import__(#{markdown_components_dependency.id.inspect})::Default" : "{}",
+                markdown_components_source: markdown_components_dependency ? "__klenod_import__(#{markdown_components_dependency.id.inspect})" : "{}",
                 variables: @variables,
                 event_handler: @event_handler,
                 cache_static_subtrees: @cache_static_subtrees
@@ -246,19 +248,26 @@ module Klenod
           def import_value(resolved_dependency, record, context)
             styles_import = class_names_runtime_import_value(resolved_dependency, record, context)
             return styles_import if styles_import
-            return nil unless record.id.extname == ".haml"
+            return nil unless default_export?(record)
 
-            context.mods.fetch(record.id).const_get(:Exports)::Default
+            context.mods.fetch(record.id).const_get(:Exports).const_get(:Default, false)
           end
 
           def runtime_import_value(resolved_dependency, record, _context)
             styles_import = class_names_runtime_runtime_import_value(resolved_dependency, record)
             return styles_import if styles_import
-            return Runtime::DefaultImport.new(:Default) if record.id.extname == ".haml"
+            return Runtime::DefaultImport.new(:Default) if default_export?(record)
 
             super
           end
 
+          # Components and the helper module both export Default. The helper is
+          # unwrapped here as well as by the Ruby plugin, so a context built
+          # without the Ruby plugin still renders.
+          def default_export?(record)
+            record.id.extname == ".haml" || record.id == HAML_HELPER_MODULE_ID
+          end
+
           def invalidate_module_ids(paths, context)
             paths
               .filter_map { |path| companion_owner_module_id(path, context) }

data/lib/klenod/build/plugins/markdown_plugin.rb

@@ -168,13 +168,13 @@ module Klenod
                 specifier: "/markdown-components",
                 importer_id: module_id,
                 kind: :markdown_components,
-                metadata: {optional: true}
+                metadata: {optional: true, import_name: :Default}
               )
               .with(id: dependency_id(module_id))
           end
 
           def components_source_for(dependency)
-            dependency ? "__klenod_import__(#{dependency.id.inspect})::Default" : "{}"
+            dependency ? "__klenod_import__(#{dependency.id.inspect})" : "{}"
           end
 
           def dependency_id(module_id)

data/lib/klenod/build/plugins/ruby_plugin.rb

@@ -53,7 +53,7 @@ module Klenod
           def transform(module_id, code, context)
             return TransformResult.identity(code) unless module_id.extname == ".rb"
 
-            assert_parses!(module_id, code)
+            program = parse!(module_id, code)
 
             result =
               begin
@@ -68,21 +68,77 @@ module Klenod
               rescue SyntaxTree::Parser::ParseError => error
                 raise ParseError.new(error, source: code, module_id: module_id)
               end
-            TransformResult.new(result.code, result.dependencies, nil, [], result.watched_patterns, {})
+            TransformResult.new(
+              result.code,
+              result.dependencies,
+              nil,
+              [],
+              result.watched_patterns,
+              {ruby_constants: top_level_constants(program)}
+            )
+          end
+
+          # The value an importer receives: the requested constant, or Default
+          # when the module defines one. Nil keeps the Exports module.
+          def import_value(resolved_dependency, record, context)
+            name = import_constant_name(resolved_dependency, record)
+            return nil unless name
+
+            context.mods.fetch(record.id).const_get(:Exports).const_get(name, false)
+          end
+
+          def runtime_import_value(resolved_dependency, record, _context)
+            name = import_constant_name(resolved_dependency, record)
+            return nil unless name
+
+            Runtime::DefaultImport.new(name)
           end
 
           private
 
           # The rewriter only parses a file that contains an import it cannot
-          # rewrite literally, so without this check most syntax errors would
+          # rewrite literally, so without this parse most syntax errors would
           # not surface until the module was evaluated -- and a production build
           # never evaluates application modules, so the bundle would ship
-          # broken. Prism is the parser CRuby itself uses, and validating costs
-          # well under a tenth of a millisecond per file.
-          def assert_parses!(module_id, code)
-            return if Prism.parse_success?(code)
+          # broken. Prism is the parser CRuby itself uses, and parsing costs
+          # well under a millisecond per file. The same tree tells us which
+          # constants the module exports.
+          def parse!(module_id, code)
+            result = Prism.parse(code)
+            raise ParseError.new(result, source: code, module_id: module_id) if result.failure?
+
+            result.value
+          end
+
+          # The constants a module defines at its top level, meaning directly
+          # on its Exports module. Only static definitions count: `const_set`,
+          # constants inside `if` or `begin`, `A::B = 1`, and `class ::A` are
+          # not exports.
+          def top_level_constants(program)
+            program.statements.body.flat_map { |node| defined_constant_names(node) }.uniq
+          end
+
+          def defined_constant_names(node)
+            case node
+            when Prism::ConstantWriteNode
+              [node.name]
+            when Prism::ClassNode, Prism::ModuleNode
+              node.constant_path.is_a?(Prism::ConstantReadNode) ? [node.constant_path.name] : []
+            when Prism::MultiWriteNode
+              [*node.lefts, *node.rights].grep(Prism::ConstantTargetNode).map(&:name)
+            else
+              []
+            end
+          end
+
+          # Records without a constant list were not transformed by this plugin
+          # and keep whatever value other plugins or the graph supply.
+          def import_constant_name(resolved_dependency, record)
+            constants = record.metadata[:ruby_constants]
+            return nil unless constants
 
-            raise ParseError.new(Prism.parse(code), source: code, module_id: module_id)
+            name = resolved_dependency.dependency.metadata.fetch(:import_name, :Default)
+            constants.include?(name) ? name : nil
           end
         end
       end

data/lib/klenod/build/ruby_import_rewriter.rb

@@ -11,7 +11,7 @@ module Klenod
   module Build
     class RubyImportRewriter
       ImportCall =
-        Data.define(:specifier, :location, :dynamic, :method_name, :eager_override) do
+        Data.define(:specifier, :location, :dynamic, :method_name, :eager_override, :import_name) do
           def eager
             eager_override.nil? ? RubyImportRewriter::IMPORT_METHODS.fetch(method_name).fetch(:eager) : eager_override
           end
@@ -213,21 +213,33 @@ module Klenod
 
         first = unwrap_paren(parts.first)
         string_parts = first&.instance_variable_get(:@parts)
-        literal =
-          (parts.length == 1) &&
+        literal_specifier =
           first&.class&.name == "SyntaxTree::StringLiteral" &&
           string_parts&.length == 1 &&
           string_parts.first.instance_of?(::SyntaxTree::TStringContent)
+        import_name = (parts.length == 2) ? constant_symbol_value(parts.fetch(1)) : nil
+        literal = literal_specifier && (parts.length == 1 || !import_name.nil?)
 
         ImportCall.new(
           literal ? string_parts.first.value : nil,
           node.instance_variable_get(:@location),
           !literal,
           node.instance_variable_get(:@message).value,
-          nil
+          nil,
+          literal ? import_name : nil
         )
       end
 
+      # The optional second argument of `import`: a symbol literal spelled like
+      # a constant, such as `:Bar`. Anything else (`:bar`, `:"Bar"`, a string,
+      # a variable) is reported as a dynamic import.
+      def constant_symbol_value(node)
+        return unless node.instance_of?(::SyntaxTree::SymbolLiteral)
+
+        value = node.instance_variable_get(:@value)
+        value.instance_of?(::SyntaxTree::Const) ? value.value.to_sym : nil
+      end
+
       def build_import_glob_from_parts(node, parts)
         first = unwrap_paren(parts.first)
         string_parts = first&.instance_variable_get(:@parts)
@@ -250,7 +262,8 @@ module Klenod
           node.instance_variable_get(:@location),
           !literal || !valid_options,
           node.instance_variable_get(:@message).value,
-          eager
+          eager,
+          nil
         )
       end
 
@@ -304,20 +317,29 @@ module Klenod
       end
 
       def raise_dynamic_import!(call)
-        expected = (call.method_name == "import_glob") ? "import_glob(\"...\")" : "import(\"...\")"
+        expected =
+          if call.method_name == "import_glob"
+            "import_glob(\"...\")"
+          else
+            "#{call.method_name}(\"...\") or #{call.method_name}(\"...\", :Constant)"
+          end
         raise DynamicImportError, "Only literal #{expected} calls are supported in #{@module_id}"
       end
 
       def build_dependency(call, dependency_index)
-        Dependency
-          .create(
-            specifier: call.specifier,
-            importer_id: @module_id,
-            kind: @kind,
-            loc: source_location(call.location)
-          )
-          .with(eager: call.eager)
-          .with(id: "#{@module_id}:dependency:#{dependency_index}")
+        dependency =
+          Dependency
+            .create(
+              specifier: call.specifier,
+              importer_id: @module_id,
+              kind: @kind,
+              loc: source_location(call.location)
+            )
+            .with(eager: call.eager)
+            .with(id: "#{@module_id}:dependency:#{dependency_index}")
+        return dependency unless call.import_name
+
+        dependency.with(metadata: {import_name: call.import_name}.freeze)
       end
 
       def expand_glob_import(call, dependency_index)

data/lib/klenod/build/source_error.rb

@@ -110,6 +110,43 @@ module Klenod
       end
     end
 
+    # A named import (`import("./x", :Bar)`) of a constant the target module
+    # does not define at its top level.
+    #
+    # The check uses the constants the Ruby plugin recorded statically, so a
+    # typo fails while collecting, with an excerpt of the import, instead of
+    # surfacing as a NameError from inside module evaluation -- or, worse, at
+    # runtime, since a production build never evaluates application modules.
+    class MissingExportError < SourceError
+      Report = Data.define(:dependency, :target_id, :name, :constants)
+
+      def kind
+        "Missing export"
+      end
+
+      private
+
+      def location(report)
+        Location.new(
+          line: report.dependency.loc&.line,
+          column: report.dependency.loc&.column,
+          detail: "#{report.target_id} does not define #{report.name}",
+          hints: [hint_for(report)]
+        )
+      end
+
+      def hint_for(report)
+        case report.constants
+        when nil
+          "Named imports need a Ruby module; #{report.target_id} is not one"
+        when []
+          "#{report.target_id} defines no top-level constants; import it without a name to get its Exports module"
+        else
+          "It defines #{report.constants.join(", ")}"
+        end
+      end
+    end
+
     # Ruby generated from another format that does not parse.
     #
     # This is a bug in the plugin that generated it rather than in anything the

data/lib/klenod/build/version.rb

@@ -2,6 +2,6 @@
 
 module Klenod
   module Build
-    VERSION = "0.0.16"
+    VERSION = "0.0.18"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: klenod-build
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.18
 platform: ruby
 authors:
 - Andrés Alin
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.16
+        version: 0.0.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.16
+        version: 0.0.18
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement