feat-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f64fac3df2e3ba9d2dc9db569472dd8329bea2d4fb4f2117d44e65a45d9e652
+  data.tar.gz: 4d60e7877bc7df301aa90a96bd19b11c211d6941387ffe834793c84db04ad353
+SHA512:
+  metadata.gz: 2a990fc8a48b6176329fc664001c314b37fd5523122d91481700f804df7ec0d75f9705167eced27696627de0bfa25b895e0950b7aa69dd2d73785d917b7175b3
+  data.tar.gz: 8bbbed51ad214a26652743a15f036ea1936f431d74606c634f63282bfaaaee67310606e9110748a46385b9fa5786e441a6cd3690666a146c924ba4324420a1f2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 feat HQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# feat-sdk
+
+Server-side Ruby SDK for [feat](https://feat.so) feature flags. Local flag evaluation against a polled datafile. Standard library only - no gem dependencies.
+
+## Install
+
+```ruby
+# Gemfile
+gem "feat-sdk"
+```
+
+```bash
+bundle install
+```
+
+Ruby 3.0+.
+
+## Usage
+
+```ruby
+require "feat"
+
+client = Feat::Client.new(
+  api_key: ENV.fetch("FEAT_SERVER_KEY"),
+  data_plane_url: "https://data.feat.so",
+)
+client.start
+
+ctx = {
+  targetingKey: "user-123",
+  user: { plan: "pro", email: "alice@example.com" },
+}
+
+if client.get_boolean_value("checkout-v2", false, ctx)
+  # ...
+end
+
+client.close
+```
+
+Use a **server** API key (`feat_sdk_...`).
+
+## How it works
+
+- Fetches a per-environment datafile and keeps it in memory.
+- Polls every 30 seconds by default. ETag-aware via `If-None-Match`.
+- Evaluation runs in-process: no per-flag network call.
+- A background thread handles polling; `close` stops it cleanly.
+
+## License
+
+MIT

data/lib/feat/bucketing.rb

@@ -0,0 +1,36 @@
+require "digest"
+
+module Feat
+  # Deterministic bucketing for percentage rollouts. Algorithm matches
+  # @feathq/feat-eval (JS), feat-go-sdk (Go), and feat (Python)
+  # bit-for-bit:
+  #
+  #   sha1(salt + "." + flag_key + "." + context_key)
+  #   -> first 8 bytes as big-endian uint64
+  #   -> shift right 4 (drop low bits) for exactly 60 bits
+  #   -> modulo 100_000
+  module Bucketing
+    BUCKET_SCALE = 100_000
+
+    module_function
+
+    def bucket(salt:, flag_key:, context_key:)
+      digest = Digest::SHA1.digest("#{salt}.#{flag_key}.#{context_key}")
+      first8 = digest[0, 8].unpack1("Q>") # big-endian unsigned 64-bit
+      sixty = first8 >> 4
+      sixty % BUCKET_SCALE
+    end
+
+    # Walk cumulative weights; return the variation whose range contains
+    # bucket_value. Defensive fallback to the last variation if upstream
+    # weights underflow the scale.
+    def pick_by_weight(bucket_value, variations)
+      cumulative = 0
+      variations.each do |v|
+        cumulative += v.weight
+        return v.variationId if bucket_value < cumulative
+      end
+      variations.empty? ? nil : variations.last.variationId
+    end
+  end
+end

data/lib/feat/client.rb

@@ -0,0 +1,128 @@
+require "json"
+require "net/http"
+require "uri"
+
+module Feat
+  # Polling HTTP client. Uses stdlib only - zero gem dependencies.
+  class Client
+    DEFAULT_POLL_INTERVAL = 30.0
+    MIN_POLL_INTERVAL = 5.0
+    MAX_DATAFILE_BYTES = 10 * 1024 * 1024
+
+    def initialize(api_key:, data_plane_url:, poll_interval: DEFAULT_POLL_INTERVAL, http_client: nil)
+      raise ArgumentError, "api_key is required" if api_key.nil? || api_key.empty?
+      raise ArgumentError, "data_plane_url is required" if data_plane_url.nil? || data_plane_url.empty?
+
+      assert_https_url!(data_plane_url)
+
+      @api_key       = api_key
+      @data_plane_url = data_plane_url.chomp("/")
+      @poll_interval = [poll_interval.to_f, MIN_POLL_INTERVAL].max
+      @http_client   = http_client
+      @datafile      = nil
+      @etag          = nil
+      @mutex         = Mutex.new
+      @stop          = false
+      @thread        = nil
+    end
+
+    # Blocking initial fetch; spawns a background poller thread.
+    def start
+      refresh
+      @thread ||= Thread.new { poll_loop }
+    end
+
+    def close
+      @stop = true
+    end
+
+    def refresh
+      fetch_once
+    end
+
+    def evaluate(flag_key, default_value, ctx)
+      df = @datafile
+      if df.nil?
+        return EvaluationResult.new(
+          value: default_value, reason: Reason::ERROR,
+          error_message: "client not ready: call #start before #evaluate"
+        )
+      end
+      Eval.call(flag_key: flag_key, default_value: default_value, ctx: ctx, datafile: df)
+    end
+
+    def get_boolean_value(flag_key, default, ctx)
+      r = evaluate(flag_key, default, ctx)
+      r.value == true || r.value == false ? r.value : default
+    end
+
+    def get_string_value(flag_key, default, ctx)
+      r = evaluate(flag_key, default, ctx)
+      r.value.is_a?(String) ? r.value : default
+    end
+
+    def get_number_value(flag_key, default, ctx)
+      r = evaluate(flag_key, default, ctx)
+      r.value.is_a?(Numeric) && !(r.value == true || r.value == false) ? r.value : default
+    end
+
+    def get_object_value(flag_key, default, ctx)
+      r = evaluate(flag_key, default, ctx)
+      r.value
+    end
+
+    private
+
+    def assert_https_url!(url)
+      uri = URI.parse(url)
+      return if uri.scheme == "https"
+      return if uri.scheme == "http" && %w[localhost 127.0.0.1].include?(uri.host)
+      raise ArgumentError, "data_plane_url must use https:// (http://localhost allowed for tests)"
+    rescue URI::InvalidURIError
+      raise ArgumentError, "data_plane_url is not a valid URL"
+    end
+
+    def poll_loop
+      until @stop
+        sleep @poll_interval
+        break if @stop
+
+        begin
+          fetch_once
+        rescue StandardError
+          # Defensive: keep polling on any transient error.
+        end
+      end
+    end
+
+    def fetch_once
+      uri = URI.parse("#{@data_plane_url}/sdk/v1/datafile")
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{@api_key}"
+      @mutex.synchronize { req["If-None-Match"] = @etag if @etag }
+
+      res = (@http_client || Net::HTTP).start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(req)
+      end
+
+      case res.code.to_i
+      when 304, 404
+        false
+      when 200
+        length = res["Content-Length"]&.to_i
+        raise "datafile exceeds maximum allowed size" if length && length > MAX_DATAFILE_BYTES
+        body = res.body
+        raise "datafile exceeds maximum allowed size" if body.bytesize > MAX_DATAFILE_BYTES
+        data = JSON.parse(body)
+        new_etag = res["ETag"]
+        @mutex.synchronize do
+          @datafile = Datafile.from_json(data)
+          @etag = new_etag if new_etag
+        end
+        true
+      else
+        raise "feat: fetch datafile failed: #{res.code}"
+      end
+    end
+  end
+end

data/lib/feat/context.rb

@@ -0,0 +1,66 @@
+module Feat
+  # SDK-consumer-supplied context. Mirrors OpenFeature's pattern: a
+  # `targeting_key` shorthand for "user.key", and a `kinds` hash whose
+  # keys match the datafile's `contextKinds` map.
+  #
+  # Example:
+  #
+  #   Feat::EvalContext.new(
+  #     targeting_key: "user-123",
+  #     kinds: {
+  #       "user"         => { "key" => "user-123", "email" => "u@example.com" },
+  #       "organization" => { "key" => "acme",     "plan"  => "pro" }
+  #     }
+  #   )
+  EvalContext = Struct.new(:targeting_key, :kinds, keyword_init: true) do
+    def initialize(targeting_key: nil, kinds: {})
+      super
+    end
+  end
+
+  module ContextResolver
+    module_function
+
+    # Walks "user.email", "organization.plan", "user.address.city"
+    # against the EvalContext. Returns nil if any segment is missing
+    # — operators treat nil as a non-match.
+    def resolve_attribute(ctx, attribute_path)
+      return nil if attribute_path.nil? || attribute_path.empty?
+
+      parts = attribute_path.split(".", 2)
+      kind_obj = read_kind(ctx, parts[0])
+      return nil if kind_obj.nil?
+      return kind_obj["key"] if parts.length == 1
+
+      rest = parts[1]
+      cur = kind_obj
+      rest.split(".").each do |p|
+        return nil unless cur.is_a?(Hash)
+        return nil unless cur.key?(p)
+
+        cur = cur[p]
+      end
+      cur
+    end
+
+    def read_context_key(ctx, kind_key)
+      obj = read_kind(ctx, kind_key)
+      return nil if obj.nil?
+
+      key = obj["key"]
+      key.is_a?(String) ? key : nil
+    end
+
+    def read_kind(ctx, kind_key)
+      if kind_key == "user"
+        obj = ctx.kinds["user"]
+        return obj if obj.is_a?(Hash)
+        return { "key" => ctx.targeting_key } if ctx.targeting_key
+
+        return nil
+      end
+      obj = ctx.kinds[kind_key]
+      obj.is_a?(Hash) ? obj : nil
+    end
+  end
+end

data/lib/feat/datafile.rb

@@ -0,0 +1,104 @@
+module Feat
+  # Wire-format types. JSON field names mirror @feathq/datafile-schema
+  # exactly (camelCase) — `from_json` keeps the hash keys, no rekeying.
+  module Datafile
+    VariationSpec      = Struct.new(:id, :name, :value, keyword_init: true)
+    TargetSpec         = Struct.new(:contextKindKey, :contextKey, :variationId, keyword_init: true)
+    ConditionSpec      = Struct.new(:attributePath, :operator, :values, keyword_init: true)
+    ConditionGroupSpec = Struct.new(:conditions, keyword_init: true)
+    RolloutVariation   = Struct.new(:variationId, :weight, keyword_init: true)
+    Rollout            = Struct.new(:bucketingContextKindKey, :variations, keyword_init: true)
+    RuleSpec           = Struct.new(
+      :id, :bucketingContextKindKey, :variationId, :rollout, :groups,
+      keyword_init: true
+    )
+    FlagSpec = Struct.new(
+      :id, :key, :valueType, :salt, :archived, :isEnabled, :offVariationId,
+      :defaultVariationId, :defaultRollout, :defaultBucketingContextKindKey,
+      :variations, :targets, :rules,
+      keyword_init: true
+    )
+    SegmentRuleSpec = Struct.new(:conditions, keyword_init: true)
+    SegmentSpec     = Struct.new(:key, :rules, keyword_init: true)
+    ContextKindSpec = Struct.new(
+      :key, :availableForRules, :availableForExperiments,
+      keyword_init: true
+    )
+
+    File = Struct.new(
+      :schemaVersion, :envId, :envKey, :projectId, :version, :etag,
+      :generatedAt, :flags, :segments, :contextKinds,
+      keyword_init: true
+    )
+
+    # Parse a wire-format hash (typically JSON.parse output) into a
+    # Datafile::File. Hash keys must already be string-keyed (default for
+    # JSON.parse).
+    def self.from_json(data)
+      File.new(
+        schemaVersion: data["schemaVersion"],
+        envId:         data["envId"],
+        envKey:        data["envKey"],
+        projectId:     data["projectId"],
+        version:       data["version"],
+        etag:          data["etag"],
+        generatedAt:   data["generatedAt"],
+        flags:         data["flags"].each_with_object({}) { |(k, v), o| o[k] = build_flag(v) },
+        segments:      (data["segments"] || {}).each_with_object({}) { |(k, v), o| o[k] = build_segment(v) },
+        contextKinds:  (data["contextKinds"] || {}).each_with_object({}) { |(k, v), o| o[k] = ContextKindSpec.new(**symbolize(v)) }
+      )
+    end
+
+    def self.build_flag(d)
+      FlagSpec.new(
+        id:                             d["id"],
+        key:                            d["key"],
+        valueType:                      d["valueType"],
+        salt:                           d["salt"],
+        archived:                       d["archived"],
+        isEnabled:                      d["isEnabled"],
+        offVariationId:                 d["offVariationId"],
+        defaultVariationId:             d["defaultVariationId"],
+        defaultRollout:                 build_rollout(d["defaultRollout"]),
+        defaultBucketingContextKindKey: d["defaultBucketingContextKindKey"],
+        variations:                     d["variations"].map { |v| VariationSpec.new(**symbolize(v)) },
+        targets:                        d["targets"].map { |t| TargetSpec.new(**symbolize(t)) },
+        rules:                          d["rules"].map { |r| build_rule(r) }
+      )
+    end
+
+    def self.build_rule(d)
+      RuleSpec.new(
+        id:                      d["id"],
+        bucketingContextKindKey: d["bucketingContextKindKey"],
+        variationId:             d["variationId"],
+        rollout:                 build_rollout(d["rollout"]),
+        groups:                  d["groups"].map { |g|
+          ConditionGroupSpec.new(conditions: g["conditions"].map { |c| ConditionSpec.new(**symbolize(c)) })
+        }
+      )
+    end
+
+    def self.build_rollout(d)
+      return nil if d.nil?
+
+      Rollout.new(
+        bucketingContextKindKey: d["bucketingContextKindKey"],
+        variations:              d["variations"].map { |v| RolloutVariation.new(**symbolize(v)) }
+      )
+    end
+
+    def self.build_segment(d)
+      SegmentSpec.new(
+        key:   d["key"],
+        rules: d["rules"].map { |r|
+          SegmentRuleSpec.new(conditions: r["conditions"].map { |c| ConditionSpec.new(**symbolize(c)) })
+        }
+      )
+    end
+
+    def self.symbolize(h)
+      h.each_with_object({}) { |(k, v), o| o[k.to_sym] = v }
+    end
+  end
+end

data/lib/feat/eval.rb

@@ -0,0 +1,103 @@
+module Feat
+  # Evaluation result reasons. Match OpenFeature's enum + the
+  # cross-language SDK convention.
+  module Reason
+    TARGETING_MATCH = "TARGETING_MATCH".freeze
+    SPLIT           = "SPLIT".freeze
+    FALLTHROUGH     = "FALLTHROUGH".freeze
+    DEFAULT         = "DEFAULT".freeze
+    DISABLED        = "DISABLED".freeze
+    ERROR           = "ERROR".freeze
+    STATIC          = "STATIC".freeze
+  end
+
+  EvaluationResult = Struct.new(:value, :variation_id, :reason, :error_message, keyword_init: true) do
+    def initialize(value:, variation_id: nil, reason:, error_message: nil)
+      super
+    end
+  end
+
+  module Eval
+    module_function
+
+    # Run the precedence pipeline:
+    #
+    #   1. archived flag        -> off variation        DISABLED
+    #   2. !isEnabled           -> off variation        DISABLED
+    #   3. individual target    -> target variation     TARGETING_MATCH
+    #   4. first matching rule  -> rule variation/rollout TARGETING_MATCH / SPLIT
+    #   5. default              -> default variation/rollout FALLTHROUGH / SPLIT
+    #   6. nothing matched      -> off variation        DEFAULT
+    def call(flag_key:, default_value:, ctx:, datafile:)
+      flag = datafile.flags[flag_key]
+      if flag.nil?
+        return EvaluationResult.new(
+          value: default_value, reason: Reason::ERROR,
+          error_message: "flag could not be evaluated"
+        )
+      end
+
+      if flag.archived || !flag.isEnabled
+        return resolve_variation(flag, flag.offVariationId, Reason::DISABLED, default_value)
+      end
+
+      flag.targets.each do |target|
+        ctx_key = ContextResolver.read_context_key(ctx, target.contextKindKey)
+        if !ctx_key.nil? && ctx_key == target.contextKey
+          return resolve_variation(flag, target.variationId, Reason::TARGETING_MATCH, default_value)
+        end
+      end
+
+      flag.rules.each do |rule|
+        next unless match_rule?(rule, ctx, datafile)
+
+        if !rule.variationId.nil?
+          return resolve_variation(flag, rule.variationId, Reason::TARGETING_MATCH, default_value)
+        end
+        if !rule.rollout.nil?
+          picked = pick_rollout(flag, rule.rollout, ctx)
+          return resolve_variation(flag, picked, Reason::SPLIT, default_value) unless picked.nil?
+        end
+      end
+
+      if !flag.defaultVariationId.nil?
+        return resolve_variation(flag, flag.defaultVariationId, Reason::FALLTHROUGH, default_value)
+      end
+      if !flag.defaultRollout.nil?
+        picked = pick_rollout(flag, flag.defaultRollout, ctx)
+        return resolve_variation(flag, picked, Reason::SPLIT, default_value) unless picked.nil?
+      end
+
+      resolve_variation(flag, flag.offVariationId, Reason::DEFAULT, default_value)
+    end
+
+    def match_rule?(rule, ctx, datafile)
+      return false if rule.groups.empty?
+
+      rule.groups.any? do |group|
+        next false if group.conditions.empty?
+
+        group.conditions.all? { |cond| Segments.match_condition(cond, ctx, datafile) }
+      end
+    end
+
+    def pick_rollout(flag, rollout, ctx)
+      ctx_key = ContextResolver.read_context_key(ctx, rollout.bucketingContextKindKey)
+      return nil if ctx_key.nil?
+
+      b = Bucketing.bucket(salt: flag.salt, flag_key: flag.key, context_key: ctx_key)
+      Bucketing.pick_by_weight(b, rollout.variations)
+    end
+
+    def resolve_variation(flag, variation_id, reason, default_value)
+      v = flag.variations.find { |x| x.id == variation_id }
+      if v.nil?
+        return EvaluationResult.new(
+          value: default_value, reason: Reason::ERROR,
+          error_message: "flag could not be evaluated"
+        )
+      end
+      EvaluationResult.new(value: v.value, variation_id: variation_id, reason: reason)
+    end
+  end
+end

data/lib/feat/operators.rb

@@ -0,0 +1,177 @@
+require "date"
+require "time"
+
+module Feat
+  # Per-operator predicates. Defensive: type-mismatch / parse-failure
+  # returns false rather than raising — matches the JS engine's posture
+  # against malformed contexts at the edge.
+  #
+  # segment_match / segment_not_match are dispatched by the rule
+  # evaluator (they recurse into the datafile's segments map), not here.
+  module Operators
+    module_function
+
+    def match(operator, lhs, values)
+      case operator
+      when "is_one_of"        then any_eq?(lhs, values)
+      when "is_not_one_of"    then !any_eq?(lhs, values)
+      when "is_empty"         then empty?(lhs)
+      when "is_not_empty"     then !empty?(lhs)
+      when "contains"         then string_any?(lhs, values) { |s, v| s.include?(v) }
+      when "does_not_contain"
+        return true unless lhs.is_a?(String)
+
+        !string_any?(lhs, values) { |s, v| s.include?(v) }
+      when "starts_with"      then string_any?(lhs, values) { |s, v| s.start_with?(v) }
+      when "ends_with"        then string_any?(lhs, values) { |s, v| s.end_with?(v) }
+      when "matches_regex"
+        return false unless lhs.is_a?(String)
+
+        any_string_value?(values) { |v|
+          next false unless safe_regex?(v)
+
+          begin
+            !!(lhs =~ Regexp.new(v))
+          rescue RegexpError
+            false
+          end
+        }
+      when "gt"               then numeric_cmp(lhs, values) { |a, b| a > b }
+      when "gte"              then numeric_cmp(lhs, values) { |a, b| a >= b }
+      when "lt"               then numeric_cmp(lhs, values) { |a, b| a < b }
+      when "lte"              then numeric_cmp(lhs, values) { |a, b| a <= b }
+      when "before"           then date_cmp(lhs, values) { |a, b| a < b }
+      when "after"            then date_cmp(lhs, values) { |a, b| a > b }
+      when "semver_eq"        then semver_cmp(lhs, values) { |c| c.zero? }
+      when "semver_gt"        then semver_cmp(lhs, values) { |c| c.positive? }
+      when "semver_gte"       then semver_cmp(lhs, values) { |c| c >= 0 }
+      when "semver_lt"        then semver_cmp(lhs, values) { |c| c.negative? }
+      when "semver_lte"       then semver_cmp(lhs, values) { |c| c <= 0 }
+      when "segment_match", "segment_not_match"
+        false
+      else
+        false
+      end
+    end
+
+    def empty?(lhs)
+      lhs.nil? || lhs == ""
+    end
+
+    # JS-engine-compatible equality with string/number coercion.
+    def deep_eq(a, b)
+      return true if a == b
+
+      if a.is_a?(Numeric) && b.is_a?(String)
+        return a.to_s == b || float_eq(a, b)
+      end
+      if a.is_a?(String) && b.is_a?(Numeric)
+        return a == b.to_s || float_eq(b, a)
+      end
+
+      false
+    end
+
+    def float_eq(num, str)
+      Float(str) == num.to_f
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    def any_eq?(lhs, values)
+      values.any? { |v| deep_eq(lhs, v) }
+    end
+
+    def string_any?(lhs, values)
+      return false unless lhs.is_a?(String)
+
+      values.any? { |v| v.is_a?(String) && yield(lhs, v) }
+    end
+
+    def any_string_value?(values)
+      values.any? { |v| v.is_a?(String) && yield(v) }
+    end
+
+    def numeric_cmp(lhs, values)
+      a = to_number(lhs)
+      return false if a.nil?
+
+      values.any? do |v|
+        b = to_number(v)
+        b && yield(a, b)
+      end
+    end
+
+    def to_number(x)
+      case x
+      when Numeric then x.to_f
+      when String
+        Float(x)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def date_cmp(lhs, values)
+      a = to_time(lhs)
+      return false if a.nil?
+
+      values.any? do |v|
+        b = to_time(v)
+        b && yield(a, b)
+      end
+    end
+
+    def to_time(x)
+      case x
+      when String then Time.iso8601(x)
+      when Numeric then Time.at(x.to_f / 1000.0)
+      end
+    rescue ArgumentError
+      nil
+    end
+
+    # ReDoS guard for matches_regex. Caps pattern length and rejects the
+    # most common catastrophic-backtracking shapes. False positives just
+    # turn the rule into a non-match, which is the safe default.
+    REDOS_SHAPES = /\([^)]*[+*][^)]*\)\s*[+*]|\([^)]*\|[^)]*\)\s*[+*]/
+
+    def safe_regex?(pattern)
+      return false if pattern.length > 512
+      return false if REDOS_SHAPES.match?(pattern)
+
+      true
+    end
+
+    SEMVER_RE = /\A(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?\z/
+
+    def parse_semver(x)
+      return nil unless x.is_a?(String)
+
+      m = x.strip.match(SEMVER_RE)
+      return nil if m.nil?
+
+      [m[1].to_i, m[2].to_i, m[3].to_i, m[4]]
+    end
+
+    def compare_semver(a, b)
+      3.times { |i| return a[i] - b[i] if a[i] != b[i] }
+      ap, bp = a[3], b[3]
+      return 0 if ap == bp
+      return 1 if ap.nil?
+      return -1 if bp.nil?
+
+      ap <=> bp
+    end
+
+    def semver_cmp(lhs, values)
+      a = parse_semver(lhs)
+      return false if a.nil?
+
+      values.any? do |v|
+        b = parse_semver(v)
+        b && yield(compare_semver(a, b))
+      end
+    end
+  end
+end

data/lib/feat/segments.rb

@@ -0,0 +1,32 @@
+module Feat
+  module Segments
+    module_function
+
+    # True iff context matches the segment. Unknown segment keys
+    # evaluate to false (never raise).
+    def match_segment(segment_key, ctx, datafile)
+      seg = datafile.segments[segment_key]
+      return false if seg.nil?
+
+      seg.rules.any? do |rule|
+        next false if rule.conditions.empty?
+
+        rule.conditions.all? { |cond| match_condition(cond, ctx, datafile) }
+      end
+    end
+
+    def match_condition(cond, ctx, datafile)
+      case cond.operator
+      when "segment_match"
+        keys = cond.values.select { |v| v.is_a?(String) }
+        keys.any? { |k| match_segment(k, ctx, datafile) }
+      when "segment_not_match"
+        keys = cond.values.select { |v| v.is_a?(String) }
+        !keys.any? { |k| match_segment(k, ctx, datafile) }
+      else
+        lhs = ContextResolver.resolve_attribute(ctx, cond.attributePath)
+        Operators.match(cond.operator, lhs, cond.values)
+      end
+    end
+  end
+end

data/lib/feat/version.rb

@@ -0,0 +1,3 @@
+module Feat
+  VERSION = "0.1.0".freeze
+end

data/lib/feat.rb

@@ -0,0 +1,14 @@
+require "feat/version"
+require "feat/datafile"
+require "feat/context"
+require "feat/bucketing"
+require "feat/operators"
+require "feat/segments"
+require "feat/eval"
+require "feat/client"
+
+# Feat - feature-flag SDK for Ruby.
+#
+# Server-side evaluation against a locally-cached datafile.
+module Feat
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: feat-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- feat HQ
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Server-side Ruby SDK for feat. Polls a per-environment datafile and evaluates
+  flags locally with no per-flag network call. Stdlib only.
+email:
+- engineering@feat.so
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/feat.rb
+- lib/feat/bucketing.rb
+- lib/feat/client.rb
+- lib/feat/context.rb
+- lib/feat/datafile.rb
+- lib/feat/eval.rb
+- lib/feat/operators.rb
+- lib/feat/segments.rb
+- lib/feat/version.rb
+homepage: https://feat.so
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://feat.so
+  source_code_uri: https://github.com/feathq/ruby-sdk
+  bug_tracker_uri: https://github.com/feathq/ruby-sdk/issues
+  changelog_uri: https://github.com/feathq/ruby-sdk/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: feat feature-flag SDK for Ruby (server-side, local evaluation)
+test_files: []