hackle-ruby-sdk 1.0.0 → 2.0.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/model/target'
+
+module Hackle
+  class TargetingType
+
+    # @!attribute [r] supported_key_types
+    #   @return [Array<TargetKeyType>]
+    attr_reader :supported_key_types
+
+    # @param supported_key_types [Array<TargetKeyType>]
+    def initialize(supported_key_types)
+      # @type [Array<TargetKeyType>]
+      @supported_key_types = supported_key_types
+    end
+
+    # @param key_type [TargetKeyType]
+    def supports?(key_type)
+      @supported_key_types.include?(key_type)
+    end
+
+    IDENTIFIER = new(
+      [
+        TargetKeyType::SEGMENT
+      ]
+    )
+    PROPERTY = new(
+      [
+        TargetKeyType::SEGMENT,
+        TargetKeyType::USER_PROPERTY,
+        TargetKeyType::HACKLE_PROPERTY,
+        TargetKeyType::AB_TEST,
+        TargetKeyType::FEATURE_FLAG
+      ]
+    )
+    SEGMENT = new(
+      [
+        TargetKeyType::USER_ID,
+        TargetKeyType::USER_PROPERTY,
+        TargetKeyType::HACKLE_PROPERTY
+      ]
+    )
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Hackle
+  class ValueType
+    # @!attribute [r] name
+    #   @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      name
+    end
+
+    NULL = new('NULL')
+    UNKNOWN = new('UNKNOWN')
+    STRING = new('STRING')
+    NUMBER = new('NUMBER')
+    BOOLEAN = new('BOOLEAN')
+    VERSION = new('VERSION')
+    JSON = new('JSON')
+
+    @types = {
+      'NULL' => NULL,
+      'UNKNOWN' => UNKNOWN,
+      'STRING' => STRING,
+      'NUMBER' => NUMBER,
+      'BOOLEAN' => BOOLEAN,
+      'VERSION' => VERSION,
+      'JSON' => JSON
+    }.freeze
+
+    # @param name [String]
+    # @return [ValueType, nil]
+    def self.from_or_nil(name)
+      @types[name.upcase]
+    end
+
+    # @return [Array<ValueType>]
+    def self.values
+      @types.values
+    end
+
+    class << self
+      def string?(value)
+        return false if value.nil?
+
+        value.is_a?(String)
+      end
+
+      def empty_string?(value)
+        string?(value) && value.empty?
+      end
+
+      def not_empty_string?(value)
+        string?(value) && !value.empty?
+      end
+
+      def number?(value)
+        return false if value.nil?
+
+        value.is_a?(Numeric)
+      end
+
+      def boolean?(value)
+        return false if value.nil?
+
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Variation
+
+    # @!attribute [r] id
+    #   @return [Integer]
+    # @!attribute [r] key
+    #   @return [String]
+    # @!attribute [r] is_dropped
+    #   @return [boolean]
+    # @!attribute [r] parameter_configuration_id
+    #   @return [Integer]
+    attr_reader :id, :key, :is_dropped, :parameter_configuration_id
+
+    # @param id [Integer]
+    # @param key [String]
+    # @param is_dropped [boolean]
+    # @param parameter_configuration_id [Integer, nil]
+    def initialize(id:, key:, is_dropped:, parameter_configuration_id:)
+      @id = id
+      @key = key
+      @is_dropped = is_dropped
+      @parameter_configuration_id = parameter_configuration_id
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Hackle
+  class Version
+    include Comparable
+
+    # @!attribute [r] core_version
+    #   @return [CoreVersion]
+    # @!attribute [r] prerelease
+    #   @return [MetadataVersion]
+    # @!attribute [r] build
+    #   @return [MetadataVersion]
+    attr_reader :core_version, :prerelease, :build
+
+    # @param major [Integer]
+    # @param minor [Integer]
+    # @param patch [Integer]
+    # @param prerelease [MetadataVersion]
+    # @param build [MetadataVersion]
+
+    def initialize(core_version:, prerelease:, build:)
+      @core_version = core_version
+      @prerelease = prerelease
+      @build = build
+    end
+
+    VERSION_REGEX = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?(?:\.(0|[1-9]\d*))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+(\S+))?$/.freeze
+
+    # @param version [Object]
+    # @return [Version, nil]
+    def self.parse_or_nil(value)
+      return nil unless value.is_a?(String)
+
+      match = VERSION_REGEX.match(value)
+      return nil unless match
+
+      core_version = CoreVersion.new(major: match[1].to_i, minor: (match[2] || 0).to_i, patch: (match[3] || 0).to_i)
+      prerelease = MetadataVersion.parse(match[4])
+      build = MetadataVersion.parse(match[5])
+      new(core_version: core_version, prerelease: prerelease, build: build)
+    end
+
+    def <=>(other)
+      core_comparison = core_version <=> other.core_version
+      return core_comparison unless core_comparison.zero?
+
+      prerelease <=> other.prerelease
+    end
+
+    def ==(other)
+      other.is_a?(Version) && (self <=> other).zero?
+    end
+
+    def to_s
+      str = core_version.to_s
+      str += "-#{prerelease}" unless prerelease.empty?
+      str += "+#{build}" unless build.empty?
+      str
+    end
+  end
+
+  class CoreVersion
+    include Comparable
+
+    # @!attribute [r] major
+    #   @return [Integer]
+    # @!attribute [r] minor
+    #   @return [Integer]
+    # @!attribute [r] patch
+    #   @return [Integer]
+    attr_reader :major, :minor, :patch
+
+    # @param major [Integer]
+    # @param minor [Integer]
+    # @param patch [Integer]
+    def initialize(major:, minor:, patch:)
+      @major = major
+      @minor = minor
+      @patch = patch
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(CoreVersion)
+
+      [major, minor, patch] <=> [other.major, other.minor, other.patch]
+    end
+
+    def ==(other)
+      other.is_a?(CoreVersion) && (major == other.major && minor == other.minor && patch == other.patch)
+    end
+
+    def to_s
+      "#{major}.#{minor}.#{patch}"
+    end
+  end
+
+  class MetadataVersion
+    include Comparable
+
+    # @!attribute [r] identifiers
+    #   @return [Array<String>]
+    attr_reader :identifiers
+
+    def initialize(identifiers)
+      @identifiers = identifiers
+    end
+
+    def self.parse(value)
+      return new([]) unless value
+
+      new(value.split('.'))
+    end
+
+    def ==(other)
+      other.is_a?(MetadataVersion) && identifiers == other.identifiers
+    end
+
+    def <=>(other)
+      return 0 if empty? && other.empty?
+      return -1 if empty?
+      return 1 if other.empty?
+
+      compare_identifiers(other)
+    end
+
+    def compare_identifiers(other)
+      min_length = [identifiers.length, other.identifiers.length].min
+      min_length.times do |i|
+        result = compare_single_identifier(identifiers[i], other.identifiers[i])
+        return result if result != 0
+      end
+      identifiers.length <=> other.identifiers.length
+    end
+
+    def compare_single_identifier(id1, id2)
+      num1 = id1.to_i
+      num2 = id2.to_i
+      if id1.to_i.to_s == id1 && id2.to_i.to_s == id2
+        num1 <=> num2
+      else
+        id1 <=> id2
+      end
+    end
+
+    def to_s
+      identifiers.join('.')
+    end
+
+    def empty?
+      identifiers.empty?
+    end
+  end
+end

data/lib/hackle/internal/properties/properties_builder.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/logger/logger'
+
+module Hackle
+  class PropertiesBuilder
+    def initialize
+      # @type [Hash{String => Object}]
+      @properties = {}
+    end
+
+    # @param key [String]
+    # @param value [Object, nil]
+    # @return [Hackle::PropertiesBuilder]
+    def add(key, value)
+      return self if @properties.length >= MAX_PROPERTIES_COUNT
+
+      unless valid_key?(key)
+        Log.get.warn { "Invalid property key: #{key} (expected: string[1..128])" }
+        return self
+      end
+
+      sanitized_value = sanitize_value_or_nil(key, value)
+      @properties[key] = sanitized_value unless sanitized_value.nil?
+      self
+    end
+
+    # @param properties [Hash{String => Object}]
+    # @return [Hackle::PropertiesBuilder]
+    def add_all(properties)
+      if properties.nil? || !properties.is_a?(Hash)
+        Log.get.warn { "Invalid properties: #{properties} (expected: Hash{String => Object})" }
+        return self
+      end
+
+      properties.each { |key, value| add(key, value) }
+      self
+    end
+
+    # @return [Hash{String (frozen)->Object}]
+    def build
+      @properties.dup
+    end
+
+    private
+
+    SYSTEM_PROPERTY_KEY_PREFIX = '$'
+    MAX_PROPERTIES_COUNT = 128
+    MAX_PROPERTY_KEY_LENGTH = 128
+    MAX_PROPERTY_VALUE_LENGTH = 1024
+
+    # @param key [String]
+    # @param value [Object, nil]
+    # @return [Object, nil]
+    def sanitize_value_or_nil(key, value)
+      return nil if value.nil?
+      return value.filter { |it| valid_element?(it) } if value.is_a?(Array)
+      return value if valid_value?(value)
+      return value if key.start_with?(SYSTEM_PROPERTY_KEY_PREFIX)
+
+      nil
+    end
+
+    # @param key [String]
+    # @return [boolean]
+    def valid_key?(key)
+      return false if key.nil?
+      return false unless key.is_a?(String)
+      return false if key.empty?
+      return false if key.length > MAX_PROPERTY_KEY_LENGTH
+
+      true
+    end
+
+    # @param value [Object]
+    # @return [boolean]
+    def valid_value?(value)
+      case value
+      when String
+        value.length <= MAX_PROPERTY_VALUE_LENGTH
+      when Numeric, TrueClass, FalseClass
+        true
+      else
+        false
+      end
+    end
+
+    # @param element [Object]
+    # @return [boolean]
+    def valid_element?(element)
+      case element
+      when String
+        element.length <= MAX_PROPERTY_VALUE_LENGTH
+      when Numeric
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/hackle/internal/user/hackle_user.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/identifiers/identifier_builder'
+require 'hackle/internal/properties/properties_builder'
+
+module Hackle
+  class HackleUser
+
+    # @return [Hash{String => String}]
+    attr_reader :identifiers
+
+    # @return [Hash{String => Object}]
+    attr_reader :properties
+
+    # @param identifiers [Hash{String => String}]
+    # @param properties [Hash{String => Object}]
+    def initialize(identifiers:, properties:)
+      @identifiers = identifiers
+      @properties = properties
+    end
+
+    def ==(other)
+      other.is_a?(Hackle::HackleUser) && identifiers == other.identifiers && properties == other.properties
+    end
+
+    def self.builder
+      Builder.new
+    end
+
+    class Builder
+      def initialize
+        @identifiers = IdentifiersBuilder.new
+        @properties = PropertiesBuilder.new
+      end
+
+      # @param type [String]
+      # @param value [String, nil]
+      # @return [Builder]
+      def identifier(type, value)
+        @identifiers.add(type, value)
+        self
+      end
+
+      # @param identifiers [Hash{String => String}]
+      # @return [Builder]
+      def identifiers(identifiers)
+        @identifiers.add_all(identifiers)
+        self
+      end
+
+      # @param key [String]
+      # @param value [Object, nil]
+      # @return [Builder]
+      def property(key, value)
+        @properties.add(key, value)
+        self
+      end
+
+      # @param properties [Hash{String => Object}]
+      # @return [Builder]
+      def properties(properties)
+        @properties.add_all(properties)
+        self
+      end
+
+      def build
+        HackleUser.new(
+          identifiers: @identifiers.build,
+          properties: @properties.build
+        )
+      end
+    end
+  end
+end

data/lib/hackle/internal/user/hackle_user_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'hackle/user'
+require 'hackle/internal/user/hackle_user'
+
+module Hackle
+  class HackleUserResolver
+    # @param user [User]
+    # @return [HackleUser]
+    def resolve_or_nil(user)
+      return nil if user.nil?
+      return nil unless user.is_a?(User)
+
+      builder = HackleUser.builder
+      builder.identifiers(user.identifiers)
+      builder.identifier('$id', user.id) unless user.id.nil?
+      builder.identifier('$deviceId', user.device_id) unless user.device_id.nil?
+      builder.identifier('$userId', user.user_id) unless user.user_id.nil?
+      builder.properties(user.properties)
+      hackle_user = builder.build
+
+      return nil if hackle_user.identifiers.empty?
+
+      hackle_user
+    end
+  end
+end

data/lib/hackle/internal/workspace/http_workspace_fetcher.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'hackle/internal/http/http'
+require 'hackle/internal/workspace/workspace'
+
+module Hackle
+  class HttpWorkspaceFetcher
+    # @param http_client [HttpClient]
+    # @param sdk [Sdk]
+    def initialize(http_client:, sdk:)
+
+      # @type [String]
+      @url = "/api/v2/workspaces/#{sdk.key}/config"
+
+      # @type [HttpClient]
+      @http_client = http_client
+
+      # @type [String, nil]
+      @last_modified = nil
+    end
+
+    # @return [Hackle::Workspace, nil]
+    def fetch_if_modified
+      request = create_request
+      response = @http_client.execute(request)
+      handle_response(response)
+    end
+
+    private
+
+    # @return [Net::HTTPRequest]
+    def create_request
+      request = Net::HTTP::Get.new(@url)
+      request['If-Modified-Since'] = @last_modified unless @last_modified.nil?
+      request
+    end
+
+    # @param response [Net::HTTPResponse]
+    # @return [Workspace, nil]
+    def handle_response(response)
+      return nil if HTTP.not_modified?(response)
+      raise "http status code: #{response.code}" unless HTTP.successful?(response)
+
+      @last_modified = response.header['Last-Modified']
+      response_body = JSON.parse(response.body, symbolize_names: true)
+      Workspace.from_hash(response_body)
+    end
+  end
+end

data/lib/hackle/internal/workspace/polling_workspace_fetcher.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'hackle/internal/logger/logger'
+require 'hackle/internal/workspace/workspace_fetcher'
+
+module Hackle
+  class PollingWorkspaceFetcher
+    include WorkspaceFetcher
+    # @param http_workspace_fetcher [HttpWorkspaceFetcher]
+    # @param scheduler [Scheduler]
+    # @param polling_interval_seconds [Float]
+    def initialize(http_workspace_fetcher:, scheduler:, polling_interval_seconds:)
+      # @type [HttpWorkspaceFetcher]
+      @http_workspace_fetcher = http_workspace_fetcher
+
+      # @type [Scheduler]
+      @scheduler = scheduler
+
+      # @type [Float]
+      @polling_interval_seconds = polling_interval_seconds
+
+      # @type [ScheduledJob, nil]
+      @polling_job = nil
+
+      # @type [Workspace, nil]
+      @workspace = nil
+    end
+
+    # @return [Workspace, nil]
+    def fetch
+      @workspace
+    end
+
+    def start
+      return unless @polling_job.nil?
+
+      poll
+      @polling_job = @scheduler.schedule_periodically(@polling_interval_seconds, -> { poll })
+    end
+
+    def stop
+      @polling_job&.cancel
+      @polling_job = nil
+    end
+
+    def resume
+      @polling_job&.cancel
+      @polling_job = @scheduler.schedule_periodically(@polling_interval_seconds, -> { poll })
+    end
+
+    private
+
+    def poll
+      workspace = @http_workspace_fetcher.fetch_if_modified
+      return if workspace.nil?
+
+      @workspace = workspace
+    rescue => e
+      Log.get.error { "Failed to poll Workspace: #{e.inspect}" }
+    end
+  end
+end