prefab-cloud-ruby 0.7.0 → 0.10.0

data/run_test_harness_server.sh

@@ -1,2 +1,2 @@
-PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_API_KEY="1|local_development_api_key" PREFAB_API_URL="localhost:50051" ruby -Ilib test/harness_server.rb
+PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_GRPC_URL="localhost:50051" ruby -Ilib test/harness_server.rb
 #GRPC_TRACE=all GRPC_VERBOSITY=DEBUG PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_API_KEY="1|local_development_api_key" PREFAB_API_URL="localhost:50051" ruby -Ilib test/harness_server.rb

data/test/harness_server.rb

@@ -15,31 +15,39 @@ class RackApp
 
     key = props["key"]
     namespace = props["namespace"]
-    environment = props["environment"]
+    project_env_id = props["project_env_id"]
     user_key = props["user_key"]
     is_feature_flag = !props["feature_flag"].nil?
 
     client = Prefab::Client.new(
-      api_key: "1-#{environment}-local_development_api_key", #sets environment
+      api_key: "1-#{project_env_id}-local_development_api_key-SDK", #sets environment
       namespace: namespace,
     )
 
     puts "Key #{key}"
     puts "User #{user_key}"
-    puts "Environment #{environment}"
+    puts "project_env_id #{project_env_id}"
     puts "Namespace #{namespace}"
     puts "Props! #{props}"
     puts "is_feature_flag! #{is_feature_flag}"
 
+    puts client.config_client.to_s
+
     if is_feature_flag
       puts "EVALFF #{key} #{user_key}"
       rtn = client.feature_flag_client.get(key, user_key, []).to_s
     else
       rtn = client.config_client.get(key).to_s
     end
+
     puts "return #{rtn}"
 
     [200, { "Content-Type" => "text/plain" }, rtn]
+
+    rescue Exception => e
+      puts "ERROR #{e.message}"
+      puts e.backtrace
+      [500, { "Content-Type" => "text/plain" }, e.message]
   end
 end
 

data/test/test_config_loader.rb

@@ -16,26 +16,26 @@ class TestConfigLoader < Minitest::Test
 
   def test_highwater
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 1, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 1, @loader.highwater_mark
 
-    @loader.set(Prefab::ConfigDelta.new(id: 5, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 5, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 5, @loader.highwater_mark
   end
 
   def test_keeps_most_recent
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 1, key: "sample_int", default: Prefab::ConfigValue.new(int: 1)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]))
     assert_equal 1, @loader.highwater_mark
     should_be :int, 1, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 4, key: "sample_int", default: Prefab::ConfigValue.new(int: 4)))
+    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", default: Prefab::ConfigValue.new(int: 2)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,37 +43,37 @@ class TestConfigLoader < Minitest::Test
   def test_api_precedence
     should_be :int, 123, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     should_be :int, 456, "sample_int"
   end
 
   def test_api_deltas
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
+    @loader.set(config)
 
-    deltas = Prefab::ConfigDeltas.new
-    deltas.deltas << delta
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    configs.configs << config
+    assert_equal configs, @loader.get_api_deltas
   end
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
+    @loader.set(config)
 
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: nil)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [])
+    @loader.set(config)
 
-    deltas = Prefab::ConfigDeltas.new
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    assert_equal configs, @loader.get_api_deltas
   end
 
   private
 
   def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key].default.type
-    assert_equal value, @loader.calc_config[key].default.send(type)
+    assert_equal type, @loader.calc_config[key].rows[0].value.type
+    assert_equal value, @loader.calc_config[key].rows[0].value.send(type)
   end
 
 end

data/test/test_config_resolver.rb

@@ -2,45 +2,58 @@ require 'test_helper'
 
 class TestConfigResolver < Minitest::Test
 
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+
   def test_resolution
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "key" => Prefab::ConfigDelta.new(
+      "key" => Prefab::Config.new(
         key: "key",
-        default: Prefab::ConfigValue.new(string: "value_no_env_default"),
-        envs: [{
-                 environment: "test",
-                 default: Prefab::ConfigValue.new(string: "value_none"),
-                 namespace_values: [
-                   {
-                     namespace: "projectA",
-                     config_value: Prefab::ConfigValue.new(string: "valueA")
-                   },
-                   {
-                     namespace: "projectB",
-                     config_value: Prefab::ConfigValue.new(string: "valueB")
-                   },
-                   {
-                     namespace: "projectB.subprojectX",
-                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectX")
-                   },
-                   {
-                     namespace: "projectB.subprojectY",
-                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectY")
-                   },
-                 ]
-               }]
+        rows: [
+          Prefab::ConfigRow.new(
+            value: Prefab::ConfigValue.new(string: "value_no_env_default"),
+          ),
+          Prefab::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            value: Prefab::ConfigValue.new(string: "value_none"),
+          ),
+          Prefab::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            namespace: "projectA",
+            value: Prefab::ConfigValue.new(string: "valueA"),
+          ),
+          Prefab::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            namespace: "projectB",
+            value: Prefab::ConfigValue.new(string: "valueB"),
+          ),
+          Prefab::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            namespace: "projectB.subprojectX",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectX"),
+          ),
+          Prefab::ConfigRow.new(
+            project_env_id: TEST_ENV_ID,
+            namespace: "projectB.subprojectY",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectY"),
+          ),
+
+        ]
       ),
-      "key2" => Prefab::ConfigDelta.new(
+      "key2" => Prefab::Config.new(
         key: "key2",
-        default: Prefab::ConfigValue.new(string: "valueB2"),
+        rows: [
+          value: Prefab::ConfigValue.new(string: "valueB2"),
+        ]
       )
     }
 
     @loader.stub :calc_config, loaded_values do
 
-      @resolverA = resolver_for_namespace("", @loader, environment: "some_other_env")
+      @resolverA = resolver_for_namespace("", @loader, project_env_id: PRODUCTION_ENV_ID)
       assert_equal "value_no_env_default", @resolverA.get("key")
 
       ## below here in the test env
@@ -91,34 +104,34 @@ class TestConfigResolver < Minitest::Test
   end
 
   def test_special_ff_variant_copying
+
     @loader = MockConfigLoader.new
     loaded_values = {
-      "ff" => Prefab::ConfigDelta.new(
+      "ff" => Prefab::Config.new(
         key: "ff",
-        default: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-          variants: [
-            Prefab::FeatureFlagVariant.new(string: "inactive"),
-            Prefab::FeatureFlagVariant.new(string: "default"),
-            Prefab::FeatureFlagVariant.new(string: "env"),
-          ],
-          inactive_variant_idx: 0,
-          default: Prefab::VariantDistribution.new(variant_idx: 1)
-        )),
-        envs: [
-          Prefab::EnvironmentValues.new(
-            environment: "test",
-            default: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+        variants: [
+          Prefab::FeatureFlagVariant.new(string: "inactive"),
+          Prefab::FeatureFlagVariant.new(string: "default"),
+          Prefab::FeatureFlagVariant.new(string: "env"),
+        ],
+        rows: [
+          { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+            inactive_variant_idx: 0,
+            default: Prefab::VariantDistribution.new(variant_idx: 1)
+          )) },
+          { project_env_id: TEST_ENV_ID,
+            value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
               inactive_variant_idx: 0,
-              default: Prefab::VariantDistribution.new(variant_idx: 2)))
-          )
+              default: Prefab::VariantDistribution.new(variant_idx: 2)
+            )) }
         ]
       )
     }
     @loader.stub :calc_config, loaded_values do
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      ff = resolver.get("ff")
-      assert_equal 3, ff.variants.size
-      assert_equal %w(inactive default env), ff.variants.map(&:string)
+      config = resolver.get_config("ff")
+      assert_equal 3, config.variants.size
+      assert_equal %w(inactive default env), config.variants.map(&:string)
     end
   end
 
@@ -127,13 +140,17 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "Key:With:Colons" => Prefab::ConfigDelta.new(
+      "Key:With:Colons" => Prefab::Config.new(
         key: "Key:With:Colons",
-        default: Prefab::ConfigValue.new(string: "value"),
+        rows: [Prefab::ConfigRow.new(
+          value: Prefab::ConfigValue.new(string: "value")
+        )]
       ),
-      "proj:apikey" => Prefab::ConfigDelta.new(
+      "proj:apikey" => Prefab::Config.new(
         key: "proj:apikey",
-        default: Prefab::ConfigValue.new(string: "v2"),
+        rows: [Prefab::ConfigRow.new(
+          value: Prefab::ConfigValue.new(string: "v2")
+        )]
       )
     }
 
@@ -171,8 +188,8 @@ class TestConfigResolver < Minitest::Test
     end
   end
 
-  def resolver_for_namespace(namespace, loader, environment: "test")
-    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace, environment: environment), loader)
+  def resolver_for_namespace(namespace, loader, project_env_id: TEST_ENV_ID)
+    Prefab::ConfigResolver.new(MockBaseClient.new(namespace: namespace, project_env_id: project_env_id), loader)
   end
 
 end

data/test/test_feature_flag_client.rb

@@ -13,12 +13,12 @@ class TestFeatureFlagClient < Minitest::Test
   def test_pct
     feature = "FlagName"
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_weights:
                                                  Prefab::VariantWeights.new(weights: [
@@ -32,52 +32,52 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal false,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
   def test_basic_active_inactive
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_idx: 1)
     )
     assert_equal true,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: false,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_idx: 1)
     )
     assert_equal false,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal false,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
   def test_user_targets
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "user target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "user target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       user_targets: [
         variant_idx: 1,
@@ -87,22 +87,22 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "user target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
     assert_equal "user target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], flag, variants)
   end
 
   def test_inclusion_rule
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -115,9 +115,9 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
   end
 
@@ -135,7 +135,7 @@ class TestFeatureFlagClient < Minitest::Test
 
   def test_segments
     segment_key = "prefab-segment-beta-group"
-    @mock_base_client.mock_this_config(segment_key,
+    @mock_base_client.config_client.mock_this_config(segment_key,
                                        Prefab::Segment.new(
                                          name: "Beta Group",
                                          includes: ["user:1"]
@@ -143,13 +143,13 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -162,15 +162,15 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
   end
 
   def test_in_multiple_segments_has_or_behavior
     segment_key_one = "prefab-segment-segment-1"
-    @mock_base_client.mock_this_config(segment_key_one,
+    @mock_base_client.config_client.mock_this_config(segment_key_one,
                                        Prefab::Segment.new(
                                          name: "Segment-1",
                                          includes: ["user:1", "user:2"],
@@ -178,7 +178,7 @@ class TestFeatureFlagClient < Minitest::Test
                                        )
     )
     segment_key_two = "prefab-segment-segment-2"
-    @mock_base_client.mock_this_config(segment_key_two,
+    @mock_base_client.config_client.mock_this_config(segment_key_two,
                                        Prefab::Segment.new(
                                          name: "Segment-2",
                                          includes: ["user:3", "user:4"],
@@ -187,13 +187,13 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -206,15 +206,15 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:2", [], flag), "matches segment 1"
+                 @client.evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:4", [], flag)
+                 @client.evaluate(feature, "user:4", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:5", [], flag)
+                 @client.evaluate(feature, "user:5", [], flag, variants)
 
   end
 end

data/test/test_helper.rb

@@ -2,29 +2,50 @@ require 'minitest/autorun'
 require 'prefab-cloud-ruby'
 
 class MockBaseClient
-  attr_reader :namespace, :logger, :environment
+  STAGING_ENV_ID = 1
+  PRODUCTION_ENV_ID = 2
+  TEST_ENV_ID = 3
+  attr_reader :namespace, :logger, :project_env_id, :config_client
 
-  def initialize(environment: "test", namespace: "")
-    @environment = environment
+  def initialize(project_env_id: TEST_ENV_ID, namespace: "")
+    @project_env_id = project_env_id
     @namespace = namespace
     @logger = Logger.new($stdout)
-    @config_values = {}
+    @config_client = MockConfigClient.new
   end
 
   def project_id
     1
   end
 
+  def project_env_id
+    @project_env_id
+  end
+
   def log_internal level, message
   end
 
-  def mock_this_config key, config_value
-    @config_values[key] = config_value
+  def config_value key
+    @config_values[key]
   end
 
+end
+
+class MockConfigClient
+  def initialize(config_values = {})
+    @config_values = config_values
+  end
   def get(key)
     @config_values[key]
   end
+
+  def get_config(key)
+    Prefab::Config.new(value: @config_values[key], key: key)
+  end
+
+  def mock_this_config key, config_value
+    @config_values[key] = config_value
+  end
 end
 
 class MockConfigLoader

data/test/test_logger.rb

@@ -39,13 +39,3 @@ class TestCLogger < Minitest::Test
                  @logger.level_of("app.models.user")
   end
 end
-
-class MockConfigClient
-  def initialize(hash)
-    @hash = hash
-  end
-
-  def get(key)
-    @hash[key]
-  end
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -44,6 +44,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ld-eventsource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: grpc
   requirement: !ruby/object:Gem::Requirement