launchdarkly
diff --git a/‎.circleci/config.yml
+65 b/‎.circleci/config.yml
+65
diff --git a/‎azure-pipelines.yml
-51 b/‎azure-pipelines.yml
-51
diff --git a/‎contract-tests/client_entity.rb
+12 b/‎contract-tests/client_entity.rb
+12
diff --git a/‎contract-tests/service.rb
+2 b/‎contract-tests/service.rb
+2
diff --git a/‎lib/ldclient-rb/config.rb
+20 b/‎lib/ldclient-rb/config.rb
+20
diff --git a/‎lib/ldclient-rb/impl/evaluator.rb
+25-34 b/‎lib/ldclient-rb/impl/evaluator.rb
+25-34
diff --git a/‎lib/ldclient-rb/impl/evaluator_helpers.rb
+53 b/‎lib/ldclient-rb/impl/evaluator_helpers.rb
+53
@@ -1,9 +1,13 @@
 version: 2.1
 
+orbs:
+  win: circleci/windows@4.1.1
+
 workflows:
   version: 2
   test:
     jobs:
+      - build-test-windows
       - build-test-linux:
           name: Ruby 2.5
           docker-image: cimg/ruby:2.5
@@ -22,6 +26,67 @@ workflows:
           jruby: true
 
 jobs:
+  build-test-windows:
+    executor:
+      name: win/default
+
+    steps:
+      - checkout
+
+      - run:
+          name: "Setup DynamoDB"
+          command: |
+            iwr -outf dynamo.zip https://s3-us-west-2.amazonaws.com/dynamodb-local/dynamodb_local_latest.zip
+            mkdir dynamo
+            Expand-Archive -Path dynamo.zip -DestinationPath dynamo
+      - run:
+          name: "Run DynamoDB"
+          background: true
+          working_directory: dynamo
+          command: javaw -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar
+
+      - run:
+          name: "Setup Consul"
+          command: |
+            iwr -outf consul.zip https://releases.hashicorp.com/consul/1.4.2/consul_1.4.2_windows_amd64.zip
+            mkdir consul
+            Expand-Archive -Path consul.zip -DestinationPath consul
+            sc.exe create "Consul" binPath="C:/Users/circleci/project/consul/consul.exe agent -dev"
+      - run:
+          name: "Run Consul"
+          background: true
+          working_directory: consul
+          command: sc.exe start "Consul"
+
+      - run:
+          name: "Setup Redis"
+          command: |
+            iwr -outf redis.zip https://github.com/MicrosoftArchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip
+            mkdir redis
+            Expand-Archive -Path redis.zip -DestinationPath redis
+            cd redis
+            ./redis-server --service-install
+      - run:
+          name: "Run Redis"
+          background: true
+          working_directory: redis
+          command: |
+            ./redis-server --service-start
+
+      - run: ruby -v
+      - run: choco install msys2 --allow-downgrade -y --version 20200903.0.0
+      - run: ridk.cmd exec pacman -S --noconfirm --needed base-devel mingw-w64-x86_64-toolchain
+
+      - run: gem install bundler -v 2.2.33
+      - run: bundle _2.2.33_ install
+      - run: mkdir /tmp/circle-artifacts
+      - run: bundle _2.2.33_ exec rspec --format documentation --format RspecJunitFormatter -o /tmp/circle-artifacts/rspec.xml spec
+
+      - store_test_results:
+          path: /tmp/circle-artifacts
+      - store_artifacts:
+          path: /tmp/circle-artifacts
+
   build-test-linux:
     parameters:
       docker-image:
 
@@ -14,6 +14,11 @@ def initialize(log, config)
       streaming = config[:streaming]
       opts[:stream_uri] = streaming[:baseUri] if !streaming[:baseUri].nil?
       opts[:initial_reconnect_delay] = streaming[:initialRetryDelayMs] / 1_000.0 if !streaming[:initialRetryDelayMs].nil?
+    elsif config[:polling]
+      polling = config[:polling]
+      opts[:stream] = false
+      opts[:base_uri] = polling[:baseUri] if !polling[:baseUri].nil?
+      opts[:poll_interval] = polling[:pollIntervalMs] / 1_000.0 if !polling[:pollIntervalMs].nil?
     end
 
     if config[:events]
@@ -29,6 +34,13 @@ def initialize(log, config)
       opts[:send_events] = false
     end
 
+    if config[:tags]
+      opts[:application] = {
+        :id => config[:tags][:applicationId],
+        :version => config[:tags][:applicationVersion],
+      }
+    end
+
     startWaitTimeMs = config[:startWaitTimeMs] || 5_000
 
     @client = LaunchDarkly::LDClient.new(
 
@@ -25,9 +25,11 @@
   {
     capabilities: [
       'server-side',
+      'server-side-polling',
       'all-flags-with-reasons',
       'all-flags-client-side-only',
       'all-flags-details-only-for-tracked-flags',
+      'tags',
     ]
   }.to_json
 end
 
@@ -44,6 +44,7 @@ class Config
     # @option opts [String] :wrapper_version See {#wrapper_version}.
     # @option opts [#open] :socket_factory See {#socket_factory}.
     # @option opts [BigSegmentsConfig] :big_segments See {#big_segments}.
+    # @option opts [Hash] :application See {#application}
     #
     def initialize(opts = {})
       @base_uri = (opts[:base_uri] || Config.default_base_uri).chomp("/")
@@ -77,6 +78,7 @@ def initialize(opts = {})
       @wrapper_version = opts[:wrapper_version]
       @socket_factory = opts[:socket_factory]
       @big_segments = opts[:big_segments] || BigSegmentsConfig.new(store: nil)
+      @application = LaunchDarkly::Impl::Util.validate_application_info(opts[:application] || {}, @logger)
     end
 
     #
@@ -284,6 +286,24 @@ def offline?
     #
     attr_reader :big_segments
 
+    #
+    # An object that allows configuration of application metadata.
+    #
+    # Application metadata may be used in LaunchDarkly analytics or other product features, but does not affect feature flag evaluations.
+    #
+    # If you want to set non-default values for any of these fields, provide the appropriately configured hash to the {Config} object.
+    #
+    # @example Configuring application information
+    #   opts[:application] = {
+    #     id: "MY APPLICATION ID",
+    #     version: "MY APPLICATION VERSION"
+    #   }
+    #   config = LDConfig.new(opts)
+    #
+    # @return [Hash]
+    #
+    attr_reader :application
+
     # @deprecated This is replaced by {#data_source}.
     attr_reader :update_processor
 
 
@@ -1,5 +1,6 @@
 require "ldclient-rb/evaluation_detail"
 require "ldclient-rb/impl/evaluator_bucketing"
+require "ldclient-rb/impl/evaluator_helpers"
 require "ldclient-rb/impl/evaluator_operators"
 
 module LaunchDarkly
@@ -87,19 +88,17 @@ def self.make_big_segment_ref(segment)  # method is visible for testing
 
       def eval_internal(flag, user, state)
         if !flag[:on]
-          return get_off_value(flag, EvaluationReason::off)
+          return EvaluatorHelpers.off_result(flag)
         end
 
-        prereq_failure_reason = check_prerequisites(flag, user, state)
-        if !prereq_failure_reason.nil?
-          return get_off_value(flag, prereq_failure_reason)
-        end
+        prereq_failure_result = check_prerequisites(flag, user, state)
+        return prereq_failure_result if !prereq_failure_result.nil?
 
         # Check user target matches
         (flag[:targets] || []).each do |target|
           (target[:values] || []).each do |value|
             if value == user[:key]
-              return get_variation(flag, target[:variation], EvaluationReason::target_match)
+              return EvaluatorHelpers.target_match_result(target, flag)
             end
           end
         end
@@ -111,13 +110,15 @@ def eval_internal(flag, user, state)
           if rule_match_user(rule, user, state)
             reason = rule[:_reason]  # try to use cached reason for this rule
             reason = EvaluationReason::rule_match(i, rule[:id]) if reason.nil?
-            return get_value_for_variation_or_rollout(flag, rule, user, reason)
+            return get_value_for_variation_or_rollout(flag, rule, user, reason,
+              EvaluatorHelpers.rule_precomputed_results(rule))
           end
         end
 
         # Check the fallthrough rule
         if !flag[:fallthrough].nil?
-          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough)
+          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough,
+            EvaluatorHelpers.fallthrough_precomputed_results(flag))
         end
 
         return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
@@ -149,8 +150,7 @@ def check_prerequisites(flag, user, state)
             end
           end
           if !prereq_ok
-            reason = prerequisite[:_reason]  # try to use cached reason
-            return reason.nil? ? EvaluationReason::prerequisite_failed(prereq_key) : reason
+            return EvaluatorHelpers.prerequisite_failed_result(prerequisite, flag)
           end
         end
         nil
@@ -253,35 +253,26 @@ def segment_rule_match_user(rule, user, segment_key, salt)
       end
 
       private
-
-      def get_variation(flag, index, reason)
-        if index < 0 || index >= flag[:variations].length
-          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index")
-          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
-        end
-        EvaluationDetail.new(flag[:variations][index], index, reason)
-      end
-
-      def get_off_value(flag, reason)
-        if flag[:offVariation].nil?  # off variation unspecified - return default value
-          return EvaluationDetail.new(nil, nil, reason)
-        end
-        get_variation(flag, flag[:offVariation], reason)
-      end
-
-      def get_value_for_variation_or_rollout(flag, vr, user, reason)
+      
+      def get_value_for_variation_or_rollout(flag, vr, user, reason, precomputed_results)
         index, in_experiment = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
-        #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
-        if in_experiment && reason.kind == :FALLTHROUGH
-          reason = EvaluationReason::fallthrough(in_experiment)
-        elsif in_experiment && reason.kind == :RULE_MATCH
-          reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
-        end
         if index.nil?
           @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": variation/rollout object with no variation or rollout")
           return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
         end
-        return get_variation(flag, index, reason)
+        if precomputed_results
+          return precomputed_results.for_variation(index, in_experiment)
+        else
+          #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
+          if in_experiment
+            if reason.kind == :FALLTHROUGH
+              reason = EvaluationReason::fallthrough(in_experiment)
+            elsif reason.kind == :RULE_MATCH
+              reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
+            end
+          end
+          return EvaluatorHelpers.evaluation_detail_for_variation(flag, index, reason)
+        end
       end
     end
   end
 
@@ -0,0 +1,53 @@
+require "ldclient-rb/evaluation_detail"
+
+# This file contains any pieces of low-level evaluation logic that don't need to be inside the Evaluator
+# class, because they don't depend on any SDK state outside of their input parameters.
+
+module LaunchDarkly
+  module Impl
+    module EvaluatorHelpers
+      def self.off_result(flag, logger = nil)
+        pre = flag[:_preprocessed]
+        pre ? pre.off_result : evaluation_detail_for_off_variation(flag, EvaluationReason::off, logger)
+      end
+
+      def self.target_match_result(target, flag, logger = nil)
+        pre = target[:_preprocessed]
+        pre ? pre.match_result : evaluation_detail_for_variation(
+          flag, target[:variation], EvaluationReason::target_match, logger)
+      end
+
+      def self.prerequisite_failed_result(prereq, flag, logger = nil)
+        pre = prereq[:_preprocessed]
+        pre ? pre.failed_result : evaluation_detail_for_off_variation(
+          flag, EvaluationReason::prerequisite_failed(prereq[:key]), logger
+        )
+      end
+
+      def self.fallthrough_precomputed_results(flag)
+        pre = flag[:_preprocessed]
+        pre ? pre.fallthrough_factory : nil
+      end
+
+      def self.rule_precomputed_results(rule)
+        pre = rule[:_preprocessed]
+        pre ? pre.all_match_results : nil
+      end
+
+      def self.evaluation_detail_for_off_variation(flag, reason, logger = nil)
+        index = flag[:offVariation]
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason, logger)
+      end
+
+      def self.evaluation_detail_for_variation(flag, index, reason, logger = nil)
+        vars = flag[:variations] || []
+        if index < 0 || index >= vars.length
+          logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index") unless logger.nil?
+          EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        else
+          EvaluationDetail.new(vars[index], index, reason)
+        end
+      end
+    end
+  end
+end
Original file line number	Diff line number	Diff line change
`@@ -25,9 +25,11 @@`
`25`	`25`	`{`
`26`	`26`	`capabilities: [`
`27`	`27`	`'server-side',`
	`28`	`+ 'server-side-polling',`
`28`	`29`	`'all-flags-with-reasons',`
`29`	`30`	`'all-flags-client-side-only',`
`30`	`31`	`'all-flags-details-only-for-tracked-flags',`
	`32`	`+ 'tags',`
`31`	`33`	`]`
`32`	`34`	`}.to_json`
`33`	`35`	`end`