featurevisor 0.3.0 → 1.1.0

data/bin/commands/assess_distribution.rb

@@ -29,13 +29,21 @@ module FeaturevisorCLI
           exit 1
         end
 
-        puts ""
-        puts "Assessing distribution for feature: \"#{@options.feature}\"..."
-        puts ""
-
-        # Parse context if provided
         context = parse_context
 
+        targets = resolve_targets
+        (targets.empty? ? [nil] : targets).each { |target| run_for_target(context, target) }
+      end
+
+      private
+
+      def run_for_target(context, target)
+        puts "\nAssess Featurevisor distribution"
+        puts "  Feature: #{@options.feature}"
+        puts "  Environment: #{@options.environment}"
+        puts "  Target: #{target}" if target
+        puts "  Iterations: #{@options.n}"
+
         # Print context information
         if @options.context
           puts "Against context: #{@options.context}"
@@ -47,10 +55,10 @@ module FeaturevisorCLI
         puts ""
 
         # Build datafile
-        datafile = build_datafile(@options.environment)
+        datafile = build_datafile(@options.environment, target)
 
         # Create SDK instance
-        instance = create_instance(datafile)
+        instance = create_featurevisor(datafile)
 
         # Check if feature has variations
         feature = instance.get_feature(@options.feature)
@@ -104,7 +112,21 @@ module FeaturevisorCLI
         end
       end
 
-      private
+      def resolve_targets
+        return [] if @options.targets.empty?
+        stdout, stderr, status = Open3.capture3("npx", "featurevisor", "list", "--targets", "--json", chdir: @project_path)
+        unless status.success?
+          puts stderr
+          exit 1
+        end
+        available = JSON.parse(stdout).map { |item| item.is_a?(Hash) ? (item["key"] || item["name"]) : item }
+        unknown = @options.targets.find { |target| !available.include?(target) }
+        if unknown
+          puts "Unknown target \"#{unknown}\". Available targets: #{available.empty? ? "none" : available.join(", ")}."
+          exit 1
+        end
+        @options.targets
+      end
 
       def parse_context
         if @options.context
@@ -121,15 +143,12 @@ module FeaturevisorCLI
         end
       end
 
-      def build_datafile(environment)
+      def build_datafile(environment, target = nil)
         puts "Building datafile for environment: #{environment}..."
 
         # Build the command similar to Go implementation
         command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--json"]
-
-        if @options.schema_version
-          command_parts << "--schemaVersion=#{@options.schema_version}"
-        end
+        command_parts << "--target=#{target}" if target
 
         if @options.inflate
           command_parts << "--inflate=#{@options.inflate}"
@@ -159,9 +178,9 @@ module FeaturevisorCLI
         [stdout, stderr, exit_status.exitstatus]
       end
 
-      def create_instance(datafile)
+      def create_featurevisor(datafile)
         # Create SDK instance
-        Featurevisor.create_instance(
+        Featurevisor.create_featurevisor(
           datafile: datafile,
           log_level: get_logger_level
         )

data/bin/commands/benchmark.rb

@@ -27,29 +27,32 @@ module FeaturevisorCLI
           exit 1
         end
 
-        puts ""
-        puts "Running benchmark for feature \"#{@options.feature}\"..."
-        puts ""
-
-        # Parse context if provided
         context = parse_context
+        targets = resolve_targets
+        (targets.empty? ? [nil] : targets).each { |target| run_for_target(context, target) }
+      end
 
-        puts "Building datafile containing all features for \"#{@options.environment}\"..."
-        datafile_build_start = Time.now
+      private
 
-        # Build datafile by executing the featurevisor build command
-        datafile = build_datafile(@options.environment)
+      def run_for_target(context, target)
+        datafile_build_start = Time.now
+        datafile = build_datafile(@options.environment, target)
         datafile_build_duration = Time.now - datafile_build_start
         datafile_build_duration_ms = (datafile_build_duration * 1000).round
 
-        puts "Datafile build duration: #{datafile_build_duration_ms}ms"
+        puts "\nBenchmark Featurevisor feature"
+        puts "  Feature: #{@options.feature}"
+        puts "  Environment: #{@options.environment}"
+        puts "  Target: #{target}" if target
+        puts "  Iterations: #{@options.n}"
+        puts "  Build duration: #{datafile_build_duration_ms}ms"
 
         # Calculate datafile size
         datafile_size = datafile.to_json.bytesize
         puts "Datafile size: #{(datafile_size / 1024.0).round(2)} kB"
 
         # Create SDK instance with the datafile
-        instance = create_instance(datafile)
+        instance = create_featurevisor(datafile)
         puts "...SDK initialized"
 
         puts ""
@@ -73,10 +76,26 @@ module FeaturevisorCLI
         value_output = format_value(output[:value])
         puts "Evaluated value : #{value_output}"
         puts "Total duration  : #{pretty_duration(output[:duration])}"
-        puts "Average duration: #{pretty_duration(output[:duration] / @options.n)}"
+        puts "Minimum duration: #{format_duration_ms(output[:min_duration])}"
+        puts "Average duration: #{format_duration_ms(output[:average_duration])}"
+        puts "Maximum duration: #{format_duration_ms(output[:max_duration])}"
       end
 
-      private
+      def resolve_targets
+        return [] if @options.targets.empty?
+        stdout, stderr, status = Open3.capture3("npx", "featurevisor", "list", "--targets", "--json", chdir: @project_path)
+        unless status.success?
+          puts stderr
+          exit 1
+        end
+        available = JSON.parse(stdout).map { |target| target.is_a?(Hash) ? (target["key"] || target["name"]) : target }
+        unknown = @options.targets.find { |target| !available.include?(target) }
+        if unknown
+          puts "Unknown target \"#{unknown}\". Available targets: #{available.empty? ? "none" : available.join(", ")}."
+          exit 1
+        end
+        @options.targets
+      end
 
       def parse_context
         if @options.context
@@ -93,24 +112,15 @@ module FeaturevisorCLI
         end
       end
 
-      def build_datafile(environment)
+      def build_datafile(environment, target = nil)
         puts "Building datafile for environment: #{environment}..."
 
-        # Build the command similar to Go implementation
         command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--json"]
-
-        # Add schema version if specified
-        if @options.schema_version && !@options.schema_version.empty?
-          command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{@options.schema_version}", "--json"]
-        end
+        command_parts << "--target=#{target}" if target
 
         # Add inflate if specified
         if @options.inflate && @options.inflate > 0
-          if @options.schema_version && !@options.schema_version.empty?
-            command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{@options.schema_version}", "--inflate=#{@options.inflate}", "--json"]
-          else
-            command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--inflate=#{@options.inflate}", "--json"]
-          end
+          command_parts << "--inflate=#{@options.inflate}"
         end
 
         command = command_parts.join(" ")
@@ -142,9 +152,9 @@ module FeaturevisorCLI
         stdout
       end
 
-      def create_instance(datafile)
+      def create_featurevisor(datafile)
         # Create a real Featurevisor instance
-        instance = Featurevisor.create_instance(
+        instance = Featurevisor.create_featurevisor(
           log_level: get_logger_level
         )
 
@@ -164,61 +174,53 @@ module FeaturevisorCLI
         end
       end
 
-      def benchmark_feature_flag(instance, feature_key, context, n)
-        start_time = Time.now
-
-        # Get the actual feature value from the SDK
-        value = instance.is_enabled(feature_key, context)
+      def benchmark_evaluation(n)
+        value = nil
+        total_duration_ns = 0
+        min_duration_ns = nil
+        max_duration_ns = 0
 
-        # Benchmark the evaluation
         n.times do
-          instance.is_enabled(feature_key, context)
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+          value = yield
+          duration_ns = Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond) - start_time
+
+          total_duration_ns += duration_ns
+          min_duration_ns = duration_ns if min_duration_ns.nil? || duration_ns < min_duration_ns
+          max_duration_ns = duration_ns if duration_ns > max_duration_ns
         end
 
-        duration = Time.now - start_time
+        duration = total_duration_ns / 1_000_000_000.0
 
         {
           value: value,
-          duration: duration
+          duration: duration,
+          min_duration: (min_duration_ns || 0) / 1_000_000_000.0,
+          average_duration: duration / n,
+          max_duration: max_duration_ns / 1_000_000_000.0
         }
       end
 
-      def benchmark_feature_variation(instance, feature_key, context, n)
-        start_time = Time.now
+      def format_duration_ms(duration)
+        format("%.6fms", duration * 1000)
+      end
 
-        # Get the actual feature variation from the SDK
-        value = instance.get_variation(feature_key, context)
+      def benchmark_feature_flag(instance, feature_key, context, n)
+        benchmark_evaluation(n) do
+          instance.is_enabled(feature_key, context)
+        end
+      end
 
-        # Benchmark the evaluation
-        n.times do
+      def benchmark_feature_variation(instance, feature_key, context, n)
+        benchmark_evaluation(n) do
           instance.get_variation(feature_key, context)
         end
-
-        duration = Time.now - start_time
-
-        {
-          value: value,
-          duration: duration
-        }
       end
 
       def benchmark_feature_variable(instance, feature_key, variable_key, context, n)
-        start_time = Time.now
-
-        # Get the actual variable value from the SDK
-        value = instance.get_variable(feature_key, variable_key, context)
-
-        # Benchmark the evaluation
-        n.times do
+        benchmark_evaluation(n) do
           instance.get_variable(feature_key, variable_key, context)
         end
-
-        duration = Time.now - start_time
-
-        {
-          value: value,
-          duration: duration
-        }
       end
 
       def format_value(value)

data/bin/commands/test.rb

@@ -21,16 +21,17 @@ module FeaturevisorCLI
         # Get project configuration
         config = get_config
         environments = get_environments(config)
-        segments_by_key = get_segments
-
-        # Use CLI schemaVersion option or fallback to config
-        schema_version = @options.schema_version
-        if schema_version.nil? || schema_version.empty?
-          schema_version = config[:schemaVersion]
+        available_targets = get_targets
+        unknown_target = @options.targets.find { |target| !available_targets.include?(target) }
+        if unknown_target
+          puts "Unknown target \"#{unknown_target}\". Available targets: #{available_targets.empty? ? "none" : available_targets.join(", ")}."
+          exit 1
         end
+        targets = @options.targets.empty? ? available_targets : @options.targets
+        segments_by_key = get_segments
 
-        # Build datafiles for all environments (+ scoped/tagged variants)
-        datafiles_by_key = build_datafiles(config, environments, schema_version, @options.inflate)
+        # Build base and Target datafiles for all environments.
+        datafiles_by_key = build_datafiles(environments, targets, @options.inflate)
 
         puts ""
 
@@ -84,6 +85,34 @@ module FeaturevisorCLI
         end
       end
 
+      def get_targets
+        puts "Getting targets..."
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor list --targets --json)"
+        targets_output = execute_command(command)
+
+        begin
+          targets = JSON.parse(targets_output, symbolize_names: true)
+
+          if targets.is_a?(Array)
+            targets.filter_map do |target|
+              if target.is_a?(Hash)
+                target[:name] || target[:key]
+              else
+                target
+              end
+            end
+          elsif targets.is_a?(Hash)
+            targets.keys
+          else
+            []
+          end
+        rescue JSON::ParserError => e
+          puts "Error: Failed to parse targets JSON: #{e.message}"
+          puts "Command output: #{targets_output}"
+          exit 1
+        end
+      end
+
       def get_environments(config)
         environments = config[:environments]
 
@@ -97,23 +126,15 @@ module FeaturevisorCLI
         environment == false ? false : environment
       end
 
-      def scoped_datafile_key(environment, scope_name)
-        if environment == false
-          "scope-#{scope_name}"
-        else
-          "#{environment}-scope-#{scope_name}"
-        end
-      end
-
-      def tagged_datafile_key(environment, tag)
+      def target_datafile_key(environment, target)
         if environment == false
-          "tag-#{tag}"
+          "false-target-#{target}"
         else
-          "#{environment}-tag-#{tag}"
+          "#{environment}-target-#{target}"
         end
       end
 
-      def build_datafiles(config, environments, schema_version, inflate)
+      def build_datafiles(environments, targets, inflate)
         datafiles_by_key = {}
 
         environments.each do |environment|
@@ -122,61 +143,35 @@ module FeaturevisorCLI
 
           datafiles_by_key[base_datafile_key(environment)] = build_single_datafile(
             environment: environment,
-            schema_version: schema_version,
             inflate: inflate
           )
 
-          if @options.with_scopes && config[:scopes].is_a?(Array)
-            config[:scopes].each do |scope|
-              next unless scope[:name]
-
-              puts "Building scoped datafile for scope: #{scope[:name]}..."
-              datafiles_by_key[scoped_datafile_key(environment, scope[:name])] = build_single_datafile(
-                environment: environment,
-                schema_version: schema_version,
-                inflate: inflate,
-                scope: scope[:name]
-              )
-            end
-          end
-
-          if @options.with_tags && config[:tags].is_a?(Array)
-            config[:tags].each do |tag|
-              puts "Building tagged datafile for tag: #{tag}..."
-              datafiles_by_key[tagged_datafile_key(environment, tag)] = build_single_datafile(
-                environment: environment,
-                schema_version: schema_version,
-                inflate: inflate,
-                tag: tag
-              )
-            end
+          targets.each do |target|
+            puts "Building datafile for target: #{target}..."
+            datafiles_by_key[target_datafile_key(environment, target)] = build_single_datafile(
+              environment: environment,
+              inflate: inflate,
+              target: target
+            )
           end
         end
 
         datafiles_by_key
       end
 
-      def build_single_datafile(environment:, schema_version:, inflate:, scope: nil, tag: nil)
+      def build_single_datafile(environment:, inflate:, target: nil)
         command_parts = ["npx", "featurevisor", "build", "--json"]
 
         if environment != false && !environment.nil?
           command_parts << "--environment=#{Shellwords.escape(environment.to_s)}"
         end
 
-        if schema_version && !schema_version.empty?
-          command_parts << "--schemaVersion=#{Shellwords.escape(schema_version.to_s)}"
-        end
-
         if inflate && inflate > 0
           command_parts << "--inflate=#{inflate}"
         end
 
-        if scope
-          command_parts << "--scope=#{Shellwords.escape(scope.to_s)}"
-        end
-
-        if tag
-          command_parts << "--tag=#{Shellwords.escape(tag.to_s)}"
+        if target
+          command_parts << "--target=#{Shellwords.escape(target.to_s)}"
         end
 
         command = "(cd #{Shellwords.escape(@project_path)} && #{command_parts.join(' ')})"
@@ -224,29 +219,15 @@ module FeaturevisorCLI
         end
       end
 
-      def get_scope_context(config, scope_name)
-        return {} unless scope_name && config[:scopes].is_a?(Array)
-
-        scope = config[:scopes].find { |s| s[:name] == scope_name }
-        return {} unless scope && scope[:context].is_a?(Hash)
-
-        parse_context(scope[:context])
-      end
-
       def resolve_datafile_for_assertion(assertion, datafiles_by_key)
         environment = assertion.key?(:environment) ? assertion[:environment] : false
         environment = false if environment.nil?
 
-        scoped_key = assertion[:scope] ? scoped_datafile_key(environment, assertion[:scope]) : nil
-        tagged_key = assertion[:tag] ? tagged_datafile_key(environment, assertion[:tag]) : nil
+        target_key = assertion[:target] ? target_datafile_key(environment, assertion[:target]) : nil
         base_key = base_datafile_key(environment)
 
-        if scoped_key && datafiles_by_key.key?(scoped_key)
-          return datafiles_by_key[scoped_key]
-        end
-
-        if tagged_key && datafiles_by_key.key?(tagged_key)
-          return datafiles_by_key[tagged_key]
+        if target_key && datafiles_by_key.key?(target_key)
+          return datafiles_by_key[target_key]
         end
 
         datafiles_by_key[base_key]
@@ -255,19 +236,19 @@ module FeaturevisorCLI
       def create_tester_instance(datafile, level, assertion)
         sticky = parse_sticky(assertion[:sticky])
 
-        Featurevisor.create_instance(
+        Featurevisor.create_featurevisor(
           datafile: datafile,
           sticky: sticky,
           log_level: level,
-          hooks: [
+          modules: [
             {
-              name: "tester-hook",
+              name: "test-module",
               bucket_value: ->(options) do
                 at = assertion[:at]
                 if at.is_a?(Numeric)
                   (at * 1000).to_i
                 else
-                  options.bucket_value
+                  options[:bucket_value]
                 end
               end
             }
@@ -284,6 +265,12 @@ module FeaturevisorCLI
         tests.each do |test|
           test_key = test[:key]
           assertions = test[:assertions] || []
+          if test[:feature] && !@options.targets.empty?
+            assertions = assertions.select do |assertion|
+              assertion[:target].nil? || @options.targets.include?(assertion[:target])
+            end
+            next if assertions.empty?
+          end
           results = ""
           test_has_error = false
           test_duration = 0.0
@@ -297,19 +284,13 @@ module FeaturevisorCLI
                 if datafile.nil?
                   test_result = {
                     has_error: true,
-                    errors: "      ✘ no datafile found for assertion scope/tag/environment combination\n",
+                    errors: "      ✘ no datafile found for assertion target/environment combination\n",
                     duration: 0
                   }
                 end
 
                 if datafile
                   instance = create_tester_instance(datafile, level, assertion)
-                  scope_context = {}
-
-                  if assertion[:scope] && !@options.with_scopes
-                    # If not using scoped datafiles, mimic JS behavior by merging scope context.
-                    scope_context = get_scope_context(config, assertion[:scope])
-                  end
 
                   # Show datafile if requested
                   if @options.show_datafile
@@ -318,7 +299,7 @@ module FeaturevisorCLI
                     puts ""
                   end
 
-                  test_result = run_test_feature(assertion, test[:feature], instance, level, scope_context)
+                  test_result = run_test_feature(assertion, test[:feature], instance, level)
                 end
               elsif test[:segment]
                 segment_key = test[:segment]
@@ -366,9 +347,8 @@ module FeaturevisorCLI
         end
       end
 
-      def run_test_feature(assertion, feature_key, instance, level, scope_context = {})
+      def run_test_feature(assertion, feature_key, instance, level)
         context = parse_context(assertion[:context])
-        context = { **scope_context, **context } if scope_context && !scope_context.empty?
         sticky = parse_sticky(assertion[:sticky])
 
         # Set context and sticky for this assertion
@@ -680,7 +660,7 @@ module FeaturevisorCLI
         }
 
         # Create SDK instance for segment testing
-        instance = Featurevisor.create_instance(
+        instance = Featurevisor.create_featurevisor(
           datafile: datafile,
           log_level: level
         )
@@ -768,16 +748,14 @@ module FeaturevisorCLI
           return instance.send(method_name, feature_key, variable_key, context, override_options)
         end
 
-        if instance.respond_to?(:parent) && instance.respond_to?(:sticky)
-          parent = instance.parent
-          combined_context = if instance.respond_to?(:context)
-            { **(instance.context || {}), **context }
-          else
-            context
-          end
+        if instance.is_a?(Featurevisor::ChildInstance)
+          parent = instance.instance_variable_get(:@parent)
+          child_context = instance.instance_variable_get(:@context) || {}
+          child_sticky = instance.instance_variable_get(:@sticky)
+          combined_context = { **child_context, **context }
 
           combined_options = {
-            sticky: instance.sticky,
+            __featurevisor_child_sticky: child_sticky,
             **override_options
           }