3.0.0

circle.yml

@@ -1,31 +1,33 @@
 machine:
   environment:
-    RUBIES: "ruby-2.4.1;ruby-2.2.3;ruby-2.1.7;ruby-2.0.0;ruby-1.9.3;jruby-1.7.22"
+    RUBIES: "ruby-2.4.2 ruby-2.2.7 ruby-2.1.9 ruby-2.0.0 ruby-1.9.3 jruby-1.7.22 jruby-9.0.5.0 jruby-9.1.13.0"
   services:
     - redis
 
 dependencies:
   cache_directories:
-    - '../.rvm/rubies'
+    - '/opt/circleci/.rvm/rubies'
 
   override:
-    - >
-      rubiesArray=(${RUBIES//;/ });
-      for i in "${rubiesArray[@]}";
+    - |
+      set -e
+      for i in $RUBIES;
       do
         rvm install $i;
         rvm use $i;
-        gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+        if [[ $i == jruby* ]]; then
+          gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+        fi
         gem install bundler;
         bundle install;
         mv Gemfile.lock "Gemfile.lock.$i"
       done
 
 test:
   override:
-    - >
-      rubiesArray=(${RUBIES//;/ });
-      for i in "${rubiesArray[@]}";
+    - |
+      set -e
+      for i in $RUBIES;
       do
         rvm use $i;
         cp "Gemfile.lock.$i" Gemfile.lock;

ldclient-rb.gemspec

@@ -30,8 +30,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "moneta", "~> 1.0.0"
 
   spec.add_runtime_dependency "json", [">= 1.8", "< 3"]
-  spec.add_runtime_dependency "faraday", [">= 0.9", "< 2"]
-  spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 3"]
+  if RUBY_VERSION >= "2.1.0"
+    spec.add_runtime_dependency "faraday", [">= 0.9", "< 2"]
+    spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 3"]
+  else
+    spec.add_runtime_dependency "faraday", [">= 0.9", "< 0.14.0"]
+    spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 2"]
+  end
   spec.add_runtime_dependency "semantic", "~> 1.6.0"
   spec.add_runtime_dependency "thread_safe", "~> 0.3"
   spec.add_runtime_dependency "net-http-persistent", "~> 2.9"

lib/ldclient-rb.rb

@@ -3,12 +3,12 @@
 require "ldclient-rb/ldclient"
 require "ldclient-rb/cache_store"
 require "ldclient-rb/memoized_value"
+require "ldclient-rb/in_memory_store"
 require "ldclient-rb/config"
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
 require "ldclient-rb/polling"
 require "ldclient-rb/event_serializer"
 require "ldclient-rb/events"
-require "ldclient-rb/feature_store"
-require "ldclient-rb/redis_feature_store"
+require "ldclient-rb/redis_store"
 require "ldclient-rb/requestor"

lib/ldclient-rb/config.rb

@@ -34,6 +34,8 @@ class Config
     # @option opts [Object] :cache_store A cache store for the Faraday HTTP caching
     #   library. Defaults to the Rails cache in a Rails environment, or a
     #   thread-safe in-memory store otherwise.
+    # @option opts [Object] :feature_store A store for feature flags and related data. Defaults to an in-memory
+    #   cache, or you can use RedisFeatureStore.
     # @option opts [Boolean] :use_ldd (false) Whether you are using the LaunchDarkly relay proxy in
     #   daemon mode. In this configuration, the client will not use a streaming connection to listen
     #   for updates, but instead will get feature state from a Redis instance. The `stream` and
@@ -171,7 +173,6 @@ def offline?
     #
     attr_reader :feature_store
 
-
     # The proxy configuration string
     #
     attr_reader :proxy

lib/ldclient-rb/evaluation.rb

@@ -22,16 +22,18 @@ module Evaluation
     end
 
     SEMVER_OPERAND = lambda do |v|
+      semver = nil
       if v.is_a? String
         for _ in 0..2 do
           begin
-            return Semantic::Version.new(v)
+            semver = Semantic::Version.new(v)
+            break  # Some versions of jruby cannot properly handle a return here and return from the method that calls this lambda
           rescue ArgumentError
             v = addZeroVersionComponent(v)
           end
         end
       end
-      nil
+      semver
     end
 
     def self.addZeroVersionComponent(v)
@@ -98,7 +100,11 @@ def self.comparator(converter)
       semVerLessThan:
         comparator(SEMVER_OPERAND) { |n| n < 0 },
       semVerGreaterThan:
-        comparator(SEMVER_OPERAND) { |n| n > 0 }
+        comparator(SEMVER_OPERAND) { |n| n > 0 },
+      segmentMatch:
+        lambda do |a, b|
+          false   # we should never reach this - instead we special-case this operator in clause_match_user
+        end
     }
 
     class EvaluationError < StandardError
@@ -136,54 +142,46 @@ def evaluate(flag, user, store)
     def eval_internal(flag, user, store, events)
       failed_prereq = false
       # Evaluate prerequisites, if any
-      if !flag[:prerequisites].nil?
-        flag[:prerequisites].each do |prerequisite|
-          prereq_flag = store.get(prerequisite[:key])
+      (flag[:prerequisites] || []).each do |prerequisite|
+        prereq_flag = store.get(FEATURES, prerequisite[:key])
 
-          if prereq_flag.nil? || !prereq_flag[:on]
-            failed_prereq = true
-          else
-            begin
-              prereq_res = eval_internal(prereq_flag, user, store, events)
-              variation = get_variation(prereq_flag, prerequisite[:variation])
-              events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
-              if prereq_res.nil? || prereq_res != variation
-                failed_prereq = true
-              end
-            rescue => exn
-              @config.logger.error("[LDClient] Error evaluating prerequisite: #{exn.inspect}")
+        if prereq_flag.nil? || !prereq_flag[:on]
+          failed_prereq = true
+        else
+          begin
+            prereq_res = eval_internal(prereq_flag, user, store, events)
+            variation = get_variation(prereq_flag, prerequisite[:variation])
+            events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
+            if prereq_res.nil? || prereq_res != variation
               failed_prereq = true
             end
+          rescue => exn
+            @config.logger.error("[LDClient] Error evaluating prerequisite: #{exn.inspect}")
+            failed_prereq = true
           end
         end
+      end
 
-        if failed_prereq
-          return nil
-        end
+      if failed_prereq
+        return nil
       end
       # The prerequisites were satisfied.
       # Now walk through the evaluation steps and get the correct
       # variation index
-      eval_rules(flag, user)
+      eval_rules(flag, user, store)
     end
 
-    def eval_rules(flag, user)
+    def eval_rules(flag, user, store)
       # Check user target matches
-      if !flag[:targets].nil?
-        flag[:targets].each do |target|
-          if !target[:values].nil?
-            target[:values].each do |value|
-              return get_variation(flag, target[:variation]) if value == user[:key]
-            end
-          end
+      (flag[:targets] || []).each do |target|
+        (target[:values] || []).each do |value|
+          return get_variation(flag, target[:variation]) if value == user[:key]
         end
       end
-
+    
       # Check custom rules
-      if !flag[:rules].nil?
-        flag[:rules].each do |rule|
-          return variation_for_user(rule, user, flag) if rule_match_user(rule, user)
-        end
+      (flag[:rules] || []).each do |rule|
+        return variation_for_user(rule, user, flag) if rule_match_user(rule, user, store)
       end
 
       # Check the fallthrough rule
@@ -202,17 +200,30 @@ def get_variation(flag, index)
       flag[:variations][index]
     end
 
-    def rule_match_user(rule, user)
+    def rule_match_user(rule, user, store)
       return false if !rule[:clauses]
 
-      rule[:clauses].each do |clause|
-        return false if !clause_match_user(clause, user)
+      (rule[:clauses] || []).each do |clause|
+        return false if !clause_match_user(clause, user, store)
       end
 
       return true
     end
 
-    def clause_match_user(clause, user)
+    def clause_match_user(clause, user, store)
+      # In the case of a segment match operator, we check if the user is in any of the segments,
+      # and possibly negate
+      if clause[:op].to_sym == :segmentMatch
+        (clause[:values] || []).each do |v|
+          segment = store.get(SEGMENTS, v)
+          return maybe_negate(clause, true) if !segment.nil? && segment_match_user(segment, user)
+        end
+        return maybe_negate(clause, false)
+      end
+      clause_match_user_no_segments(clause, user)
+    end
+
+    def clause_match_user_no_segments(clause, user)
       val = user_value(user, clause[:attribute])
       return false if val.nil?
 
@@ -250,6 +261,33 @@ def variation_for_user(rule, user, flag)
       end
     end
 
+    def segment_match_user(segment, user)
+      return false unless user[:key]
+
+      return true if segment[:included].include?(user[:key])
+      return false if segment[:excluded].include?(user[:key])
+
+      (segment[:rules] || []).each do |r|
+        return true if segment_rule_match_user(r, user, segment[:key], segment[:salt])
+      end
+
+      return false
+    end
+
+    def segment_rule_match_user(rule, user, segment_key, salt)
+      (rule[:clauses] || []).each do |c|
+        return false unless clause_match_user_no_segments(c, user)
+      end
+
+      # If the weight is absent, this rule matches
+      return true if !rule[:weight]
+
+      # All of the clauses are met. See if the user buckets in
+      bucket = bucket_user(user, segment_key, rule[:bucketBy].nil? ? "key" : rule[:bucketBy], salt)
+      weight = rule[:weight].to_f / 100000.0
+      return bucket < weight
+    end
+
     def bucket_user(user, key, bucket_by, salt)
       return nil unless user[:key]