cocoapods-git-private-repo 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f0407365e723398f091ede37a3f5895cd17748fa1f3b71111860799a33b491b
-  data.tar.gz: 0a5b341a278b0f79bc7f753c3e022521e107fd8621d94ac8986c06762c173ed0
+  metadata.gz: 864c5d089acf55f2e26da12c399a5df85915109bd7f0da8ebd3e205e6c27d4f9
+  data.tar.gz: a63a4821072bd6970efc076d919cd1bb4daa636fbeaa41e5ed025b09ca92c039
 SHA512:
-  metadata.gz: 8204b5770defacd3e49718c45a6f4c58e71398340065cde8cacf9ce540ece4a18ce8e09fc5bed128963db0ffd626e59dcae56b6e201b7bf8093df22bb1209715
-  data.tar.gz: 26d7ba9d5c55322aedd894b5ea0c4659680823780d486fbbbfb9a1e15da2c3c5d591bac202c811008be48f959fe8feab8582f9158dcb466c851b7bb134b121b6
+  metadata.gz: f8628fe232f7d30d4d861e72700202312c8aa213623c8382046d8474045430fa2224a0e50622932c621f93cc76ca425e646f57d57b0e579cd19bef68d64a41be
+  data.tar.gz: 6bb9499b704b003831e64bd203635f46b5116ed995d3361c5f1d6f0dd3b4c8814334cebc700dcf4e61d08218a37800efbc9d02305f602a466b7346f8d480d486

data/lib/cocoapods-git-private-repo/gem_version.rb

@@ -1,3 +1,3 @@
 module CocoapodsGitPrivateRepo
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/cocoapods-git-private-repo/git_private_repo_executable.rb

@@ -0,0 +1,297 @@
+require 'cocoapods'
+require 'json'
+
+module Pod
+  # Monkey patch for the Executable module to handle SSH keys
+  module Executable
+    class << self
+      alias_method :original_execute_command, :execute_command
+      alias_method :original_capture_command, :capture_command
+      
+      # Override execute_command to handle SSH keys for git commands
+      def execute_command(executable, command, raise_on_failure = true)
+        # Only apply SSH key for git commands
+        if executable.to_s == 'git'
+          # Check if a private key should be used for this git command
+          private_key_path = find_private_key_for_command(command)
+          
+          if private_key_path
+            UI.message("Using private key: #{private_key_path} for git command") if Config.instance.verbose?
+            
+            bin = which!(executable)
+            command = command.map(&:to_s)
+            full_command = "#{bin} #{command.join(' ')}"
+            
+            if Config.instance.verbose?
+              UI.message("$ #{full_command} (with SSH key)")
+              stdout = Indenter.new(STDOUT)
+              stderr = Indenter.new(STDERR)
+            else
+              stdout = Indenter.new
+              stderr = Indenter.new
+            end
+            
+            # Create environment with SSH key setting
+            env = { "GIT_SSH_COMMAND" => "ssh -i #{private_key_path} -o IdentitiesOnly=yes" }
+
+            UI.message("Executing command environment: #{env.inspect}") if Config.instance.verbose?
+            
+            require 'open3'
+            status = nil
+            
+            # Execute with environment
+            Open3.popen3(env, bin, *command) do |i, o, e, t|
+              reader_threads = []
+              reader_threads << reader(o, stdout)
+              reader_threads << reader(e, stderr)
+              i.close
+              
+              status = t.value
+              
+              o.flush
+              e.flush
+              sleep(0.01)
+              
+              # Wait for reader threads to complete
+              reader_threads.each(&:join)
+            end
+            
+            stdout = stdout.join
+            stderr = stderr.join
+            output = stdout + stderr
+
+            unless status.success?
+              if raise_on_failure
+                raise Informative, "#{full_command}\n\n#{output}"
+              else
+                UI.message("[!] Failed: #{full_command}".red)
+              end
+            end
+            
+            return output
+          end
+        end
+        
+        # Fall back to original implementation for non-git commands
+        # or git commands that don't need SSH keys
+        original_execute_command(executable, command, raise_on_failure)
+      end
+      
+      # Override capture_command to handle SSH keys for git commands
+      def capture_command(executable, command, capture: :merge, env: {}, **kwargs)
+        # Only apply SSH key for git commands
+        if executable.to_s == 'git'
+          # Check if a private key should be used for this git command
+          private_key_path = find_private_key_for_command(command)
+          
+          if private_key_path
+            UI.message("Using private key: #{private_key_path} for git command (capture)") if Config.instance.verbose?
+            
+            # Add SSH key setting to the environment
+            git_ssh_cmd = "ssh -i #{private_key_path} -o IdentitiesOnly=yes"
+            ssh_env = { "GIT_SSH_COMMAND" => git_ssh_cmd }
+            
+            # Merge with any existing environment variables
+            env = env.merge(ssh_env)
+            
+            UI.message("Executing capture_command with environment: #{env.inspect}") if Config.instance.verbose?
+          end
+        end
+        
+        # Call the original method with possibly modified environment
+        original_capture_command(executable, command, capture: capture, env: env, **kwargs)
+      end
+    
+      # Override capture_command! to use our overridden capture_command
+      def capture_command!(executable, command, **kwargs)
+        capture_command(executable, command, **kwargs).tap do |result|
+          result = Array(result)
+          status = result.last
+          unless status.success?
+            output = result[0..-2].join
+            
+            # If this is a git command that might have used a private key
+            if executable.to_s == 'git'
+              private_key_path = find_private_key_for_command(command)
+              if private_key_path
+                error_message = enhance_ssh_error_message(output, private_key_path)
+                raise Informative, "#{executable} #{command.join(' ')}\n\n#{error_message}".strip
+              end
+            end
+            
+            # Default error handler
+            raise Informative, "#{executable} #{command.join(' ')}\n\n#{output}".strip
+          end
+        end
+      end
+    
+    # Helper method to determine if a private key should be used
+    def find_private_key_for_command(command)
+      # Extract repository URL from git commands
+      repo_url = extract_repo_url_from_command(command)
+
+      return nil unless repo_url
+
+      # Find keys.json in standard locations
+      json_config_path = find_json_config_path()
+
+      return nil unless json_config_path && File.exist?(json_config_path)
+      
+      begin
+        private_key_configs = JSON.parse(File.read(json_config_path))
+        
+        # Find a matching URL in the configuration
+        if private_key_configs.is_a?(Array)
+          matching_config = private_key_configs.find { |config| config["url"] == repo_url }
+
+          return matching_config["key_path"] if matching_config && matching_config["key_path"]
+        end
+      rescue => e
+        UI.warn "Error reading keys.json: #{e.message}" if Config.instance.verbose?
+      end
+      
+      nil
+    end
+
+    # Get the path to the keys.json configuration file
+    # Searches in several standard locations related to the Podfile
+    def find_json_config_path
+      # First, look in the current directory
+      return 'keys.json' if File.exist?('keys.json')
+      
+      # Get the Podfile path
+      podfile_path = find_podfile_path
+      return nil unless podfile_path
+      
+      # Look for keys.json next to the Podfile
+      podfile_dir = File.dirname(podfile_path)
+      config_next_to_podfile = File.join(podfile_dir, 'keys.json')
+      return config_next_to_podfile if File.exist?(config_next_to_podfile)
+      
+      # Also check in the .cocoapods directory if it exists
+      cocoapods_dir = File.join(podfile_dir, '.cocoapods')
+      if Dir.exist?(cocoapods_dir)
+        config_in_cocoapods = File.join(cocoapods_dir, 'keys.json')
+        return config_in_cocoapods if File.exist?(config_in_cocoapods)
+      end
+      
+      # Finally, check user's home directory
+      home_config = File.expand_path('~/.cocoapods/keys.json')
+      return home_config if File.exist?(home_config)
+      
+      # Could not find keys.json
+      nil
+    end
+    
+    # Find the path to the Podfile in the current project
+    def find_podfile_path
+      # First try the Pod::Config singleton if it exists and is initialized
+      begin
+        if Pod.const_defined?(:Config) && !Pod::Config.instance.nil? && Pod::Config.instance.installation_root
+          podfile_path = File.join(Pod::Config.instance.installation_root, 'Podfile')
+          return podfile_path if File.exist?(podfile_path)
+        end
+      rescue => e
+        puts "Error accessing Pod::Config: #{e.message}" if Config.instance.verbose?
+      end
+      
+      # If that fails, try searching up from the current directory
+      current_dir = Dir.pwd
+      while current_dir != '/'
+        podfile_path = File.join(current_dir, 'Podfile')
+        return podfile_path if File.exist?(podfile_path)
+        current_dir = File.dirname(current_dir)
+      end
+      
+      # Also try all parent directories of the repo being cloned if we're in a git command
+      if defined?(@repo_path) && @repo_path
+        current_dir = File.dirname(@repo_path)
+        while current_dir != '/'
+          podfile_path = File.join(current_dir, 'Podfile')
+          return podfile_path if File.exist?(podfile_path)
+          current_dir = File.dirname(current_dir)
+        end
+      end
+      
+      nil
+    end
+    
+    # Extract repository URL from git commands like clone, fetch, etc.
+    def extract_repo_url_from_command(command)
+      # Common git commands that include repository URLs
+      if command.include?('clone')
+        # git clone URL [DIR]
+        idx = command.index('clone')
+        repo_url = command[idx + 1] if idx && command.size > idx + 1
+        
+        # Store the destination directory for potential Podfile lookup later
+        if idx && command.size > idx + 2
+          @repo_path = command[idx + 2]
+        end
+        
+        return repo_url
+      elsif command.include?('fetch') || command.include?('pull')
+        # Find the path parameter in the command
+        path = nil
+        
+        # Look for directory parameter (git -C path fetch/pull)
+        if c_idx = command.index('-C')
+          if c_idx + 1 < command.size
+            path = command[c_idx + 1]
+          end
+        end
+
+        return nil unless path
+
+        # Fetch the origin URL from git config using the path
+        return get_origin_url(path)
+      end
+      
+      nil
+    end
+    
+    # Get the origin URL from git config
+    def get_origin_url(path = nil)
+      # Try to get the origin URL from the git config
+      begin
+        if path && File.directory?(path)
+          # If we have a path, use it to get the remote URL
+          url_command = "git -C \"#{path}\" config --get remote.origin.url"
+        else
+          # Otherwise use the current directory
+          url_command = "git config --get remote.origin.url"
+        end
+        
+        result = `#{url_command}`.strip
+
+        return result unless result.empty?
+      rescue => e
+        puts "Error getting origin URL: #{e.message}" if Config.instance.verbose?
+        nil
+      end
+    end
+    
+    # This is the original reader method from Pod::Executable
+    def reader(input, output)
+      Thread.new do
+        buf = ''
+        begin
+          loop do
+            buf << input.readpartial(4096)
+            loop do
+              string, separator, buf = buf.partition(/[\r\n]/)
+              if separator.empty?
+                buf = string
+                break
+              end
+              output << (string << separator)
+            end
+          end
+        rescue EOFError, IOError
+          output << (buf << $/) unless buf.empty?
+        end
+      end
+    end
+    end # end of class << self
+  end # end of module Executable
+end # end of module Pod

data/lib/cocoapods_plugin.rb

@@ -1,2 +1 @@
-require 'cocoapods-git-private-repo/cocoapods_downloader'
-require 'cocoapods-git-private-repo/cocoapods_sources_manager'
+require 'cocoapods-git-private-repo/git_private_repo_executable'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-git-private-repo
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Nonthawat Srichad
@@ -53,10 +53,8 @@ files:
 - Rakefile
 - cocoapods-git-private-repo.gemspec
 - lib/cocoapods-git-private-repo.rb
-- lib/cocoapods-git-private-repo/cocoapods_downloader.rb
-- lib/cocoapods-git-private-repo/cocoapods_sources_manager.rb
 - lib/cocoapods-git-private-repo/gem_version.rb
-- lib/cocoapods-git-private-repo/git_private_repo_downloader.rb
+- lib/cocoapods-git-private-repo/git_private_repo_executable.rb
 - lib/cocoapods_plugin.rb
 - spec/spec_helper.rb
 homepage: https://github.com/nonth/cocoapods-git-private-repo

data/lib/cocoapods-git-private-repo/cocoapods_downloader.rb

@@ -1,17 +0,0 @@
-require 'cocoapods-git-private-repo/git_private_repo_downloader'
-
-module Pod
-  module Downloader
-    class <<self
-      alias_method :real_downloader_class_by_key, :downloader_class_by_key
-    end
-
-    def self.downloader_class_by_key
-      original = self.real_downloader_class_by_key
-      original[:git] = GitPrivateRepoDownloader
-
-      original
-    end
-
-  end
-end

data/lib/cocoapods-git-private-repo/cocoapods_sources_manager.rb

@@ -1,67 +0,0 @@
-require 'cocoapods-core/source'
-require 'json'
-
-module Pod
-  module GitPrivateRepoSourceExtension
-    def repo_git(args, include_error: false)      
-      # Check for private key in configuration
-      if private_key_path = find_private_key_for_repo        
-        # Build git command with SSH key
-        command = "GIT_SSH_COMMAND='ssh -i #{private_key_path} -o IdentitiesOnly=yes' git -C \"#{repo}\" " << args.join(' ')
-        command << ' 2>&1' if include_error
-
-        (`#{command}` || '').strip
-      else
-        # Use original implementation if no private key is found
-        super(args, include_error: include_error)
-      end
-    end
-    
-    def update_git_repo(show_output = false)      
-      # If we have a private key, use our custom implementation
-      if private_key_path = find_private_key_for_repo        
-        command = ['pull']
-        command << '--progress' if show_output
-        repo_git(command)
-      else
-        # Use original implementation if no private key is found
-        super(show_output)
-      end
-    end
-    
-    private
-    
-    def find_private_key_for_repo
-      # Check if a JSON configuration file exists with private key mappings
-      json_config_path = 'keys.json'
-      return nil unless File.exist?(json_config_path)
-      
-      private_key_configs = JSON.parse(File.read(json_config_path))
-      
-      # Find a matching repo URL in the configuration
-      if private_key_configs.is_a?(Array)
-        # Directly get git remote url from repo to avoid recursion
-        repo_url = get_git_remote_url(repo)
-        return nil unless repo_url
-        
-        matching_config = private_key_configs.find { |config| config["url"] == repo_url }
-        return matching_config["key_path"] if matching_config && matching_config["key_path"]
-      end
-      
-      nil
-    end
-    
-    # Safely get the git remote URL directly without using Source#url
-    def get_git_remote_url(repo_path)
-      return nil unless repo_path
-      
-      # Use git directly to get URL from the repo config
-      url_command = "git -C \"#{repo_path}\" config --get remote.origin.url"
-      remote_url = `#{url_command}`.strip
-      return remote_url unless remote_url.empty?
-    end
-  end
-  
-  # Prepend the module to Source to override methods
-  Source.prepend(GitPrivateRepoSourceExtension)
-end

data/lib/cocoapods-git-private-repo/git_private_repo_downloader.rb

@@ -1,39 +0,0 @@
-module Pod
-  module Downloader
-    class GitPrivateRepoDownloader < Git
-      def initialize(target_path, url, options)
-        super(target_path, url, options)
-
-        # Check if a JSON configuration file exists with private key mappings
-        json_config_path = 'keys.json'
-
-        # Only proceed with JSON processing if the file exists
-        return unless File.exist?(json_config_path)
-        
-        begin
-          require 'json'
-          private_key_configs = JSON.parse(File.read(json_config_path))
-
-          # Find a matching URL in the array of objects and no private_key_path is already set
-          if !options[:private_key_path] && private_key_configs.is_a?(Array)
-            matching_config = private_key_configs.find { |config| config["url"] == url }
-            
-            if matching_config && matching_config["key_path"]
-              options[:private_key_path] = matching_config["key_path"]
-            end
-          end
-        end
-      end
-
-      def execute_command(executable, command, raise_on_failure = false)
-        if executable == 'git' && options[:private_key_path]
-          private_key = options[:private_key_path]
-          
-          command = command + ['-c', "core.sshCommand=ssh -i #{private_key}"]
-        end
-        
-        super(executable, command, raise_on_failure)
-      end
-    end
-  end
-end