secure-keys 1.1.2 → 1.1.4

data/lib/core/utils/extensions/string/to_bool.rb

@@ -0,0 +1,16 @@
+# Adds some useful methods to the String class
+module BooleanCasting
+  # Casts a string to a boolean
+  # @return [Boolean] the boolean value of the string
+  def to_bool
+    return self if [true, false].include?(self)
+    return false if nil? || empty?
+    return false if self =~ /^(false|f|no|n|0)$/i
+    return true if self =~ /^(true|t|yes|y|1)$/i
+
+    # If the string is not a boolean, return false by default
+    false
+  end
+  alias to_b to_bool
+  alias to_boolean to_bool
+end

data/lib/core/utils/swift/package.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require_relative './swift'
+require_relative '../../console/shell'
 
 module SecureKeys
   module Swift
@@ -14,7 +15,7 @@ module SecureKeys
           swift package init --name #{SWIFT_PACKAGE_NAME} --type library
         BASH
 
-        system(command)
+        Core::Console::Shell.sh(command:)
       end
     end
   end

data/lib/core/utils/swift/writer.rb

@@ -30,8 +30,6 @@ module SecureKeys
         end
       end
 
-      private
-
       # Generate the formatted keys content using Swift code format
       # @return [String] The formatted keys content
       def formatted_keys
@@ -44,7 +42,7 @@ module SecureKeys
             /// The decrypted value of the key
             public var decryptedValue: String {
                 switch self {
-                    #{mapped_keys.map { |key| switch_case_key_declaration_template(name: key[:name], value: key[:value], iv: key[:iv], tag: key[:tag]) }.join("\t\t\t")}
+                    #{mapped_keys.map { |key| switch_case_key_declaration_template(name: key[:name], value: key[:value], iv: key[:iv], tag: key[:tag]) }.join("\t\t")}
                     case .unknown: fatalError("Unknown key \\(rawValue)")
                 }
             }
@@ -61,25 +59,7 @@ module SecureKeys
         import Foundation
         import CryptoKit
 
-        // MARK: - Global methods
-
-        /// Fetch the decrypted value of the key
-        ///
-        /// - Parameter:
-        ///    - key: The key to fetch the decrypted value for
-        ///
-        /// - Returns: The decrypted value of the key
-        @available(iOS 13.0, *)
-        public func key(for key: SecureKey) -> String { key.decryptedValue }
-
-        /// Fetch the decrypted value of the key
-        ///
-        /// - Parameter:
-        ///    - key: The key to fetch the decrypted value for
-        ///
-        /// - Returns: The decrypted value of the key
-        @available(iOS 13.0, *)
-        public func key(_ key: SecureKey) -> String { key.decryptedValue }
+        #{key_swift_global_helper_functions}
 
         // MARK: - SecureKey enum
 
@@ -92,50 +72,95 @@ module SecureKeys
             #{content}
         }
 
-        // MARK: - Decrypt keys from array extension
+        #{key_array_decrypt_swift_extension}
 
-        @available(iOS 13.0, *)
-        extension Array where Element == UInt8 {
+        #{key_string_swift_extension}
 
-            // MARK: - Methods
+        // swiftlint:enable all
+        SWIFT
+      end
 
-            func decrypt(key: [UInt8], iv: [UInt8], tag: [UInt8]) -> String {
-                guard let sealedBox = try? AES.GCM.SealedBox(nonce: AES.GCM.Nonce(data: Data(iv)),
-                                                             ciphertext: Data(self),
-                                                             tag: Data(tag)),
-                      let decryptedData = try? AES.GCM.open(sealedBox, using: SymmetricKey(data: Data(key))),
-                      let decryptedKey = String(data: decryptedData, encoding: .utf8) else {
-                    fatalError("Failed to decrypt the key")
-                }
-                return decryptedKey
-            }
-        }
+      private
 
-        // MARK: - String extension for secure keys
+      # Generate the key global helper functions
+      # @return [String] The key global helper functions
+      def key_swift_global_helper_functions
+        <<~SWIFT
+          // MARK: - Global methods
+
+          /// Fetch the decrypted value of the key
+          ///
+          /// - Parameter:
+          ///    - key: The key to fetch the decrypted value for
+          ///
+          /// - Returns: The decrypted value of the key
+          @available(iOS 13.0, *)
+          public func key(for key: SecureKey) -> String { key.decryptedValue }
+
+          /// Fetch the decrypted value of the key
+          ///
+          /// - Parameter:
+          ///    - key: The key to fetch the decrypted value for
+          ///
+          /// - Returns: The decrypted value of the key
+          @available(iOS 13.0, *)
+          public func key(_ key: SecureKey) -> String { key.decryptedValue }
+        SWIFT
+      end
 
-        @available(iOS 13.0, *)
-        extension String {
+      # Generate the key array decrypt extension
+      # @return [String] The key array decrypt extension
+      def key_array_decrypt_swift_extension
+        <<~SWIFT
+          // MARK: - Decrypt keys from array extension
+
+          @available(iOS 13.0, *)
+          extension Array where Element == UInt8 {
+
+              // MARK: - Methods
+
+              func decrypt(key: [UInt8], iv: [UInt8], tag: [UInt8]) -> String {
+                  guard let sealedBox = try? AES.GCM.SealedBox(nonce: AES.GCM.Nonce(data: Data(iv)),
+                                                              ciphertext: Data(self),
+                                                              tag: Data(tag)),
+                        let decryptedData = try? AES.GCM.open(sealedBox, using: SymmetricKey(data: Data(key))),
+                        let decryptedKey = String(data: decryptedData, encoding: .utf8) else {
+                      fatalError("Failed to decrypt the key")
+                  }
+                  return decryptedKey
+              }
+          }
+        SWIFT
+      end
+
+      # Generate the key string extension
+      # @return [String] The key string extension
+      def key_string_swift_extension
+        <<~SWIFT
+          // MARK: - String extension for secure keys
 
-            // MARK: - Methods
+          @available(iOS 13.0, *)
+          extension String {
 
-            /// Fetch the key from the secure keys enum
-            public var secretKey: SecureKey { SecureKey(rawValue: self) ?? .unknown }
+              // MARK: - Methods
 
-            /// Fetch the decrypted value of the key
-            ///
-            /// - Parameters:
-            ///    - key: The key to fetch the decrypted value for
-            ///
-            /// - Returns: The decrypted value of the key
-            public static func key(for key: SecureKey) -> String { key.decryptedValue }
-        }
+              /// Fetch the key from the secure keys enum
+              public var secretKey: SecureKey { SecureKey(rawValue: self) ?? .unknown }
 
-        // swiftlint:enable all
+              /// Fetch the decrypted value of the key
+              ///
+              /// - Parameters:
+              ///    - key: The key to fetch the decrypted value for
+              ///
+              /// - Returns: The decrypted value of the key
+              public static func key(for key: SecureKey) -> String { key.decryptedValue }
+          }
         SWIFT
       end
 
       # Generate the case key declaration template
       # @param name [String] The name of the key
+      # @return [String] The case key declaration template
       def case_key_declaration_template(name:)
         <<~SWIFT
         case #{name}
@@ -144,6 +169,10 @@ module SecureKeys
 
       # Generate the switch case key declaration template
       # @param name [String] The name of the key
+      # @param value [String] The value of the key
+      # @param iv [String] The IV of the key
+      # @param tag [String] The tag of the key
+      # @return [String] The switch case key declaration template
       def switch_case_key_declaration_template(name:, value:, iv:, tag:) # rubocop:disable Naming/MethodParameterName
         <<~SWIFT
         case .#{name}: #{value}.decrypt(key: #{secure_key_bytes}, iv: #{iv}, tag: #{tag})

data/lib/core/utils/swift/xcframework.rb

@@ -2,6 +2,10 @@
 
 require_relative './swift'
 require_relative '../../globals/globals'
+require_relative '../../console/shell'
+require_relative '../../console/logger'
+require_relative '../../console/arguments/handler'
+require_relative '../swift/xcodeproj'
 
 module SecureKeys
   module Swift
@@ -12,7 +16,7 @@ module SecureKeys
         # Currently this is failling with the following error:
         # "library with the identifier 'ios-arm64' already exists."
         %w[Release].each do |configuration|
-          SecureKeys::Globals.ios_platforms.each do |platform|
+          Globals.ios_platforms.each do |platform|
             generate_key_modules(configuration:, platform:)
             generate_key_libraries(configuration:, platform: platform[:path])
           end
@@ -20,6 +24,12 @@ module SecureKeys
         generate_key_xcframework
       end
 
+      # Configure the XCFramework to the Xcode project
+      def configure_xcframework_to_xcodeproj
+        remove_xcframework_from_xcodeproj_target_if_needed if Globals.replace_xcframework?
+        add_xcframework_to_xcodeproj_target_if_needed if Globals.replace_xcframework? || Globals.add_xcframework?
+      end
+
       private
 
       # Generate the Swift package modules
@@ -35,7 +45,7 @@ module SecureKeys
             ARCHS="arm64" BUILD_DIR="../#{BUILD_DIRECTORY}"
         BASH
 
-        system(command)
+        Core::Console::Shell.sh(command:)
       end
 
       # Generate the Swift package libraries
@@ -48,7 +58,7 @@ module SecureKeys
             #{BUILD_DIRECTORY}/#{configuration}-#{platform}/#{SWIFT_PACKAGE_NAME}.o
         BASH
 
-        system(command)
+        Core::Console::Shell.sh(command:)
       end
 
       # Generate the XCFramework from the Swift package libraries
@@ -61,7 +71,7 @@ module SecureKeys
             -output #{XCFRAMEWORK_DIRECTORY}
         BASH
 
-        system(command)
+        Core::Console::Shell.sh(command:)
       end
 
       # Generate the XCFramework library command
@@ -76,6 +86,37 @@ module SecureKeys
           end.join(' ')
         end.join(' ')
       end
+
+      # Add the XCFramework to the Xcode project target if needed
+      # @param target_name [String] The target name to add the XCFramework
+      def add_xcframework_to_xcodeproj_target_if_needed(target_name: nil)
+        target_name ||= Core::Console::Argument::Handler.fetch(key: %i[xcframework target])
+        return if target_name.to_s.empty?
+
+        Core::Console::Logger.important(message: "Adding the XCFramework to the target '#{target_name}'")
+        xcodeproj = Xcodeproj.xcodeproj
+        xcodeproj_target = Xcodeproj.xcodeproj_target_by_target_name(xcodeproj:, target_name:)
+        Xcodeproj.add_framework_search_path(xcodeproj_target:)
+        Xcodeproj.add_xcframework_to_build_phases(xcodeproj:, xcodeproj_target:)
+
+        xcodeproj.save
+        Core::Console::Logger.success(message: "The XCFramework was added to the target '#{target_name}'")
+      end
+
+      # Remove the XCFramework from the Xcode project target if needed
+      # @param target_name [String] The target name to remove the XCFramework
+      def remove_xcframework_from_xcodeproj_target_if_needed(target_name: nil)
+        target_name ||= Core::Console::Argument::Handler.fetch(key: %i[xcframework target])
+        return if target_name.to_s.empty?
+
+        Core::Console::Logger.important(message: "Removing the XCFramework from the target '#{target_name}'")
+        xcodeproj = Xcodeproj.xcodeproj
+        xcodeproj_target = Xcodeproj.xcodeproj_target_by_target_name(xcodeproj:, target_name:)
+        Xcodeproj.remove_xcframework(xcodeproj:, xcodeproj_target:, xcframework_path: Xcodeproj.xcframework_relative_path)
+
+        xcodeproj.save
+        Core::Console::Logger.success(message: "The XCFramework was removed from the target '#{target_name}'")
+      end
     end
   end
 end

data/lib/core/utils/swift/xcodeproj.rb

@@ -0,0 +1,135 @@
+require 'xcodeproj'
+require_relative '../../globals/globals'
+require_relative '../../utils/swift/swift'
+require_relative '../../console/logger'
+
+module SecureKeys
+  module Swift
+    module Xcodeproj
+      module_function
+
+      # Add the SecureKeys XCFramework to the Xcodeproj target build settings
+      # @param target_name [String] The target name to add the XCFramework
+      # @param configurations [Array<String>] The configurations to add the XCFramework
+      def add_framework_search_path(xcodeproj_target:, configurations: %w[Debug Release])
+        configurations.each do |config|
+          paths = ['$(inherited)', "$(SRCROOT)/#{xcframework_relative_path}"]
+          xcodeproj_target.build_settings(config)['FRAMEWORK_SEARCH_PATHS'] = paths
+        end
+      end
+
+      # Add the SecureKeys XCFramework to the Xcodeproj target build phases
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to add the XCFramework
+      # @param xcodeproj_target [Xcodeproj] The Xcodeproj target to add the XCFramework
+      def add_xcframework_to_build_phases(xcodeproj:, xcodeproj_target:)
+        Core::Console::Logger.crash!(message: "The xcodeproj #{xcodeproj} already have the #{XCFRAMEWORK_DIRECTORY}") if xcodeproj_has_secure_keys_xcframework?(xcodeproj:)
+        xcframework_reference = xcodeproj.frameworks_group.new_file(xcframework_relative_path)
+        xcodeproj_target.frameworks_build_phase.add_file_reference(xcframework_reference)
+      end
+
+      # Get the Xcodeproj target by target name
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to get the target
+      # @param target_name [String] The target name to get
+      # @return [Xcodeproj] The Xcodeproj target
+      # @raise [StandardError] If the target was not found
+      def xcodeproj_target_by_target_name(xcodeproj:, target_name:)
+        xcodeproj_target = xcodeproj.targets.find { |target| target.name.eql?(target_name) }
+        Core::Console::Logger.crash!(message: "The target #{target_name} was not found") if xcodeproj_target.nil?
+
+        xcodeproj_target
+      end
+
+      # Get the Xcodeproj
+      # @return [Xcodeproj] The Xcodeproj
+      def xcodeproj
+        ::Xcodeproj::Project.open(Globals.xcodeproj_path)
+      end
+
+      # Remove all references to SecureKeys.xcframework from the Xcodeproj
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_path [String] The XCFramework path to remove
+      def remove_xcframework(xcodeproj:, xcodeproj_target:, xcframework_path:)
+        xcframework_filename = File.basename(xcframework_path)
+
+        remove_xcframework_from_build_phase(xcodeproj_target:, xcframework_filename:)
+        remove_xcframework_file_references(xcodeproj:, xcframework_filename:)
+        remove_xcframework_from_groups(xcodeproj:, xcframework_filename:)
+        remove_xcframework_from_search_paths(xcodeproj_target:, xcframework_filename:)
+      end
+
+      # Get the XCFramework relative path
+      # @return [Pathname] The XCFramework relative path
+      def xcframework_relative_path
+        Pathname.new(Globals.secure_keys_xcframework_path)
+                .relative_path_from(Pathname.new(Globals.xcodeproj_path).dirname)
+      end
+
+      # Check if the Xcode project has the secure keys XCFramework
+      # @param xcodeproj [Xcodeproj::Project] The Xcode project
+      # @return [Bool] true if the Xcode project has the secure keys XCFramework
+      def xcodeproj_has_secure_keys_xcframework?(xcodeproj:)
+        xcodeproj.targets.any? do |target|
+          target.frameworks_build_phase.files.any? do |file|
+            return false if file.file_ref.nil?
+
+            file.file_ref.path.include?(Globals.secure_keys_xcframework_path)
+          end
+        end
+      end
+
+      # Remove the XCFramework from the "Link Binary With Libraries" build phase
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_build_phase(xcodeproj_target:, xcframework_filename:)
+        build_phase_files = xcodeproj_target.frameworks_build_phase.files.select do |file|
+          file.file_ref&.path&.include?(xcframework_filename)
+        end
+
+        build_phase_files.each do |file|
+          file.remove_from_project
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} from Link Binary With Libraries in target #{xcodeproj_target.name}")
+        end
+      end
+
+      # Remove the XCFramework from the file references
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_file_references(xcodeproj:, xcframework_filename:)
+        file_references = xcodeproj.files.select { |file| file.path&.include?(xcframework_filename) }
+        file_references.each do |file_ref|
+          file_ref.remove_from_project
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} file reference")
+        end
+
+        # Ensure no orphaned references remain
+        xcodeproj.objects.select { |obj| obj.isa == 'PBXFileReference' && obj.path&.include?(xcframework_filename) }.each(&:remove_from_project)
+        xcodeproj.objects.select { |obj| obj.isa == 'PBXBuildFile' && obj.file_ref&.path&.include?(xcframework_filename) }.each(&:remove_from_project)
+      end
+
+      # Remove the XCFramework from groups (e.g., Frameworks Group)
+      # @param xcodeproj [Xcodeproj::Project] The Xcodeproj to remove the XCFramework
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_groups(xcodeproj:, xcframework_filename:)
+        frameworks_group = xcodeproj.frameworks_group
+        group_references = frameworks_group.files.select { |file| file.path&.include?(xcframework_filename) }
+
+        group_references.each do |file_ref|
+          frameworks_group.remove_reference(file_ref)
+          Core::Console::Logger.verbose(message: "Removed #{xcframework_filename} from Frameworks group")
+        end
+      end
+
+      # Remove the XCFramework from FRAMEWORK_SEARCH_PATHS
+      # @param xcodeproj_target [Xcodeproj::Project::Object::PBXNativeTarget] The target where the XCFramework is linked
+      # @param xcframework_filename [String] The XCFramework filename to remove
+      def remove_xcframework_from_search_paths(xcodeproj_target:, xcframework_filename:)
+        xcodeproj_target.build_configurations.each do |config|
+          framework_search_paths = config.build_settings['FRAMEWORK_SEARCH_PATHS'] || []
+          new_search_paths = framework_search_paths.reject { |path| path.include?(xcframework_filename) }
+          config.build_settings['FRAMEWORK_SEARCH_PATHS'] = new_search_paths unless framework_search_paths == new_search_paths
+        end
+      end
+    end
+  end
+end

data/lib/keys.rb

@@ -1,84 +1,18 @@
 #!/usr/bin/env ruby
 
+require_relative './core/utils/extensions/kernel'
+require_relative './core/generator'
 require_relative './core/globals/globals'
-require_relative './core/environment/ci'
-require_relative './core/environment/keychain'
-require_relative './core/utils/swift/writer'
-require_relative './core/utils/swift/package'
-require_relative './core/utils/swift/swift'
-require_relative './core/utils/swift/xcframework'
-require_relative './core/utils/openssl/cipher'
+require_relative './core/console/logger'
 require_relative './core/console/arguments/parser'
+require_relative './core/utils/swift/xcframework'
 
 module SecureKeys
-  class Generator
-    private
-
-    attr_accessor :cipher, :secrets_source, :secret_keys, :mapped_keys
-
-    public
-
-    def initialize
-      # Configure the argument parser
-      SecureKeys::Core::Console::Argument::Parser.new
-
-      puts "🔔 You're using a custom delimiter '#{SecureKeys::Globals.key_delimiter}'" unless SecureKeys::Globals.key_delimiter.eql?(SecureKeys::Globals.default_key_delimiter)
-      puts "🔔 You're using a custom key access identifier '#{SecureKeys::Globals.key_access_identifier}'" unless SecureKeys::Globals.key_access_identifier.eql?(SecureKeys::Globals.default_key_access_identifier)
-
-      # Configure cipher
-      self.cipher = SecureKeys::OpenSSL::Cipher.new
-
-      # Configure the secret source based on the environment
-      if SecureKeys::Globals.ci?
-        self.secrets_source = SecureKeys::Core::Environment::CI.new
-      else
-        self.secrets_source = SecureKeys::Core::Environment::Keychain.new
-      end
-
-      # Define the keys that we want to map
-      self.secret_keys = secrets_source.fetch(key: SecureKeys::Globals.key_access_identifier)
-                                       .to_s
-                                       .split(SecureKeys::Globals.key_delimiter)
-                                       .map(&:strip)
-
-      # Add the keys that we want to map
-      self.mapped_keys = secret_keys.map do |key|
-        encrypted_data = cipher.encrypt(value: secrets_source.fetch(key:))
-        # Convert the first key chart to downcase
-        key[0] = key[0].downcase
-        { name: key, **encrypted_data }
-      end
-    end
-
-    def setup
-      pre_actions
-
-      package = SecureKeys::Swift::Package.new
-      package.generate
-
-      writer = SecureKeys::Swift::Writer.new(mapped_keys: mapped_keys,
-                                             secure_key_bytes: cipher.secure_key_bytes)
-      writer.write
-
-      xcframework = SecureKeys::Swift::XCFramework.new
-      xcframework.generate
-
-      post_actions
-    end
-
-    private
-
-    def pre_actions
-      # Remove the keys directory
-      system("rm -rf #{SecureKeys::Swift::KEYS_DIRECTORY}")
-    end
-
-    def post_actions
-      # Remove the keys directory
-      system("rm -rf #{SecureKeys::Swift::SWIFT_PACKAGE_DIRECTORY}")
+  def self.run
+    # Configure the argument parser
+    Core::Console::Argument::Parser.new
 
-      # Remove the build directory
-      system("rm -rf #{SecureKeys::Swift::KEYS_DIRECTORY}/#{SecureKeys::Swift::BUILD_DIRECTORY}")
-    end
+    # Generate the keys
+    Core::Generator.new.generate
   end
 end

data/lib/version.rb

@@ -1,8 +1,8 @@
 #!/usr/bin/env ruby
 
 module SecureKeys
-  VERSION = '1.1.2'.freeze
+  VERSION = '1.1.4'.freeze
   SUMMARY = 'Secure Keys is a simple tool for managing your secret keys'.freeze
   DESCRIPTION = 'Secure Keys is a simple tool to manage your secret keys in your iOS project'.freeze
-  HOMEPAGE_URI = 'https://github.com/DerianCordobaPerez/secure-keys-generator'.freeze
+  HOMEPAGE_URI = 'https://github.com/derian-cordoba/secure-keys'.freeze
 end