check_dependencies 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c93afde106f0bdadef1bb10d34557c0b6a8db5f694c640d4394eca3c4ba41f7b
-  data.tar.gz: f4c6be89a2628be0484909a1b554d6cc62ef61562c97f728b71c655cf2c9eeef
+  metadata.gz: 4f5ba3bacaefc1ba390830e283976ce506c933131f4d7ec1af61d56aa551b4e5
+  data.tar.gz: f7061fabae1d98b1ec5c449be1b86a28990e08eafee37690bd4d1ff381ab12f4
 SHA512:
-  metadata.gz: 24cd973fd238721f8c9be9fa5f6697d158c351875b1e25d21e9c1cbf225e6bbebcac18cc91759d3df3922b40f487a6cc970f3c7c825eb8ef4c765e349716b945
-  data.tar.gz: 2e28f32fa8925925ee33c48bc8271d0d59e158e6040101e1daf1a3a4232d994be3afa9638cb7f6c05e48154e8dbd028edec852da000ef374ccfb82190dc33927
+  metadata.gz: 1888a329986a98689335b452abe4bff3a166bdebac48ad351d0818f5af202347fb11b1cb9c25f5ea54e4269f996a58dee2cdca29c363093a7796339706c1de69
+  data.tar.gz: b46d24918f7b1b8d94cff1ae14c3de266e98acb842f1b26aeec14c10d22143e5a580a322302eff095e4bc45f03a727e49bd5e549ea14ea2d2581d4d2a5a8b871

data/README.md

@@ -1,86 +1,90 @@
-```markdown
-# check_dependencies Gem
+Based on your script, which involves generating podfile entries and comparing Podfile.lock files, here's a README outline that explains how to use it. You can customize this template to better fit your script's specifics and requirements.
 
-check_dependencies Gem is a Ruby gem that offers utilities to assist in managing CocoaPods dependencies within iOS projects. This gem provides functionality to dynamically switch between local path-based dependencies and remote git branch-based dependencies.
+---
 
-## Installation
+# Podfile Utilities Script
 
-Install the gem by adding it to your Gemfile:
+This script provides utilities for iOS development with CocoaPods, including generating podfile entries for new dependencies and comparing differences between `Podfile.lock` files. It's designed to facilitate the management of dependencies in large-scale iOS projects.
 
-```ruby
-gem 'check_dependencies', git: 'https://github.com/ITxiansheng/check_dependencies.git'
-```
-
-And then execute:
+## Features
 
-```bash
-$ bundle install
-```
+- **Generate Podfile Entries**: Automatically generates podfile entries for dependencies specified in a configuration file.
+- **Compare Podfile.lock Files**: Compares two `Podfile.lock` files and highlights the added or removed dependencies, similar to a git diff.
 
-Or install it yourself as:
+## Requirements
 
-```bash
-$ gem install check_dependencies
-```
-
-Remember to add GEM_BIN_DIR to your PATH.
-
-you can run :
-```bash
- curl -sSL https://raw.githubusercontent.com/ITxiansheng/check_dependencies/main/gem_env_install.sh | bash
- ```
+- Ruby (version 2.5 or later)
+- JSON files for specifying dependencies
 
 ## Usage
 
-The gem provides a command-line interface for interacting with its functionalities. You can use the `check_dependencies` command followed by appropriate options.
-```bash
-check_dependencies --help
-``` 
-### Command Syntax
+### Generating Podfile Entries
+
+To generate new podfile entries based on a JSON configuration:
 
-```bash
-check_dependencies --lockPath LOCK_PATH --depWay DEP_WAY --configPath CONFIG_PATH
+```shell
+ruby script.rb gen_pod --lockPath <path_to_Podfile.lock> --depWay <path_or_branch> --configPath <path_to_config.json>
 ```
 
-### Options
+- `lockPath`: Path to your `Podfile.lock`.
+- `depWay`: Specify "path" or "branch" to indicate how the dependencies are to be fetched.
+- `configPath`: Path to your JSON configuration file listing the dependencies.
+
+**Example JSON Configuration (`gen_pod_config.json`):**
+
+```json
+{
+  "A": {
+    "branch": "release",
+    "path": "/path/to/A",
+    "git_url": "git@github.com:Example/A.git"
+  },
+  "B": {
+    "branch": "release",
+    "path": "/path/to/B",
+    "git_url": "git@github.com:Example/B.git"
+  }
+}
+```
 
-- `--lockPath LOCK_PATH`: Specifies the path to your Podfile.lock file.
-- `--depWay DEP_WAY`: Specifies the dependency mode. This can be either `path` for local path dependencies or `branch` for remote git branch dependencies.
-- `--configPath CONFIG_PATH`: Specifies the path to the configuration file containing dependency configurations.
+### Comparing Podfile.lock Files
 
-### Example
+To compare two `Podfile.lock` files and list differences in dependencies:
 
-```bash
-check_dependencies --lockPath ./Podfile.lock --depWay path --configPath ./repo_configs.txt
+```shell
+ruby script.rb dif_pod --oldLockPath <path_to_old_Podfile.lock> --newLockPath <path_to_new_Podfile.lock> [--configPath <path_to_config.json>]
 ```
 
-## Functions Overview
-
-The gem provides the following key functionalities:
-
-- Parsing `Podfile.lock` content to extract pod dependencies.
-- Generating Podfile entries for local path or remote git branch dependencies.
-- Processing and formatting dependencies for correct integration into Podfiles.
+- `oldLockPath`: Path to the older `Podfile.lock`.
+- `newLockPath`: Path to the newer `Podfile.lock`.
+- `configPath` (optional): Path to a JSON configuration file specifying which libraries to include in the comparison.
 
-## Workflow
+**Example JSON Configuration (`dif_pod_config.json`):**
 
-1. **Configuration Preparation**: Prepare the `repo_configs` file with the necessary configuration for each library. This file should map library names to their configuration, including local path, branch name, and git URL.
+```json
+[
+  "A",
+  "B"
+]
+```
 
-2. **Running the Gem**: Execute the gem with the required options. Based on the specified `depWay`, the gem will process the `Podfile.lock` file and the `repo_configs` to output the necessary Podfile entries.
+## Configuration
 
-3. **Integration**: After generating the Podfile entries, integrate them into your Podfile as needed. This allows you to switch between using local versions of libraries (for development or debugging) and their remote versions (for production or shared development).
+The configuration file for generating podfile entries should list each dependency along with its fetch method (path or branch) and relevant details. For comparing `Podfile.lock` files, the configuration file (optional) should list the names of the libraries to be included in the comparison.
 
-## Note
+## Notes
 
-- Ensure that the `repo_configs` file is properly formatted and from a trusted source to avoid potential security risks.
+- Ensure the JSON configuration files are correctly formatted and located at the specified path.
+- The script provides output similar to git diff, with dependencies being added marked in green and those being removed marked in red.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at [example/check_dependencies](https://github.com/ITxiansheng/check_dependencies). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/ITxiansheng/check_dependencies/blob/main/CODE_OF_CONDUCT.md).
+Feel free to fork this repository and submit pull requests to contribute to its development.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-```
+Specify your license or leave it blank if you haven't decided on one yet.
+
+---
 
-This README provides an overview of the gem's installation, usage, functions, workflow, notes, contributing guidelines, and license information. Adjust as needed for your specific project and preferences.
+Remember to replace placeholder texts with actual information relevant to your script and project. This README provides a basic structure and explanation for users on how to utilize your script effectively.

data/check_dependencies.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "check_dependencies"
-  spec.version       = "0.1.3"
+  spec.version       = "0.1.4"
   spec.authors       = ["ITxiansheng"]
   spec.email         = ["itxiansheng@gmail.com"]
 

data/lib/check_dependencies.rb

@@ -1,5 +1,81 @@
 
 #!/usr/bin/env ruby
+# Usage Hint
+require 'optparse'
+require 'json'
+require 'set'
+
+# Method to check for required options and print usage if missing
+def check_required_options(options, required_keys, parser)
+  missing_options = required_keys.select { |key| options[key].nil? }
+  unless missing_options.empty?
+    puts "Missing required options: #{missing_options.join(', ')}"
+    puts parser
+    exit
+  end
+end
+
+# Define and parse options based on the command
+options = {}
+global_options = OptionParser.new do |opts|
+  opts.banner = "Usage: script.rb [command] [options]"
+  opts.separator ""
+  opts.separator "Commands:"
+  opts.separator "  gen_pod: Generate podfile entries for new dependencies"
+  opts.separator "  dif_pod: Generate differences between Podfile.lock files"
+  opts.separator ""
+  opts.separator "For command-specific help, run: script.rb [command] --help"
+end
+
+gen_pod_config_string = <<~CONFIG
+{
+  "A": {
+    "branch": "release",
+    "path": "XXXXXXXXXXXXXXX",
+    "git_url": "XXXXXXXXXXXXXXX"
+  },
+  "B": {
+    "branch": "release",
+    "path": "XXXXXXXXXXXXXXX",
+    "git_url": "XXXXXXXXXXXXXXX"
+  },
+}
+CONFIG
+
+dif_pod_config_string = <<~CONFIG
+[
+  "A",
+  "B"
+]
+CONFIG
+
+
+command = ARGV.shift
+case command
+when "gen_pod"
+command_options = OptionParser.new do |opts|
+    opts.banner = "Usage: gen_pod --lockPath LOCK_PATH --depWay DEP_WAY [--configPath CONFIG_PATH]"
+    opts.on("--lockPath LOCK_PATH", String, "Specify the Podfile.lock path") { |v| options[:lockPath] = v }
+    opts.on("--depWay DEP_WAY", String, "Specify the depWay parameter (path or branch)") { |v| options[:depWay] = v }
+    opts.on("--configPath CONFIG_PATH", String, "Specify the path to repo_configs\n\n\n repo_configs examples:\n#{gen_pod_config_string}") { |v| options[:configPath] = v }
+  end.parse!(ARGV)
+  check_required_options(options, [:lockPath, :depWay, :configPath], command_options)
+
+when "dif_pod"
+  command_options = OptionParser.new do |opts|
+    opts.banner = "Usage: dif_pod --oldLockPath OLD_LOCK_PATH --newLockPath NEW_LOCK_PATH [--configPath CONFIG_PATH]"
+    opts.on("--oldLockPath OLD_LOCK_PATH", String, "Specify old Podfile.lock path") { |v| options[:oldLockPath] = v }
+    opts.on("--newLockPath NEW_LOCK_PATH", String, "Specify new Podfile.lock path") { |v| options[:newLockPath] = v }
+    opts.on("--configPath CONFIG_PATH", String, "Specify the path of conf which contains dif libs (optional) \n\n\n repo_configs examples:\n#{dif_pod_config_string}") { |v| options[:configPath] = v }
+  end.parse!(ARGV)
+  check_required_options(options, [:oldLockPath, :newLockPath], command_options)
+
+else
+  puts global_options
+  exit
+end
+
+
 # Analyzes the Podfile.lock content to extract pod dependencies
 def analyze_podfile_lock(podfile_lock_content)
   unless podfile_lock_content.is_a?(String)
@@ -160,69 +236,72 @@ def generate_map_path_podfiles(lockPath, repo_configs)
   podfile_entrys.join("\n")
 end
 
-require 'optparse'
-require 'json'
 
-options = {}
-OptionParser.new do |opts|
-  opts.banner = "Usage: check_dependencies --lockPath LOCK_PATH --depWay DEP_WAY --configPath CONFIG_PATH"
+def colorize(text, color_code)
+  "\e[#{color_code}m#{text}\e[0m"
+end
+def red(text); colorize(text, 31); end
+def green(text); colorize(text, 32); end
 
-  opts.on("--lockPath LOCK_PATH", "Specify the Podfile.lock path") do |lockPath|
-    options[:lockPath] = lockPath
+def read_json_array_from_file_as_set(file_path)
+  # 确保文件存在
+  if File.exist?(file_path)
+    # 读取文件内容
+    file_content = File.read(file_path)
+    # 解析 JSON 字符串为 Ruby 数组
+    json_array = JSON.parse(file_content)
+    # 将数组转换为 Set 并返回
+    return json_array.to_set
+  else
+    puts "File not found: #{file_path}"
+    exit
   end
+rescue JSON::ParserError => e
+  puts "Error parsing JSON from #{file_path}: #{e.message}"
+  exit
+end
 
-  opts.on("--depWay DEP_WAY", "Specify the depWay parameter (path or branch)") do |depWay|
-    options[:depWay] = depWay
-  end
+def compare_podfile_locks(old_lock_path, new_lock_path, config_path = nil)
+  config_set = read_json_array_from_file_as_set(config_path)
+  
+  old_pods = read_local_podfile_lock(old_lock_path)
+  new_pods = read_local_podfile_lock(new_lock_path)
 
-  # repo_configs examples
-  config_string = <<~CONFIG
-    repo_configs = {
-      'Lib1' => {
-        "branch" => "dev1",
-        "path" => "/Users/xxxxxxxxx/xxxxlib",
-        "git_url" => "xxxxxxxxxxxxxxxxxx"
-      },
-      'Lib2' => {
-        "branch" => "dev2",
-        "path" => "/Users/xxxxxxxxx/xxxxlib",
-        "git_url" => "xxxxxxxxxxxxxxxxxx"
-      },
-      'Lib3' => {
-        "branch" => "dev3",
-        "path" => "/Users/xxxxxxxxx/xxxxlib",
-        "git_url" => "xxxxxxxxxxxxxxxxxx"
-      }
-    }
-  CONFIG
+  old_unique_deps = find_shortest_paths(extract_unique_dependencies(old_pods)).to_set
+  new_unique_deps = find_shortest_paths(extract_unique_dependencies(new_pods)).to_set
+  if !config_set.empty?
+      old_unique_deps = old_unique_deps.select { |dep| config_set.include?(dep.split('/').first) }
+      new_unique_deps = new_unique_deps.select { |dep| config_set.include?(dep.split('/').first) }
+  end
+  only_in_old = old_unique_deps - new_unique_deps
+  only_in_new = new_unique_deps - old_unique_deps
   
-  opts.on("--configPath CONFIG_PATH", "Specify the path to repo_configs\n\n\n repo_configs examples:\n #{config_string}") do |configPath|
-    options[:configPath] = configPath
+  # 检查差异并决定退出状态
+  if only_in_old.empty? && only_in_new.empty?
+    puts "没有差异，成功退出"
+    exit 0
+  else
+    puts "存在差异："
+    only_in_old.each { |dep| puts "#{red('-')} #{dep}" }
+    only_in_new.each { |dep| puts "#{green('+')} #{dep}" }
+    exit 1
   end
-end.parse!
-
-# Check if all required arguments were provided
-if options[:lockPath].nil? || options[:depWay].nil? || options[:configPath].nil?
-  puts "Please provide lockPath, depWay, and configPath parameters.\n  you can run:\n check_dependencies --help "
-  exit
 end
 
-# Function to read and parse the repo_configs.txt file
-def read_repo_configs(config_path)
-  content = File.read(config_path)
-  eval(content) # Using eval to parse the Ruby hash from the file, be cautious with its use!
-rescue
-  puts "Failed to read or parse the repo_configs from #{config_path}"
-  exit
+if command == "gen_pod"
+    file_content = File.read(options[:configPath])
+    puts file_content
+    repo_configs =JSON.parse(file_content)
+    puts repo_configs
+    # Calls before pod install complete
+    if options[:depWay] == "path"
+        generate_map_path_podfiles(options[:lockPath], repo_configs)
+    elsif options[:depWay] == "branch"
+        generate_map_branch_podfiles(options[:lockPath], repo_configs)
+    else
+      puts "Invalid argument. Please provide 'path' or 'branch'."
+    end
+elsif command == "dif_pod"
+  compare_podfile_locks(options[:oldLockPath], options[:newLockPath], options[:configPath])
 end
 
-repo_configs = read_repo_configs(options[:configPath])
-
-# Calls before pod install complete
-if options[:depWay] == "path"
-    generate_map_path_podfiles(options[:lockPath], repo_configs)
-elsif options[:depWay] == "branch"
-    generate_map_branch_podfiles(options[:lockPath], repo_configs)
-else
-  puts "Invalid argument. Please provide 'path' or 'branch'."
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: check_dependencies
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - ITxiansheng
@@ -57,6 +57,7 @@ files:
 - bin/check_dependencies
 - bin/console
 - bin/setup
+- check_dependencies-0.1.3.gem
 - check_dependencies.gemspec
 - gem_env_install.sh
 - lib/check_dependencies.rb