cocoapods-dylint 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b4658775ee818d70e6eaee8d34a8b44d0c3e667
+  data.tar.gz: e69e6ec2f4b3958d61fdc1b42d51ad96ecebe434
+SHA512:
+  metadata.gz: ccd5e484f3cc3481a339dcfebe58d87263e41906cdd674c9544d70709cb3dd933cc0e35ac5d79271ee096c99ff9aacbc8a03098a10a5f5239b91d0e1c6e05437
+  data.tar.gz: ded5dce255d40479ad8375b52baa554b33ad8f0cb51cb343e0d6492f2ca2f83ef0c576dfe32d7acc0ca69855a76a1e86cf9c795d4a9c2c12c90dbce8c0cc3bee

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+pkg
+.idea/

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cocoapods-dylint.gemspec
+gemspec
+
+group :development do
+  gem 'cocoapods'
+
+  gem 'mocha'
+  gem 'bacon'
+  gem 'mocha-on-bacon'
+  gem 'prettybacon'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2018 黄露洋 <huangluyang@douyu.tv>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,11 @@
+# cocoapods-dylint
+
+取消 `pod lib lint` 模拟器验证。
+
+## Installation
+
+    $ gem install cocoapods-dylint
+
+## Usage
+
+    $ pod lib dylint POD_NAME

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+
+def specs(dir)
+  FileList["spec/#{dir}/*_spec.rb"].shuffle.join(' ')
+end
+
+desc 'Runs all the specs'
+task :specs do
+  sh "bundle exec bacon #{specs('**')}"
+end
+
+task :default => :specs
+

data/cocoapods-dylint.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pod/gem_version.rb'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cocoapods-dylint'
+  spec.version       = CocoapodsDylint::VERSION
+  spec.authors       = ['黄露洋']
+  spec.email         = ['huangluyang@douyu.tv']
+  spec.description   = %q{Validates a Pod without simulator.}
+  spec.summary       = %q{Validates the Pod using the files in the working directory without simulator.}
+  spec.homepage      = 'http://gitlab.douyuios.com/douyu-ios/cocoapods-dylint'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/lib/cocoapods-dylint.rb

@@ -0,0 +1 @@
+require 'pod/gem_version'

data/lib/cocoapods_plugin.rb

@@ -0,0 +1 @@
+require 'pod/command'

data/lib/pod/command/lib/dylint.rb

@@ -0,0 +1,135 @@
+require File.expand_path('../validator.rb', __FILE__)
+module Pod
+  class Command
+    # This is an example of a cocoapods plugin adding a top-level subcommand
+    # to the 'pod' command.
+    #
+    # You can also create subcommands of existing or new commands. Say you
+    # wanted to add a subcommand to `list` to show newly deprecated pods,
+    # (e.g. `pod list deprecated`), there are a few things that would need
+    # to change.
+    #
+    # - move this file to `lib/pod/command/list/deprecated.rb` and update
+    #   the class to exist in the the Pod::Command::List namespace
+    # - change this class to extend from `List` instead of `Command`. This
+    #   tells the plugin system that it is a subcommand of `list`.
+    # - edit `lib/cocoapods_plugins.rb` to require this file
+    #
+    # @todo Create a PR to add your plugin to CocoaPods/cocoapods.org
+    #       in the `plugins.json` file, once your plugin is released.
+    #
+    class Lib < Command
+      class Dylint < Lib
+        self.summary = 'Validates a Pod without simulator'
+
+        self.description = <<-DESC
+          Validates the Pod using the files in the working directory without simulator.
+        DESC
+
+        def self.options
+          [
+            ['--quick', 'Lint skips checks that would require to download and build the spec'],
+            ['--allow-warnings', 'Lint validates even if warnings are present'],
+            ['--subspec=NAME', 'Lint validates only the given subspec'],
+            ['--no-subspecs', 'Lint skips validation of subspecs'],
+            ['--no-clean', 'Lint leaves the build directory intact for inspection'],
+            ['--fail-fast', 'Lint stops on the first failing platform or subspec'],
+            ['--use-libraries', 'Lint uses static libraries to install the spec'],
+            ['--sources=https://github.com/artsy/Specs,master', 'The sources from which to pull dependent pods ' \
+              '(defaults to https://github.com/CocoaPods/Specs.git). ' \
+              'Multiple sources must be comma-delimited.'],
+            ['--private', 'Lint skips checks that apply only to public specs'],
+            ['--swift-version=VERSION', 'The SWIFT_VERSION that should be used to lint the spec. ' \
+              'This takes precedence over a .swift-version file.'],
+            ['--skip-import-validation', 'Lint skips validating that the pod can be imported'],
+            ['--skip-tests', 'Lint skips building and running tests during validation'],
+          ].concat(super)
+        end
+
+        def initialize(argv)
+          @quick           = argv.flag?('quick')
+          @allow_warnings  = argv.flag?('allow-warnings')
+          @clean           = argv.flag?('clean', true)
+          @fail_fast       = argv.flag?('fail-fast', false)
+          @subspecs        = argv.flag?('subspecs', true)
+          @only_subspec    = argv.option('subspec')
+          @use_frameworks  = !argv.flag?('use-libraries')
+          @source_urls     = argv.option('sources', 'https://github.com/CocoaPods/Specs.git').split(',')
+          @private         = argv.flag?('private', false)
+          @swift_version   = argv.option('swift-version', nil)
+          @skip_import_validation = argv.flag?('skip-import-validation', false)
+          @skip_tests = argv.flag?('skip-tests', false)
+          @podspecs_paths = argv.arguments!
+          super
+        end
+
+        def validate!
+          super
+        end
+
+        def run
+          UI.puts
+          podspecs_to_lint.each do |podspec|
+            validator                = Pod::DyValidator.new(podspec, @source_urls)
+            validator.local          = true
+            validator.quick          = @quick
+            validator.no_clean       = !@clean
+            validator.fail_fast      = @fail_fast
+            validator.allow_warnings = @allow_warnings
+            validator.no_subspecs    = !@subspecs || @only_subspec
+            validator.only_subspec   = @only_subspec
+            validator.use_frameworks = @use_frameworks
+            validator.ignore_public_only_results = @private
+            validator.swift_version = @swift_version
+            validator.skip_import_validation = @skip_import_validation
+            validator.skip_tests = @skip_tests
+            validator.validate
+
+            unless @clean
+              UI.puts "Pods workspace available at `#{validator.validation_dir}/App.xcworkspace` for inspection."
+              UI.puts
+            end
+            if validator.validated?
+              UI.puts "#{validator.spec.name} passed validation.".green
+            else
+              spec_name = podspec
+              spec_name = validator.spec.name if validator.spec
+              message = "#{spec_name} did not pass validation, due to #{validator.failure_reason}."
+
+              if @clean
+                message << "\nYou can use the `--no-clean` option to inspect " \
+                  'any issue.'
+              end
+              raise Informative, message
+            end
+          end
+        end
+
+        private
+
+        #----------------------------------------#
+
+        # !@group Private helpers
+
+        # @return [Pathname] The path of the podspec found in the current
+        #         working directory.
+        #
+        # @raise  If no podspec is found.
+        # @raise  If multiple podspecs are found.
+        #
+        def podspecs_to_lint
+          if !@podspecs_paths.empty?
+            Array(@podspecs_paths)
+          else
+            podspecs = Pathname.glob(Pathname.pwd + '*.podspec{.json,}')
+            if podspecs.count.zero?
+              raise Informative, 'Unable to find a podspec in the working ' \
+                'directory'
+            end
+            podspecs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pod/command/lib/validator.rb

@@ -0,0 +1,898 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/string/inflections'
+
+module Pod
+  # Validates a Specification.
+  #
+  # Extends the Linter from the Core to add additional which require the
+  # LocalPod and the Installer.
+  #
+  # In detail it checks that the file patterns defined by the user match
+  # actually do match at least a file and that the Pod builds, by installing
+  # it without integration and building the project with xcodebuild.
+  #
+  class DyValidator
+    include Config::Mixin
+
+    # The default version of Swift to use when linting pods
+    #
+    DEFAULT_SWIFT_VERSION = '3.2'.freeze
+
+    # @return [Specification::Linter] the linter instance from CocoaPods
+    #         Core.
+    #
+    attr_reader :linter
+
+    # Initialize a new instance
+    #
+    # @param  [Specification, Pathname, String] spec_or_path
+    #         the Specification or the path of the `podspec` file to lint.
+    #
+    # @param  [Array<String>] source_urls
+    #         the Source URLs to use in creating a {Podfile}.
+    #
+    def initialize(spec_or_path, source_urls)
+      @linter = Specification::Linter.new(spec_or_path)
+      @source_urls = if @linter.spec && @linter.spec.dependencies.empty? && @linter.spec.recursive_subspecs.all? { |s| s.dependencies.empty? }
+                       []
+                     else
+                       source_urls.map { |url| config.sources_manager.source_with_name_or_url(url) }.map(&:url)
+                     end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    # @return [Specification] the specification to lint.
+    #
+    def spec
+      @linter.spec
+    end
+
+    # @return [Pathname] the path of the `podspec` file where {#spec} is
+    #         defined.
+    #
+    def file
+      @linter.file
+    end
+
+    # @return [Sandbox::FileAccessor] the file accessor for the spec.
+    #
+    attr_accessor :file_accessor
+
+    #-------------------------------------------------------------------------#
+
+    # Lints the specification adding a {Result} for any
+    # failed check to the {#results} list.
+    #
+    # @note   This method shows immediately which pod is being processed and
+    #         overrides the printed line once the result is known.
+    #
+    # @return [Bool] whether the specification passed validation.
+    #
+    def validate
+      @results = []
+
+      # Replace default spec with a subspec if asked for
+      a_spec = spec
+      if spec && @only_subspec
+        subspec_name = @only_subspec.start_with?(spec.root.name) ? @only_subspec : "#{spec.root.name}/#{@only_subspec}"
+        a_spec = spec.subspec_by_name(subspec_name, true, true)
+        @subspec_name = a_spec.name
+      end
+
+      UI.print " -> #{a_spec ? a_spec.name : file.basename}\r" unless config.silent?
+      $stdout.flush
+
+      perform_linting
+      perform_extensive_analysis(a_spec) if a_spec && !quick
+
+      UI.puts ' -> '.send(result_color) << (a_spec ? a_spec.to_s : file.basename.to_s)
+      print_results
+      validated?
+    end
+
+    # Prints the result of the validation to the user.
+    #
+    # @return [void]
+    #
+    def print_results
+      UI.puts results_message
+    end
+
+    def results_message
+      message = ''
+      results.each do |result|
+        if result.platforms == [:ios]
+          platform_message = '[iOS] '
+        elsif result.platforms == [:osx]
+          platform_message = '[OSX] '
+        elsif result.platforms == [:watchos]
+          platform_message = '[watchOS] '
+        elsif result.platforms == [:tvos]
+          platform_message = '[tvOS] '
+        end
+
+        subspecs_message = ''
+        if result.is_a?(Result)
+          subspecs = result.subspecs.uniq
+          if subspecs.count > 2
+            subspecs_message = '[' + subspecs[0..2].join(', ') + ', and more...] '
+          elsif subspecs.count > 0
+            subspecs_message = '[' + subspecs.join(',') + '] '
+          end
+        end
+
+        case result.type
+        when :error   then type = 'ERROR'
+        when :warning then type = 'WARN'
+        when :note    then type = 'NOTE'
+        else raise "#{result.type}" end
+        message << "    - #{type.ljust(5)} | #{platform_message}#{subspecs_message}#{result.attribute_name}: #{result.message}\n"
+      end
+      message << "\n"
+    end
+
+    def failure_reason
+      results_by_type = results.group_by(&:type)
+      results_by_type.default = []
+      return nil if validated?
+      reasons = []
+      if (size = results_by_type[:error].size) && size > 0
+        reasons << "#{size} #{'error'.pluralize(size)}"
+      end
+      if !allow_warnings && (size = results_by_type[:warning].size) && size > 0
+        reason = "#{size} #{'warning'.pluralize(size)}"
+        pronoun = size == 1 ? 'it' : 'them'
+        reason << " (but you can use `--allow-warnings` to ignore #{pronoun})" if reasons.empty?
+        reasons << reason
+      end
+      if results.all?(&:public_only)
+        reasons << 'all results apply only to public specs, but you can use ' \
+                   '`--private` to ignore them if linting the specification for a private pod'
+      end
+
+      reasons.to_sentence
+    end
+
+    #-------------------------------------------------------------------------#
+
+    #  @!group Configuration
+
+    # @return [Bool] whether the validation should skip the checks that
+    #         requires the download of the library.
+    #
+    attr_accessor :quick
+
+    # @return [Bool] whether the linter should not clean up temporary files
+    #         for inspection.
+    #
+    attr_accessor :no_clean
+
+    # @return [Bool] whether the linter should fail as soon as the first build
+    #         variant causes an error. Helpful for i.e. multi-platforms specs,
+    #         specs with subspecs.
+    #
+    attr_accessor :fail_fast
+
+    # @return [Bool] whether the validation should be performed against the root of
+    #         the podspec instead to its original source.
+    #
+    # @note   Uses the `:path` option of the Podfile.
+    #
+    attr_accessor :local
+    alias_method :local?, :local
+
+    # @return [Bool] Whether the validator should fail on warnings, or only on errors.
+    #
+    attr_accessor :allow_warnings
+
+    # @return [String] name of the subspec to check, if nil all subspecs are checked.
+    #
+    attr_accessor :only_subspec
+
+    # @return [Bool] Whether the validator should validate all subspecs.
+    #
+    attr_accessor :no_subspecs
+
+    # @return [Bool] Whether the validator should skip building and running tests.
+    #
+    attr_accessor :skip_tests
+
+    # @return [Bool] Whether frameworks should be used for the installation.
+    #
+    attr_accessor :use_frameworks
+
+    # @return [Boolean] Whether attributes that affect only public sources
+    #         Bool be skipped.
+    #
+    attr_accessor :ignore_public_only_results
+
+    attr_accessor :skip_import_validation
+    alias_method :skip_import_validation?, :skip_import_validation
+
+    #-------------------------------------------------------------------------#
+
+    # !@group Lint results
+
+    #
+    #
+    attr_reader :results
+
+    # @return [Boolean]
+    #
+    def validated?
+      result_type != :error && (result_type != :warning || allow_warnings)
+    end
+
+    # @return [Symbol] The type, which should been used to display the result.
+    #         One of: `:error`, `:warning`, `:note`.
+    #
+    def result_type
+      applicable_results = results
+      applicable_results = applicable_results.reject(&:public_only?) if ignore_public_only_results
+      types              = applicable_results.map(&:type).uniq
+      if    types.include?(:error)   then :error
+      elsif types.include?(:warning) then :warning
+      else  :note
+      end
+    end
+
+    # @return [Symbol] The color, which should been used to display the result.
+    #         One of: `:green`, `:yellow`, `:red`.
+    #
+    def result_color
+      case result_type
+      when :error   then :red
+      when :warning then :yellow
+      else :green end
+    end
+
+    # @return [Pathname] the temporary directory used by the linter.
+    #
+    def validation_dir
+      @validation_dir ||= Pathname(Dir.mktmpdir(['CocoaPods-Lint-', "-#{spec.name}"]))
+    end
+
+    # @return [String] the SWIFT_VERSION to use for validation.
+    #
+    def swift_version
+      return @swift_version unless @swift_version.nil?
+      if (version = spec.swift_version) || (version = dot_swift_version)
+        @swift_version = version.to_s
+      else
+        DEFAULT_SWIFT_VERSION
+      end
+    end
+
+    # Set the SWIFT_VERSION that should be used to validate the pod.
+    #
+    attr_writer :swift_version
+
+    # @return [String] the SWIFT_VERSION in the .swift-version file or nil.
+    #
+    def dot_swift_version
+      return unless file
+      swift_version_path = file.dirname + '.swift-version'
+      return unless swift_version_path.exist?
+      swift_version_path.read.strip
+    end
+
+    # @return [Boolean] Whether any of the pod targets part of this validator use Swift or not.
+    #
+    def uses_swift?
+      @installer.pod_targets.any?(&:uses_swift?)
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Lint steps
+
+    #
+    #
+    def perform_linting
+      linter.lint
+      @results.concat(linter.results.to_a)
+    end
+
+    # Perform analysis for a given spec (or subspec)
+    #
+    def perform_extensive_analysis(spec)
+      if spec.test_specification?
+        error('spec', "Validating a test spec (`#{spec.name}`) is not supported.")
+        return false
+      end
+      validate_homepage(spec)
+      validate_screenshots(spec)
+      validate_social_media_url(spec)
+      validate_documentation_url(spec)
+      validate_source_url(spec)
+
+      valid = spec.available_platforms.send(fail_fast ? :all? : :each) do |platform|
+        UI.message "\n\n#{spec} - Analyzing on #{platform} platform.".green.reversed
+        @consumer = spec.consumer(platform)
+        setup_validation_environment
+        begin
+          create_app_project
+          download_pod
+          check_file_patterns
+          install_pod
+          validate_swift_version
+          add_app_project_import
+          validate_vendored_dynamic_frameworks
+          build_pod
+          test_pod unless skip_tests
+        ensure
+          tear_down_validation_environment
+        end
+        validated?
+      end
+      return false if fail_fast && !valid
+      perform_extensive_subspec_analysis(spec) unless @no_subspecs
+    rescue => e
+      message = e.to_s
+      message << "\n" << e.backtrace.join("\n") << "\n" if config.verbose?
+      error('unknown', "Encountered an unknown error (#{message}) during validation.")
+      false
+    end
+
+    # Recursively perform the extensive analysis on all subspecs
+    #
+    def perform_extensive_subspec_analysis(spec)
+      spec.subspecs.reject(&:test_specification?).send(fail_fast ? :all? : :each) do |subspec|
+        @subspec_name = subspec.name
+        perform_extensive_analysis(subspec)
+      end
+    end
+
+    attr_accessor :consumer
+    attr_accessor :subspec_name
+
+    # Performs validation of a URL
+    #
+    def validate_url(url)
+      resp = Pod::HTTP.validate_url(url)
+
+      if !resp
+        warning('url', "There was a problem validating the URL #{url}.", true)
+      elsif !resp.success?
+        warning('url', "The URL (#{url}) is not reachable.", true)
+      end
+
+      resp
+    end
+
+    # Performs validations related to the `homepage` attribute.
+    #
+    def validate_homepage(spec)
+      if spec.homepage
+        validate_url(spec.homepage)
+      end
+    end
+
+    # Performs validation related to the `screenshots` attribute.
+    #
+    def validate_screenshots(spec)
+      spec.screenshots.compact.each do |screenshot|
+        response = validate_url(screenshot)
+        if response && !(response.headers['content-type'] && response.headers['content-type'].first =~ /image\/.*/i)
+          warning('screenshot', "The screenshot #{screenshot} is not a valid image.")
+        end
+      end
+    end
+
+    # Performs validations related to the `social_media_url` attribute.
+    #
+    def validate_social_media_url(spec)
+      validate_url(spec.social_media_url) if spec.social_media_url
+    end
+
+    # Performs validations related to the `documentation_url` attribute.
+    #
+    def validate_documentation_url(spec)
+      validate_url(spec.documentation_url) if spec.documentation_url
+    end
+
+    # Performs validations related to the `source` -> `http` attribute (if exists)
+    #
+    def validate_source_url(spec)
+      return if spec.source.nil? || spec.source[:http].nil?
+      url = spec.source[:http]
+      return if url.downcase.start_with?('https://')
+      warning('http', "The URL (`#{url}`) doesn't use the encrypted HTTPs protocol. " \
+              'It is crucial for Pods to be transferred over a secure protocol to protect your users from man-in-the-middle attacks. '\
+              'This will be an error in future releases. Please update the URL to use https.')
+    end
+
+    # Performs validation for which version of Swift is used during validation.
+    #
+    # An error will be displayed if the user has provided a `swift_version` attribute within the podspec but is also
+    # using either  `--swift-version` parameter or a `.swift-version with a different Swift version.
+    #
+    # The user will be warned that the default version of Swift was used if the following things are true:
+    #   - The project uses Swift at all
+    #   - The user did not supply a Swift version via a parameter
+    #   - There is no `swift_version` attribute set within the specification
+    #   - There is no `.swift-version` file present either.
+    #
+    def validate_swift_version
+      return unless uses_swift?
+      spec_swift_version = spec.swift_version
+      unless spec_swift_version.nil?
+        message = nil
+        if !dot_swift_version.nil? && dot_swift_version != spec_swift_version.to_s
+          message = "Specification `#{spec.name}` specifies an inconsistent `swift_version` (`#{spec_swift_version}`) compared to the one present in your `.swift-version` file (`#{dot_swift_version}`). " \
+                    'Please remove the `.swift-version` file which is now deprecated and only use the `swift_version` attribute within your podspec.'
+        elsif !@swift_version.nil? && @swift_version != spec_swift_version.to_s
+          message = "Specification `#{spec.name}` specifies an inconsistent `swift_version` (`#{spec_swift_version}`) compared to the one passed during lint (`#{@swift_version}`)."
+        end
+        unless message.nil?
+          error('swift', message)
+          return
+        end
+      end
+      if @swift_version.nil? && spec_swift_version.nil? && dot_swift_version.nil?
+        warning('swift',
+                'The validator used ' \
+                "Swift #{DEFAULT_SWIFT_VERSION} by default because no Swift version was specified. " \
+                'To specify a Swift version during validation, add the `swift_version` attribute in your podspec. ' \
+                'Note that usage of the `--swift-version` parameter or a `.swift-version` file is now deprecated.')
+      end
+    end
+
+    def setup_validation_environment
+      validation_dir.rmtree if validation_dir.exist?
+      validation_dir.mkpath
+      @original_config = Config.instance.clone
+      config.installation_root   = validation_dir
+      config.silent              = !config.verbose
+    end
+
+    def tear_down_validation_environment
+      validation_dir.rmtree unless no_clean
+      Config.instance = @original_config
+    end
+
+    def deployment_target
+      deployment_target = spec.subspec_by_name(subspec_name).deployment_target(consumer.platform_name)
+      if consumer.platform_name == :ios && use_frameworks
+        minimum = Version.new('8.0')
+        deployment_target = [Version.new(deployment_target), minimum].max.to_s
+      end
+      deployment_target
+    end
+
+    def download_pod
+      podfile = podfile_from_spec(consumer.platform_name, deployment_target, use_frameworks, consumer.spec.test_specs.map(&:name))
+      sandbox = Sandbox.new(config.sandbox_root)
+      @installer = Installer.new(sandbox, podfile)
+      @installer.use_default_plugins = false
+      @installer.has_dependencies = !spec.dependencies.empty?
+      %i(prepare resolve_dependencies download_dependencies).each { |m| @installer.send(m) }
+      @file_accessor = @installer.pod_targets.flat_map(&:file_accessors).find { |fa| fa.spec.name == consumer.spec.name }
+    end
+
+    def create_app_project
+      app_project = Xcodeproj::Project.new(validation_dir + 'App.xcodeproj')
+      Pod::Generator::AppTargetHelper.add_app_target(app_project, consumer.platform_name, deployment_target)
+      app_project.root_object.attributes['TargetAttributes'] = {app_project.targets[0].uuid => {"ProvisioningStyle" => "Manual"}}
+      target = app_project.targets[0]
+      info_plist_path = validation_dir + 'Info.plist'
+      info_plist = Pod::Generator::InfoPlistFile.new('1.0', :ios, :appl)
+      f = File.new(info_plist_path, 'w+')
+      f.write(info_plist.generate)
+      f.close
+      target.build_configurations.each do |c|
+        c.build_settings['INFOPLIST_FILE'] = 'Info.plist'
+        c.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'com.douyu.app'
+        c.build_settings['PROVISIONING_PROFILE_SPECIFIER'] = 'match Development *'
+        c.build_settings['CODE_SIGN_IDENTITY'] = 'iPhone Developer'
+        c.build_settings['DEVELOPMENT_TEAM'] = 'KW288R5J73'
+      end
+      app_project.save
+      app_project.recreate_user_schemes
+    end
+
+    def add_app_project_import
+      app_project = Xcodeproj::Project.open(validation_dir + 'App.xcodeproj')
+      app_target = app_project.targets.first
+      pod_target = @installer.pod_targets.find { |pt| pt.pod_name == spec.root.name }
+      Pod::Generator::AppTargetHelper.add_app_project_import(app_project, app_target, pod_target, consumer.platform_name, use_frameworks)
+      Pod::Generator::AppTargetHelper.add_swift_version(app_target, swift_version)
+      Pod::Generator::AppTargetHelper.add_xctest_search_paths(app_target) if @installer.pod_targets.any? { |pt| pt.spec_consumers.any? { |c| c.frameworks.include?('XCTest') } }
+      app_project.save
+      Xcodeproj::XCScheme.share_scheme(app_project.path, 'App')
+      # Share the pods xcscheme only if it exists. For pre-built vendored pods there is no xcscheme generated.
+      Xcodeproj::XCScheme.share_scheme(@installer.pods_project.path, pod_target.label) if shares_pod_target_xcscheme?(pod_target)
+    end
+
+    # It creates a podfile in memory and builds a library containing the pod
+    # for all available platforms with xcodebuild.
+    #
+    def install_pod
+      %i(validate_targets generate_pods_project integrate_user_project
+         perform_post_install_actions).each { |m| @installer.send(m) }
+
+      deployment_target = spec.subspec_by_name(subspec_name).deployment_target(consumer.platform_name)
+      configure_pod_targets(@installer.aggregate_targets, deployment_target)
+      @installer.pods_project.save
+    end
+
+    def configure_pod_targets(targets, deployment_target)
+      targets.each do |target|
+        target.pod_targets.each do |pod_target|
+          next unless (native_target = pod_target.native_target)
+          native_target.build_configuration_list.build_configurations.each do |build_configuration|
+            (build_configuration.build_settings['OTHER_CFLAGS'] ||= '$(inherited)') << ' -Wincomplete-umbrella'
+            build_configuration.build_settings['SWIFT_VERSION'] = (pod_target.swift_version || swift_version) if pod_target.uses_swift?
+          end
+          if pod_target.uses_swift?
+            pod_target.test_native_targets.each do |test_native_target|
+              test_native_target.build_configuration_list.build_configurations.each do |build_configuration|
+                build_configuration.build_settings['SWIFT_VERSION'] = swift_version
+              end
+            end
+          end
+        end
+        if target.pod_targets.any?(&:uses_swift?) && consumer.platform_name == :ios &&
+            (deployment_target.nil? || Version.new(deployment_target).major < 8)
+          uses_xctest = target.spec_consumers.any? { |c| (c.frameworks + c.weak_frameworks).include? 'XCTest' }
+          error('swift', 'Swift support uses dynamic frameworks and is therefore only supported on iOS > 8.') unless uses_xctest
+        end
+      end
+    end
+
+    def validate_vendored_dynamic_frameworks
+      deployment_target = spec.subspec_by_name(subspec_name).deployment_target(consumer.platform_name)
+
+      unless file_accessor.nil?
+        dynamic_frameworks = file_accessor.vendored_dynamic_frameworks
+        dynamic_libraries = file_accessor.vendored_dynamic_libraries
+        if (dynamic_frameworks.count > 0 || dynamic_libraries.count > 0) && consumer.platform_name == :ios &&
+            (deployment_target.nil? || Version.new(deployment_target).major < 8)
+          error('dynamic', 'Dynamic frameworks and libraries are only supported on iOS 8.0 and onwards.')
+        end
+      end
+    end
+
+    # Performs platform specific analysis. It requires to download the source
+    # at each iteration
+    #
+    # @note   Xcode warnings are treaded as notes because the spec maintainer
+    #         might not be the author of the library
+    #
+    # @return [void]
+    #
+    def build_pod
+      if !xcodebuild_available?
+        UI.warn "Skipping compilation with `xcodebuild' because it can't be found.\n".yellow
+      else
+        UI.message "\nBuilding with xcodebuild.\n".yellow do
+          scheme = if skip_import_validation?
+                     @installer.pod_targets.find { |pt| pt.pod_name == spec.root.name }.label
+                   else
+                     'App'
+                   end
+          output = xcodebuild('build', scheme, 'Release')
+          UI.puts output
+          parsed_output = parse_xcodebuild_output(output)
+          translate_output_to_linter_messages(parsed_output)
+        end
+      end
+    end
+
+    # Builds and runs all test sources associated with the current specification being validated.
+    #
+    # @note   Xcode warnings are treaded as notes because the spec maintainer
+    #         might not be the author of the library
+    #
+    # @return [void]
+    #
+    def test_pod
+      if !xcodebuild_available?
+        UI.warn "Skipping test validation with `xcodebuild' because it can't be found.\n".yellow
+      else
+        UI.message "\nTesting with xcodebuild.\n".yellow do
+          pod_target = @installer.pod_targets.find { |pt| pt.pod_name == spec.root.name }
+          consumer.spec.test_specs.each do |test_spec|
+            scheme = pod_target.native_target_for_spec(test_spec)
+            output = xcodebuild('test', scheme, 'Debug')
+            UI.puts output
+            parsed_output = parse_xcodebuild_output(output)
+            translate_output_to_linter_messages(parsed_output)
+          end
+        end
+      end
+    end
+
+    def xcodebuild_available?
+      !Executable.which('xcodebuild').nil? && ENV['COCOAPODS_VALIDATOR_SKIP_XCODEBUILD'].nil?
+    end
+
+    FILE_PATTERNS = %i(source_files resources preserve_paths vendored_libraries
+                       vendored_frameworks public_header_files preserve_paths
+                       private_header_files resource_bundles).freeze
+
+    # It checks that every file pattern specified in a spec yields
+    # at least one file. It requires the pods to be already present
+    # in the current working directory under Pods/spec.name.
+    #
+    # @return [void]
+    #
+    def check_file_patterns
+      FILE_PATTERNS.each do |attr_name|
+        if respond_to?("_validate_#{attr_name}", true)
+          send("_validate_#{attr_name}")
+        end
+
+        if !file_accessor.spec_consumer.send(attr_name).empty? && file_accessor.send(attr_name).empty?
+          error('file patterns', "The `#{attr_name}` pattern did not match any file.")
+        end
+      end
+
+      _validate_header_mappings_dir
+      if consumer.spec.root?
+        _validate_license
+        _validate_module_map
+      end
+    end
+
+    def _validate_private_header_files
+      _validate_header_files(:private_header_files)
+    end
+
+    def _validate_public_header_files
+      _validate_header_files(:public_header_files)
+    end
+
+    def _validate_license
+      unless file_accessor.license || spec.license && (spec.license[:type] == 'Public Domain' || spec.license[:text])
+        warning('license', 'Unable to find a license file')
+      end
+    end
+
+    def _validate_module_map
+      if spec.module_map
+        unless file_accessor.module_map.exist?
+          error('module_map', 'Unable to find the specified module map file.')
+        end
+        unless file_accessor.module_map.extname == '.modulemap'
+          relative_path = file_accessor.module_map.relative_path_from file_accessor.root
+          error('module_map', "Unexpected file extension for modulemap file (#{relative_path}).")
+        end
+      end
+    end
+
+    def _validate_resource_bundles
+      file_accessor.resource_bundles.each do |bundle, resource_paths|
+        next unless resource_paths.empty?
+        error('file patterns', "The `resource_bundles` pattern for `#{bundle}` did not match any file.")
+      end
+    end
+
+    # Ensures that a list of header files only contains header files.
+    #
+    def _validate_header_files(attr_name)
+      header_files = file_accessor.send(attr_name)
+      non_header_files = header_files.
+        select { |f| !Sandbox::FileAccessor::HEADER_EXTENSIONS.include?(f.extname) }.
+        map { |f| f.relative_path_from(file_accessor.root) }
+      unless non_header_files.empty?
+        error(attr_name, "The pattern matches non-header files (#{non_header_files.join(', ')}).")
+      end
+      non_source_files = header_files - file_accessor.source_files
+      unless non_source_files.empty?
+        error(attr_name, 'The pattern includes header files that are not listed ' \
+          "in source_files (#{non_source_files.join(', ')}).")
+      end
+    end
+
+    def _validate_header_mappings_dir
+      return unless header_mappings_dir = file_accessor.spec_consumer.header_mappings_dir
+      absolute_mappings_dir = file_accessor.root + header_mappings_dir
+      unless absolute_mappings_dir.directory?
+        error('header_mappings_dir', "The header_mappings_dir (`#{header_mappings_dir}`) is not a directory.")
+      end
+      non_mapped_headers = file_accessor.headers.
+        reject { |h| h.to_path.start_with?(absolute_mappings_dir.to_path) }.
+        map { |f| f.relative_path_from(file_accessor.root) }
+      unless non_mapped_headers.empty?
+        error('header_mappings_dir', "There are header files outside of the header_mappings_dir (#{non_mapped_headers.join(', ')}).")
+      end
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Result Helpers
+
+    def error(*args)
+      add_result(:error, *args)
+    end
+
+    def warning(*args)
+      add_result(:warning, *args)
+    end
+
+    def note(*args)
+      add_result(:note, *args)
+    end
+
+    def translate_output_to_linter_messages(parsed_output)
+      parsed_output.each do |message|
+        # Checking the error for `InputFile` is to work around an Xcode
+        # issue where linting would fail even though `xcodebuild` actually
+        # succeeds. Xcode.app also doesn't fail when this issue occurs, so
+        # it's safe for us to do the same.
+        #
+        # For more details see https://github.com/CocoaPods/CocoaPods/issues/2394#issuecomment-56658587
+        #
+        if message.include?("'InputFile' should have")
+          next
+        end
+
+        if message =~ /\S+:\d+:\d+: error:/
+          error('xcodebuild', message)
+        elsif message =~ /\S+:\d+:\d+: warning:/
+          warning('xcodebuild', message)
+        else
+          note('xcodebuild', message)
+        end
+      end
+    end
+
+    def shares_pod_target_xcscheme?(pod_target)
+      Pathname.new(@installer.pods_project.path + pod_target.label).exist?
+    end
+
+    def add_result(type, attribute_name, message, public_only = false)
+      result = results.find do |r|
+        r.type == type && r.attribute_name && r.message == message && r.public_only? == public_only
+      end
+      unless result
+        result = Result.new(type, attribute_name, message, public_only)
+        results << result
+      end
+      result.platforms << consumer.platform_name if consumer
+      result.subspecs << subspec_name if subspec_name && !result.subspecs.include?(subspec_name)
+    end
+
+    # Specialized Result to support subspecs aggregation
+    #
+    class Result < Specification::Linter::Results::Result
+      def initialize(type, attribute_name, message, public_only = false)
+        super(type, attribute_name, message, public_only)
+        @subspecs = []
+      end
+
+      attr_reader :subspecs
+    end
+
+    #-------------------------------------------------------------------------#
+
+    private
+
+    # !@group Helpers
+
+    # @return [Array<String>] an array of source URLs used to create the
+    #         {Podfile} used in the linting process
+    #
+    attr_reader :source_urls
+
+    # @param  [String] platform_name
+    #         the name of the platform, which should be declared
+    #         in the Podfile.
+    #
+    # @param  [String] deployment_target
+    #         the deployment target, which should be declared in
+    #         the Podfile.
+    #
+    # @param  [Bool] use_frameworks
+    #         whether frameworks should be used for the installation
+    #
+    # @param [Array<String>] test_spec_names
+    #         the test spec names to include in the podfile.
+    #
+    # @return [Podfile] a podfile that requires the specification on the
+    #         current platform.
+    #
+    # @note   The generated podfile takes into account whether the linter is
+    #         in local mode.
+    #
+    def podfile_from_spec(platform_name, deployment_target, use_frameworks = true, test_spec_names = [])
+      name     = subspec_name || spec.name
+      podspec  = file.realpath
+      local    = local?
+      urls     = source_urls
+      Pod::Podfile.new do
+        install! 'cocoapods', :deterministic_uuids => false
+        urls.each { |u| source(u) }
+        target 'App' do
+          use_frameworks!(use_frameworks)
+          platform(platform_name, deployment_target)
+          if local
+            pod name, :path => podspec.dirname.to_s
+          else
+            pod name, :podspec => podspec.to_s
+          end
+          test_spec_names.each do |test_spec_name|
+            if local
+              pod test_spec_name, :path => podspec.dirname.to_s
+            else
+              pod test_spec_name, :podspec => podspec.to_s
+            end
+          end
+        end
+      end
+    end
+
+    # Parse the xcode build output to identify the lines which are relevant
+    # to the linter.
+    #
+    # @param  [String] output the output generated by the xcodebuild tool.
+    #
+    # @note   The indentation and the temporary path is stripped form the
+    #         lines.
+    #
+    # @return [Array<String>] the lines that are relevant to the linter.
+    #
+    def parse_xcodebuild_output(output)
+      lines = output.split("\n")
+      selected_lines = lines.select do |l|
+        l.include?('error: ') && (l !~ /errors? generated\./) && (l !~ /error: \(null\)/) ||
+          l.include?('warning: ') && (l !~ /warnings? generated\./) && (l !~ /frameworks only run on iOS 8/) ||
+          l.include?('note: ') && (l !~ /expanded from macro/)
+      end
+      selected_lines.map do |l|
+        new = l.gsub(%r{#{validation_dir}/Pods/}, '')
+        new.gsub!(/^ */, ' ')
+      end
+    end
+
+    # @return [String] Executes xcodebuild in the current working directory and
+    #         returns its output (both STDOUT and STDERR).
+    #
+    def xcodebuild(action, scheme, configuration)
+      require 'fourflusher'
+      command = %W(clean #{action} -workspace #{File.join(validation_dir, 'App.xcworkspace')} -scheme #{scheme} -configuration #{configuration})
+      case consumer.platform_name
+      when :osx, :macos
+        command += %w(CODE_SIGN_IDENTITY=)
+      when :ios
+        #command += %w(CODE_SIGN_IDENTITY=- -sdk iphonesimulator)
+        #command += Fourflusher::SimControl.new.destination(:oldest, 'iOS', deployment_target)
+        command += %w(-sdk iphoneos -destination generic/platform=iOS)
+      when :watchos
+        command += %w(CODE_SIGN_IDENTITY=- -sdk watchsimulator)
+        command += Fourflusher::SimControl.new.destination(:oldest, 'watchOS', deployment_target)
+      when :tvos
+        command += %w(CODE_SIGN_IDENTITY=- -sdk appletvsimulator)
+        command += Fourflusher::SimControl.new.destination(:oldest, 'tvOS', deployment_target)
+      end
+
+      output, status = _xcodebuild(command)
+
+      unless status.success?
+        message = 'Returned an unsuccessful exit code.'
+        message += ' You can use `--verbose` for more information.' unless config.verbose?
+        error('xcodebuild', message)
+      end
+
+      output
+    end
+
+    # Executes the given command in the current working directory.
+    #
+    # @return [(String, Status)] The output of the given command and its
+    #         resulting status.
+    #
+    def _xcodebuild(command)
+      UI.puts 'xcodebuild ' << command.join(' ') if config.verbose
+      Executable.capture_command('xcodebuild', command, :capture => :merge)
+    end
+
+    #-------------------------------------------------------------------------#
+  end
+end

data/lib/pod/command.rb

@@ -0,0 +1 @@
+require 'pod/command/lib/dylint'

data/lib/pod/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsDylint
+  VERSION = "0.0.1"
+end

data/spec/command/dylint_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+module Pod
+  describe Command::Dylint do
+    describe 'CLAide' do
+      it 'registers it self' do
+        Command.parse(%w{ dylint }).should.be.instance_of Command::Dylint
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+$:.unshift((ROOT + 'lib').to_s)
+$:.unshift((ROOT + 'spec').to_s)
+
+require 'bundler/setup'
+require 'bacon'
+require 'mocha-on-bacon'
+require 'pretty_bacon'
+require 'pathname'
+require 'cocoapods'
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+require 'cocoapods_plugin'
+
+#-----------------------------------------------------------------------------#
+
+module Pod
+
+  # Disable the wrapping so the output is deterministic in the tests.
+  #
+  UI.disable_wrap = true
+
+  # Redirects the messages to an internal store.
+  #
+  module UI
+    @output = ''
+    @warnings = ''
+
+    class << self
+      attr_accessor :output
+      attr_accessor :warnings
+
+      def puts(message = '')
+        @output << "#{message}\n"
+      end
+
+      def warn(message = '', actions = [])
+        @warnings << "#{message}\n"
+      end
+
+      def print(message)
+        @output << message
+      end
+    end
+  end
+end
+
+#-----------------------------------------------------------------------------#

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-dylint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- 黄露洋
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-31 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: Validates a Pod without simulator.
+email:
+- huangluyang@douyu.tv
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cocoapods-dylint.gemspec
+- lib/cocoapods-dylint.rb
+- lib/cocoapods_plugin.rb
+- lib/pod/command.rb
+- lib/pod/command/lib/dylint.rb
+- lib/pod/command/lib/validator.rb
+- lib/pod/gem_version.rb
+- spec/command/dylint_spec.rb
+- spec/spec_helper.rb
+homepage: http://gitlab.douyuios.com/douyu-ios/cocoapods-dylint
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Validates the Pod using the files in the working directory without simulator.
+test_files:
+- spec/command/dylint_spec.rb
+- spec/spec_helper.rb