hackle-ruby-sdk 0.1.0 → 2.0.0

data/lib/hackle/internal/model/container.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Hackle
+
+  class Container
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] bucket_id
+    #   @return [Integer]
+    # @!attribute [r] groups
+    #   @return [Array<ContainerGroup>]
+    attr_reader :id, :bucket_id, :groups
+
+    # @param id [Integer]
+    # @param bucket_id [Integer]
+    # @param groups [Array<ContainerGroup>]
+    def initialize(id:, bucket_id:, groups:)
+      @id = id
+      @bucket_id = bucket_id
+      @groups = groups
+    end
+
+    # @param group_id [Integer]
+    # @return [ContainerGroup, nil]
+    def get_group_or_nil(group_id)
+      groups.each do |group|
+        return group if group.id == group_id
+      end
+      nil
+    end
+  end
+
+  class ContainerGroup
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] experiments
+    #   @return [Array<Integer>]
+    attr_reader :id, :experiments
+
+    # @param id [Integer]
+    # @param experiments [Array<Integer>]
+    def initialize(id:, experiments:)
+      @id = id
+      @experiments = experiments
+    end
+  end
+end

data/lib/hackle/internal/model/decision_reason.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hackle
+  class DecisionReason
+    SDK_NOT_READY = 'SDK_NOT_READY'
+    EXCEPTION = 'EXCEPTION'
+    INVALID_INPUT = 'INVALID_INPUT'
+
+    EXPERIMENT_NOT_FOUND = 'EXPERIMENT_NOT_FOUND'
+    EXPERIMENT_DRAFT = 'EXPERIMENT_DRAFT'
+    EXPERIMENT_PAUSED = 'EXPERIMENT_PAUSED'
+    EXPERIMENT_COMPLETED = 'EXPERIMENT_COMPLETED'
+    OVERRIDDEN = 'OVERRIDDEN'
+    TRAFFIC_NOT_ALLOCATED = 'TRAFFIC_NOT_ALLOCATED'
+    TRAFFIC_ALLOCATED = 'TRAFFIC_ALLOCATED'
+    TRAFFIC_ALLOCATED_BY_TARGETING = 'TRAFFIC_ALLOCATED_BY_TARGETING'
+    VARIATION_DROPPED = 'VARIATION_DROPPED'
+    NOT_IN_EXPERIMENT_TARGET = 'NOT_IN_EXPERIMENT_TARGET'
+    NOT_IN_MUTUAL_EXCLUSION_EXPERIMENT = 'NOT_IN_MUTUAL_EXCLUSION_EXPERIMENT'
+    IDENTIFIER_NOT_FOUND = 'IDENTIFIER_NOT_FOUND'
+
+    FEATURE_FLAG_NOT_FOUND = 'FEATURE_FLAG_NOT_FOUND'
+    FEATURE_FLAG_INACTIVE = 'FEATURE_FLAG_INACTIVE'
+    INDIVIDUAL_TARGET_MATCH = 'INDIVIDUAL_TARGET_MATCH'
+    TARGET_RULE_MATCH = 'TARGET_RULE_MATCH'
+    DEFAULT_RULE = 'DEFAULT_RULE'
+
+    REMOTE_CONFIG_PARAMETER_NOT_FOUND = 'REMOTE_CONFIG_PARAMETER_NOT_FOUND'
+    TYPE_MISMATCH = 'TYPE_MISMATCH'
+  end
+end

data/lib/hackle/internal/model/event_type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hackle
+  class EventType
+
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] key
+    #   @return [String]
+    attr_accessor :id, :key
+
+    # @param id [Integer]
+    # @param key [String]
+    def initialize(id:, key:)
+      @id = id
+      @key = key
+    end
+  end
+end

data/lib/hackle/internal/model/experiment.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Experiment
+    # @return [Integer]
+    attr_reader :id
+
+    # @return [Integer]
+    attr_reader :key
+
+    # @return [String, nil]
+    attr_reader :name
+
+    # @return [ExperimentType]
+    attr_reader :type
+
+    # @return [String]
+    attr_reader :identifier_type
+
+    # @return [ExperimentStatus]
+    attr_reader :status
+
+    # @return [Integer]
+    attr_reader :version
+
+    # @return [Integer]
+    attr_reader :execution_version
+
+    # @return [Array<Variation>]
+    attr_reader :variations
+
+    # @return [Hash{String => Integer}]
+    attr_reader :user_overrides
+
+    # @return [Array<TargetRule>]
+    attr_reader :segment_overrides
+
+    # @return [Array<Target>]
+    attr_reader :target_audiences
+
+    # @return [Array<TargetRule>]
+    attr_reader :target_rules
+
+    # @return [Action]
+    attr_reader :default_rule
+
+    # @return [Integer, nil]
+    attr_reader :container_id
+
+    # @return [Integer, nil]
+    attr_reader :winner_variation_id
+
+    # @param [Integer] id
+    # @param [Integer] key
+    # @param [String, nil] name
+    # @param [ExperimentType] type
+    # @param [String] identifier_type
+    # @param [ExperimentStatus] status
+    # @param [Integer] version
+    # @param [Integer] execution_version
+    # @param [Array<Variation>] variations
+    # @param [Hash{String => Integer}] user_overrides
+    # @param [Array<TargetRule>] segment_overrides
+    # @param [Array<Target>] target_audiences
+    # @param [Array<TargetRule>] target_rules
+    # @param [Action] default_rule
+    # @param [Integer, nil] container_id
+    # @param [Integer, nil] winner_variation_id
+    def initialize(
+      id:,
+      key:,
+      name:,
+      type:,
+      identifier_type:,
+      status:,
+      version:,
+      execution_version:,
+      variations:,
+      user_overrides:,
+      segment_overrides:,
+      target_audiences:,
+      target_rules:,
+      default_rule:,
+      container_id:,
+      winner_variation_id:
+    )
+      @id = id
+      @key = key
+      @name = name
+      @type = type
+      @identifier_type = identifier_type
+      @status = status
+      @version = version
+      @execution_version = execution_version
+      @variations = variations
+      @user_overrides = user_overrides
+      @segment_overrides = segment_overrides
+      @target_audiences = target_audiences
+      @target_rules = target_rules
+      @default_rule = default_rule
+      @container_id = container_id
+      @winner_variation_id = winner_variation_id
+    end
+
+    # @param id [Integer]
+    # @return [Hackle::Variation, nil]
+    def get_variation_or_nil_by_id(id)
+      variations.find { |v| v.id == id }
+    end
+
+    # @param key [String]
+    # @return [Hackle::Variation, nil]
+    def get_variation_or_nil_by_key(key)
+      variations.find { |v| v.key == key }
+    end
+
+    # @return [Hackle::Variation, nil]
+    def winner_variation_or_nil
+      get_variation_or_nil_by_id(winner_variation_id) unless winner_variation_id.nil?
+    end
+  end
+
+  class ExperimentType
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    AB_TEST = new('AB_TEST')
+    FEATURE_FLAG = new('FEATURE_FLAG')
+
+    @types = {
+      'AB_TEST' => AB_TEST,
+      'FEATURE_FLAG' => FEATURE_FLAG
+    }.freeze
+
+    # @param name [String]
+    # @return [ExperimentType, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<ExperimentType>]
+    def self.values
+      @types.values
+    end
+  end
+
+  class ExperimentStatus
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    DRAFT = new('DRAFT')
+    RUNNING = new('RUNNING')
+    PAUSED = new('PAUSED')
+    COMPLETED = new('COMPLETED')
+
+    @types = {
+      'READY' => DRAFT,
+      'RUNNING' => RUNNING,
+      'PAUSED' => PAUSED,
+      'STOPPED' => COMPLETED
+    }.freeze
+
+    # @param name [String]
+    # @return [ExperimentStatus, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<ExperimentStatus>]
+    def self.values
+      @types.values
+    end
+  end
+end

data/lib/hackle/internal/model/parameter_configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hackle
+  class ParameterConfiguration
+
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] parameters
+    #   @return [Hash{String => Object}]
+    attr_accessor :id, :parameters
+
+    # @param id [Integer]
+    # @param parameters [Hash{String => Object}]
+    def initialize(id:, parameters:)
+      @id = id
+      @parameters = parameters
+    end
+  end
+end

data/lib/hackle/internal/model/remote_config_parameter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Hackle
+
+  class RemoteConfigParameter
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] key
+    #   @return [String]
+    # @!attribute [r] type
+    #   @return [ValueType]
+    # @!attribute [r] identifier_type
+    #   @return [String]
+    # @!attribute [r] target_rules
+    #   @return [Array<RemoteConfigTargetRule>]
+    # @!attribute [r] default_value
+    #   @return [RemoteConfigValue]
+    attr_accessor :id, :key, :type, :identifier_type, :target_rules, :default_value
+
+    # @param id [Integer]
+    # @param key [String]
+    # @param type [ValueType]
+    # @param identifier_type [String]
+    # @param target_rules [Array<RemoteConfigTargetRule>]
+    # @param default_value [RemoteConfigValue]
+    def initialize(id:, key:, type:, identifier_type:, target_rules:, default_value:)
+      @id = id
+      @key = key
+      @type = type
+      @identifier_type = identifier_type
+      @target_rules = target_rules
+      @default_value = default_value
+    end
+  end
+
+  class RemoteConfigTargetRule
+    # @!attribute [r] key
+    #   @return [String]
+    # @!attribute [r] name
+    #   @return [String]
+    # @!attribute [r] target
+    #   @return [Target]
+    # @!attribute [r] bucket_id
+    #   @return [Integer]
+    # @!attribute [r] value
+    #   @return [RemoteConfigValue]
+    attr_reader :key, :name, :target, :bucket_id, :value
+
+    # @param key [String]
+    # @param name [String]
+    # @param target [Target]
+    # @param bucket_id [Integer]
+    # @param value [RemoteConfigValue]
+    def initialize(key:, name:, target:, bucket_id:, value:)
+      @key = key
+      @name = name
+      @target = target
+      @bucket_id = bucket_id
+      @value = value
+
+    end
+  end
+
+  class RemoteConfigValue
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] raw_value
+    #   @return [Object]
+    attr_accessor :id, :raw_value
+
+    def initialize(id:, raw_value:)
+      @id = id
+      @raw_value = raw_value
+    end
+  end
+end

data/lib/hackle/internal/model/sdk.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Sdk
+
+    # @!attribute [r] name
+    #   @return [String]
+    # @!attribute [r] version
+    #   @return [String]
+    # @!attribute [r] key
+    #   @return [String]
+    attr_reader :name, :version, :key
+
+    # @param name [String]
+    # @param version [String]
+    # @param key [String]
+    def initialize(name:, version:, key:)
+      @name = name
+      @version = version
+      @key = key
+    end
+  end
+end

data/lib/hackle/internal/model/segment.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Segment
+
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] key
+    #   @return [String]
+    # @!attribute [r] type
+    #   @return [SegmentType]
+    # @!attribute [r] targets
+    #   @return [Array<Target>]
+    attr_accessor :id, :key, :type, :targets
+
+    # @param id [Integer]
+    # @param key [String]
+    # @param type [SegmentType]
+    # @param targets [Array<Target>]
+    def initialize(id:, key:, type:, targets:)
+      @id = id
+      @key = key
+      @type = type
+      @targets = targets
+    end
+  end
+
+  class SegmentType
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    USER_ID = new('USER_ID')
+    USER_PROPERTY = new('USER_PROPERTY')
+
+    @types = {
+      'USER_ID' => USER_ID,
+      'USER_PROPERTY' => USER_PROPERTY
+    }.freeze
+
+    # @param name [String]
+    # @return [SegmentType, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<SegmentType>]
+    def self.values
+      @types.values
+    end
+  end
+end

data/lib/hackle/internal/model/target.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Target
+    # @!attribute [r] conditions
+    #   @return [Array<TargetCondition>]
+    attr_reader :conditions
+
+    # @param conditions [Array<TargetCondition>]
+    def initialize(conditions:)
+      @conditions = conditions
+    end
+  end
+
+  class TargetCondition
+    # @!attribute [r] key
+    #   @return [TargetKey]
+    # @!attribute [r] match
+    #   @return [TargetMatch]
+    attr_reader :key, :match
+
+    def initialize(key:, match:)
+      @key = key
+      @match = match
+    end
+  end
+
+  class TargetKey
+    # @!attribute [r] type
+    #   @return [TargetKeyType]
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :type, :name
+
+    # @param type [TargetKeyType]
+    # @param name [String]
+    def initialize(type:, name:)
+      @type = type
+      @name = name
+    end
+  end
+
+  class TargetMatch
+
+    # @!attribute [r] type
+    #   @return [TargetMatchType]
+    # @!attribute [r] operator
+    #   @return [TargetOperator]
+    # @!attribute [r] value_type
+    #   @return [ValueType]
+    # @!attribute [r] values
+    #   @return [Array<Object>]
+    attr_reader :type, :operator, :value_type, :values
+
+    # @param type [TargetMatchType]
+    # @param operator [TargetOperator]
+    # @param value_type [ValueType]
+    # @param values [Array<Object>]
+    def initialize(type:, operator:, value_type:, values:)
+      @type = type
+      @operator = operator
+      @value_type = value_type
+      @values = values
+    end
+
+  end
+
+  class TargetKeyType
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    USER_ID = new('USER_ID')
+    USER_PROPERTY = new('USER_PROPERTY')
+    HACKLE_PROPERTY = new('HACKLE_PROPERTY')
+    SEGMENT = new('SEGMENT')
+    AB_TEST = new('AB_TEST')
+    FEATURE_FLAG = new('FEATURE_FLAG')
+
+    @types = {
+      'USER_ID' => USER_ID,
+      'USER_PROPERTY' => USER_PROPERTY,
+      'HACKLE_PROPERTY' => HACKLE_PROPERTY,
+      'SEGMENT' => SEGMENT,
+      'AB_TEST' => AB_TEST,
+      'FEATURE_FLAG' => FEATURE_FLAG
+    }.freeze
+
+    # @param name [String]
+    # @return [TargetKeyType, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<TargetKeyType>]
+    def self.values
+      @types.values
+    end
+  end
+
+  class TargetMatchType
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    MATCH = new('MATCH')
+    NOT_MATCH = new('NOT MATCH')
+
+    @types = {
+      'MATCH' => MATCH,
+      'NOT_MATCH' => NOT_MATCH
+    }
+
+    # @param name [String]
+    # @return [TargetMatchType, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<TargetMatchType>]
+    def self.values
+      @types.values
+    end
+
+    # @param type [TargetMatchType]
+    # @param matches [boolean]
+    # @return [boolean]
+    def self.matches(type, matches)
+      case type
+      when MATCH
+        matches
+      when NOT_MATCH
+        !matches
+      else
+        raise ArgumentError, "Unsupported type: #{type}"
+      end
+    end
+  end
+
+  class TargetOperator
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    IN = new('IN')
+    CONTAINS = new('CONTAINS')
+    STARTS_WITH = new('STARTS_WITH')
+    ENDS_WITH = new('ENDS_WITH')
+    GT = new('GT')
+    GTE = new('GTE')
+    LT = new('LT')
+    LTE = new('LTE')
+
+    @types = {
+      'IN' => IN,
+      'CONTAINS' => CONTAINS,
+      'STARTS_WITH' => STARTS_WITH,
+      'ENDS_WITH' => ENDS_WITH,
+      'GT' => GT,
+      'GTE' => GTE,
+      'LT' => LT,
+      'LTE' => LTE
+    }.freeze
+
+    # @param name [String]
+    # @return [TargetOperator, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<TargetOperator>]
+    def self.values
+      @types.values
+    end
+  end
+end

data/lib/hackle/internal/model/target_rule.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Hackle
+  class TargetRule
+
+    # @!attribute [r] target
+    #   @return [Target]
+    # @!attribute [r] action
+    #   @return [Action]
+    attr_accessor :target, :action
+
+    # @param target [Target]
+    # @param action [Action]
+    def initialize(target:, action:)
+      @target = target
+      @action = action
+    end
+  end
+end