shipeasy-sdk 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0453ca27510264bd268b40868bb5c55a942835b7a20076b11e19305b4eeb27a7
-  data.tar.gz: c9c0b1ee3c80cf28abac5af4ec8bdaec1613f8b3235708b79b27223e38d2d463
+  metadata.gz: ad9abca98f87069daf53c2e2347e9f2975595b437576738aef381fbc2a4a9a10
+  data.tar.gz: 300a69f50db74da6279666d9d6d8698dbb22d08365e846f20403609e001ea638
 SHA512:
-  metadata.gz: d92ea1c2016d7e81791a7d7b8d6a0cd631da001893227685297e570c86372dc905da89cf54641d85ef7715e6ffd5ae0498a8781714326352fc139cf5adae0320
-  data.tar.gz: bfd396eeac063d46053f15fc865f8444f8284dae480cee7f064809a43bb288cd48ebd7cf559d08d5d3f0f68c3252a360800a8a2f787c5b63e2a3c25601e8d555
+  metadata.gz: cfb4185054243325d9130de44d40fff6d28af91ee2100150a7f594c2a9925c8ab20f931a2d1ccb433b830521ac07b7ff2381ff2325cf3b1ada0591d674f30c0d
+  data.tar.gz: 5b89a4b38c9f6b9eebc9946e50ebd74bbfb5336c0354cee43321b7ea94652fff7da669deebf74317a7aee6492db6760e471ea29b0c375885474e5ab2e37fbdab

data/lib/shipeasy/engine.rb

@@ -485,6 +485,8 @@ module Shipeasy
           attr("data-api-url", base),
         ]
         attrs << attr("data-anon-id", anon_id) if anon_id && !anon_id.empty?
+        data_user = identity_attrs(user)
+        attrs << attr("data-user", data_user) if data_user
         %(<script src="#{CGI.escapeHTML("#{base}/sdk/bootstrap.js")}" #{attrs.join(' ')}></script>)
       end
 
@@ -745,6 +747,28 @@ module Shipeasy
         %(#{name}="#{CGI.escapeHTML(value.to_s)}")
       end
 
+      # Serialize the server-identified user's traits for the SSR bootstrap tag's
+      # data-user attribute: the request user minus `anonymous_id`, dropping
+      # nil values only (empty strings and other present values are kept, to
+      # match the cross-SDK contract). Returns a stable-keyed JSON object, or nil when nothing
+      # identified remains (a purely anonymous request) so data-user is omitted.
+      # The browser SDK adopts this identity on first paint, killing the
+      # anon->identified flip. See experiment-platform/18-identity-bucketing.md.
+      def identity_attrs(user)
+        return nil unless user.is_a?(Hash)
+
+        traits = {}
+        user.each do |k, v|
+          next if k.to_s == "anonymous_id"
+          next if v.nil?
+
+          traits[k.to_s] = v
+        end
+        return nil if traits.empty?
+
+        JSON.generate(traits.sort.to_h)
+      end
+
       def start_poll
         @timer = Thread.new do
           loop do

data/lib/shipeasy/sdk/eval.rb

@@ -70,10 +70,102 @@ module Shipeasy
         user["user_id"] || user[:user_id] || user["anonymous_id"] || user[:anonymous_id]
       end
 
+      def self.clamp_pct(n)
+        return 0 if n < 0
+        return 10000 if n > 10000
+        n
+      end
+
+      # Effective rollout % for a stack entry at time +now+ (epoch ms). A
+      # condition with no explicit rolloutPct defaults to 100% (match => pass); a
+      # rollout to 0%. A ramp linearly interpolates from=>to over
+      # [startAt, startAt + durationMs] via truncating-toward-zero division — the
+      # cross-SDK contract (experiment-platform/04-evaluation.md). Mirrors core's
+      # effectivePct.
+      def self.effective_pct(entry, now)
+        type = entry["type"] || entry[:type]
+        raw  = entry["rolloutPct"] || entry[:rolloutPct]
+        base = raw.nil? ? (type == "condition" ? 10000 : 0) : raw
+        ramp = entry["ramp"] || entry[:ramp]
+        return base unless ramp
+
+        from      = ramp["from"] || ramp[:from]
+        to        = ramp["to"] || ramp[:to]
+        start_at  = ramp["startAt"] || ramp[:startAt]
+        duration  = ramp["durationMs"] || ramp[:durationMs]
+        return from if now <= start_at
+        return to if now >= start_at + duration
+
+        delta   = to - from # signed
+        elapsed = now - start_at
+        # .to_i on the float quotient truncates toward zero (works for a negative
+        # ramp-down delta, unlike Ruby's floor-division integer `/`).
+        clamp_pct(from + (delta * elapsed).fdiv(duration).to_i)
+      end
+
+      # Hash the caller into [0, 10000) and test against +pct+. No-unit contract
+      # (experiment-platform/18): a fully-rolled bucket is on for everyone without
+      # a unit id; a fractional one needs a stable unit, so it is off. Mirrors
+      # core's bucketHit.
+      def self.bucket_hit(pct, uid, salt)
+        return false if pct <= 0
+        return pct >= 10000 if uid.nil? || uid.to_s.empty?
+        return true if pct >= 10000
+        murmur3("#{salt}:#{uid}") % 10000 < pct
+      end
+
+      # Evaluate one gatekeeper stack entry. A `condition` gates on its rules
+      # (pass: "all" | "any") then buckets at its own rollout % (default 100%); a
+      # `rollout` buckets everyone who reached it (default 0%). A condition's
+      # default bucketing salt is its own id so each step buckets independently;
+      # a rollout falls back to the gate salt so existing entries don't re-bucket.
+      # Mirrors core's evalStackEntry.
+      def self.eval_stack_entry(entry, user, fallback_salt, now)
+        type = entry["type"] || entry[:type]
+        bucket_by = entry["bucketBy"] || entry[:bucketBy]
+        entry_salt = entry["salt"] || entry[:salt]
+
+        if type == "condition"
+          rules = entry["rules"] || entry[:rules] || []
+          return false if rules.empty?
+
+          mode = entry["pass"] || entry[:pass] || "all"
+          matched =
+            if mode == "any"
+              rules.any? { |r| match_rule(r, user) }
+            else
+              rules.all? { |r| match_rule(r, user) }
+            end
+          return false unless matched
+
+          salt = (entry_salt && !entry_salt.to_s.empty?) ? entry_salt : (entry["id"] || entry[:id] || fallback_salt)
+          bucket_hit(effective_pct(entry, now), pick_identifier(user, bucket_by), salt)
+        else
+          salt = (entry_salt && !entry_salt.to_s.empty?) ? entry_salt : fallback_salt
+          bucket_hit(effective_pct(entry, now), pick_identifier(user, bucket_by), salt)
+        end
+      end
+
       def self.eval_gate(gate, user)
         return false if enabled?(gate["killswitch"])
         return false unless enabled?(gate["enabled"])
 
+        # Modern gatekeepers ship an ordered `stack`; evaluate it top-to-bottom and
+        # pass on the first entry whose rules match AND whose bucket hits. This is
+        # the canonical model — the flat `rules`/`rolloutPct` below are a lossy
+        # approximation (a whitelist condition at 100% collapses to `rolloutPct: 0`
+        # once the public rollout is 0%, which the flat path would wrongly read as
+        # "never"). Mirrors @shipeasy/core evalGatekeeper — keep the two in sync.
+        stack = gate["stack"] || gate[:stack]
+        if stack.is_a?(Array) && !stack.empty?
+          now = (Time.now.to_f * 1000).to_i
+          gate_salt = gate["salt"] || gate[:salt]
+          stack.each do |entry|
+            return true if eval_stack_entry(entry, user, gate_salt, now)
+          end
+          return false
+        end
+
         (gate["rules"] || []).each do |rule|
           return false unless match_rule(rule, user)
         end

data/lib/shipeasy/sdk/version.rb

@@ -1,5 +1,5 @@
 module Shipeasy
   module SDK
-    VERSION = "3.5.0"
+    VERSION = "3.6.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shipeasy-sdk
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Shipeasy, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-17 00:00:00.000000000 Z
+date: 2026-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec