leptris 1.9.221.1 → 1.9.222.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abec97f5dc76127e52554fe9254f7b9a93676c0583dde964e474a7e662884878
-  data.tar.gz: d2d30b60d8ad656c6ed3564e63e9ea7ecc006ebe17cdb026075dfd8407311dd8
+  metadata.gz: 403ad2f7e9b542b03e8f770c1b070e0e972ac0b4aca5ae16e5ed8f675b7599e4
+  data.tar.gz: 5e5c49bb4ffdda23e1466b653346e6c20de604212a2941c97a9fa2c6b2297f83
 SHA512:
-  metadata.gz: fe37f35a8359f66544471ea70405b3895ce07acc64d9e92067fd26d9945b1c6ec2f2b82ca7a4b18628f59ca012c8347adbea24a173a8fc52bf725dacdd761e36
-  data.tar.gz: d2531467d1c319ff967ab0eb7b6cafc54beead04048d3d788300e8bc042cd1ce20784caf98d9e1646944d6db346cec66368bece7f1e1ace2adbf05d779039906
+  metadata.gz: 751de9f301ea9157169b546b3d81c8c65942e6c13fd8516bbd4e7ec6e940877146e634bccb92ab1b043c63f0b77bca5c3ea7cb83d81d539228a38cba6eaba072
+  data.tar.gz: e38a36cfdcf7d4d52d007389dbc6ca5ab4e5f84f8794af81667837005a5928a776dc532b86b50dc8dc32644e8d0cbde979f9edfaa89695564e91e33dd5320d02

data/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.222.0] - 2026-09-22
+
+### Fixed — engine sync (1.9.222): the interleaved lane's namespace regression
+
+- Vendored libleptris 1.9.222: the interleaved parse lane
+  (`LEPTRIS_INTERLEAVED=1`) dropped the namespace URI of every
+  prefixed attribute — `xml:space` lost the XML namespace
+  (leptris#1295, Canon-reported). The lane now stamps the #542 ns
+  side-cache exactly like the classic parser; regression-tested
+  against both lanes (leptris#1300). Also: the borrowed-text
+  contract is lane-explicit. No binding-facing surface changes;
+  audit 342/342, suite 770/0.
+
 ## [1.9.221.0] - 2026-09-22
 
 ### Performance — engine sync (1.9.221)

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.221"
+LIBLEPTRIS_VERSION = "1.9.222"
 # Vendored alongside libleptris for fn:normalize-unicode (TODO
 # .restructure/20): built per platform with a RELOCATABLE @rpath
 # install name, loaded by ffi.rb before libleptris so the

data/ext/build_windows_native.rb

@@ -43,12 +43,27 @@ Dir.chdir(ext_dir) do
   # string table while exporting only mkmf's Init_native (the arm64
   # toolchain ignores our .def when its own wins the link) — only a
   # real lookup proves native_<minor>.so will load.
-  require "fiddle"
+  #
+  # Ruby 4.0 moved fiddle out of the default gems (bundled_gems
+  # intercepts the require → LoadError when it's not in the
+  # Gemfile), so the gate is conditional there: skip loudly — the
+  # release workflow's strings gate still hard-verifies the
+  # export, and native.c pins the symbols with dllexport at the
+  # source level.
   begin
-    Fiddle.dlopen(File.expand_path(so))[INIT_PREFIX + minor_us]
-  rescue Fiddle::DLError => e
-    abort "#{so} does not export #{INIT_PREFIX + minor_us} — refusing to " \
-          "install a DLL that would 127 at require (#{e.message})"
+    require "fiddle"
+  rescue LoadError => e
+    warn "fiddle unavailable under #{RUBY_VERSION} (#{e.message}) — " \
+         "skipping the functional export gate; the release workflow's " \
+         "strings gate still applies"
+  end
+  if defined?(Fiddle)
+    begin
+      Fiddle.dlopen(File.expand_path(so))[INIT_PREFIX + minor_us]
+    rescue Fiddle::DLError => e
+      abort "#{so} does not export #{INIT_PREFIX + minor_us} — refusing to " \
+            "install a DLL that would 127 at require (#{e.message})"
+    end
   end
   dest = File.join(root, "lib", "leptris", "xml", "native_#{minor_us}.so")
   # The artifact must reference only this minor's Ruby DLL.

data/ext/leptris/native/native.c

@@ -2027,19 +2027,73 @@ static void plan_walk(void *node, int depth, VALUE spec, VALUE stack,
                                       rb_enc_interned_str(an, strlen(an),
                                                           rb_utf8_encoding()))
                                 : Qnil;
-                if (!NIL_P(slot)) {
-                    const char *av = f_attr_value(node, a);
-                    rb_struct_aset(value, slot,
+                const char *av = f_attr_value(node, a);
+                if (NIL_P(slot)) continue;
+                if (RB_TYPE_P(slot, T_ARRAY) && RARRAY_LEN(slot) == 2) {
+                    /* Typed entry [slot, tag]: 1 = integer, 2 = float
+                     * (strtod — the engine's float getter is 32-bit
+                     * and loses 19.99), 3 = boolean. Parsed C-side
+                     * from the fetched bytes: no Ruby String is
+                     * materialized for typed slots; unparseable
+                     * input degrades to the raw String (#1269a
+                     * lenient). */
+                    VALUE typed_slot = RARRAY_AREF(slot, 0);
+                    int tag = FIX2INT(RARRAY_AREF(slot, 1));
+                    char *end = NULL;
+                    if (av && tag == 1) {
+                        long lv = strtol(av, &end, 10);
+                        if (end != av) {
+                            rb_struct_aset(value, typed_slot, LONG2NUM(lv));
+                            continue;
+                        }
+                    } else if (av && tag == 2) {
+                        double dv = strtod(av, &end);
+                        if (end != av) {
+                            rb_struct_aset(value, typed_slot, DBL2NUM(dv));
+                            continue;
+                        }
+                    } else if (av && tag == 3) {
+                        if (av[0] == 't' || av[0] == '1' ||
+                            av[0] == 'y' || av[0] == 'Y') {
+                            rb_struct_aset(value, typed_slot, Qtrue);
+                        } else {
+                            rb_struct_aset(value, typed_slot, Qfalse);
+                        }
+                        continue;
+                    }
+                    rb_struct_aset(value, typed_slot,
                                    av ? rb_utf8_str_new_cstr(av) : Qnil);
+                    continue;
                 }
+                rb_struct_aset(value, slot,
+                               av ? rb_utf8_str_new_cstr(av) : Qnil);
             }
             if (!NIL_P(text_slot)) {
+                VALUE t_slot = text_slot;
+                int t_tag = 0;
+                if (RB_TYPE_P(t_slot, T_ARRAY) && RARRAY_LEN(t_slot) == 2) {
+                    t_tag = FIX2INT(RARRAY_AREF(t_slot, 1));
+                    t_slot = RARRAY_AREF(t_slot, 0);
+                }
                 void *c;
                 for (c = f_first_child(node); c; c = f_next_sibling(c)) {
                     if (f_node_type(c) == WS_NODE_TEXT) {
                         const char *t = f_text_content(c);
-                        rb_struct_aset(value, text_slot,
-                                       t ? rb_utf8_str_new_cstr(t) : Qnil);
+                        if (!t) {
+                            rb_struct_aset(value, t_slot, Qnil);
+                        } else if (t_tag == 1) {
+                            rb_struct_aset(value, t_slot,
+                                           LONG2NUM(strtol(t, NULL, 10)));
+                        } else if (t_tag == 2) {
+                            rb_struct_aset(value, t_slot,
+                                           DBL2NUM(strtod(t, NULL)));
+                        } else if (t_tag == 3) {
+                            rb_struct_aset(value, t_slot,
+                                           (t[0] == 't' || t[0] == '1') ? Qtrue : Qfalse);
+                        } else {
+                            rb_struct_aset(value, t_slot,
+                                           rb_utf8_str_new_cstr(t));
+                        }
                         break;
                     }
                 }
@@ -2085,6 +2139,17 @@ static void plan_walk(void *node, int depth, VALUE spec, VALUE stack,
     }
 }
 
+/* Capability marker (moxml): the executor understands typed spec
+ * entries ([slot, tag] attr/text slots; 1 = integer, 2 = float via
+ * strtod, 3 = boolean, lenient raw-String fallback). Consumers
+ * probe this instead of version-gating — lockstep releases can
+ * publish without the face. */
+static VALUE nf_plan_structs_typed_p(VALUE self)
+{
+    (void)self;
+    return Qtrue;
+}
+
 static VALUE nf_plan_structs(VALUE self, VALUE document, VALUE addr,
                              VALUE spec)
 {
@@ -2667,6 +2732,8 @@ LEPTRIS_INIT_EXPORT void Init_native(void)
                               nf_attribute_pairs, 2);
     rb_define_module_function(m_native, "plan_structs",
                               nf_plan_structs, 3);
+    rb_define_module_function(m_native, "plan_structs_typed?",
+                              nf_plan_structs_typed_p, 0);
     rb_define_module_function(m_native, "doc_handle_attach",
                               nf_doc_handle_attach, 1);
     rb_define_module_function(m_native, "doc_handle_release",

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.221.1"
+  VERSION = "1.9.222.0"
 end

data/vendor-src/README.md

@@ -1,7 +1,7 @@
 Sources vendored in this gem (recompile rights; the ruby
 variant builds them at install via extconf.rb):
 
-- libleptris v1.9.221
+- libleptris v1.9.222
 - utf8proc v2.11.0
 
 Rebuild by hand:

data/vendor-src/libleptris/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.9.222] - 2026-09-22
+
+### Fixed
+
+- **parse:** the interleaved lane (`LEPTRIS_INTERLEAVED=1`) dropped the
+  namespace URI of every prefixed attribute — `xml:space` lost the XML
+  namespace, breaking namespace-based whitespace handling (reported by
+  Canon, #1295). The lane now stamps the #542 ns side-cache exactly like
+  the classic parser. Regression-tested against both lanes (#1300).
+- **dom:** the borrowed-text contract is now lane-explicit: runs
+  terminated in place (HTML builder, interleaved lane) are served
+  directly by `leptris_text_get_content`; `borrowed` means non-owning,
+  not unterminated (#1299). A new CI leg runs the whole suite with the
+  lane forced, so env-gated parse paths can no longer ship divergences
+  unnoticed (#1301).
+
+
+
 ## [1.9.221] - 2026-09-22
 
 ### Performance

data/vendor-src/libleptris/CMakeLists.txt

@@ -3,7 +3,7 @@
 cmake_minimum_required(VERSION 3.20)
 
 project(leptris
-    VERSION 1.9.221
+    VERSION 1.9.222
     DESCRIPTION "Fast XML parser and XPath evaluator in pure C"
     LANGUAGES C CXX
 )

data/vendor-src/libleptris/src/leptris/dom/text.h

@@ -20,10 +20,16 @@
  *
  * TODO 115 Phase B: a "borrowed" text node stores a pointer into a
  * caller-owned buffer (typically the parser's writable input buffer)
- * instead of pool-resident storage. Its `content` is NOT NUL-terminated
- * — `content_len` is the only authoritative size. The `pool` field
- * holds the pool to use for lazy materialization when a consumer asks
- * for a NUL-terminated view via leptris_text_get_content.
+ * instead of pool-resident storage. `content_len` is the only
+ * authoritative size — the run MAY be terminated in place (the HTML
+ * builder and the interleaved XML lane write the terminator into the
+ * doc-owned copy) or not (classic XML lane defers the NUL). The
+ * `pool` field holds the pool for lazy materialization:
+ * leptris_text_get_content serves terminated, entity-free runs in
+ * place (no allocation, the node stays borrowed) and materializes a
+ * pool-owned NUL-terminated copy otherwise, flipping the node out of
+ * borrowed mode. (#1299: serve mode is lane-dependent by design;
+ * both uphold the terminated-view contract.)
  *
  * Issue #168: parent_off mirrors next_sibling_off so the parent of a
  * text node can be queried in O(1). */
@@ -32,7 +38,7 @@ typedef struct leptris_text_node {
     char* content;                    /* Text content - NEVER trim! */
     size_t content_len;               /* Byte length of content (excl. NUL) */
     LeptrisMemoryPool* pool;           /* Pool for lazy materialization (NULL if content is NUL-term'd) */
-    int borrowed;                     /* 1 = content is borrowed (non-NUL-term'd) */
+    int borrowed;                     /* 1 = non-owning view; 0 = pool-resident (materialized). Not "unterminated": in-place-terminated runs stay borrowed (#1299). */
     /* (#450) int32 sibling edge — was cp16 (±256 KB). Text nodes
      * link to ELEMENT siblings across the parse-time element↔text
      * block gap, which scales with document size and regularly

data/vendor-src/libleptris/src/leptris/flat/direct_parse.c

@@ -2441,6 +2441,39 @@ static struct leptris_document* dp_il_build(
                     at->name_hash = 0;  /* lazy-hash sentinel */
                     at->ns_cache_off = 0;
                     at->next_cp = 0;
+                    /* #542 ns side-cache stamp, parity with the
+                     * classic lane's fused pass: prefixed attrs
+                     * carry prefix + owner so the namespace
+                     * accessors resolve. Without it xml:space and
+                     * every declared prefix read as no-namespace
+                     * (#1295). The lane bails on xmlns, so any
+                     * colon here is a genuine namespaced attr. */
+                    {
+                        const char* anm = scratch + a->name_off;
+                        const char* acolon =
+                            a->name_len >= 3
+                                ? (const char*)memchr(anm, ':',
+                                                      a->name_len)
+                                : NULL;
+                        if (acolon) {
+                            struct leptris_attr_ns_cache* nc =
+                                (struct leptris_attr_ns_cache*)
+                                    leptris_pool_alloc(pool, sizeof(*nc));
+                            if (nc) {
+                                memset(nc, 0, sizeof(*nc));
+                                size_t pl = (size_t)(acolon - anm);
+                                char* pfx = (char*)leptris_pool_alloc(
+                                    pool, pl + 1);
+                                if (pfx) {
+                                    memcpy(pfx, anm, pl);
+                                    pfx[pl] = '\0';
+                                    nc->prefix = pfx;
+                                }
+                                nc->owner_elem = e;
+                                attr_set_ns_cache(at, nc);
+                            }
+                        }
+                    }
                     /* dup detection — first wins (#1200) */
                     int dup = 0;
                     for (struct leptris_attribute* d =

data/vendor-src/libleptris/test/dom/test_text_borrowed.cpp

@@ -2,13 +2,22 @@
 //
 // Verifies that the parser hands text nodes a non-owning view into the
 // document's writable input buffer (no per-node pool allocation for
-// content), that consumers see correct content despite the missing
-// NUL terminator, and that lazy materialization produces a stable
-// NUL-terminated view.
+// content), that consumers see correct content despite a possibly
+// missing NUL terminator, and that leptris_text_get_content produces a
+// stable NUL-terminated view.
+//
+// #1299: the get_content serve mode is lane-dependent. When the parser
+// terminated the run in place (HTML builder, interleaved XML lane),
+// get_content serves the doc-owned pointer directly — no allocation,
+// the borrowed flag stays 1. Otherwise (classic XML lane, deferred
+// NUL) it materializes a pool-owned copy and flips the flag to 0.
+// Both modes must uphold the documented contract: correct bytes,
+// NUL-terminated view, pointer-stable across calls.
 
 #include <gtest/gtest.h>
 #include <cstring>
 #include <string>
+#include <cstdlib>
 #include "leptris.h"
 
 extern "C" {
@@ -40,13 +49,15 @@ TEST(TextBorrowed, ParsedTextNodeIsBorrowedFromInputBuffer) {
      * itself is internal to the document. */
     EXPECT_NE(text->content, nullptr);
 
-    /* The materialized pointer (after leptris_text_get_content) is
-     * pool-resident and therefore different from the borrowed pointer. */
-    const char* borrowed_ptr = text->content;
-    const char* materialized_ptr = leptris_text_get_content(text);
-    EXPECT_NE(materialized_ptr, borrowed_ptr)
-        << "materialization must allocate a fresh NUL-terminated copy";
-    EXPECT_EQ(text->borrowed, 0) << "get_content flips the borrowed flag";
+    /* Serve mode is lane-dependent (#1299): a run terminated in place
+     * (HTML builder, interleaved lane) is served directly — the
+     * returned pointer IS the borrowed pointer and the flag stays 1;
+     * the classic lane materializes a fresh pool copy and flips to 0.
+     * Either way the view must be correct and pointer-stable. */
+    const char* first = leptris_text_get_content(text);
+    EXPECT_STREQ(first, "hello world");
+    EXPECT_EQ(leptris_text_get_content(text), first)
+        << "served view must be pointer-stable across calls";
 
     leptris_document_free(doc);
 }
@@ -117,10 +128,58 @@ TEST(TextBorrowed, MaterializationIsStableAcrossCalls) {
 
     LeptrisNodeRef child = leptris_node_first_child(leptris_element_as_node(root));
     LeptrisTextNode* text = (LeptrisTextNode*)child;
-    EXPECT_EQ(text->borrowed, 0) << "materialization should flip the borrowed flag";
+    /* The flip is a materialize-path side effect, not the contract
+     * (#1299): in-place serve keeps borrowed at 1 — the mode is
+     * owned by ServeContractHoldsInBothParseLanes below. */
 
     const char* second = leptris_element_text(root);
     EXPECT_EQ(second, first) << "repeated calls return the same pointer";
 
     leptris_document_free(doc);
 }
+
+/* #1299: both serve modes uphold the get_content contract for parsed
+ * text. The interleaved lane is exercised with the env gate forced
+ * in-process (same toggle discipline as test/parser/test_interleaved.cpp;
+ * empty-string values count as off for MSVC). */
+#ifdef _WIN32
+static void tb_set_env(const char* k, const char* v) { _putenv_s(k, v); }
+static void tb_unset_env(const char* k) { _putenv_s(k, ""); }
+#else
+static void tb_set_env(const char* k, const char* v) { setenv(k, v, 1); }
+static void tb_unset_env(const char* k) { unsetenv(k); }
+#endif
+
+TEST(TextBorrowed, ServeContractHoldsInBothParseLanes) {
+    const char* xml = "<r>hello world</r>";
+    for (int lane = 0; lane <= 1; lane++) {
+        SCOPED_TRACE(lane ? "interleaved" : "classic");
+        if (lane) tb_set_env("LEPTRIS_INTERLEAVED", "1");
+        else tb_unset_env("LEPTRIS_INTERLEAVED");
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument doc = leptris_parse_string(xml, std::strlen(xml), &st);
+        ASSERT_NE(doc, nullptr);
+        LeptrisElement root = leptris_document_root(doc);
+        ASSERT_NE(root, nullptr);
+        LeptrisNodeRef child =
+            leptris_node_first_child(leptris_element_as_node(root));
+        ASSERT_NE(child, nullptr);
+        ASSERT_EQ(child->type, LEPTRIS_NODE_TYPE_TEXT);
+
+        LeptrisTextNode* text = (LeptrisTextNode*)child;
+        /* non-owning in both lanes */
+        EXPECT_EQ(text->borrowed, 1);
+        EXPECT_EQ(text->content_len, std::strlen("hello world"));
+
+        const char* a = leptris_text_get_content(text);
+        ASSERT_NE(a, nullptr);
+        EXPECT_STREQ(a, "hello world");
+        EXPECT_EQ(leptris_text_get_content(text), a)
+            << "served view must be pointer-stable across calls";
+        /* still correct after the first access */
+        EXPECT_STREQ(leptris_element_text(root), "hello world");
+
+        leptris_document_free(doc);
+    }
+    tb_unset_env("LEPTRIS_INTERLEAVED");
+}

data/vendor-src/libleptris/test/parser/test_interleaved.cpp

@@ -204,6 +204,65 @@ TEST(InterleavedParity, EngagementCanaryFiresOnlyWhenLaneRuns) {
 }
 #endif  /* !_WIN32: canary capture uses POSIX pipe/dup2 */
 
+/* #1295: namespace accessors on prefixed attributes. The il lane
+ * built attributes without the #542 ns side-cache stamp, so
+ * leptris_attribute_namespace_uri (and prefix) returned NULL for
+ * every prefixed attribute — xml: included, which broke Canon's
+ * namespace-based xml:space handling. This fixture keeps the il
+ * lane engaged: the lane defers xmlns-bearing documents to classic
+ * (il_scan bails on declarations), and xml: needs no declaration. */
+TEST(InterleavedParity, XmlAttrNamespaceParity) {
+    const char* kXmlNs = "http://www.w3.org/XML/1998/namespace";
+    const char* xml = "<root><code xml:space='preserve'>t</code></root>";
+    for (int lane = 0; lane <= 1; lane++) {
+        SCOPED_TRACE(lane ? "interleaved" : "classic");
+        if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
+        else unset_env("LEPTRIS_INTERLEAVED");
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+        ASSERT_NE(d, nullptr);
+        LeptrisElement root = leptris_document_root(d);
+        ASSERT_NE(root, nullptr);
+        LeptrisElement code = leptris_element_first_child(root, NULL);
+        ASSERT_NE(code, nullptr);
+        LeptrisAttribute a = leptris_element_first_attribute(code);
+        ASSERT_NE(a, nullptr);
+        EXPECT_STREQ(leptris_attribute_prefix(a), "xml");
+        EXPECT_STREQ(leptris_attribute_namespace_uri(a), kXmlNs);
+        /* expanded-name lookup rides the element-side resolver and
+         * must agree with the attr-side URI */
+        EXPECT_STREQ(leptris_element_attribute_ns(code, kXmlNs, "space"),
+                     "preserve");
+        EXPECT_STREQ(leptris_element_attribute(code, "xml:space"),
+                     "preserve");
+        leptris_document_free(d);
+    }
+    unset_env("LEPTRIS_INTERLEAVED");
+}
+
+/* Declared-prefix parity. The il lane bails to classic on xmlns
+ * today, so this runs classic twice in practice — but if the
+ * declaration bail ever lifts, the ns stamp must come with it. */
+TEST(InterleavedParity, DeclaredPrefixNamespaceParity) {
+    const char* xml = "<d xmlns:q='http://example/q' q:k='v'/>";
+    for (int lane = 0; lane <= 1; lane++) {
+        SCOPED_TRACE(lane ? "interleaved" : "classic");
+        if (lane) set_env("LEPTRIS_INTERLEAVED", "1");
+        else unset_env("LEPTRIS_INTERLEAVED");
+        LeptrisStatus st = LEPTRIS_OK;
+        LeptrisDocument d = leptris_parse_string(xml, strlen(xml), &st);
+        ASSERT_NE(d, nullptr);
+        LeptrisElement root = leptris_document_root(d);
+        ASSERT_NE(root, nullptr);
+        LeptrisAttribute a = leptris_element_first_attribute(root);
+        ASSERT_NE(a, nullptr);
+        EXPECT_STREQ(leptris_attribute_prefix(a), "q");
+        EXPECT_STREQ(leptris_attribute_namespace_uri(a), "http://example/q");
+        leptris_document_free(d);
+    }
+    unset_env("LEPTRIS_INTERLEAVED");
+}
+
 TEST(InterleavedParity, DupAttrDiagnosticParity) {
     const char* xml = "<r a='1' a='2'/>";
     for (int lane = 0; lane <= 1; lane++) {

data/vendor-src/libleptris/vcpkg.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
   "name": "leptris",
-  "version": "1.9.221",
+  "version": "1.9.222",
   "description": "High-performance XML parser and XPath 1.0 engine in C (libleptris)",
   "homepage": "https://github.com/leptris/leptris",
   "license": "MIT",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.221.1
+  version: 1.9.222.0
 platform: ruby
 authors:
 - Ribose Inc.