launchdarkly_api_helper 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48a1fa66d19b0af509741df158d57e04cbcd379e1cc0f921bd8755bfd2b8bfd6
-  data.tar.gz: 10fe7dcfb0fe90a797f874b56c2f99deecc0e69028e7d58fbd69c84f5b1e41b4
+  metadata.gz: f063313104693353f6dd3e18a6ecd69c5142b62eb3f072b08f96b8b51e9175e0
+  data.tar.gz: 1f83a4dc6665e8864605decdb1d265178232785d44cca584488533fe21bd4ce6
 SHA512:
-  metadata.gz: 1349639032b66a4091b84d0188d0b5935dd5758aa5ab4eede29c57312972d57b1b648988dc135ceba8b82fd4c8425d451235436f7723b85da54945dcb8dc0ff4
-  data.tar.gz: b1de7f7890f2f68d19b31936b789670aefab91b259676f5c2aa26d6aa093156fa0f9a13950640e95451d9f9153aa7180f7930818d9099a37c0317ab9c47eb327
+  metadata.gz: e9fadbf1588e1d429f3cf3d1bf9bcccf6b06bda032baa707970a65714321a970e8e5d8f952baa99be5115e4986564c45bbcfcc07034f829637522569e5fd9f15
+  data.tar.gz: b947d46ef24947acba122a57ce2e2c582af6342806e357de59864523ba4b8e78e9d81185dc6f51d4b183621d94b97d206840d020dc5226731db866ef77a25c7a

data/.rubocop.yml

@@ -9,12 +9,21 @@ Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
 
+Style/OptionalBooleanParameter:
+  Enabled: false
+
 Layout/LineLength:
   Max: 120
 
 Metrics/MethodLength:
   Max: 100
 
+Metrics/MethodName:
+  Max: 100
+
+Metrics/ClassLength:
+  Max: 150
+
 Metrics/AbcSize:
   Enabled: false
 

data/README.md

@@ -1,8 +1,10 @@
 # LaunchdarklyApiHelper
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/launchdarkly_api_helper`. To experiment with that code, run `bin/console` for an interactive prompt.
+[LaunchDarklyApiHelper](https://rubygems.org/gems/launchdarkly_api_helper) provides you a way to access your [Launch Darkly](https://apidocs.launchdarkly.com/) account using [API token](https://app.launchdarkly.com/settings/authorization/tokens/new) to view, edit or delete them accordingly.
 
-TODO: Delete this and the text above, and describe your gem
+![alt text](https://docs.launchdarkly.com/static/de107a76f0cd388da14d5bd650ec1f5c/b8471/settings-access-tokens-obscured-callout.png)
+
+[Launch Darkly API Documentation](https://apidocs.launchdarkly.com/)
 
 ## Installation
 
@@ -16,7 +18,193 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+add `require 'launchdarkly_api_helper'` line at the beginning of your Ruby file
+
+add `include LaunchdarklyApiHelper` line to access LaunchdarklyApiHelper module in gem _launchdarkly_api_helper_
+
+To perform any operations such as add, remove, replace, move, copy, test you should have a working knowledge of [JSON Patch](https://datatracker.ietf.org/doc/html/rfc6902)
+
+```ruby
+parameters:
+access_token (*required): this token will be used to send all requests to LaunchDarkly (string)
+log_file: all logs will be writeen to file 'launchdarkly.log' by default if no file name specified
+
+# set your LD API token and log file to capture logs
+def ld_access_token(access_token, log_file = 'launchdarkly.log') 
+  # code ...
+end
+```
+
+[Get feature flag](https://apidocs.launchdarkly.com/tag/Feature-flags#operation/getFeatureFlag)
+
+```ruby
+GET REQUEST
+https://app.launchdarkly.com/api/v2/flags/default/developer_flag_for_regression
+
+parameters:
+env (*required): name of the environment for which you want to get the details (string)
+flag (*required): name of the feature flag for which you want to get the details (string)
+                                             
+Here, 'developer_flag_for_regression' is the feature flag name and default is our Project name - eg. AmitSinghBisht
+By default, this returns the configurations for all environments
+You can filter environments with the env query parameter. For example, setting env=staging restricts the returned configurations to just the staging environment
+https://app.launchdarkly.com/api/v2/flags/default/developer_flag_for_regression?env=staging
+
+# this method will give you entire details about a flag for that particular environment
+def ld_fetch_flag_details(env, flag)
+  # code ...
+end
+
+@return value (response of feature flag details):
+response = "https://app.launchdarkly.com/api/v2/flags/default/#{flag}?env=#{env}" (string)
+```
+
+```ruby
+Get toggle status feature flag
+
+parameters:
+env (*required): name of the environment for which you want to get the details (string) 
+flag (*required): name of the feature flag for which you want to get the details (string)
+
+response = https://app.launchdarkly.com/api/v2/flags/default/developer_flag_for_regression?env=staging
+grab the value of the ['environments'][env]['on'] obtained from the above response
+
+# this method will return the status of the flag, whether it is on or off viz set to true or false
+def ld_fetch_flag_toggle_status(env, flag)
+  # code ...
+end
+
+@return value (response of feature flag toggle status):
+response = "https://app.launchdarkly.com/api/v2/flags/default/#{flag}?env=#{env}"
+response['environments'][env]['on'] (boolean)
+```
+
+```ruby
+Create a feature flag
+https://apidocs.launchdarkly.com/tag/Feature-flags/#operation/postFeatureFlag
+
+POST REQUEST
+https://app.launchdarkly.com/api/v2/flags/default
+
+Here, default is our Project name - eg. AmitSinghBisht
+
+parameters:
+key (*required): A unique key used to reference the feature flag in your code (string)
+name (*required): A human-friendly name for the feature flag (string)
+description: Description of the feature flag. Defaults to an empty string (string)
+tags: Tags for the feature flag. Defaults to an empty array (Array of strings)
+variations: An array of possible variations for the flag. The variation values must be unique. If omitted, two boolean variations of true and false will be used (Array of objects)
+
+defaults
+  * onVariation (*required): The index, from the array of variations for this flag, of the variation to serve by default when targeting is on (integer)
+  * offVariation (*required): The index, from the array of variations for this flag, of the variation to serve by default when targeting is off (integer)
+
+{
+  "key": "developer_flag_for_regression",
+  "name": "developer_flag_for_regression",
+  "description": "developer_flag_for_regression is created via regression api on 18_10_2022",
+  "tags": [
+    "created_via_regression_api_on_18_10_2022"
+  ],
+  "variations": [
+    {
+      "age": 10
+    },
+    {
+      "age": 20
+    }
+  ],
+  "defaults": {
+    "onVariation": 1,
+    "offVariation": 0
+  }
+}
+
+Above code will create a key 'developer_flag_for_regression' with name as 'developer_flag_for_regression' and description as 'developer_flag_for_regression is created via regression api on 18_10_2022'
+
+Variations are provided while creating key, by default variation is a boolean value (true and false). once flag with a specific variation is created, its type cannot be modified later, hence choose your variation type smartly (Boolean, String, Number, JSON) In above example we are creating a flag with JSON type and its two values are 'age': 10 and 'age': 20
+
+Also, variation has by default two values, and you must also define two variations while creating your own custom feature flag
+
+Default will specify which variation to serve when flag is on or off. In above example when flag is turned on, '1' variation is served [Note: 0 and 1 are index position], so variations at first index ie variations[1] will be served when flag is turned on ie 'age': 20
+
+# this method will create a new feature flag, NOTE: feature falg are created at global level and environment resides inside feature flag
+def ld_create_flag(key, name = key, description = key, tags = ['created_via_regression_api'])
+  # code ...
+end
+```
+
+```ruby
+Update feature flag
+https://apidocs.launchdarkly.com/tag/Feature-flags#operation/patchFeatureFlag
+
+PATCH REQUEST
+https://app.launchdarkly.com/api/v2/flags/default/developer_flag_for_regression
+
+parameters:
+env (*required): name of the environment for which you want to get the details (string)
+flag (*required): name of the feature flag for which you want to get the details (string)
+flag_value: status of the feature flag that you want to set either on (true) or off (false) (boolean)
+
+Here, 'developer_flag_for_regression' is the flag key and default is our Project name - eg. AmitSinghBisht
+You can update any parameter of feature flag using this method
+
+# this method will be used to toggle status of feature flag either on / off for a particular environment
+def ld_toggle_specific_environment(env, flag, flag_value = true)
+  # code ...
+end
+
+@return value (response of feature flag toggle status):
+response = "https://app.launchdarkly.com/api/v2/flags/default/#{flag}?env=#{env}"
+response['environments'][env]['on'] (boolean)
+```
+
+```ruby
+Get status of feature flag
+https://apidocs.launchdarkly.com/tag/Feature-flags#operation/patchFeatureFlag
+ 
+def ld_toggle_variation_served(env, flag)
+  # code ...
+end
+
+@returns: [fetch_flag_toggle_status_response, feature_flag_variation_index_response, feature_flag_variation_value_response, feature_flag_variation_name_response]
+@return parameter:
+response = "https://app.launchdarkly.com/api/v2/flags/default/#{flag}?env=#{env}"
+fetch_flag_toggle_status_response: response['environments'][env]['on'] (boolean)
+feature_flag_variation_index_response: response (integer)
+feature_flag_variation_value_response: response['variations'][feature_flag_variation_index_response]['value'] (object)
+feature_flag_variation_name_response: response['variations'][feature_flag_variation_index_response]['name'] (string)
+```
+
+```ruby
+def ld_rules_clauses_index(env, flag, clause_name)
+  # code ...
+end
+```
+
+```ruby
+def ld_get_values_from_clauses(env, flag, clause_name)
+  # code ...
+end
+```
+
+```ruby
+def ld_add_values_to_clause(env, flag, clause_name, clause_value)
+  # code ...
+end
+```
+
+```ruby
+def ld__remove_values_from_clause(env, flag, clause_name, clause_value)
+  # code ...
+end
+```
+
+```ruby
+def ld_delete_flag(flag)
+  # code ...
+end
+```
 
 ## Development
 

data/lib/launchdarkly_api_helper/constants.rb

@@ -21,4 +21,4 @@ REQUEST_CLASSES = {
     'code' => 204,
     'message' => 'No Content'
   }
-}.freeze
+}.freeze

data/lib/launchdarkly_api_helper/launchdarkly_api_helper_class.rb

@@ -59,18 +59,18 @@ class LaunchdarklyApiHelperClass
     ld_request(:post, request_url, request_body)
   end
 
-  def toggle_flag_for_specific_environment(env, flag, flag_value)
+  def toggle_specific_environment(env, flag, flag_value)
     request_url = "#{LAUNCH_DARKLY_FLAGS}/#{flag}"
     request_body = { 'op' => 'replace', 'path' => "/environments/#{env}/on", 'value' => flag_value }
     response_body = ld_request(:patch, request_url, [request_body])
     response_body['environments'][env]['on']
   end
 
-  def feature_flag_variation_index(fetch_flag_toggle_status_response, fetch_flag_details_response)
-    variations = fetch_flag_details_response['variations']
+  def feature_flag_variation_index(status_response, details_response)
+    variations = details_response['variations']
     value_at_index = -1
     variations.length.times do |index|
-      next unless variations[index]['value'].eql? fetch_flag_toggle_status_response
+      next unless variations[index]['value'].eql? status_response
 
       value_at_index = index
       break
@@ -78,60 +78,81 @@ class LaunchdarklyApiHelperClass
     value_at_index
   end
 
-  def feature_flag_variation_value(fetch_flag_details_response, feature_flag_variation_index_response)
-    fetch_flag_details_response['variations'][feature_flag_variation_index_response]['value']
+  def feature_flag_variation_value(details_response, index_response)
+    details_response['variations'][index_response]['value']
   end
 
-  def feature_flag_variation_name(fetch_flag_details_response, feature_flag_variation_index_response)
-    fetch_flag_details_response['variations'][feature_flag_variation_index_response]['name']
+  def feature_flag_variation_name(details_response, index_response)
+    details_response['variations'][index_response]['name']
   end
 
-  def toggle_variation_served_status(env, flag)
-    fetch_flag_details_response = fetch_flag_details(env, flag)
-    fetch_flag_toggle_status_response = fetch_flag_toggle_status(env, flag)
-    feature_flag_variation_index_response = feature_flag_variation_index(fetch_flag_toggle_status_response, fetch_flag_details_response) # ['environments'][env]['fallthrough']['variation']
-    feature_flag_variation_value_response = feature_flag_variation_value(fetch_flag_details_response, feature_flag_variation_index_response) # ['variations'][feature_flag_variation_index_response]['value']
-    feature_flag_variation_name_response = feature_flag_variation_name(fetch_flag_details_response, feature_flag_variation_index_response)
-    [fetch_flag_toggle_status_response, feature_flag_variation_index_response, feature_flag_variation_value_response, feature_flag_variation_name_response]
+  def ld_toggle_variation_served(env, flag)
+    details_response = fetch_flag_details(env, flag)
+    toggle_status_response = fetch_flag_toggle_status(env, flag)
+    variation_index_response = feature_flag_variation_index(toggle_status_response, details_response) # ['environments'][env]['fallthrough']['variation']
+    variation_value_response = feature_flag_variation_value(details_response, variation_index_response) # ['variations'][variation_index_response]['value']
+    variation_name_response = feature_flag_variation_name(details_response, variation_index_response)
+    [toggle_status_response, variation_index_response, variation_value_response, variation_name_response]
   end
 
-  def search_value_in_hash(feature_flag_hash, attribute)
+  def search_rule_index_clause_index(clause_name)
+    rule_at_index = -1
+    clause_at_index = -1
+    @feature_flag_rules_list.length.times do |rule_index|
+      @feature_flag_clauses_list = @feature_flag_rules_list[rule_index]['clauses']
+      @feature_flag_clauses_list.length.times do |clause_index|
+        next unless @feature_flag_clauses_list[clause_index]['attribute'].eql? clause_name
+
+        rule_at_index = rule_index
+        clause_at_index = clause_index
+        break
+      end
+    end
+    [rule_at_index, clause_at_index]
+  end
+
+  def search_value_index(rule_at_index, clause_at_index, clause_value)
     value_at_index = -1
-    feature_flag_hash.length.times do |index|
-      next unless feature_flag_hash[index].to_s.include? attribute.to_s
+    @feature_flag_values_list = @feature_flag_rules_list[rule_at_index]['clauses'][clause_at_index]['values']
+    @feature_flag_values_list.length.times do |value_index|
+      next unless @feature_flag_values_list[value_index].eql? clause_value
 
-      value_at_index = index
+      value_at_index = value_index
       break
     end
     value_at_index
   end
 
-  def feature_flag_rules_clauses_index(flag, attribute, env = ENV['PROFILE'])
-    @feature_flag_response = fetch_flag(flag, env)
-    feature_flag_env = @feature_flag_response['environments'][env]
-    @feature_flag_env_rules = feature_flag_env['rules']
-    rule_index = search_value_in_hash(@feature_flag_env_rules, attribute)
-    @feature_flag_env_rules_clauses = @feature_flag_env_rules[rule_index]['clauses']
-    clause_index = search_value_in_hash(@feature_flag_env_rules_clauses, attribute)
-    [rule_index, clause_index]
+  def rules_clauses_index(env, flag, clause_name)
+    feature_flag_response = fetch_flag_details(env, flag)
+    @feature_flag_rules_list = feature_flag_response['environments'][env]['rules']
+    search_rule_index_clause_index(clause_name)
   end
 
-  def feature_flag_add_values_to_rules(flag, attribute, value, env = ENV['PROFILE'])
-    @flag = flag
-    @attribute = attribute
-    @value = value
-    @rule_index, @clause_index = feature_flag_rules_clauses_index(flag, attribute)
+  def get_values_from_clauses(env, flag, clause_name)
+    rule_at_index, clause_at_index = feature_flag_rules_clauses_index(env, flag, clause_name)
+    @feature_flag_rules_list[rule_at_index]['clauses'][clause_at_index]['values']
+  end
+
+  def add_values_to_clause(env, flag, clause_name, clause_value)
+    rule_at_index, clause_at_index = feature_flag_rules_clauses_index(env, flag, clause_name)
     request_url = "#{LAUNCH_DARKLY_FLAGS}/#{flag}"
-    request_body = { 'op' => 'add', 'path' => "/environments/#{env}/rules/#{@rule_index}/clauses/#{@clause_index}/values/0", 'value' => value }
+    request_body = { 'op' => 'add', 'path' => "/environments/#{env}/rules/#{rule_at_index}/clauses/#{clause_at_index}/values/0", 'value' => clause_value }
     ld_request(:patch, request_url, [request_body])
   end
 
-  def feature_flag_remove_values_to_rules(flag = @flag, attribute = @attribute, value = @value, env = ENV['PROFILE'])
-    @rule_index, @clause_index = feature_flag_rules_clauses_index(flag, attribute, env = ENV['PROFILE']) unless flag || attribute
-    feature_flag_env_rules_clauses_values = @feature_flag_env_rules_clauses[@clause_index]['values']
-    value_index = search_value_in_hash(feature_flag_env_rules_clauses_values, value)
+  def remove_values_from_clause(env, flag, clause_name, clause_value)
+    rule_at_index, clause_at_index = feature_flag_rules_clauses_index(env, flag, clause_name)
+    value_at_index = search_value_index(rule_at_index, clause_at_index, clause_value)
+    puts "value_index: #{value_at_index}"
     request_url = "#{LAUNCH_DARKLY_FLAGS}/#{flag}"
-    request_body = { 'op': 'test', 'path': "/environments/#{env}/rules/#{@rule_index}/clauses/#{@clause_index}/values/#{value_index}", 'value': value }, { 'op' => 'remove', 'path' => "/environments/#{env}/rules/#{@rule_index}/clauses/#{@clause_index}/values/#{value_index}" }
+    request_body = { 'op' => 'test', 'path' => "/environments/#{env}/rules/#{rule_at_index}/clauses/#{clause_at_index}/values/#{value_at_index}", 'value' => clause_value },
+                   { 'op' => 'remove', 'path' => "/environments/#{env}/rules/#{rule_at_index}/clauses/#{clause_at_index}/values/#{value_at_index}" }
     ld_request(:patch, request_url, request_body)
   end
+
+  def delete_flag(flag)
+    request_url = "#{LAUNCH_DARKLY_FLAGS}/#{flag}"
+    ld_request(:delete, request_url)
+  end
 end

data/lib/launchdarkly_api_helper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LaunchdarklyApiHelper
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/launchdarkly_api_helper.rb

@@ -135,8 +135,8 @@ module LaunchdarklyApiHelper
   # == Here, 'developer_flag_for_regression' is the flag key and default is our Project name - Browserstack
   # == You can update any parameter of feature flag using this method
 
-  def ld_toggle_flag_for_specific_environment(env, flag, flag_value = true)
-    @launchdarkly_helper.toggle_flag_for_specific_environment(env, flag, flag_value)
+  def ld_toggle_specific_environment(env, flag, flag_value = true)
+    @launchdarkly_helper.toggle_specific_environment(env, flag, flag_value)
   end
 
   # == Get status of feature flag
@@ -144,12 +144,27 @@ module LaunchdarklyApiHelper
   #
   # [fetch_flag_toggle_status_response, feature_flag_variation_index_response, feature_flag_variation_value_response, feature_flag_variation_name_response]
 
-  def ld_toggle_variation_served_status(env, flag)
-    @launchdarkly_helper.toggle_variation_served_status(env, flag)
+  def ld_toggle_variation_served(env, flag)
+    @launchdarkly_helper.ld_toggle_variation_served(env, flag)
   end
 
-  def delete_flag(flag)
-    request_url = "#{LAUNCH_DARKLY_FLAGS}/#{flag}"
-    ld_request(:delete, request_url)
+  def ld_rules_clauses_index(env, flag, clause_name)
+    @launchdarkly_helper.rules_clauses_index(env, flag, clause_name)
+  end
+
+  def ld_get_values_from_clauses(env, flag, clause_name)
+    @launchdarkly_helper.get_values_from_clauses(env, flag, clause_name)
+  end
+
+  def ld_add_values_to_clause(env, flag, clause_name, clause_value)
+    @launchdarkly_helper.add_values_to_clause(env, flag, clause_name, clause_value)
+  end
+
+  def ld__remove_values_from_clause(env, flag, clause_name, clause_value)
+    @launchdarkly_helper.remove_values_from_clause(env, flag, clause_name, clause_value)
+  end
+
+  def ld_delete_flag(flag)
+    @launchdarkly_helper.delete_flag(flag)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly_api_helper
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - amit-singh-bisht
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-18 00:00:00.000000000 Z
+date: 2022-11-19 00:00:00.000000000 Z
 dependencies: []
 description: Write a longer description or delete this line.
 email: