cocoapods-modularization 0.0.2

data/lib/cocoapods-modularization/meta/meta_reference.rb

@@ -0,0 +1,255 @@
+module Pod
+  module Meta
+  	module MetaReference
+  	  class << self
+        require 'cocoapods-modularization/private'
+        require 'json'
+        require 'fileutils'
+        require 'yaml'
+
+        # podfile => meta & data
+        def decode_podfile(config)
+          # check podfile
+          podfile = Podfile.from_file(podfile_path_in_dir(installation_root))
+
+          unless File.directory?(MetaConstants.pods_scripts_path)
+            FileUtils.mkdir_p(MetaConstants.pods_scripts_path)
+          end
+
+          unless File.directory?(MetaConstants.pods_generator_path)
+            FileUtils.mkdir_p(MetaConstants.pods_generator_path)
+          end
+
+          UI.puts "podfile to meta"
+          podfile_to_meta(podfile)
+
+          UI.puts "podfile to data"
+          podfile_to_data(podfile, config)
+        end
+
+        # podfile <= meta & data
+        def encode_podfile(enable_branch = false)
+          meta = MetaConstants.generate_yml_to_hash(MetaConstants.meta_path)
+          data = MetaConstants.read_data(enable_branch)
+
+          target_definitions = meta['target_definitions']
+          cached_branch_hash = enable_branch ? Private::PrivateCache.cached_branch_hash : nil
+          target_definitions.each do |target_definition|
+            next unless target_definition.kind_of?(Hash)
+            meta_dependency_from_data(target_definition, data, enable_branch)
+          end
+
+          File::open('CocoaPods.podfile.yaml', "w") { |io| io.puts meta.to_yaml }
+        end
+
+        def installation_root
+          @installation_root ||= begin
+            current_dir = Pathname.new(Dir.pwd.unicode_normalize(:nfkc))
+            current_path = current_dir
+            until current_path.root?
+              if podfile_path_in_dir(current_path)
+                installation_root = current_path
+                unless current_path == current_dir
+                  UI.puts("[in #{current_path}]")
+                end
+                break
+              else
+                current_path = current_path.parent
+              end
+            end
+            installation_root || current_dir
+          end
+        end
+
+        def podfile_path_in_dir(dir)
+          PODFILE_NAMES.each do |filename|
+            candidate = dir + filename
+            if candidate.file?
+              return candidate
+            end
+          end
+          nil
+        end
+
+        PODFILE_NAMES = [
+          'CocoaPods.podfile.yaml',
+          'CocoaPods.podfile',
+          'Podfile',
+          'Podfile.rb',
+        ].freeze
+
+        private
+        def meta_dependency_from_data(meta, data, enable_branch)
+          dependencies = meta['dependencies'] if data.kind_of?(Hash)
+          meta['dependencies'] = dependencies.map { |e| hash_from(e, data, enable_branch) } if dependencies.kind_of?(Array)
+          childrens = meta['children']
+          childrens.each { |c| meta_dependency_from_data(c, data, enable_branch) } if childrens.kind_of?(Array)
+        end
+
+        def hash_from(e, data, enable_branch)
+          dependency_data = data[e]
+
+          git_branch_hash = try_git_branch(e, dependency_data) if enable_branch
+          return git_branch_hash if git_branch_hash.kind_of?(Hash)
+
+          local = dependency_data[MetaConstants.local_key]
+          local_path = dependency_data[MetaConstants.local_path_key]
+
+          if local && local_path.kind_of?(String)
+            return Hash[e => [Hash[:path => local_path]]]
+          else
+            return try_source(e, dependency_data)
+          end
+        end
+
+        def try_git_branch(e, dependency_data)
+          value = Private::PrivateCache.cached_branch_hash[e] if Private::PrivateCache.cached_branch_hash.kind_of?(Hash)
+          return nil unless value.kind_of?(Hash)
+
+          git = value[MetaConstants.git_key] if value.kind_of?(Hash)
+          branch = value[MetaConstants.branch_key] if value.kind_of?(Hash)
+
+          return nil unless git.kind_of?(String) && branch.kind_of?(String)
+
+          Hash[e => [Hash[:git => git, :branch => branch]]]
+        end
+
+        def try_source(e, dependency_data)
+          binary = dependency_data[MetaConstants.binary_key]
+          source_url = dependency_data[MetaConstants.source_key]
+          if binary
+            source_url ||= Private::PrivateCache.binary_repo_url
+          else
+            source_url ||= Private::PrivateCache.source_repo_url
+          end
+          Hash[e => [dependency_data[MetaConstants.version_key], Hash[:source => source_url]]]
+        end
+
+        def podfile_to_meta(podfile)
+          podfile_hash = podfile.to_hash
+          generate_dependency(podfile_hash)
+          File::open(MetaConstants.meta_path, "w") { |io| io.puts "#{podfile_hash.to_yaml}" }
+        end
+
+        def podfile_to_data(podfile, config)
+          data = generate_data(podfile, config)
+          File::open(MetaConstants.data_path, "w") { |io| io.puts "#{data.to_yaml}" }
+
+          local_data = generate_local_data(podfile)
+          File::open(MetaConstants.podfile_local_path, "w") { |io| io.puts "#{local_data.to_yaml}" }
+        end
+
+        def generate_local_data(podfile)
+          data = Hash.new
+
+          podfile.dependencies.select do |dependency|
+            if dependency.local?
+              podspec = File.directory?(dependency.local?) ? Pod::Specification.from_file("#{dependency.local?}/#{dependency.name.to_s}.podspec") : Pod::Specification.from_file(dependency.local?)
+              next podspec.name.to_s == dependency.name.to_s
+            end
+            if [Private::PrivateCache.source_repo_url, Private::PrivateCache.binary_repo_url].include?(dependency.podspec_repo)
+              next true
+            end
+            next false
+          end.each do |dependency|
+            data_element = Hash.new
+
+            if dependency.local?
+              data_element[MetaConstants.local_key] = true
+              data_element[MetaConstants.local_path_key] = dependency.local?
+            else
+              data_element[MetaConstants.local_key] = false
+              data_element[MetaConstants.local_path_key] = Private::PrivateCache.read_local_path(dependency.name)
+            end
+
+            data_element[MetaConstants.binary_key] = dependency.podspec_repo == Private::PrivateCache.binary_repo_url
+
+            data[dependency.name.to_s] = data_element
+          end
+
+          data
+        end
+
+        def generate_data(podfile, config)
+          data = Hash.new
+
+          podfile.dependencies.each do |dependency|
+            data_element = Hash.new
+
+            data_element[MetaConstants.version_key] = generate_version(dependency)
+
+            if dependency.podspec_repo.kind_of?(String)
+              if [Private::PrivateCache.source_repo_url, Private::PrivateCache.binary_repo_url].include?(dependency.podspec_repo)
+                data_element[MetaConstants.binary_key] = dependency.podspec_repo == Private::PrivateCache.binary_repo_url
+              else
+                data_element[MetaConstants.source_key] = dependency.podspec_repo
+              end
+            else 
+              if File.exists?("#{podfile.defined_in_file.parent.parent}/Binary/#{dependency.name.to_s}.podspec")
+                data_element[MetaConstants.binary_key] = false
+              end
+            end
+
+            data[dependency.name.to_s] = data_element
+          end
+
+          data
+        end
+
+        def generate_version(dependency)
+          if dependency.local?.kind_of?(String)
+            podspec_path = dependency.local?
+            if File.directory?(podspec_path)
+              "= #{Pod::Specification.from_file("#{podspec_path}/#{dependency.name.to_s}.podspec").version.to_s}"
+            elsif File.file?(podspec_path)
+              "= #{Pod::Specification.from_file(podspec_path).version.to_s}"
+            else
+              raise "#{dependency.name} unrecognized local path"
+            end
+          else
+            dependency.requirement.to_s
+          end
+        end
+
+        def generate_dependency(podfile_hash)
+          target_definitions = podfile_hash["target_definitions"]
+          return unless target_definitions.kind_of?(Array)
+
+          target_definitions.each { |target| internal_generate_dependency(target) }
+        end
+
+        def internal_generate_dependency(target)
+          children = target['children']
+          children.each { |c| internal_generate_dependency(c) } if children.kind_of?(Array)
+
+          dependencies = target['dependencies']
+          return unless dependencies.kind_of?(Array)
+
+          dependencies = dependencies.map do |dependency|
+            key = dependency.kind_of?(Hash) ? dependency.keys.first : dependency
+            generated_name = key
+            generated_name
+          end
+
+          target['dependencies'] = dependencies
+        end
+
+        def prompt(message, default)
+          print "#{message} (or press enter to use: #{default}) > "
+          input = STDIN.gets.chomp
+          input = nil if input.strip.empty?
+          input
+        end
+
+        def validate_version(tag)
+          if tag.index(/[0-9]{1,2}.[0-9]{1,2}.[0-9]{1,2}/) 
+            return true
+          else
+            UI.puts("Illegal tag: #{tag}")
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-modularization/meta.rb

@@ -0,0 +1,7 @@
+module Pod
+  module Meta
+    autoload :MetaAccessor, 'cocoapods-modularization/meta/meta_accessor'
+    autoload :MetaConstants, 'cocoapods-modularization/meta/meta_constants'
+    autoload :MetaReference, 'cocoapods-modularization/meta/meta_reference'
+  end
+end

data/lib/cocoapods-modularization/private/private_cache.rb

@@ -0,0 +1,277 @@
+module Pod
+  module Private
+    module PrivateCache
+      class BranchCache
+        def initialize(key, path)
+          @key = key
+          @path = path
+        end
+
+        def key
+          @key
+        end
+
+        def git
+          git = `git -C #{@path} remote get-url origin`.lines.to_a.first
+          git.strip if git
+        end
+
+        def branch
+          branch = `git -C #{@path} rev-parse --abbrev-ref HEAD`.lines.to_a.first
+          branch.strip if branch
+        end
+      end
+
+      class << self
+        require 'pathname'
+        require 'fileutils'
+        require 'json'
+
+        @@root_path = Pathname.new(File.expand_path('~')) + 'Projects/Pods'
+        @@path_map = '.path_map.json'
+        @@repo_map = '.repo_map.json'
+        @@path_map_path = @@root_path + @@path_map
+        @@repo_map_path = @@root_path + @@repo_map
+
+        @@binary_repo_key = 'binary'
+        @@source_repo_key = 'source'
+
+        def cache_repo(repo_name, repo_url, is_binary)
+          make_workspace
+          repo_map = cached_repo_map
+
+          if is_binary
+            repo_map[@@binary_repo_key] = Hash[repo_name => repo_url]
+          else
+            repo_map[@@source_repo_key] = Hash[repo_name => repo_url]
+          end
+
+          File.open(@@repo_map_path, 'w') { |io| io << repo_map.to_json }
+        end
+
+        def binary_repo_name
+          repo_map = cached_repo_map
+          binary_map = repo_map[@@binary_repo_key]
+          return nil unless binary_map.kind_of?(Hash)
+          binary_map.keys.first
+        end
+
+        def source_repo_name
+          repo_map = cached_repo_map
+          source_map = repo_map[@@source_repo_key]
+          return nil unless source_map.kind_of?(Hash)
+          source_map.keys.first
+        end
+
+        def binary_repo_url
+          repo_map = cached_repo_map
+          binary_map = repo_map[@@binary_repo_key]
+          return nil unless binary_map.kind_of?(Hash)
+          binary_map.values.first
+        end
+
+        def source_repo_url
+          repo_map = cached_repo_map
+          source_map = repo_map[@@source_repo_key]
+          return nil unless source_map.kind_of?(Hash)
+          source_map.values.first
+        end
+
+        def cache_branch(branch_caches)
+          make_branch_cache_workspace_if_needed
+          branch_hash = Hash.new
+
+          branch_caches.each do |e|
+            branch_hash[e.key] = {Meta::MetaConstants.branch_key => e.branch, Meta::MetaConstants.git_key => e.git}
+          end
+
+          File.open(Meta::MetaConstants.branch_cache_path, "w") { |io| io << branch_hash.to_yaml }
+        end 
+
+        def cached_branch_hash
+          unless File.exists?(Meta::MetaConstants.branch_cache_path)
+            return Hash.new
+          end
+
+          yaml = YAML.load_file(Meta::MetaConstants.branch_cache_path)
+          yaml
+        end
+
+        def set_search_path(search_path)
+          make_workspace()
+          content = File.open(@@path_map_path)
+          json = JSON.load(content)
+
+          map = Hash.new
+          if json.kind_of?(JSON)
+            map = json.to_hash
+          end
+          map['search_path'] = search_path
+
+          File.open(@@path_map_path, "w") { |io| io.puts map.to_json }
+        end
+
+        def start(repo_name)
+          current_pwd = Dir.pwd
+
+          # 1.检查repo_name合法性, 是否在repos中存在
+          repos_path = locate_repos_path
+          raise "#{repo_name} not found in configured source, run 'pod mod config' or 'pod repo uppdate' at first" unless repos_path
+
+          # 2.读取@@path_map缓存，是否有repo_name对应的pod的path存在
+          make_workspace()
+          # 2.1 如果repo_name对应的path存在, 返回他
+          local_path = read_local_path(repo_name)
+          return local_path if local_path.kind_of?(String)
+
+          ## 2.3 使用repos的地址clone到@@root中并在@@path_map中写入缓存地址
+          version = Meta::MetaAccessor.version(repo_name)
+          version_path = Pathname.new(repos_path) + repo_name
+          raise "#{version}不存在, run `pod repo update #{File.basename(repos_path)}`" unless Dir.entries(version_path).include?(version)
+
+          repo_spec_path = version_path + "#{version}/#{repo_name}.podspec"
+          raise "#{repo_spec_path} 不存在, 不是一个合法的podspec" unless File.exists?(repo_spec_path)
+
+          ## 切换workspace
+          FileUtils.cd(@@root_path)
+          ## 判断repo_name是否存在，如果存在，删除他，可能是一些临时文件
+          if File.exists?(repo_name)
+            UI.puts '清空workspace'
+            FileUtils.rm_rf(repo_name)
+          end
+
+          git_clone_command = package_clone_command(repo_spec_path, repo_name)
+          UI.puts "clone #{repo_name} into #{@@root_path}"
+          system_build(git_clone_command)
+
+          ## 下载完成之后，把路径写入缓存
+          local_path = "#{@@root_path}/#{repo_name}"
+          write_path_into_cache(repo_name, path)
+
+          ## 结束后，重置pwd
+          FileUtils.cd(current_pwd)
+
+          return local_path
+        end
+
+        def write_path_into_cache(repo_name, path)
+          content = File.open(@@path_map_path)
+          json = JSON.load(content)
+
+          map = Hash.new
+          if json.kind_of?(JSON)
+            map = json.to_hash
+          end
+          map[repo_name] = path
+
+          # path的上一级作为search_path
+          map['search_path'] = Pathname.new(path).parent
+
+          File.open(@@path_map_path, "w") { |io| io.puts map.to_json }
+        end
+
+        def read_local_path(repo_name)
+          return "" unless File.exists?(@@path_map_path)
+          content = File.open(@@path_map_path)
+          json = JSON.load(content)
+          local_path = json[repo_name] if json.kind_of?(Hash)
+          return local_path if local_path.kind_of?(String)
+
+          # 如果不存在, 先在search_path中寻找
+          local_path = locate_spec_in_search_path(repo_name)
+          if local_path.kind_of?(String)
+            write_path_into_cache(repo_name, local_path)
+            return local_path 
+          end
+        end
+
+        private
+        def cached_repo_map
+          repo_map = Hash.new
+          if File.exists?(@@repo_map_path)
+            content = File.read(@@repo_map_path)
+            _repo_map = JSON.load(content).to_hash
+            repo_map = _repo_map if _repo_map.kind_of?(Hash)
+          end
+          repo_map
+        end
+
+        def make_branch_cache_workspace_if_needed
+          unless File.directory?(Meta::MetaConstants.pods_generator_path)
+            raise "#{Meta::MetaConstants.pods_generator_path} not found"
+          end
+
+          unless File.exists?(Meta::MetaConstants.branch_cache_path)
+            FileUtils.touch(Meta::MetaConstants.branch_cache_path)
+          end
+        end
+
+        ## 查询repos的路径
+        def locate_repos_path
+          repos_path = Pathname.new(File.expand_path('~')) + '.cocoapods/repos'
+
+          path = Dir.glob("#{repos_path}/*").select { |f| File.directory? f }.detect do |p|
+            ssh = `/usr/bin/env -u GIT_CONFIG git -C #{p} config --get remote.origin.url`.lines.to_a.first.to_s
+            ssh = ssh.strip if ssh.kind_of?(String)
+            ssh.kind_of?(String) and [source_repo_url, binary_repo_url].include?(ssh)
+          end
+        end
+
+        def locate_spec_in_search_path(repo_name)
+          return Dir.glob("#{search_path}/#{repo_name}").first
+        end
+
+        ## 检查yrepos下是否包含repo_name
+        def is_repos_include(repo_path, repo_name)
+          Dir.entries(frepo_path).select { |entry| File.directory? File.join(repo_path, entry) and !(entry =='.' || entry == '..') }.include?(repo_name)
+        end
+
+        def package_clone_command(repo_spec_path, repo_name)
+          spec = Pod::Specification.from_file(repo_spec_path)
+          source_map = spec.source.to_hash
+          git = source_map[:git]
+          return unless git.kind_of?(String)
+
+          command = "git clone #{git}"
+          branch = source_map[:branch]
+          if branch.kind_of?(String)
+            command = command + " --branch #{branch} --depth 1 --single-branch #{@@root_path}/#{repo_name}"
+          end
+
+          command
+        end
+
+        def system_build(command)
+          output = `#{command}`.lines.to_a
+
+          if $?.exitstatus != 0
+            UI::BuildFailedReport.report(command, output)
+            Process.exit
+          end
+        end
+
+        def make_workspace
+          unless File.exists?(@@path_map_path)
+            # 如果root_path不存在，新建一个文件
+            unless Dir.exists?(@@root_path)
+              FileUtils.mkdir_p(@@root_path)
+              UI.puts "mkdir: #{@@root_path}"
+            end
+
+            # 如果ux_path_map不存在，创建一个文件
+            FileUtils.cd(@@root_path)
+            FileUtils.touch(@@path_map)
+
+            UI.puts "touch: #{@@path_map}"
+          end
+        end
+
+        def search_path
+          content = File.open(@@path_map_path)
+          json = JSON.load(content)
+          return json['search_path'] if json.kind_of?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-modularization/private.rb

@@ -0,0 +1,5 @@
+module Pod
+  module Private
+    autoload :PrivateCache, 'cocoapods-modularization/private/private_cache'
+  end
+end

data/lib/cocoapods-modularization.rb

@@ -0,0 +1 @@
+require 'cocoapods-modularization/gem_version'

data/lib/cocoapods_plugin.rb

@@ -0,0 +1 @@
+require 'cocoapods-modularization/command'

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-modularization
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- lazy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A short description of cocoapods-modularization.
+email:
+- 515310192@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cocoapods-modularization.rb
+- lib/cocoapods-modularization/command.rb
+- lib/cocoapods-modularization/command/install.rb
+- lib/cocoapods-modularization/command/mod.rb
+- lib/cocoapods-modularization/command/mod/add.rb
+- lib/cocoapods-modularization/command/mod/base.rb
+- lib/cocoapods-modularization/command/mod/binary.rb
+- lib/cocoapods-modularization/command/mod/config.rb
+- lib/cocoapods-modularization/command/mod/create.rb
+- lib/cocoapods-modularization/command/mod/inspect.rb
+- lib/cocoapods-modularization/command/mod/source.rb
+- lib/cocoapods-modularization/command/mod/sync.rb
+- lib/cocoapods-modularization/command/mod/update.rb
+- lib/cocoapods-modularization/gem_version.rb
+- lib/cocoapods-modularization/generate.rb
+- lib/cocoapods-modularization/generate/configuration.rb
+- lib/cocoapods-modularization/generate/installer.rb
+- lib/cocoapods-modularization/generate/podfile_generator.rb
+- lib/cocoapods-modularization/meta.rb
+- lib/cocoapods-modularization/meta/meta_accessor.rb
+- lib/cocoapods-modularization/meta/meta_constants.rb
+- lib/cocoapods-modularization/meta/meta_reference.rb
+- lib/cocoapods-modularization/private.rb
+- lib/cocoapods-modularization/private/private_cache.rb
+- lib/cocoapods_plugin.rb
+homepage: https://github.com/EXAMPLE/cocoapods-modularization
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A longer description of cocoapods-modularization.
+test_files: []