cocoapods-podfile_patch 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db532f51a36d8ed122fe39dff75ad95af60c9ed4
-  data.tar.gz: 8801633e0db80778e6c28348a0e235b96458dcbc
+  metadata.gz: c9bf1d36382cafc83dbcb729efa0d106ab8e8491
+  data.tar.gz: 74eb48c80a663f9e0cedc9f34a464d1843d62f0f
 SHA512:
-  metadata.gz: 0d7bfa8726d98dfcb688ea598642082c60f85efc7e9e9f1c4cde0cc5aba2efe42283052f0965c868ff3dc85db8690f2d76d006ce9d3d6f0eb8a16de5562ef4c3
-  data.tar.gz: 303764e98bf05c41a6aea36a4b92e920b1119ca987e7e21902c9e92f0de991f0d542cbba2742354e089dfacf27e1eb8f282a5dfc9ed6a2e6a78a724a20a3fe65
+  metadata.gz: 4d9297e7fb71edee6df68c3bbefb2a1f1aa241e01d8337e9fb133c5d5bb18a0e28f39c21646d17a81446f3b9f41c03e2b3b0bccdfec8bdc5b70b67e8821d0ab0
+  data.tar.gz: 02d02291d91aab7a7d1ff28e8f6491701728590e9a96d3f3da1a7656909a319e11dabcbbba47876d56a3177f502f7021d9a59b9d91d7579997ed527347971bb1

data/lib/cocoapods-podfile_patch/gem_version.rb

@@ -1,3 +1,3 @@
 module CocoapodsPodfile_patch
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/cocoapods-podfile_patch/main.rb

@@ -39,17 +39,17 @@ module Pod
             #
             def use_patch_file!(patchfile_path = 'Podfile.patch')
                 
-                @current_patch_files ||= []
-                if @current_patch_files.include? patchfile_path
+                @CococapodsPodfilePatch_current_patch_files ||= []
+                if @CococapodsPodfilePatch_current_patch_files.include? patchfile_path
                     # Yes, you could even use it recureively, but don't use the same patch file.
                     raise "`use_patch_file!` called recursively. Most case is it's used in Patch file."
                     return 
                 end
                 
-                @current_patch_files << patchfile_path
+                @CococapodsPodfilePatch_current_patch_files << patchfile_path
                 require 'cocoapods-podfile_patch/podfile_patch'
-                @patch_target = PodfilePatch.new.load_patch_target self, patchfile_path
-                @current_patch_files.delete(patchfile_path)
+                @CococapodsPodfilePatch_patch_target = CococapodsPodfilePatch::PodfilePatch.new.load_patch_target self, patchfile_path
+                @CococapodsPodfilePatch_current_patch_files.delete(patchfile_path)
             end
 
         end
@@ -62,8 +62,8 @@ module Pod
         define_method(:initialize) do |defined_in_file = nil, internal_hash = {}, &block|
             old_initialize_function.bind(self).(defined_in_file, internal_hash, &block)
 
-            if not @patch_target.nil?
-                PodfilePatch.new.merge_patch_and_original_podfile(self, @patch_target)
+            if not @CococapodsPodfilePatch_patch_target.nil?
+                CococapodsPodfilePatch::PodfilePatch.new.merge_patch_and_original_podfile(self, @CococapodsPodfilePatch_patch_target)
             end
         end
     end

data/lib/cocoapods-podfile_patch/podfile_patch.rb

@@ -4,248 +4,246 @@ require 'cocoapods-core/podfile'
 require 'pathname'
 require 'set'
 
+module CococapodsPodfilePatch
+    class PodfilePatch
 
-class PodfilePatch
+        ABSTRACT_PATCH_TARGET_NAME = "#{self}-fake-target"
 
-    ABSTRACT_PATCH_TARGET_NAME = "cocoapods-podfile_patch-fake-target"
+        def load_patch_target(podfile, patchfile_path)
 
+            # find patch file
+            patch_file_path = Pathname.new(patchfile_path)
+            if not patch_file_path.expand_path.file? 
+                podfile_root_path = Pathname.new(podfile.defined_in_file).dirname
+                patch_file_path = (podfile_root_path + patch_file_path).expand_path
+            end
+            if not patch_file_path.file?
+                Pod::UI.info "Podfile patch feature is enabled. (No patch file now.)"
+                return  
+            end
+            
+            # load patch file content. And add it to a abstract target
+            contents = File.read(patch_file_path)
+            podfile.target ABSTRACT_PATCH_TARGET_NAME do
+                podfile.instance_eval contents
+            end
 
-    def load_patch_target(podfile, patchfile_path)
+            # find the patch target and delete it in original podfile
+            root_target = podfile.root_target_definitions[0]
+            patch_target = root_target.children.find {|t| t.name == ABSTRACT_PATCH_TARGET_NAME }
+            root_target.children.delete(patch_target)
 
-        # find patch file
-        patch_file_path = Pathname.new(patchfile_path)
-        if not patch_file_path.expand_path.file? 
-            podfile_root_path = Pathname.new(podfile.defined_in_file).dirname
-            patch_file_path = (podfile_root_path + patch_file_path).expand_path
-        end
-        if not patch_file_path.file?
-            Pod::UI.info "Podfile patch feature is enabled. (No patch file now.)"
-            return  
+            return patch_target
         end
         
-        # load patch file content. And add it to a abstract target
-        contents = File.read(patch_file_path)
-        podfile.target ABSTRACT_PATCH_TARGET_NAME do
-            podfile.instance_eval contents
-        end
-
-        # find the patch target and delete it in original podfile
-        root_target = podfile.root_target_definitions[0]
-        patch_target = root_target.children.find {|t| t.name == ABSTRACT_PATCH_TARGET_NAME }
-        root_target.children.delete(patch_target)
-
-        return patch_target
-    end
-    
 
-    def merge_patch_and_original_podfile(podfile, patch_target)
-        
-        root_target = podfile.root_target_definitions[0]
-        
-        # merge patch_target and original_target
-        patch_target.name = root_target.name
-        merge_target_definitions_dependency(root_target,  patch_target)
-
-        Pod::UI.titled_section "Podfile patch feature is enabled" do
-            next unless Pod::UI.config.verbose?
-            Pod::UI.section "Patchfile Info" do 
-                self.print_podfile_raw_dependencies patch_target
-            end
-            Pod::UI.section "Modified Podfile Info" do 
-                self.print_podfile_raw_dependencies root_target
+        def merge_patch_and_original_podfile(podfile, patch_target)
+            
+            root_target = podfile.root_target_definitions[0]
+            
+            # merge patch_target and original_target
+            patch_target.name = root_target.name
+            merge_target_definitions_dependency(root_target,  patch_target)
+
+            Pod::UI.titled_section "Podfile patch feature is enabled" do
+                next unless Pod::UI.config.verbose?
+                Pod::UI.section "Patchfile Info" do 
+                    self.print_podfile_raw_dependencies patch_target
+                end
+                Pod::UI.section "Modified Podfile Info" do 
+                    self.print_podfile_raw_dependencies root_target
+                end
             end
         end
-    end
 
 
-    def merge_target_definitions_dependency(targetdef, patch_targetdef)
-        # Demo Data
-        # Original Target
-        # ```
-        # TargetDefination 'Pods':
-        # [{"BDWebImage"=>["1.0.1.1-binary"]}]
-        #
-        #     TargetDefination 'Pods-FrameworkDemos_Tests':
-        #     ["BDWebImage/SDAdapter", "BDWebImage/Download", {"TTNetworkManager"=>["2.2.8.46-rc.18"]}, {"AFNetworking"=>[{:path=>"/Users/lea/Downloads/AFNetworking"}]}]
-        #   
-        #     TargetDefination 'Pods-FrameworkDemos_Example':
-        #     ["BDWebImage", {"TTNetworkManager"=>["2.2.8.46-rc.18"]}]
-        # ```
-        #
-        # Patch Target
-        # ```
-        # TargetDefination 'Pods':
-        # [{"AFNetworking"=>["2.3"]}]
-        # ```
-
-        # 1. find all dependency patch_targetdef: patched_dependencies
-        # 2. modify targetdef's depedencies recursively:
-        #       - replace the requirement to the one in patched_dependencies 
-        #       - add to target if not contained
-
-
-        def get_raw_dependencies(target_defination)
-            (target_defination.send :get_hash_value, 'dependencies') || []
-        end
+        def merge_target_definitions_dependency(targetdef, patch_targetdef)
+            # Demo Data
+            # Original Target
+            # ```
+            # TargetDefination 'Pods':
+            # [{"BDWebImage"=>["1.0.1.1-binary"]}]
+            #
+            #     TargetDefination 'Pods-FrameworkDemos_Tests':
+            #     ["BDWebImage/SDAdapter", "BDWebImage/Download", {"TTNetworkManager"=>["2.2.8.46-rc.18"]}, {"AFNetworking"=>[{:path=>"/Users/lea/Downloads/AFNetworking"}]}]
+            #   
+            #     TargetDefination 'Pods-FrameworkDemos_Example':
+            #     ["BDWebImage", {"TTNetworkManager"=>["2.2.8.46-rc.18"]}]
+            # ```
+            #
+            # Patch Target
+            # ```
+            # TargetDefination 'Pods':
+            # [{"AFNetworking"=>["2.3"]}]
+            # ```
+
+            # 1. find all dependency patch_targetdef: patched_dependencies
+            # 2. modify targetdef's depedencies recursively:
+            #       - replace the requirement to the one in patched_dependencies 
+            #       - add to target if not contained
+
+
+            def get_raw_dependencies(target_defination)
+                (target_defination.send :get_hash_value, 'dependencies') || []
+            end
 
-        all_dependencies_in_patch = begin
-            def all_dependencies(target_defination)
-                d = get_raw_dependencies(target_defination) 
-                d += (target_defination.children.map do |subtarget|
-                    all_dependencies(subtarget)
-                end.flatten || [])
-                d
+            all_dependencies_in_patch = begin
+                def all_dependencies(target_defination)
+                    d = get_raw_dependencies(target_defination) 
+                    d += (target_defination.children.map do |subtarget|
+                        all_dependencies(subtarget)
+                    end.flatten || [])
+                    d
+                end
+                all_dependencies(patch_targetdef)
             end
-            all_dependencies(patch_targetdef)
-        end
-        
-        def transform_target_dependency_to_dict(dependencies)
-            dict = {}
-            dependencies.each do |name_or_hash|
-                if name_or_hash.is_a?(Hash)
-                    name = name_or_hash.keys.first
-                    requirements = name_or_hash.values.first
-                    dict[name] = requirements
-                else
-                    dict[name_or_hash] = {}
+            
+            def transform_target_dependency_to_dict(dependencies)
+                dict = {}
+                dependencies.each do |name_or_hash|
+                    if name_or_hash.is_a?(Hash)
+                        name = name_or_hash.keys.first
+                        requirements = name_or_hash.values.first
+                        dict[name] = requirements
+                    else
+                        dict[name_or_hash] = {}
+                    end
                 end
+                dict
             end
-            dict
-        end
 
-        dependencies_dict_in_patch = transform_target_dependency_to_dict(all_dependencies_in_patch)
+            dependencies_dict_in_patch = transform_target_dependency_to_dict(all_dependencies_in_patch)
 
-        def modify_target_defination_recursively(target_defination, &block)
-            block.call(target_defination)
-            target_defination.children.each { |t| modify_target_defination_recursively(t, &block) }
-        end
+            def modify_target_defination_recursively(target_defination, &block)
+                block.call(target_defination)
+                target_defination.children.each { |t| modify_target_defination_recursively(t, &block) }
+            end
 
-        patch_file_all_targets_dict = begin
-            targets = {}
-            modify_target_defination_recursively(patch_targetdef) do |t|
-                targets[t.name] = t
+            patch_file_all_targets_dict = begin
+                targets = {}
+                modify_target_defination_recursively(patch_targetdef) do |t|
+                    targets[t.name] = t
+                end
+                targets
             end
-            targets
-        end
 
-        patch_file_target_to_dependency_dict = begin
-            dict = {}
-            modify_target_defination_recursively(patch_targetdef) do |t|
-                deps = get_raw_dependencies(t)
-                dict[t.name] = transform_target_dependency_to_dict(deps)
+            patch_file_target_to_dependency_dict = begin
+                dict = {}
+                modify_target_defination_recursively(patch_targetdef) do |t|
+                    deps = get_raw_dependencies(t)
+                    dict[t.name] = transform_target_dependency_to_dict(deps)
+                end
+                dict
             end
-            dict
-        end
 
-        modified_dependencies_names = {} # pod name => target name
+            modified_dependencies_names = {} # pod name => target name
 
-        modify_target_defination_recursively(targetdef) do |t|
-            deps = get_raw_dependencies(t)
-            new_deps = []
-            deps_set = Set.new
-            
-            # modify origianl dependency
-            deps.each do |name_or_hash|
-                name = nil
-                if name_or_hash.is_a?(Hash)
-                    name = name_or_hash.keys.first
-                else
-                    name = name_or_hash
+            modify_target_defination_recursively(targetdef) do |t|
+                deps = get_raw_dependencies(t)
+                new_deps = []
+                deps_set = Set.new
+                
+                # modify origianl dependency
+                deps.each do |name_or_hash|
+                    name = nil
+                    if name_or_hash.is_a?(Hash)
+                        name = name_or_hash.keys.first
+                    else
+                        name = name_or_hash
+                    end
+                    if dependencies_dict_in_patch.key? name
+                        new_deps << {name => dependencies_dict_in_patch[name]}
+                        modified_dependencies_names[name] = t
+                    else
+                        new_deps << name_or_hash
+                    end
+                    deps_set.add(name)
                 end
-                if dependencies_dict_in_patch.key? name
-                    new_deps << {name => dependencies_dict_in_patch[name]}
-                    modified_dependencies_names[name] = t
-                else
-                    new_deps << name_or_hash
+                # add new dependency
+                patching_deps = patch_file_target_to_dependency_dict[t.name]
+                if not patching_deps.blank?
+                    patching_deps.each do |name, requirements|
+                        if not deps_set.include? name
+                            new_deps << (requirements.empty? ? name : {name => requirements})
+                            modified_dependencies_names[name] = t
+                        end
+                    end
                 end
-                deps_set.add(name)
+
+                t.send :set_hash_value, "dependencies", new_deps
             end
-            # add new dependency
-            patching_deps = patch_file_target_to_dependency_dict[t.name]
-            if not patching_deps.blank?
-                patching_deps.each do |name, requirements|
-                    if not deps_set.include? name
-                        new_deps << (requirements.empty? ? name : {name => requirements})
-                        modified_dependencies_names[name] = t
+
+            # handle MODULAR_HEADERS & INHIBIT_WARNING
+            [ 'inhibit_warnings',
+            'use_modular_headers'].each do |method|
+                modify_target_defination_recursively(targetdef) do |t|
+                    original_inhibit_warning_dict = t.send(:get_hash_value,method, {})
+                    original_inhibit_warning_dict.each do |key, value|
+                        # the key is "for_pods" or "not_for_pods" or "all"
+                        # Clear if patchfile have modified the pod
+                        next unless value.kind_of? Array
+                        value.reject! { |name| modified_dependencies_names.include? name}
+                    end
+        
+                    patch_target = patch_file_all_targets_dict[t.name]
+                    if not patch_target.nil?
+                        patch_inhibit_warning_dict = patch_target.send(:get_hash_value,method, {})
+                        patch_inhibit_warning_dict.each do |key, value|
+                            if value.kind_of? Array
+                                original = original_inhibit_warning_dict[key] || []
+                                original.concat(value).uniq! 
+                                original_inhibit_warning_dict[key] = original
+                            elsif [true, false].include? value # "all"
+                                original_inhibit_warning_dict[key] = value
+                            end
+                        end
+                    end
+                    # delete key if blank
+                    if original_inhibit_warning_dict.empty?
+                        t.send(:internal_hash).delete(method)
                     end
                 end
             end
 
-            t.send :set_hash_value, "dependencies", new_deps
-        end
-
-        # handle MODULAR_HEADERS & INHIBIT_WARNING
-        [ 'inhibit_warnings',
-          'use_modular_headers'].each do |method|
+            # handle CONFIGURATION_WHITELIST
             modify_target_defination_recursively(targetdef) do |t|
-                original_inhibit_warning_dict = t.send(:get_hash_value,method, {})
-                original_inhibit_warning_dict.each do |key, value|
-                    # the key is "for_pods" or "not_for_pods" or "all"
+                key = "configuration_pod_whitelist"
+                original = t.send :get_hash_value, key, {}
+                original.each do |config_name, pods|
                     # Clear if patchfile have modified the pod
-                    next unless value.kind_of? Array
-                    value.reject! { |name| modified_dependencies_names.include? name}
+                    next unless pods.kind_of? Array
+                    pods.reject! { |name| modified_dependencies_names.include? name}
                 end
-    
+                
                 patch_target = patch_file_all_targets_dict[t.name]
                 if not patch_target.nil?
-                    patch_inhibit_warning_dict = patch_target.send(:get_hash_value,method, {})
-                    patch_inhibit_warning_dict.each do |key, value|
-                        if value.kind_of? Array
-                            original = original_inhibit_warning_dict[key] || []
-                            original.concat(value).uniq! 
-                            original_inhibit_warning_dict[key] = original
-                        elsif [true, false].include? value # "all"
-                            original_inhibit_warning_dict[key] = value
-                        end
+                    patched = patch_target.send :raw_configuration_pod_whitelist
+                    patched.each do |config_name, pods|
+                        next unless pods.kind_of? Array
+                        original_pods = original[config_name] || []
+                        original_pods.concat(pods).uniq! 
+                        original[config_name] = original_pods
                     end
                 end
                 # delete key if blank
-                if original_inhibit_warning_dict.empty?
-                    t.send(:internal_hash).delete(method)
+                if original.empty?
+                    t.send(:internal_hash).delete(key)
                 end
             end
         end
 
-        # handle CONFIGURATION_WHITELIST
-        modify_target_defination_recursively(targetdef) do |t|
-            key = "configuration_pod_whitelist"
-            original = t.send :get_hash_value, key, {}
-            original.each do |config_name, pods|
-                # Clear if patchfile have modified the pod
-                next unless pods.kind_of? Array
-                pods.reject! { |name| modified_dependencies_names.include? name}
-            end
-            
-            patch_target = patch_file_all_targets_dict[t.name]
-            if not patch_target.nil?
-                patched = patch_target.send :raw_configuration_pod_whitelist
-                patched.each do |config_name, pods|
-                    next unless pods.kind_of? Array
-                    original_pods = original[config_name] || []
-                    original_pods.concat(pods).uniq! 
-                    original[config_name] = original_pods
+        def print_podfile_raw_dependencies(target)
+
+            def print_target_def_and_its_dependencies(target_def, intend = "")
+                puts "|\n"
+                puts "| #{intend}TARGET_DEFINITION: #{target_def}"
+                puts "| #{intend}INHIBIT_WARNING: #{target_def.send :raw_inhibit_warnings_hash}"
+                puts "| #{intend}DEPS: #{target_def.send :get_hash_value, 'dependencies'}"
+                target_def.children.each do |target_def|
+                    print_target_def_and_its_dependencies(target_def, intend + "    ")
                 end
             end
-            # delete key if blank
-            if original.empty?
-                t.send(:internal_hash).delete(key)
-            end
-        end
+            print_target_def_and_its_dependencies(target)
+        end 
     end
-
-    def print_podfile_raw_dependencies(target)
-
-        def print_target_def_and_its_dependencies(target_def, intend = "")
-            puts "|\n"
-            puts "| #{intend}TARGET_DEFINITION: #{target_def}"
-            puts "| #{intend}INHIBIT_WARNING: #{target_def.send :raw_inhibit_warnings_hash}"
-            puts "| #{intend}DEPS: #{target_def.send :get_hash_value, 'dependencies'}"
-            target_def.children.each do |target_def|
-                print_target_def_and_its_dependencies(target_def, intend + "    ")
-            end
-        end
-        print_target_def_and_its_dependencies(target)
-    end 
 end
-
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cocoapods-podfile_patch
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Gao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2019-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler