arkana-bitrise 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18b9c3836b57659a724f0c32a2448b21344bb9512fbd434df315a86b740a6129
+  data.tar.gz: 102f2dd14df51e0e78079c0485577bb2d881d8b4a5430708c1099a078311b943
+SHA512:
+  metadata.gz: 74a62ba2fbecf0cea025590c11e79c754461822644d9a80a420d438b9ae82666ce478854c59ae036f74aeda668280e4429ab2fe16e641039750f7d68bf04e44b
+  data.tar.gz: 7fd1ab9b7dce867112b1dd4380ba6ec39c54395c013d1f71558a16840a45403162f52490259472f82506a8ebc331c20c7cee1a61047b3683040e447c972ba096

data/bin/arkana

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "arkana"
+require "arkana/models/arguments"
+
+arguments = Arguments.new # Parses ARGV
+Arkana.run(arguments)

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "arkana"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/arkana/config_parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "models/config"
+require_relative "helpers/ui"
+
+# The config parser is responsible for parsing user CLI arguments, reading the config file and returning a `Config` object.
+module ConfigParser
+  # Parses the config file defined by the user (if any), returning a Config object.
+  #
+  # @return [Config] the config parsed from the user's options.
+  def self.parse(arguments)
+    yaml = YAML.load_file(arguments.config_filepath)
+    config = Config.new(yaml)
+    config.current_flavor = arguments.flavor
+    config.dotenv_filepath = arguments.dotenv_filepath
+    UI.warn("Dotenv file was specified but couldn't be found at '#{config.dotenv_filepath}'") if config.dotenv_filepath && !File.exist?(config.dotenv_filepath)
+    config
+  end
+end

data/lib/arkana/encoder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "arkana/helpers/string"
+
+# The encoder is responsible for finding the env vars for given keys, encoding them, and creating Secrets based on the generated data.
+module Encoder
+  # Fetches values of each key from ENV, and encodes them using the given salt.
+  #
+  # @return [Secret[]] an array of Secret objects, which contain their keys and encoded values.
+  def self.encode!(keys:, salt:, current_flavor:, environments:)
+    keys.map do |key|
+      secret = find_secret!(key: key, current_flavor: current_flavor)
+      encoded_value = encode(secret, salt.raw)
+      secret_type = Type.new(string_value: secret)
+      protocol_key = protocol_key(key: key, environments: environments)
+      Secret.new(key: key, protocol_key: protocol_key, encoded_value: encoded_value, type: secret_type)
+    end
+  end
+
+  # Encodes the given string, using the given cipher.
+  def self.encode(string, cipher)
+    bytes = string.encode("utf-8")
+    result = []
+    (0...bytes.length).each do |index|
+      byte = bytes[index].ord # Convert to its codepoint representation
+      result << (byte ^ cipher[index % cipher.length]) # XOR operation with a value of the cipher array.
+    end
+
+    encoded_key = []
+    result.each do |element|
+      # Warning: this might be specific to Swift implementation. When generating code for other languages, beware.
+      encoded_key << format("%#x", element) # Format the binary number to "0xAB" format.
+    end
+
+    encoded_key.join(", ")
+  end
+
+  def self.find_secret!(key:, current_flavor:)
+    flavor_key = "#{current_flavor.capitalize_first_letter}#{key}" if current_flavor
+    secret = ENV[flavor_key] if flavor_key
+    secret ||= ENV[key] || raise("Secret '#{flavor_key || key}' was declared but couldn't be found in the environment variables nor in the specified dotenv file.")
+    secret
+  end
+
+  def self.protocol_key(key:, environments:)
+    environments.filter_map do |env|
+      key.delete_suffix(env) if key.end_with?(env)
+    end.first || key
+  end
+end

data/lib/arkana/helpers/dotenv_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dotenv"
+
+# This helper is a mere utility used to facilitate and orchestrate the loading of multiple Dotenv files.
+module DotenvHelper
+  # Loads the appropriate dotenv file(s).
+  def self.load(config)
+    Dotenv.load(config.dotenv_filepath) if config.dotenv_filepath
+    # Must be loaded after loading the `config.dotenv_filepath` so they override each other in the right order
+    Dotenv.load(flavor_dotenv_filepath(config)) if config.current_flavor
+  end
+
+  def self.flavor_dotenv_filepath(config)
+    dotenv_dirname = File.dirname(config.dotenv_filepath)
+    flavor_dotenv_filename = ".env.#{config.current_flavor.downcase}"
+    File.join(dotenv_dirname, flavor_dotenv_filename)
+  end
+end

data/lib/arkana/helpers/string.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# String extensions and utilities.
+class String
+  # Returns a string converted from an assumed PascalCase, to camelCase.
+  def camel_case
+    return self if empty?
+
+    copy = dup
+    copy[0] = copy[0].downcase
+    copy
+  end
+
+  # Returns a string with its first character capitalized.
+  def capitalize_first_letter
+    return self if empty?
+
+    copy = dup
+    copy[0] = copy[0].upcase
+    copy
+  end
+end

data/lib/arkana/helpers/swift_template_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Utilities to reduce the amount of boilerplate code in `.swift.erb` template files.
+module SwiftTemplateHelper
+  def self.swift_type(type)
+    case type
+    when :string then "String"
+    when :boolean then "Bool"
+    else raise "Unknown variable type '#{type}' received.'"
+    end
+  end
+
+  def self.protocol_getter(declaration_strategy)
+    case declaration_strategy
+    when "lazy var" then "mutating get"
+    when "var", "let" then "get"
+    else raise "Unknown declaration strategy '#{declaration_strategy}' received.'"
+    end
+  end
+end

data/lib/arkana/helpers/ui.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "logger"
+require "colorize"
+
+# Contains utilities related to display information to the user on the Terminal (the user's interface).
+module UI
+  # Logs the message in red color and raise an error with the given message.
+  def self.crash(message)
+    logger.fatal(message.red)
+    raise message
+  end
+
+  # Logs the message in cyan color.
+  def self.debug(message)
+    logger.debug(message.cyan)
+  end
+
+  # Logs the message in green color.
+  def self.success(message)
+    logger.info(message.green)
+  end
+
+  # Logs the message in yellow color.
+  def self.warn(message)
+    logger.warn(message.yellow)
+  end
+
+  # Logger used to log all the messages.
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+end

data/lib/arkana/models/arguments.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+# Model that parses and documents the CLI options, using `OptionParser`.
+class Arguments
+  # @returns [string]
+  attr_reader :config_filepath
+  # @returns [string]
+  attr_reader :dotenv_filepath
+  # @returns [string]
+  attr_reader :flavor
+
+  def initialize
+    # Default values
+    @config_filepath = ".arkana.yml"
+    @dotenv_filepath = ".env" if File.exist?(".env")
+    @flavor = nil
+
+    OptionParser.new do |opt|
+      opt.on("-c", "--config-filepath /path/to/your/.arkana.yml", "Path to your config file. Defaults to '.arkana.yml'") do |o|
+        @config_filepath = o
+      end
+      opt.on("-e", "--dotenv-filepath /path/to/your/.env", "Path to your dotenv file. Defaults to '.env' if one exists.") do |o|
+        @dotenv_filepath = o
+      end
+      opt.on("-f", "--flavor FrostedFlakes", "Flavors are useful, for instance, when generating secrets for white-label projects. See the README for more information") do |o|
+        @flavor = o
+      end
+    end.parse!
+  end
+end

data/lib/arkana/models/config.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Model used to hold all the configuration set up by the user (both from CLI arguments and from the config file).
+class Config
+  # @returns [string[]]
+  attr_reader :environments
+  # @returns [string[]]
+  attr_reader :global_secrets
+  # @returns [string[]]
+  attr_reader :environment_secrets
+  # @returns [string]
+  attr_reader :import_name
+  # @returns [string]
+  attr_reader :namespace
+  # @returns [string]
+  attr_reader :pod_name
+  # @returns [string]
+  attr_reader :result_path
+  # @returns [string[]]
+  attr_reader :flavors
+  # @returns [string]
+  attr_reader :swift_declaration_strategy
+  # @returns [boolean]
+  attr_reader :should_generate_unit_tests
+  # @returns [string]
+  attr_reader :package_manager
+
+  # @returns [string]
+  attr_accessor :current_flavor
+  # @returns [string]
+  attr_accessor :dotenv_filepath
+
+  # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+  def initialize(yaml)
+    @environments = (yaml["environments"] || []).map(&:capitalize)
+    @environment_secrets = yaml["environment_secrets"] || []
+    @global_secrets = yaml["global_secrets"] || []
+    default_name = "ArkanaKeys"
+    @namespace = yaml["namespace"] || default_name
+    @import_name = yaml["import_name"] || default_name
+    @pod_name = yaml["pod_name"] || default_name
+    @result_path = yaml["result_path"] || default_name
+    @flavors = yaml["flavors"] || []
+    @swift_declaration_strategy = yaml["swift_declaration_strategy"] || "let"
+    @should_generate_unit_tests = yaml["should_generate_unit_tests"]
+    @should_generate_unit_tests = true if @should_generate_unit_tests.nil?
+    @package_manager = yaml["package_manager"] || "spm"
+  end
+  # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+  # TODO: Consider renaming this and environment_secrets, cuz they're confusing.
+  def environment_keys
+    result = environment_secrets.map do |k|
+      environments.map { |e| k + e }
+    end
+    result.flatten
+  end
+
+  def all_keys
+    global_secrets + environment_keys
+  end
+end

data/lib/arkana/models/salt.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+# Model used to hold the metadata for the salt bytes.
+class Salt
+  attr_reader :raw
+  # Salt, formatted as a string of comma-separated hexadecimal numbers, e.g. "0x94, 0x11, 0x1b, 0x6, 0x49, 0, 0xa7"
+  attr_reader :formatted
+
+  def initialize(raw:)
+    @raw = raw
+    formatted_salt = []
+    raw.each do |element|
+      # Warning: this might be specific to Swift implementation. When generating code for other languages, beware.
+      formatted_salt << format("%#x", element)
+    end
+    @formatted = formatted_salt.join(", ")
+  end
+end

data/lib/arkana/models/secret.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "type"
+
+# Model used to hold the metadata for a secret, such as its env var key, its protocol key, its type, and encoded value.
+class Secret
+  # @returns [string]
+  attr_accessor :key
+  # The same string as the key, except without the "environment" suffix.
+  # Used in the declaration of the protocol that defines the environment secrets.
+  # @returns [string]
+  attr_accessor :protocol_key
+  # Encoded value, formatted as a string of comma-separated hexadecimal numbers, e.g. "0x94, 0x11, 0x1b, 0x6, 0x49, 0, 0xa7"
+  # @returns [string]
+  attr_reader :encoded_value
+  # The type of the variable, as a language-agnostic enum.
+  # @returns [Type]
+  attr_reader :type
+
+  def initialize(key:, protocol_key:, encoded_value:, type:)
+    @key = key
+    @protocol_key = protocol_key
+    @encoded_value = encoded_value
+    @type = type
+  end
+
+  def environment
+    return :global if key == protocol_key
+    return key.delete_prefix(protocol_key) if key.start_with?(protocol_key)
+
+    raise("Precondition failure: the protocol_key '#{protocol_key}' is not the same as the key '#{key}' nor is its prefix. This state shouldn't be possible.")
+  end
+end

data/lib/arkana/models/template_arguments.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "arkana/models/secret"
+
+# A class that defines template arguments in a language-agnostic form.
+class TemplateArguments
+  # Generates template arguments for the given secrets and config specifications.
+  def initialize(environment_secrets:, global_secrets:, config:, salt:)
+    # The environments declared in the config file.
+    @environments = config.environments
+    # The salt used to encode all the secrets.
+    @salt = salt
+    # The encoded environment-specific secrets.
+    @environment_secrets = environment_secrets
+    # The encoded global secrets.
+    @global_secrets = global_secrets
+    # Name of the import statements (or the interfaces' prefixes).
+    @import_name = config.import_name
+    # Name of the pod that should be generated.
+    @pod_name = config.pod_name
+    # The top level namespace in which the keys will be generated. Often an enum.
+    @namespace = config.namespace
+    # The property declaration strategy declared in the config file.
+    @swift_declaration_strategy = config.swift_declaration_strategy
+    # Whether unit tests should be generated.
+    @should_generate_unit_tests = config.should_generate_unit_tests
+  end
+
+  def environment_protocol_secrets(environment)
+    @environment_secrets.select do |secret|
+      secret.environment == environment
+    end
+  end
+
+  # Generates a new test secret for a given key, using the salt stored.
+  def generate_test_secret(key:)
+    # Yes, we encode the key as the value because this is just for testing purposes
+    encoded_value = Encoder.encode(key, @salt.raw)
+    Secret.new(key: key, protocol_key: key, encoded_value: encoded_value, type: :string)
+  end
+
+  # Expose private `binding` method.
+  # rubocop:disable Naming/AccessorMethodName
+  def get_binding
+    binding
+  end
+  # rubocop:enable Naming/AccessorMethodName
+end

data/lib/arkana/models/type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# A namespace that defines language-agnostic variable types.
+module Type
+  STRING = :string
+  BOOLEAN = :boolean
+
+  def self.new(string_value:)
+    case string_value
+    when "true", "false"
+      BOOLEAN
+    else
+      STRING
+    end
+  end
+end

data/lib/arkana/salt_generator.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require_relative "models/salt"
+
+# Responsible for generating the salt.
+module SaltGenerator
+  SALT_LENGTH = 64
+
+  # Generates and returns a new Salt object.
+  #
+  # @return [Salt] the salt that was just generated.
+  def self.generate
+    chars = SecureRandom.random_bytes(SALT_LENGTH).chars # Convert array of random bytes to array of characters
+    codepoints = chars.map(&:ord) # Convert each character to its codepoint representation
+    Salt.new(raw: codepoints)
+  end
+end

data/lib/arkana/swift_code_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "erb"
+require "fileutils"
+require_relative "helpers/string"
+
+# Responsible for generating Swift source and test files.
+module SwiftCodeGenerator
+  # Generates Swift code and test files for the given template arguments.
+  def self.generate(template_arguments:, config:)
+    interface_swift_package_dir = File.join(config.result_path, "#{config.import_name}Interfaces")
+    set_up_interfaces_swift_package(interface_swift_package_dir, template_arguments, config)
+
+    swift_package_dir = File.join(config.result_path, config.import_name)
+    set_up_swift_package(swift_package_dir, template_arguments, config)
+  end
+
+  def self.set_up_interfaces_swift_package(path, template_arguments, config)
+    dirname = File.dirname(__FILE__)
+    readme_template = File.read("#{dirname}/templates/interfaces_readme.erb")
+    package_template = File.read("#{dirname}/templates/interfaces_package.swift.erb")
+    podspec_template = File.read("#{dirname}/templates/interfaces.podspec.erb")
+    sources_dir = File.join(path, "Sources")
+    source_template = File.read("#{dirname}/templates/arkana_protocol.swift.erb")
+    FileUtils.mkdir_p(path)
+    FileUtils.mkdir_p(sources_dir)
+    render(podspec_template, template_arguments, File.join(path, "#{config.pod_name.capitalize_first_letter}Interfaces.podspec")) if config.package_manager == "cocoapods"
+    render(readme_template, template_arguments, File.join(path, "README.md"))
+    render(package_template, template_arguments, File.join(path, "Package.swift"))
+    render(source_template, template_arguments, File.join(sources_dir, "#{config.import_name}Interfaces.swift"))
+  end
+
+  def self.set_up_swift_package(path, template_arguments, config)
+    dirname = File.dirname(__FILE__)
+    readme_template = File.read("#{dirname}/templates/readme.erb")
+    package_template = File.read("#{dirname}/templates/package.swift.erb")
+    sources_dir = File.join(path, "Sources")
+    source_template = File.read("#{dirname}/templates/arkana.swift.erb")
+    tests_dir = File.join(path, "Tests") if config.should_generate_unit_tests
+    tests_template = File.read("#{dirname}/templates/arkana_tests.swift.erb")
+    podspec_template = File.read("#{dirname}/templates/arkana.podspec.erb")
+    FileUtils.mkdir_p(path)
+    FileUtils.mkdir_p(sources_dir)
+    FileUtils.mkdir_p(tests_dir) if config.should_generate_unit_tests
+    render(readme_template, template_arguments, File.join(path, "README.md"))
+    render(package_template, template_arguments, File.join(path, "Package.swift"))
+    render(podspec_template, template_arguments, File.join(path, "#{config.pod_name.capitalize_first_letter}.podspec")) if config.package_manager == "cocoapods"
+    render(source_template, template_arguments, File.join(sources_dir, "#{config.import_name}.swift"))
+    render(tests_template, template_arguments, File.join(tests_dir, "#{config.import_name}Tests.swift")) if config.should_generate_unit_tests
+  end
+
+  def self.render(template, template_arguments, destination_file)
+    renderer = ERB.new(template, trim_mode: ">") # Don't automatically add newlines at the end of each template tag
+    result = renderer.result(template_arguments.get_binding)
+    File.write(destination_file, result)
+  end
+end

data/lib/arkana/templates/arkana.podspec.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY
+# Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+Pod::Spec.new do |spec|
+  spec.name                  = '<%= @pod_name %>'
+  spec.summary               = 'Contains env vars and secrets. Autogenerated by Arkana.'
+  spec.homepage              = 'https://github.com/rogerluan/arkana'
+  spec.version               = '1.0.0'
+  spec.authors               = { 'Arkana' => 'https://github.com/rogerluan/arkana' }
+  spec.source                = { path: "./" }
+  spec.source_files          = 'Sources/**/*.swift'
+  spec.ios.deployment_target = '11.0'
+  spec.swift_version         = '5.0'
+
+  spec.dependency '<%= @pod_name %>Interfaces', '~> 1.0.0'
+end

data/lib/arkana/templates/arkana.swift.erb

@@ -0,0 +1,58 @@
+<% require 'arkana/helpers/string' %>
+<% require 'arkana/helpers/swift_template_helper' %>
+<% # TODO: Sort these import statements alphabetically %>
+// DO NOT MODIFY
+// Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+import Foundation
+import <%= @import_name %>Interfaces
+
+public enum <%= @namespace %> {
+    @inline(__always)
+    fileprivate static let salt: [UInt8] = [
+        <%= @salt.formatted %>
+
+    ]
+
+    static func decode(encoded: [UInt8], cipher: [UInt8]) -> String {
+        return String(decoding: encoded.enumerated().map { offset, element in
+            element ^ cipher[offset % cipher.count]
+        }, as: UTF8.self)
+    }
+}
+
+public extension <%= @namespace %> {
+    struct Global: <%= @namespace %>GlobalProtocol {
+        public init() {}
+<% for secret in @global_secrets %>
+
+        @inline(__always)
+        public <%= @swift_declaration_strategy %> <%= secret.key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> = {
+            let encoded: [UInt8] = [
+                <%= secret.encoded_value %>
+
+            ]
+            return <%= @namespace %>.decode(encoded: encoded, cipher: <%= @namespace %>.salt)
+        }()
+<% end %>
+    }
+}
+
+<% for environment in @environments %>
+public extension <%= @namespace %> {
+    struct <%= environment %>: <%= @namespace %>EnvironmentProtocol {
+        public init() {}
+<% for secret in environment_protocol_secrets(environment) %>
+
+        @inline(__always)
+        public <%= @swift_declaration_strategy %> <%= secret.protocol_key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> = {
+            let encoded: [UInt8] = [
+                <%= secret.encoded_value %>
+
+            ]
+            return <%= @namespace %>.decode(encoded: encoded, cipher: <%= @namespace %>.salt)
+        }()
+<% end %>
+    }
+}
+<% end %>

data/lib/arkana/templates/arkana_protocol.swift.erb

@@ -0,0 +1,18 @@
+<% require 'arkana/helpers/string' %>
+<% require 'arkana/helpers/swift_template_helper' %>
+// DO NOT MODIFY
+// Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+import Foundation
+
+public protocol <%= @namespace %>GlobalProtocol {
+<% for secret in @global_secrets %>
+    var <%= secret.protocol_key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> { <%= SwiftTemplateHelper.protocol_getter(@swift_declaration_strategy) %> }
+<% end %>
+}
+
+public protocol <%= @namespace %>EnvironmentProtocol {
+<% for secret in @environment_secrets.uniq(&:protocol_key) %>
+    var <%= secret.protocol_key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> { <%= SwiftTemplateHelper.protocol_getter(@swift_declaration_strategy) %> }
+<% end %>
+}

data/lib/arkana/templates/arkana_tests.swift.erb

@@ -0,0 +1,44 @@
+// DO NOT MODIFY
+// Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+import Foundation
+import XCTest
+@testable import <%= @import_name %>
+
+
+final class <%= @namespace %>Tests: XCTestCase {
+    private var salt: [UInt8] = [
+        <%= @salt.formatted %>
+
+    ]
+
+    func test_decodeRandomHexKey_shouldDecode() {
+<% hex_key = SecureRandom.hex(64) %>
+<% secret = generate_test_secret(key: hex_key) %>
+        let encoded: [UInt8] = [
+            <%= secret.encoded_value %>
+
+        ]
+        XCTAssertEqual(<%= @namespace %>.decode(encoded: encoded, cipher: salt), "<%= hex_key %>")
+    }
+
+    func test_decodeRandomBase64Key_shouldDecode() {
+<% base64_key = SecureRandom.base64(64) %>
+<% secret = generate_test_secret(key: base64_key) %>
+        let encoded: [UInt8] = [
+            <%= secret.encoded_value %>
+
+        ]
+        XCTAssertEqual(<%= @namespace %>.decode(encoded: encoded, cipher: salt), "<%= base64_key %>")
+    }
+
+    func test_decodeUUIDKey_shouldDecode() {
+<% uuid_key = SecureRandom.uuid %>
+<% secret = generate_test_secret(key: uuid_key) %>
+        let encoded: [UInt8] = [
+            <%= secret.encoded_value %>
+
+        ]
+        XCTAssertEqual(<%= @namespace %>.decode(encoded: encoded, cipher: salt), "<%= uuid_key %>")
+    }
+}

data/lib/arkana/templates/interfaces.podspec.erb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# DO NOT MODIFY
+# Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+Pod::Spec.new do |spec|
+  spec.name                  = '<%= @pod_name %>Interfaces'
+  spec.summary               = 'Contains env vars and secrets. Autogenerated by Arkana.'
+  spec.homepage              = 'https://github.com/rogerluan/arkana'
+  spec.version               = '1.0.0'
+  spec.authors               = { 'Arkana' => 'https://github.com/rogerluan/arkana' }
+  spec.source                = { path: "./" }
+  spec.source_files          = 'Sources/**/*.swift'
+  spec.ios.deployment_target = '11.0'
+  spec.swift_version         = '5.0'
+end

data/lib/arkana/templates/interfaces_package.swift.erb

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.6
+
+// DO NOT MODIFY
+// Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+import PackageDescription
+
+let package = Package(
+    name: "<%= @import_name %>Interfaces",
+    platforms: [
+        .macOS(.v11),
+        .iOS(.v11),
+    ],
+    products: [
+        .library(
+            name: "<%= @import_name %>Interfaces",
+            targets: ["<%= @import_name %>Interfaces"]
+        ),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "<%= @import_name %>Interfaces",
+            dependencies: [],
+            path: "Sources"
+        ),
+    ]
+)

data/lib/arkana/templates/interfaces_readme.erb

@@ -0,0 +1,3 @@
+# <%= @namespace %>Interfaces
+
+This Package was autogenerated by [Arkana](https://github.com/rogerluan/arkana). Do not attempt to modify it manually, otherwise your changes will be overriden in the next code generation process. Please visit [Arkana](https://github.com/rogerluan/arkana) to read more.

data/lib/arkana/templates/package.swift.erb

@@ -0,0 +1,37 @@
+// swift-tools-version: 5.6
+
+// DO NOT MODIFY
+// Automatically generated by Arkana (https://github.com/rogerluan/arkana)
+
+import PackageDescription
+
+let package = Package(
+    name: "<%= @import_name %>",
+    platforms: [
+        .macOS(.v11),
+        .iOS(.v11),
+    ],
+    products: [
+        .library(
+            name: "<%= @import_name %>",
+            targets: ["<%= @import_name %>"]
+        ),
+    ],
+    dependencies: [
+        .package(name: "<%= @import_name%>Interfaces", path: "../<%= @import_name%>Interfaces"),
+    ],
+    targets: [
+        .target(
+            name: "<%= @import_name %>",
+            dependencies: ["<%= @import_name %>Interfaces"],
+            path: "Sources"
+        ),
+<% if @should_generate_unit_tests %>
+        .testTarget(
+            name: "<%= @import_name %>Tests",
+            dependencies: ["<%= @import_name %>"],
+            path: "Tests"
+        ),
+<% end %>
+    ]
+)

data/lib/arkana/templates/readme.erb

@@ -0,0 +1,4 @@
+# <%= @namespace %>
+
+
+This Package is autogenerated by [Arkana](https://github.com/rogerluan/arkana). Do not attempt to modify it manually, otherwise your changes will be overriden on the next code generation process. Please visit [Arkana](https://github.com/rogerluan/arkana) to read more.

data/lib/arkana/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Arkana
+  VERSION = "1.1.1"
+end

data/lib/arkana.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "arkana/config_parser"
+require_relative "arkana/encoder"
+require_relative "arkana/helpers/dotenv_helper"
+require_relative "arkana/models/template_arguments"
+require_relative "arkana/salt_generator"
+require_relative "arkana/swift_code_generator"
+require_relative "arkana/version"
+
+# Top-level namespace for Arkana's execution entry point. When ran from CLI, `Arkana.run` is what is invoked.
+module Arkana
+  def self.run(arguments)
+    config = ConfigParser.parse(arguments)
+    salt = SaltGenerator.generate
+    DotenvHelper.load(config)
+
+    begin
+      environment_secrets = Encoder.encode!(
+        keys: config.environment_keys,
+        salt: salt,
+        current_flavor: config.current_flavor,
+        environments: config.environments,
+      )
+      global_secrets = Encoder.encode!(
+        keys: config.global_secrets,
+        salt: salt,
+        current_flavor: config.current_flavor,
+        environments: config.environments,
+      )
+    rescue StandardError => e
+      # TODO: Improve this by creating an Env/Debug helper
+      puts("Something went wrong when parsing and encoding your secrets.")
+      puts("Current Flavor: #{config.current_flavor}")
+      puts("Dotenv Filepath: #{config.dotenv_filepath}")
+      puts("Config Filepath: #{arguments.config_filepath}")
+      raise e
+    end
+    template_arguments = TemplateArguments.new(
+      environment_secrets: environment_secrets,
+      global_secrets: global_secrets,
+      config: config,
+      salt: salt,
+    )
+    SwiftCodeGenerator.generate(
+      template_arguments: template_arguments,
+      config: config,
+    )
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: arkana-bitrise
+version: !ruby/object:Gem::Version
+  version: 1.1.2
+platform: ruby
+authors:
+- Erfan Andesta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: 
+email:
+- andesta.erfan@gmail.com
+executables:
+- arkana
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/arkana
+- bin/console
+- bin/setup
+- lib/arkana.rb
+- lib/arkana/config_parser.rb
+- lib/arkana/encoder.rb
+- lib/arkana/helpers/dotenv_helper.rb
+- lib/arkana/helpers/string.rb
+- lib/arkana/helpers/swift_template_helper.rb
+- lib/arkana/helpers/ui.rb
+- lib/arkana/models/arguments.rb
+- lib/arkana/models/config.rb
+- lib/arkana/models/salt.rb
+- lib/arkana/models/secret.rb
+- lib/arkana/models/template_arguments.rb
+- lib/arkana/models/type.rb
+- lib/arkana/salt_generator.rb
+- lib/arkana/swift_code_generator.rb
+- lib/arkana/templates/arkana.podspec.erb
+- lib/arkana/templates/arkana.swift.erb
+- lib/arkana/templates/arkana_protocol.swift.erb
+- lib/arkana/templates/arkana_tests.swift.erb
+- lib/arkana/templates/interfaces.podspec.erb
+- lib/arkana/templates/interfaces_package.swift.erb
+- lib/arkana/templates/interfaces_readme.erb
+- lib/arkana/templates/package.swift.erb
+- lib/arkana/templates/readme.erb
+- lib/arkana/version.rb
+homepage: https://github.com/rogerluan/arkana
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/rogerluan/arkana
+  source_code_uri: https://github.com/rogerluan/arkana
+  changelog_uri: https://github.com/rogerluan/arkana/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.9
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Store your keys and secrets away from your source code. Designed for Android
+  and iOS projects.
+test_files: []