arkana 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92172ad1f72c9c868c0a2a56c3d4b39ff925c7f12e87726e49b899feaced2665
-  data.tar.gz: 902c779d2285c30fd456450fe3487ae66e990c2c96b3f2d71e96e8c2d77f06e9
+  metadata.gz: 17be699093098399339947f5a8d0df3d5ff20fdb8186cfc9bd92fa1c3aa330d2
+  data.tar.gz: e7b919f59bf5a491bfa9d4f166753f374a94a33a5023275e5d6d35549a0d1e58
 SHA512:
-  metadata.gz: a9c93524a1aae1403ce277ca40cbd9befa86c6f0f32b9762a03fcc7f52c6cc79fb6e900fe8a8c3b5a5ad95d23fd559c8da9afe3cac21d9e746d8f11dd20c67b5
-  data.tar.gz: ce59a330a1dc11e689e2fac24e4dbc1fcabcc2114ca648d205eb5b85181e3eb541b9aebbed6fa51469791275f98c6787b93890b9ff9f41d3258ef94c1dad27c9
+  metadata.gz: fde3754bfdb500ef9607827f14927ab0e0d678f70ee30398b238d56ba07729d27c967ab890c0b933432898cf8577e6ed3e642ed1ec442a85020c11d54f6d0b0f
+  data.tar.gz: 83880b13c6eeea494d7b85d5a73fe01cba9834156eb5d5d3a51d5cc9f7030a069e312eb98d3ab017861c67b818fcc9d1abe83de3bfb0850e3ddb520df4e80e07

data/bin/arkana

@@ -1,4 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require 'arkana'
-Arkana::run(ARGV)
+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,12 @@
+# 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
+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,56 @@
+# frozen_string_literal: true
+
+require "erb"
+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,15 @@
+# frozen_string_literal: true
+
+# This file was autogenerated by Arkana. Do not attempt to modify it.
+
+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'
+end

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

@@ -0,0 +1,52 @@
+<% require 'arkana/helpers/string' %>
+<% require 'arkana/helpers/swift_template_helper' %>
+<% # TODO: Sort these import statements alphabetically %>
+import Foundation
+import <%= @import_name %>Interfaces
+
+public enum <%= @namespace %> {
+    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: <%= @import_name %>GlobalProtocol {
+        public init() {}
+<% for secret in @global_secrets %>
+
+        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 %>: <%= @import_name %>EnvironmentProtocol {
+        public init() {}
+<% for secret in environment_protocol_secrets(environment) %>
+
+        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,15 @@
+<% require 'arkana/helpers/string' %>
+<% require 'arkana/helpers/swift_template_helper' %>
+import Foundation
+
+public protocol <%= @namespace %>GlobalProtocol {
+<% for secret in @global_secrets %>
+    var <%= secret.protocol_key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> { get }
+<% end %>
+}
+
+public protocol <%= @namespace %>EnvironmentProtocol {
+<% for secret in @environment_secrets.uniq(&:protocol_key) %>
+    var <%= secret.protocol_key.camel_case %>: <%= SwiftTemplateHelper.swift_type(secret.type) %> { get }
+<% end %>
+}

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

@@ -0,0 +1,41 @@
+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,15 @@
+# frozen_string_literal: true
+
+# This file was autogenerated by Arkana. Do not attempt to modify it.
+
+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,27 @@
+// swift-tools-version: 5.6
+
+// This file was autogenerated by Arkana. Do not attempt to modify it.
+
+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,36 @@
+// swift-tools-version: 5.6
+
+// This file was autogenerated by Arkana. Do not attempt to modify it.
+
+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.0.0"
+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

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: arkana
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Roger Oba
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-21 00:00:00.000000000 Z
-dependencies: []
+date: 2022-07-03 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:
 - rogerluan.oba@gmail.com
@@ -18,14 +60,42 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
 - 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: []
+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:
@@ -34,7 +104,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -44,5 +114,6 @@ requirements: []
 rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
-summary: Store your iOS keys and secrets away from your source code
+summary: Store your keys and secrets away from your source code. Designed for Android
+  and iOS projects.
 test_files: []

data/LICENSE

@@ -1,25 +0,0 @@
-BSD 2-Clause License
-
-Copyright (c) 2022, Roger Oba
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.