hackle-ruby-sdk 0.1.0 → 2.0.0

data/lib/hackle/internal/evaluation/match/operator/operator_matcher.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Hackle
+  module OperatorMatcher
+    # @param value [String]
+    # @param match_value [String]
+    # @return [boolean]
+    def string_matches(value, match_value) end
+
+    # @param value [Numeric]
+    # @param match_value [Numeric]
+    # @return [boolean]
+    def number_matches(value, match_value) end
+
+    # @param value [boolean]
+    # @param match_value [boolean]
+    # @return [boolean]
+    def boolean_matches(value, match_value) end
+
+    # @param value [Version]
+    # @param match_value [Version]
+    # @return [boolean]
+    def version_matches(value, match_value) end
+  end
+
+  class InMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value == match_value
+    end
+
+    def number_matches(value, match_value)
+      value == match_value
+    end
+
+    def boolean_matches(value, match_value)
+      value == match_value
+    end
+
+    def version_matches(value, match_value)
+      value == match_value
+    end
+  end
+
+  class ContainsMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value.include?(match_value)
+    end
+
+    def number_matches(_value, _match_value)
+      false
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(_value, _match_value)
+      false
+    end
+  end
+
+  class StartsWithMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value.start_with?(match_value)
+    end
+
+    def number_matches(_value, _match_value)
+      false
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(_value, _match_value)
+      false
+    end
+  end
+
+  class EndsWithMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value.end_with?(match_value)
+    end
+
+    def number_matches(_value, _match_value)
+      false
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(_value, _match_value)
+      false
+    end
+  end
+
+  class GreaterThanMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value > match_value
+    end
+
+    def number_matches(value, match_value)
+      value > match_value
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(value, match_value)
+      value > match_value
+    end
+  end
+
+  class GreaterThanOrEqualToMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value >= match_value
+    end
+
+    def number_matches(value, match_value)
+      value >= match_value
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(value, match_value)
+      value >= match_value
+    end
+  end
+
+  class LessThanMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value < match_value
+    end
+
+    def number_matches(value, match_value)
+      value < match_value
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(value, match_value)
+      value < match_value
+    end
+  end
+
+  class LessThanOrEqualToMatcher
+    include OperatorMatcher
+
+    def string_matches(value, match_value)
+      value <= match_value
+    end
+
+    def number_matches(value, match_value)
+      value <= match_value
+    end
+
+    def boolean_matches(_value, _match_value)
+      false
+    end
+
+    def version_matches(value, match_value)
+      value <= match_value
+    end
+  end
+end

data/lib/hackle/internal/evaluation/match/operator/operator_matcher_factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/model/target'
+require 'hackle/internal/evaluation/match/operator/operator_matcher'
+
+module Hackle
+  class OperatorMatcherFactory
+
+    def initialize
+      @matchers = {
+        TargetOperator::IN => InMatcher.new,
+        TargetOperator::CONTAINS => ContainsMatcher.new,
+        TargetOperator::STARTS_WITH => StartsWithMatcher.new,
+        TargetOperator::ENDS_WITH => EndsWithMatcher.new,
+        TargetOperator::GT => GreaterThanMatcher.new,
+        TargetOperator::GTE => GreaterThanOrEqualToMatcher.new,
+        TargetOperator::LT => LessThanMatcher.new,
+        TargetOperator::LTE => LessThanOrEqualToMatcher.new
+      }.freeze
+    end
+
+    # @param operator [TargetOperator]
+    # @return [OperatorMatcher]
+    def get(operator)
+      matcher = @matchers[operator]
+      raise ArgumentError, "Unsupported TargetOperator [#{operator}]" unless matcher
+
+      matcher
+    end
+  end
+end

data/lib/hackle/internal/evaluation/match/target/target_matcher.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hackle
+  class TargetMatcher
+
+    # @param condition_matcher_factory [ConditionMatcherFactory]
+    def initialize(condition_matcher_factory:)
+      # @type [ConditionMatcherFactory]
+      @condition_matcher_factory = condition_matcher_factory
+    end
+
+    # @param request [EvaluatorRequest]
+    # @param context [EvaluatorContext]
+    # @param target [Target]
+    # @return [boolean]
+    def matches(request, context, target)
+      target.conditions.all? { |it| condition_matches(request, context, it) }
+    end
+
+    private
+
+    # @param request [EvaluatorRequest]
+    # @param context [EvaluatorContext]
+    # @param condition [TargetCondition]
+    # @return [boolean]
+    def condition_matches(request, context, condition)
+      condition_matcher = @condition_matcher_factory.get(condition.key.type)
+      condition_matcher.matches(request, context, condition)
+    end
+  end
+end

data/lib/hackle/internal/evaluation/match/value/value_matcher.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/model/version'
+
+module Hackle
+  module ValueMatcher
+    # @param operator_matcher [OperatorMatcher]
+    # @param value [Object]
+    # @param match_value [Object]
+    # @return [boolean]
+    def matches(operator_matcher, value, match_value) end
+  end
+
+  class StringMatcher
+    include ValueMatcher
+
+    def matches(operator_matcher, value, match_value)
+      type_value = as_string(value)
+      type_match_value = as_string(match_value)
+      return false if type_value.nil? || type_match_value.nil?
+
+      operator_matcher.string_matches(type_value, type_match_value)
+    end
+
+    private
+
+    # @param value [Object]
+    # @return [String, nil]
+    # noinspection RubyMismatchedReturnType
+    def as_string(value)
+      return value if value.is_a?(String)
+      return value.to_s if value.is_a?(Numeric)
+
+      nil
+    end
+  end
+
+  class NumberMatcher
+    include ValueMatcher
+
+    def matches(operator_matcher, value, match_value)
+      type_value = as_number(value)
+      type_match_value = as_number(match_value)
+      return false if type_value.nil? || type_match_value.nil?
+
+      operator_matcher.number_matches(type_value, type_match_value)
+    end
+
+    private
+
+    # @param value [Object]
+    # @return [Numeric, nil]
+    # noinspection RubyMismatchedReturnType
+    def as_number(value)
+      return value if value.is_a?(Numeric)
+      return Float(value, exception: false) if value.is_a?(String)
+
+      nil
+    end
+  end
+
+  class BooleanMatcher
+    include ValueMatcher
+
+    def matches(operator_matcher, value, match_value)
+      type_value = as_boolean(value)
+      type_match_value = as_boolean(match_value)
+      return false if type_value.nil? || type_match_value.nil?
+
+      operator_matcher.boolean_matches(type_value, type_match_value)
+    end
+
+    private
+
+    # @param value [Object]
+    # @return [boolean, nil]
+    def as_boolean(value)
+      return true if value.is_a?(TrueClass)
+      return false if value.is_a?(FalseClass)
+
+      nil
+    end
+  end
+
+  class VersionMatcher
+    include ValueMatcher
+
+    def matches(operator_matcher, value, match_value)
+      type_value = Version.parse_or_nil(value)
+      type_match_value = Version.parse_or_nil(match_value)
+      return false if type_value.nil? || type_match_value.nil?
+
+      operator_matcher.version_matches(type_value, type_match_value)
+    end
+  end
+end

data/lib/hackle/internal/evaluation/match/value/value_matcher_factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/model/value_type'
+require 'hackle/internal/evaluation/match/value/value_matcher'
+
+module Hackle
+  class ValueMatcherFactory
+
+    def initialize
+      @matchers = {
+        ValueType::STRING => StringMatcher.new,
+        ValueType::NUMBER => NumberMatcher.new,
+        ValueType::BOOLEAN => BooleanMatcher.new,
+        ValueType::VERSION => VersionMatcher.new,
+        ValueType::JSON => StringMatcher.new
+      }.freeze
+    end
+
+    # @param value_type [ValueType]
+    # @return [ValueMatcher]
+    def get(value_type)
+      matcher = @matchers[value_type]
+      raise ArgumentError, "Unsupported ValueType [#{value_type}]" unless matcher
+
+      matcher
+    end
+  end
+end

data/lib/hackle/internal/evaluation/match/value/value_operator_matcher.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/model/target'
+
+module Hackle
+  class ValueOperatorMatcher
+    # @param value_matcher_factory [ValueMatcherFactory]
+    # @param operator_matcher_factory [OperatorMatcherFactory]
+    def initialize(value_matcher_factory:, operator_matcher_factory:)
+      # @type [ValueMatcherFactory]
+      @value_matcher_factory = value_matcher_factory
+      # @type [OperatorMatcherFactory]
+      @operator_matcher_factory = operator_matcher_factory
+    end
+
+    # @param value [Object]
+    # @param match [TargetMatch]
+    # @return [boolean]
+    def matches(value, match)
+      value_matcher = @value_matcher_factory.get(match.value_type)
+      operator_matcher = @operator_matcher_factory.get(match.operator)
+
+      matches = internal_matches(value, match, value_matcher, operator_matcher)
+      TargetMatchType.matches(match.type, matches)
+    end
+
+    private
+
+    # @param value [Object]
+    # @param match [TargetMatch]
+    # @param value_matcher [ValueMatcher]
+    # @param operator_matcher [OperatorMatcher]
+    # @return [boolean]
+    def internal_matches(value, match, value_matcher, operator_matcher)
+      # noinspection RubyMismatchedArgumentType
+      return array_matches(value, match, value_matcher, operator_matcher) if value.is_a?(Array)
+
+      single_matches(value, match, value_matcher, operator_matcher)
+    end
+
+    # @param value [Object]
+    # @param match [TargetMatch]
+    # @param value_matcher [ValueMatcher]
+    # @param operator_matcher [OperatorMatcher]
+    # @return [boolean]
+    def single_matches(value, match, value_matcher, operator_matcher)
+      match.values.any? { |it| value_matcher.matches(operator_matcher, value, it) }
+    end
+
+    # @param values [Array<Object>]
+    # @param match [TargetMatch]
+    # @param value_matcher [ValueMatcher]
+    # @param operator_matcher [OperatorMatcher]
+    # @return [boolean]
+    def array_matches(values, match, value_matcher, operator_matcher)
+      values.any? { |it| single_matches(it, match, value_matcher, operator_matcher) }
+    end
+  end
+end

data/lib/hackle/internal/event/user_event.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Hackle
+  class UserEvent
+
+    # @return [String]
+    attr_reader :insert_id
+
+    # @return [Integer]
+    attr_reader :timestamp
+
+    # @return [HackleUser]
+    attr_reader :user
+
+    # @param insert_id [String]
+    # @param timestamp [Integer]
+    # @param user [HackleUser]
+    def initialize(insert_id:, timestamp:, user:)
+      @insert_id = insert_id
+      @timestamp = timestamp
+      @user = user
+    end
+
+    class << self
+
+      # @param evaluation [ExperimentEvaluation]
+      # @param properties [Hash{String => Object}]
+      # @param user [HackleUser]
+      # @param timestamp [Integer]
+      # @return [Hackle::ExposureEvent]
+      def exposure(evaluation, properties, user, timestamp)
+        ExposureEvent.new(
+          insert_id: SecureRandom.uuid,
+          timestamp: timestamp,
+          user: user,
+          experiment: evaluation.experiment,
+          variation_id: evaluation.variation_id,
+          variation_key: evaluation.variation_key,
+          decision_reason: evaluation.reason,
+          properties: properties
+        )
+      end
+
+      # @param event_type [EventType]
+      # @param event [Event]
+      # @param user [HackleUser]
+      # @param timestamp [Integer]
+      # @return [Hackle::TrackEvent]
+      def track(event_type, event, user, timestamp)
+        TrackEvent.new(
+          insert_id: SecureRandom.uuid,
+          timestamp: timestamp,
+          user: user,
+          event_type: event_type,
+          event: event
+        )
+      end
+
+      # @param evaluation [RemoteConfigEvaluation]
+      # @param properties [Hash{String => Object}]
+      # @param user [HackleUser]
+      # @param timestamp [Integer]
+      # @return [Hackle::RemoteConfigEvent]
+      def remote_config(evaluation, properties, user, timestamp)
+        RemoteConfigEvent.new(
+          insert_id: SecureRandom.uuid,
+          timestamp: timestamp,
+          user: user,
+          parameter: evaluation.parameter,
+          value_id: evaluation.value_id,
+          decision_reason: evaluation.reason,
+          properties: properties
+        )
+      end
+    end
+  end
+
+  class ExposureEvent < UserEvent
+
+    # @return [Experiment]
+    attr_reader :experiment
+
+    # @return [Integer, nil]
+    attr_reader :variation_id
+
+    # @return [String]
+    attr_reader :variation_key
+
+    # @return [String]
+    attr_reader :decision_reason
+
+    # @return [Hash{String => Object}]
+    attr_reader :properties
+
+    # @param insert_id [String]
+    # @param timestamp [Integer]
+    # @param user [HackleUser]
+    # @param experiment [Experiment]
+    # @param variation_id [Integer, nil]
+    # @param variation_key [String]
+    # @param decision_reason [String]
+    # @param properties [Hash{String => Object}]
+    def initialize(
+      insert_id:,
+      timestamp:,
+      user:,
+      experiment:,
+      variation_id:,
+      variation_key:,
+      decision_reason:,
+      properties:
+    )
+      super(insert_id: insert_id, timestamp: timestamp, user: user)
+      @experiment = experiment
+      @variation_id = variation_id
+      @variation_key = variation_key
+      @decision_reason = decision_reason
+      @properties = properties
+    end
+  end
+
+  class TrackEvent < UserEvent
+
+    # @return [EventType]
+    attr_reader :event_type
+
+    # @return [Event]
+    attr_reader :event
+
+    # @param insert_id [String]
+    # @param timestamp [Integer]
+    # @param user [HackleUser]
+    # @param event_type [EventType]
+    # @param event [Event]
+    def initialize(
+      insert_id:,
+      timestamp:,
+      user:,
+      event_type:,
+      event:
+    )
+      super(insert_id: insert_id, timestamp: timestamp, user: user)
+      @event_type = event_type
+      @event = event
+    end
+  end
+
+  class RemoteConfigEvent < UserEvent
+
+    # @return [RemoteConfigParameter]
+    attr_reader :parameter
+
+    # @return [Integer, nil]
+    attr_reader :value_id
+
+    # @return [String]
+    attr_reader :decision_reason
+
+    # @return [Hash{String => Object}]
+    attr_reader :properties
+
+    # @param insert_id [String]
+    # @param timestamp [Integer]
+    # @param user [HackleUser]
+    # @param parameter [RemoteConfigParameter]
+    # @param value_id [Integer, nil]
+    # @param decision_reason [String]
+    # @param properties [Hash{String => Object}]
+    def initialize(
+      insert_id:,
+      timestamp:,
+      user:,
+      parameter:,
+      value_id:,
+      decision_reason:,
+      properties:
+    )
+      super(insert_id: insert_id, timestamp: timestamp, user: user)
+      @parameter = parameter
+      @value_id = value_id
+      @decision_reason = decision_reason
+      @properties = properties
+    end
+  end
+end