subflag-rails 0.3.0 → 0.5.0

data/lib/subflag/rails/targeting.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "targeting_engine"
+
+module Subflag
+  module Rails
+    # Targeting module for evaluating rules that control who sees what flag values.
+    #
+    # Rules are stored as JSON in the database and evaluated at runtime.
+    # Use targeting to roll out features to internal teams before wider release.
+    #
+    # ## Rule Format
+    #
+    # Rules are an array of objects, each with a `value` and `conditions`:
+    #
+    #   [
+    #     {
+    #       "value" => "true",
+    #       "conditions" => {
+    #         "type" => "OR",
+    #         "conditions" => [
+    #           { "attribute" => "email", "operator" => "ENDS_WITH", "value" => "@company.com" },
+    #           { "attribute" => "role", "operator" => "IN", "value" => ["admin", "qa"] }
+    #         ]
+    #       }
+    #     }
+    #   ]
+    #
+    # ## Supported Operators
+    #
+    # - EQUALS, NOT_EQUALS - exact match
+    # - IN, NOT_IN - list membership
+    # - CONTAINS, NOT_CONTAINS - substring match
+    # - STARTS_WITH, ENDS_WITH - prefix/suffix match
+    # - GREATER_THAN, LESS_THAN, GREATER_THAN_OR_EQUAL, LESS_THAN_OR_EQUAL - numeric
+    # - MATCHES - regex match
+    #
+    # ## Evaluation
+    #
+    # Rules are evaluated in order. First match wins.
+    # If no rules match, the flag's default value is returned.
+    #
+    # TODO: Add admin UI for managing targeting rules
+    #
+    module Targeting
+    end
+  end
+end

data/lib/subflag/rails/targeting_engine.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Subflag
+  module Rails
+    # Evaluates targeting rules against evaluation contexts.
+    #
+    # Rules are arrays of { "value" => X, "conditions" => {...} } hashes.
+    # First matching rule wins. Falls back to flag's default value if nothing matches.
+    #
+    # @example Rule structure
+    #   [
+    #     {
+    #       "value" => "100",
+    #       "conditions" => {
+    #         "type" => "OR",
+    #         "conditions" => [
+    #           { "attribute" => "email", "operator" => "ENDS_WITH", "value" => "@company.com" },
+    #           { "attribute" => "role", "operator" => "IN", "value" => ["admin", "developer"] }
+    #         ]
+    #       }
+    #     }
+    #   ]
+    #
+    module TargetingEngine
+      OPERATORS = %w[
+        EQUALS NOT_EQUALS IN NOT_IN
+        CONTAINS NOT_CONTAINS STARTS_WITH ENDS_WITH
+        GREATER_THAN LESS_THAN GREATER_THAN_OR_EQUAL LESS_THAN_OR_EQUAL
+        MATCHES
+      ].freeze
+
+      class << self
+        # Evaluate targeting rules against a context
+        #
+        # @param rules [Array<Hash>, nil] Array of targeting rules with values
+        # @param context [Hash, nil] Evaluation context with attributes
+        # @return [String, nil] The matched rule's value, or nil if no match
+        def evaluate(rules, context)
+          return nil if rules.nil? || rules.empty?
+          return nil if context.nil? || context.empty?
+
+          # Normalize context keys to strings for comparison
+          normalized_context = normalize_context(context)
+
+          rules.each do |rule|
+            rule = rule.transform_keys(&:to_s)
+            conditions = rule["conditions"]
+            next unless conditions
+
+            if evaluate_rule(conditions, normalized_context)
+              return rule["value"]
+            end
+          end
+
+          nil # No rules matched
+        end
+
+        private
+
+        def normalize_context(context)
+          context.transform_keys(&:to_s).transform_values do |v|
+            v.is_a?(Symbol) ? v.to_s : v
+          end
+        end
+
+        # Evaluate an AND/OR rule block
+        def evaluate_rule(rule, context)
+          rule = rule.transform_keys(&:to_s)
+          type = rule["type"]&.upcase || "AND"
+          conditions = rule["conditions"] || []
+
+          case type
+          when "AND"
+            conditions.all? { |c| evaluate_condition(c, context) }
+          when "OR"
+            conditions.any? { |c| evaluate_condition(c, context) }
+          else
+            false
+          end
+        end
+
+        # Evaluate a single condition
+        def evaluate_condition(condition, context)
+          condition = condition.transform_keys(&:to_s)
+          attribute = condition["attribute"]
+          operator = condition["operator"]&.upcase
+          expected = condition["value"]
+
+          return false unless attribute && operator
+
+          actual = context[attribute]
+          return false if actual.nil?
+
+          case operator
+          when "EQUALS"
+            compare_equals(actual, expected)
+          when "NOT_EQUALS"
+            !compare_equals(actual, expected)
+          when "IN"
+            compare_in(actual, expected)
+          when "NOT_IN"
+            !compare_in(actual, expected)
+          when "CONTAINS"
+            compare_contains(actual, expected)
+          when "NOT_CONTAINS"
+            !compare_contains(actual, expected)
+          when "STARTS_WITH"
+            compare_starts_with(actual, expected)
+          when "ENDS_WITH"
+            compare_ends_with(actual, expected)
+          when "GREATER_THAN"
+            compare_numeric(actual, expected) { |a, e| a > e }
+          when "LESS_THAN"
+            compare_numeric(actual, expected) { |a, e| a < e }
+          when "GREATER_THAN_OR_EQUAL"
+            compare_numeric(actual, expected) { |a, e| a >= e }
+          when "LESS_THAN_OR_EQUAL"
+            compare_numeric(actual, expected) { |a, e| a <= e }
+          when "MATCHES"
+            compare_matches(actual, expected)
+          else
+            false
+          end
+        end
+
+        def compare_equals(actual, expected)
+          normalize_value(actual) == normalize_value(expected)
+        end
+
+        def compare_in(actual, expected)
+          return false unless expected.is_a?(Array)
+
+          normalized_actual = normalize_value(actual)
+          expected.any? { |e| normalize_value(e) == normalized_actual }
+        end
+
+        def compare_contains(actual, expected)
+          actual.to_s.include?(expected.to_s)
+        end
+
+        def compare_starts_with(actual, expected)
+          actual.to_s.start_with?(expected.to_s)
+        end
+
+        def compare_ends_with(actual, expected)
+          actual.to_s.end_with?(expected.to_s)
+        end
+
+        def compare_numeric(actual, expected)
+          a = to_number(actual)
+          e = to_number(expected)
+          return false if a.nil? || e.nil?
+
+          yield(a, e)
+        end
+
+        def compare_matches(actual, expected)
+          Regexp.new(expected.to_s).match?(actual.to_s)
+        rescue RegexpError
+          false
+        end
+
+        def normalize_value(value)
+          case value
+          when Symbol then value.to_s
+          when TrueClass then true
+          when FalseClass then false
+          when Numeric then value
+          else value.to_s
+          end
+        end
+
+        def to_number(value)
+          case value
+          when Numeric then value
+          when String
+            if value.include?(".")
+              Float(value)
+            else
+              Integer(value)
+            end
+          else
+            nil
+          end
+        rescue ArgumentError, TypeError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/subflag/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Subflag
   module Rails
-    VERSION = "0.3.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/subflag/rails.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "open_feature/sdk"
-require "subflag"
 
 require_relative "rails/version"
 require_relative "rails/configuration"
@@ -12,6 +11,7 @@ require_relative "rails/client"
 require_relative "rails/flag_accessor"
 require_relative "rails/helpers"
 require_relative "rails/railtie" if defined?(Rails::Railtie)
+require_relative "rails/engine" if defined?(Rails::Engine)
 
 # Test helpers are loaded separately: require "subflag/rails/test_helpers"
 
@@ -27,14 +27,25 @@ module Subflag
 
       # Configure Subflag for Rails
       #
-      # @example
+      # @example Using Subflag Cloud (SaaS)
       #   Subflag::Rails.configure do |config|
+      #     config.backend = :subflag
       #     config.api_key = Rails.application.credentials.subflag_api_key
       #     config.user_context do |user|
       #       { targeting_key: user.id.to_s, email: user.email, plan: user.plan }
       #     end
       #   end
       #
+      # @example Using ActiveRecord (self-hosted)
+      #   Subflag::Rails.configure do |config|
+      #     config.backend = :active_record
+      #   end
+      #
+      # @example Using Memory (testing)
+      #   Subflag::Rails.configure do |config|
+      #     config.backend = :memory
+      #   end
+      #
       # @yield [Configuration]
       def configure
         yield(configuration)
@@ -48,6 +59,16 @@ module Subflag
         @client ||= Client.new
       end
 
+      # Access the current provider instance
+      #
+      # Useful for the Memory backend where you can set flags directly:
+      #   Subflag::Rails.provider.set(:my_flag, true)
+      #
+      # @return [Object] The current OpenFeature provider
+      def provider
+        @provider
+      end
+
       # Prefetch all flags for a user/context in a single API call
       #
       # Call this early in a request to fetch all flags at once.
@@ -72,21 +93,53 @@ module Subflag
       def reset!
         @configuration = Configuration.new
         @client = nil
+        @provider = nil
       end
 
       private
 
       def setup_provider
-        return unless configuration.api_key
+        @provider = build_provider
+        return unless @provider
 
-        provider = ::Subflag::Provider.new(
+        OpenFeature::SDK.configure do |config|
+          config.set_provider(@provider)
+        end
+      end
+
+      def build_provider
+        case configuration.backend
+        when :subflag
+          build_subflag_provider
+        when :active_record
+          build_active_record_provider
+        when :memory
+          build_memory_provider
+        else
+          raise ArgumentError, "Unknown backend: #{configuration.backend}. Use :subflag, :active_record, or :memory"
+        end
+      end
+
+      def build_subflag_provider
+        return nil unless configuration.api_key
+
+        require_relative "rails/backends/subflag_provider"
+        Backends::SubflagProvider.new(
           api_key: configuration.api_key,
           api_url: configuration.api_url
         )
+      end
 
-        OpenFeature::SDK.configure do |config|
-          config.set_provider(provider)
-        end
+      def build_active_record_provider
+        require_relative "rails/targeting"
+        require_relative "rails/backends/active_record_provider"
+        require_relative "rails/models/flag"
+        Backends::ActiveRecordProvider.new
+      end
+
+      def build_memory_provider
+        require_relative "rails/backends/memory_provider"
+        Backends::MemoryProvider.new
       end
     end
   end

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: subflag-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Subflag
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-08 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: subflag-openfeature-provider
+  name: openfeature-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.0'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.1
+        version: '0.3'
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.0'
@@ -170,9 +170,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.1'
-description: Rails integration for Subflag feature flags. Get typed values (boolean,
-  string, integer, double, object) with user targeting. Includes generators, view
-  helpers, and ActiveRecord context integration.
+description: Feature flags for Rails with pluggable backends. Use Subflag Cloud (SaaS),
+  ActiveRecord (self-hosted), or Memory (testing). Get typed values (boolean, string,
+  integer, double, object) with the same API regardless of backend.
 email:
 - support@subflag.com
 executables: []
@@ -183,17 +183,25 @@ files:
 - LICENSE.txt
 - README.md
 - lib/generators/subflag/install_generator.rb
-- lib/generators/subflag/templates/initializer.rb
+- lib/generators/subflag/templates/create_subflag_flags.rb.tt
+- lib/generators/subflag/templates/initializer.rb.tt
 - lib/subflag-rails.rb
 - lib/subflag/rails.rb
+- lib/subflag/rails/backends/active_record_provider.rb
+- lib/subflag/rails/backends/memory_provider.rb
+- lib/subflag/rails/backends/subflag_provider.rb
 - lib/subflag/rails/client.rb
 - lib/subflag/rails/configuration.rb
 - lib/subflag/rails/context_builder.rb
+- lib/subflag/rails/engine.rb
 - lib/subflag/rails/evaluation_result.rb
 - lib/subflag/rails/flag_accessor.rb
 - lib/subflag/rails/helpers.rb
+- lib/subflag/rails/models/flag.rb
 - lib/subflag/rails/railtie.rb
 - lib/subflag/rails/request_cache.rb
+- lib/subflag/rails/targeting.rb
+- lib/subflag/rails/targeting_engine.rb
 - lib/subflag/rails/test_helpers.rb
 - lib/subflag/rails/version.rb
 homepage: https://subflag.com