spinel_kit 0.1.1 → 0.3.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spinel_kit
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ori Pekelman
@@ -10,14 +10,14 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |-
-  SpinelKit consolidates the pure-Ruby "stdlib substitute" shims that every
-  Spinel-compiled project would otherwise hand-roll. Spinel (the Ruby->native
-  AOT compiler) cannot lower the json gem's C-ext fast path / metaprogrammed
-  fallback, stdlib Logger, or C-ext git bindings -- and the spinelgems
-  compatibility catalog confirms no verified gem exists to reuse. So this gem
-  ships a JSON encoder+decoder+builder, .git/HEAD provenance, and a minimal
-  levelled logger. Pure Ruby, no native extension, no runtime dependencies --
-  it vendors cleanly via bundler-spinel. Pre-alpha.
+  SpinelKit consolidates the pure-Ruby shims that every Spinel-compiled
+  project would otherwise hand-roll and that Spinel (the Ruby->native AOT
+  compiler) does not provide: .git/HEAD provenance, URL percent-codec +
+  query parsing, a minimal levelled logger, and a hex digit/byte codec.
+  (JSON left in 0.3.0: Spinel now bundles `json` as a require-gated stdlib
+  package, so consumers use JSON.parse/JSON.generate directly.) Pure Ruby,
+  no native extension, no runtime dependencies -- it vendors cleanly via
+  bundler-spinel. Pre-alpha.
 email:
 - ori@pekelman.com
 executables: []
@@ -31,20 +31,19 @@ files:
 - docs/gem-audit-first.md
 - docs/spinel-discipline.md
 - docs/spinelgems-issues.md
-- lib/spinel_kit.rb
-- lib/spinel_kit/git.rb
-- lib/spinel_kit/json.rb
-- lib/spinel_kit/json_builder.rb
-- lib/spinel_kit/json_decoder.rb
-- lib/spinel_kit/log.rb
-- lib/spinel_kit/version.rb
 - sig/spinel_kit/git.rbs
-- sig/spinel_kit/json.rbs
-- sig/spinel_kit/json_builder.rbs
-- sig/spinel_kit/json_decoder.rbs
+- sig/spinel_kit/hex.rbs
 - sig/spinel_kit/log.rbs
+- sig/spinel_kit/url.rbs
 - sig/spinel_kit/version.rbs
+- spin.toml
 - spinel-ext.json
+- spinel_kit.rb
+- spinel_kit/git.rb
+- spinel_kit/hex.rb
+- spinel_kit/log.rb
+- spinel_kit/url.rb
+- spinel_kit/version.rb
 homepage: https://github.com/OriPekelman/spinelkit
 licenses:
 - MIT
@@ -56,7 +55,7 @@ metadata:
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
-- lib
+- "."
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -70,6 +69,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: 'The Spinel stdlib-surface gem: pure-Ruby JSON/Git/Log shims for AOT-compiled
-  apps'
+summary: Pure-Ruby Git/Url/Log/Hex shims for Spinel AOT-compiled apps
 test_files: []

data/lib/spinel_kit/json.rb

@@ -1,149 +0,0 @@
-# SpinelKit::Json -- Spinel-safe JSON ENCODERS (stateless).
-#
-# This file holds the encode half of the codec; the decode half lives in
-# spinel_kit/json_decoder.rb (also `SpinelKit::Json`), and the incremental
-# object builder in spinel_kit/json_builder.rb (`SpinelKit::Json::Builder`).
-# The three are split because Spinel has no tree-shaking: every loaded method
-# is compiled, and a set of uncalled methods can degrade each other's params
-# (e.g. the dead decoder walkers collectively widening `escape`'s string arg
-# to int, which silently miscompiled string keys to ""). Keeping
-# encode/decode/build in separate files means a consumer compiles only the
-# surface it calls, and each surface is independently warning-clean. Require
-# only what you use:
-#
-#   require "spinel_kit/json"          # encoders (this file)
-#   require "spinel_kit/json_decoder"  # decoders
-#   require "spinel_kit/json_builder"  # builder
-#
-# WHY HAND-ROLLED. Spinel cannot lower the stdlib `json` gem (C-ext fast path
-# + metaprogrammed pure fallback); `oj`/`yajl`/`multi_json` are C extensions.
-# The spinelgems catalog confirms no verified pure-Ruby JSON gem exists. This
-# is tep's encoder, standardized (the `j_`/`tj_` prefixes that worked around a
-# now-fixed Spinel inference bug are gone -- see docs/spinel-discipline.md).
-#
-# Compose objects in user code by concatenation:
-#
-#   "{" + SpinelKit::Json.encode_pair_str("name", name) + "," +
-#         SpinelKit::Json.encode_pair_int("age", age) + "}"
-module SpinelKit
-  class Json
-    # Escape a string for inclusion inside a JSON string literal (does NOT
-    # add the surrounding quotes -- use `quote(s)` for that). Handles ", \,
-    # and the JSON-required control-char escapes (\b, \f, \n, \r, \t);
-    # other control bytes go through \u00XX. Forward slash is left
-    # unescaped (legal either way; unescaped is shorter/readable).
-    def self.escape(s)
-      out = ""
-      i = 0
-      n = s.length
-      while i < n
-        c = s[i]
-        if c == "\""
-          out = out + "\\\""
-        elsif c == "\\"
-          out = out + "\\\\"
-        elsif c == "\n"
-          out = out + "\\n"
-        elsif c == "\r"
-          out = out + "\\r"
-        elsif c == "\t"
-          out = out + "\\t"
-        elsif c == "\b"
-          out = out + "\\b"
-        elsif c == "\f"
-          out = out + "\\f"
-        elsif c < " "
-          # Other control byte -- emit \u00XX. c.getbyte(0) is the raw
-          # byte value, mapped to two hex digits.
-          b = c.getbyte(0)
-          out = out + "\\u00" + Json.hex2(b)
-        else
-          out = out + c
-        end
-        i += 1
-      end
-      out
-    end
-
-    # Two-digit lowercase hex of a byte (0..255).
-    def self.hex2(n)
-      hex = "0123456789abcdef"
-      out = ""
-      out = out + hex[(n / 16) % 16, 1]
-      out = out + hex[n % 16, 1]
-      out
-    end
-
-    # Wrap a string in JSON quotes, escaping its body.
-    def self.quote(s)
-      "\"" + Json.escape(s) + "\""
-    end
-
-    # Encode a single key/value pair as `"k":"v"` (escaped both sides).
-    def self.encode_pair_str(k, v)
-      Json.quote(k) + ":" + Json.quote(v)
-    end
-
-    # Same shape, integer value side. `v` is rendered via `.to_s` so
-    # JSON-numeric output without quoting.
-    def self.encode_pair_int(k, v)
-      Json.quote(k) + ":" + v.to_s
-    end
-
-    # Encode a Hash<String,String> as a JSON object.
-    def self.from_str_hash(h)
-      out = "{"
-      first = true
-      h.each do |k, v|
-        if !first
-          out = out + ","
-        end
-        first = false
-        out = out + Json.quote(k) + ":" + Json.quote(v)
-      end
-      out + "}"
-    end
-
-    # Same shape with integer values. JSON-numeric, no quoting.
-    def self.from_int_hash(h)
-      out = "{"
-      first = true
-      h.each do |k, v|
-        if !first
-          out = out + ","
-        end
-        first = false
-        out = out + Json.quote(k) + ":" + v.to_s
-      end
-      out + "}"
-    end
-
-    # Encode a string array as a JSON array of quoted strings.
-    def self.from_str_array(a)
-      out = "["
-      i = 0
-      while i < a.length
-        if i > 0
-          out = out + ","
-        end
-        out = out + Json.quote(a[i])
-        i += 1
-      end
-      out + "]"
-    end
-
-    # Encode an int array as a JSON array of numbers.
-    def self.from_int_array(a)
-      out = "["
-      i = 0
-      while i < a.length
-        if i > 0
-          out = out + ","
-        end
-        out = out + a[i].to_s
-        i += 1
-      end
-      out + "]"
-    end
-  end
-end

data/lib/spinel_kit/json_builder.rb

@@ -1,142 +0,0 @@
-# SpinelKit::Json::Builder -- an incremental, ordered JSON-object builder.
-#
-# WHY A SEPARATE FILE/CLASS. This is toy's hand-rolled builder; the codec
-# (SpinelKit::Json, encode/decode) is tep's. They are split so a consumer
-# compiles only the surface it uses: Spinel has no tree-shaking, so an
-# uncalled method is still compiled and degrades its params, emitting benign
-# but gate-tripping `emitting 0` warnings. A builder-only consumer requires
-# THIS file and never pays for the decoder walkers; a codec-only consumer
-# requires spinel_kit/json and never pays for the builder.
-#
-# To stay self-contained, Builder carries its OWN escape/quote/hex2 rather
-# than calling SpinelKit::Json.* (which would drag the whole codec, decoders
-# included, into a builder-only compile). These are byte-identical to the
-# codec's; the small duplication buys surface isolation. The same-named
-# methods across the two classes are safe -- the Spinel name-collision bug
-# that once made that dangerous is fixed (see docs/spinel-discipline.md).
-#
-# USAGE (mutating appenders, NOT method-chaining -- chaining is a Spinel
-# poly-degradation risk):
-#
-#   j = SpinelKit::Json::Builder.new
-#   j.add_str("kind", "run_start")
-#   j.add_num("t", now)                  # int OR float via .to_s
-#   host = SpinelKit::Json::Builder.new
-#   host.add_str("name", host_name)
-#   j.add_obj("host", host)              # nest a sub-builder
-#   j.add_raw("lr", "0.001")             # already-encoded JSON literal
-#   ev = j.dump                          # "{...}"
-#
-# NUMERIC NOTE: if a single compiled program passes BOTH Integer and Float to
-# `add_num`'s `value`, Spinel unifies the param to Float and an Integer
-# renders as "N.0". For hardcoded numeric literals where byte-exact output
-# matters, use `add_raw` with an already-encoded string instead of relying on
-# `value.to_s`.
-module SpinelKit
-  class Json
-    class Builder
-      def initialize
-        @buf   = "{"
-        @first = true
-      end
-
-      # Append `"key":"escaped-value"`.
-      def add_str(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + Builder.quote(value)
-      end
-
-      # Append `"key":<number>` -- `value.to_s` covers Integer ("5") and
-      # Float ("1.5"). For hardcoded literals prefer add_raw.
-      def add_num(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + value.to_s
-      end
-
-      # Append `"key":true|false`.
-      def add_bool(key, value)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + (value ? "true" : "false")
-      end
-
-      # Append `"key":<already-encoded JSON>` -- for arrays / numeric literals.
-      def add_raw(key, raw)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + raw
-      end
-
-      # Append `"key":<nested object>` from another Builder.
-      def add_obj(key, child)
-        comma
-        @buf = @buf + Builder.quote(key) + ":" + child.dump
-      end
-
-      # Close the object and return the JSON string.
-      def dump
-        @buf + "}"
-      end
-
-      # Emit a separator before every entry except the first.
-      def comma
-        if @first
-          @first = false
-        else
-          @buf = @buf + ","
-        end
-      end
-
-      # ---- self-contained string escaping (byte-identical to
-      #      SpinelKit::Json.escape/quote/hex2; kept local so a builder-only
-      #      compile never pulls in the codec) ----
-
-      # Wrap a string in JSON quotes, escaping its body.
-      def self.quote(s)
-        "\"" + Builder.escape(s) + "\""
-      end
-
-      # Escape a string for inclusion inside a JSON string literal (no
-      # surrounding quotes). Handles ", \, and the JSON control-char escapes
-      # (\b \f \n \r \t); other control bytes go through \u00XX. ASCII-clean
-      # input passes through unchanged.
-      def self.escape(s)
-        out = ""
-        i = 0
-        n = s.length
-        while i < n
-          c = s[i]
-          if c == "\""
-            out = out + "\\\""
-          elsif c == "\\"
-            out = out + "\\\\"
-          elsif c == "\n"
-            out = out + "\\n"
-          elsif c == "\r"
-            out = out + "\\r"
-          elsif c == "\t"
-            out = out + "\\t"
-          elsif c == "\b"
-            out = out + "\\b"
-          elsif c == "\f"
-            out = out + "\\f"
-          elsif c < " "
-            b = c.getbyte(0)
-            out = out + "\\u00" + Builder.hex2(b)
-          else
-            out = out + c
-          end
-          i += 1
-        end
-        out
-      end
-
-      # Two-digit lowercase hex of a byte (0..255).
-      def self.hex2(n)
-        hex = "0123456789abcdef"
-        out = ""
-        out = out + hex[(n / 16) % 16, 1]
-        out = out + hex[n % 16, 1]
-        out
-      end
-    end
-  end
-end