cocoapods-generate 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b13e0f00ce8c1f769d2b12efad7689bfd8a46aa377abe04cbcd78e712b2f4e3
+  data.tar.gz: 7f236e2188cad4f0fac8f7e3d44819acb6a152cda2bd59bd6e8d031aa3a5465d
+SHA512:
+  metadata.gz: be0ecfd373ec36a35e41fab37ec61b30bf98fcaf69c501f8cf2798c2e45e159fa102bd7688f370749b92bd12b5fd61b3e579f44bf88591f8b80599d22d4e1417
+  data.tar.gz: e43f56eaf2d99dec52e65015c0d5d79f8523fdb5533180a81c19b8a341f917b09ca67221a3255a35cb300dfe32699468bea6c63e3692c02db8f2bdbdd0cd13ce

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at segiddins@squareup.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/README.md

@@ -0,0 +1,118 @@
+# `cocoapods-generate`
+
+A [CocoaPods](https://cocoapods.org/) plugin that allows you to easily generate a workspace from a podspec.
+
+Whether you want to completely remove all Xcode projects from your library's repository or you want to be able to focus on a small piece of a monorepo, a single `pod gen` command will build up a workspace suitable for writing, running, testing, and debugging in Xcode.
+
+When you're done working, you don't have to do anything -- and that means no merge conflicts, no managing Xcode projects, and no tearing down a sample app setup. `pod gen` manages all that for you.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cocoapods-generate'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cocoapods-generate
+
+## CLI
+
+The main point of interaction with the plugin is via the `pod gen` command.
+It takes in a list of podspecs (or directories) as arguments,
+as well as many options that modify how `gen` will create your workspace.
+
+<!-- begin cli usage -->
+```
+Usage:
+
+    $ pod gen [PODSPEC|DIR ...]
+
+      Generates Xcode workspaces from a podspec.
+
+      pod gen allows you to keep your Podfile and podspecs as the single source of
+      truth for pods under development. By generating throw-away workspaces capable of
+      building, running, and testing a pod, you can focus on library development
+      without worrying about other code or managing an Xcode project.
+
+      pod gen works particularly well for monorepo projects, since it is capable of
+      using your existing settings when generating the workspace, making each gen'ed
+      project truly a small slice of the larger application.
+
+Options:
+
+    --silent                               Show nothing
+    --verbose                              Show more debugging information
+    --no-ansi                              Show output without ANSI codes
+    --help                                 Show help banner of specified command
+    --podfile-path=PATH                    Path to podfile to use
+    --use-podfile                          Whether restrictions should be copied from
+                                           the podfile
+    --use-lockfile                         Whether the lockfile should be used
+    --use-lockfile-versions                Whether versions from the lockfile should
+                                           be used
+    --use-libraries                        Whether to use libraries instead of
+                                           frameworks
+    --gen-directory=PATH                   Path to generate workspaces in
+    --auto-open                            Whether to automatically open the generated
+                                           workspaces
+    --clean                                Whether to clean the generated directories
+                                           before generating
+    --app-host-source-dir=DIR              A directory containing sources to use for
+                                           the app host
+    --sources=SOURCE1,SOURCE2              The sources from which to pull dependant
+                                           pods (defaults to all repos in the podfile
+                                           if using the podfile, else all available
+                                           repos). Can be a repo name or URL. Multiple
+                                           sources must be comma-delimited.
+    --repo-update                          Force running `pod repo update` before
+                                           install
+    --use-default-plugins                  Whether installation should activate
+                                           default plugins
+    --deterministic-uuids                  Whether installation should use
+                                           deterministic UUIDs for pods projects
+    --share-schemes-for-development-pods   Whether installation should share schemes
+                                           for development pods
+    --warn-for-multiple-pod-sources        Whether installation should warn when a pod
+                                           is found in multiple sources
+```
+<!-- end cli usage -->
+
+## `.gen_config.yml`
+
+All of the command line options above can also be specified in a `.gen_config.yml` file.
+
+For example, the equivalent of running `pod gen --no-deterministic-uuids --sources=a,b --gen-directory=/tmp/gen --use-libraries` would be
+
+```yaml
+deterministic_uuids: false
+sources:
+- a
+- b
+gen_directory: /tmp/gen
+use_libraries: true
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/rake spec` to run the tests.
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+To release a new version, update the version number in `VERSION`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/square/cocoapods-generate. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Code of Conduct
+
+Everyone interacting in the cocoapods-generate project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/square/cocoapods-generate/blob/master/CODE_OF_CONDUCT.md).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/cocoapods/command/gen.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'cocoapods/generate'
+
+module Pod
+  class Command
+    class Gen < Command
+      self.summary = 'Generates Xcode workspaces from a podspec.'
+
+      self.description = <<-DESC.strip_heredoc
+        #{summary}
+
+        pod gen allows you to keep your Podfile and podspecs as the single source of
+        truth for pods under development. By generating throw-away workspaces capable of
+        building, running, and testing a pod, you can focus on library development
+        without worrying about other code or managing an Xcode project.
+
+        pod gen works particularly well for monorepo projects, since it is capable of
+        using your existing settings when generating the workspace, making each gen'ed
+        project truly a small slice of the larger application.
+      DESC
+
+      def self.options
+        super.concat(Generate::Configuration.options.map do |option|
+          next unless option.cli_name
+
+          flag = "--#{option.cli_name}"
+          flag += "=#{option.arg_name}" if option.arg_name
+          [flag, option.message]
+        end.compact)
+      end
+
+      self.arguments = [
+        CLAide::Argument.new(%w[PODSPEC DIR], false, true)
+      ]
+
+      # @return [Configuration]
+      #         the configuration used when generating workspaces
+      #
+      attr_reader :configuration
+
+      def initialize(argv)
+        options_hash = Generate::Configuration.options.each_with_object({}) do |option, options|
+          value =
+            if option.name == :podspec_paths
+              argv.arguments!
+            elsif option.flag?
+              argv.flag?(option.cli_name)
+            else
+              argv.option(option.cli_name)
+            end
+
+          next if value.nil?
+          options[option.name] = option.coerce(value)
+        end
+        @configuration = merge_configuration(options_hash)
+        super
+      end
+
+      def run
+        UI.puts "[pod gen] Running with #{configuration.to_s.gsub("\n", "         \n")}" if configuration.pod_config.verbose?
+
+        # this is done here rather than in the installer so we only update sources once,
+        # even if there are multiple podspecs
+        update_sources if configuration.repo_update?
+
+        Generate::PodfileGenerator.new(configuration).podfiles_by_spec.each do |spec, podfile|
+          Generate::Installer.new(configuration, spec, podfile).install!
+        end
+
+        remove_warnings(UI.warnings)
+      end
+
+      def validate!
+        super
+
+        config_errors = configuration.validate
+        help! config_errors.join("\n    ") if config_errors.any?
+      end
+
+      private
+
+      def merge_configuration(options)
+        # must use #to_enum explicitly since descend doesn't return an enumerator on 2.1
+        config_hashes = Pathname.pwd.to_enum(:descend).map do |dir|
+          path = dir + '.gen_config.yml'
+          next unless path.file?
+          Pod::Generate::Configuration.from_file(path)
+        end
+
+        env = Generate::Configuration.from_env(ENV)
+        config_hashes.insert(-2, env)
+        config_hashes << options
+
+        configuration = config_hashes.compact.each_with_object({}) { |e, h| h.merge!(e) }
+        Pod::Generate::Configuration.new(pod_config: config, **configuration)
+      end
+
+      def remove_warnings(warnings)
+        warnings.reject! do |warning|
+          warning[:message].include? 'Automatically assigning platform'
+        end
+      end
+
+      def update_sources
+        UI.title 'Updating specs repos' do
+          configuration.sources.each do |source|
+            source = config.sources_manager.source_with_name_or_url(source)
+            UI.titled_section "Updating spec repo `#{source.name}`" do
+              source.update(config.verbose?)
+              source.verify_compatibility!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generate.rb

@@ -0,0 +1,10 @@
+
+# frozen_string_literal: true
+
+module Pod
+  module Generate
+    autoload :Configuration, 'cocoapods/generate/configuration'
+    autoload :Installer, 'cocoapods/generate/installer'
+    autoload :PodfileGenerator, 'cocoapods/generate/podfile_generator'
+  end
+end

data/lib/cocoapods/generate/configuration.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Pod
+  module Generate
+    class Configuration
+      @options = []
+      class << self
+          # @return [Array<Option>]
+          #         all of the options available in the configuration
+          #
+          attr_reader :options
+      end
+
+      Option = Struct.new(:name, :type, :default, :message, :arg_name, :validator, :coercer) do
+        def validate(value)
+          return if value.nil?
+          errors = []
+          if (exceptions = Array(value).grep(Exception)) && exceptions.any?
+            errors << "Error computing #{name}"
+            errors.concat exceptions.map(&:message)
+          else
+            errors << "got type #{value.class}, expected object of type #{Array(type).join('|')}" unless Array(type).any? { |t| t === value }
+            validator_errors = begin
+                                   validator && validator[value]
+                                 rescue StandardError
+                                   "failed to run validator (#{$ERROR_INFO})"
+                                 end
+            errors.concat Array(validator_errors) if validator_errors
+            errors.unshift "#{value.inspect} invalid for #{name}" if errors.any?
+          end
+          errors.join(', ') unless errors.empty?
+        end
+
+        def cli_name
+          return unless message
+          @cli_name ||= name.to_s.tr '_', '-'
+        end
+
+        def flag?
+          arg_name.nil?
+        end
+
+        def coerce(value)
+          coercer ? coercer[value] : value
+        end
+      end
+      private_constant :Option
+
+      # Declares a new option
+      #
+      # @!macro [attach] $0
+      #   @attribute [r] $1
+      #     @return [$2] $4
+      #     defaults to `$3`
+      #
+      def self.option(*args)
+        options << Option.new(*args)
+      end
+      private_class_method :option
+
+      # @visibility private
+      #
+      # Implements `===` to do type checking against an array.
+      #
+      class ArrayOf
+        attr_reader :types
+
+        def initialize(*types)
+          @types = types
+        end
+
+        def to_s
+          "Array<#{types.join('|')}>"
+        end
+
+        # @return [Boolean] whether the given object is an array with elements all of the given types
+        #
+        def ===(other)
+          other.is_a?(Array) && other.all? { |o| types.any? { |t| t === o } }
+        end
+      end
+      private_constant :ArrayOf
+
+      coerce_to_bool = lambda do |value|
+        if value.is_a?(String)
+          value =
+            case value.downcase
+            when ''
+              nil
+            when 'true'
+              true
+            when 'false'
+              false
+            end
+        end
+        value
+      end
+
+      coerce_to_pathname = lambda do |path|
+        path && Pathname(path).expand_path
+      end
+
+      BOOLEAN = [TrueClass, FalseClass].freeze
+      private_constant :BOOLEAN
+
+      option :pod_config, Config, 'Pod::Config.instance', nil
+
+      option :podfile_path, [String, Pathname], 'pod_config.podfile_path', 'Path to podfile to use', 'PATH', ->(path) { 'file does not exist' unless path.file? }, coerce_to_pathname
+      option :podfile, [Podfile], 'Podfile.from_file(podfile_path) if (podfile_path && File.file?(File.expand_path(podfile_path)))'
+      option :use_podfile, BOOLEAN, '!!podfile', 'Whether restrictions should be copied from the podfile', nil, nil, coerce_to_bool
+
+      option :lockfile, [Pod::Lockfile], 'pod_config.lockfile', nil
+      option :use_lockfile, BOOLEAN, '!!lockfile', 'Whether the lockfile should be used to discover transitive dependencies', nil, nil, coerce_to_bool
+      option :use_lockfile_versions, BOOLEAN, 'use_lockfile', 'Whether versions from the lockfile should be used', nil, nil, coerce_to_bool
+
+      option :use_libraries, BOOLEAN, 'false', 'Whether to use libraries instead of frameworks', nil, nil, coerce_to_bool
+
+      option :gen_directory, [String, Pathname], 'Pathname("gen").expand_path', 'Path to generate workspaces in', 'PATH', ->(path) { 'path is file' if path.file? }, coerce_to_pathname
+      option :auto_open, BOOLEAN, 'false', 'Whether to automatically open the generated workspaces', nil, nil, coerce_to_bool
+      option :clean, BOOLEAN, 'false', 'Whether to clean the generated directories before generating', nil, nil, coerce_to_bool
+
+      option :app_host_source_dir, [String, Pathname], 'nil',
+             'A directory containing sources to use for the app host',
+             'DIR',
+             ->(dir) { 'not a directory' unless dir.directory? },
+             coerce_to_pathname
+
+      option :podspec_paths, ArrayOf.new(String, Pathname, URI),
+             '[Pathname(?.)]',
+             nil,
+             nil,
+             ->(paths) { ('paths do not exist' unless paths.all? { |p| p.is_a?(URI) || p.exist? }) },
+             ->(paths) { paths && paths.map { |path| path.to_s =~ %r{https?://} ? URI(path) : Pathname(path).expand_path } }
+      option :podspecs, ArrayOf.new(Pod::Specification),
+             'self.class.podspecs_from_paths(podspec_paths)',
+             nil,
+             nil,
+             ->(specs) { 'no podspecs found' if specs.empty? },
+             ->(paths) { paths && paths.map { |path| Pathname(path).expand_path } }
+
+      # installer options
+      option :sources, ArrayOf.new(String),
+             'if use_podfile && podfile then ::Pod::Installer::Analyzer.new(:sandbox, podfile).sources.map(&:url) else pod_config.sources_manager.all.map(&:url) end',
+             'The sources from which to pull dependant pods (defaults to all repos in the podfile if using the podfile, else all available repos). Can be a repo name or URL. Multiple sources must be comma-delimited.',
+             'SOURCE1,SOURCE2',
+             ->(_) { nil },
+             ->(sources) { Array(sources).flat_map { |s| s.split(',') } }
+      option :repo_update, BOOLEAN, 'false', 'Force running `pod repo update` before install', nil, nil, coerce_to_bool
+      option :use_default_plugins, BOOLEAN, 'false', 'Whether installation should activate default plugins', nil, nil, coerce_to_bool
+      option :deterministic_uuids, BOOLEAN, 'false', 'Whether installation should use deterministic UUIDs for pods projects', nil, nil, coerce_to_bool
+      option :share_schemes_for_development_pods, BOOLEAN, 'true', 'Whether installation should share schemes for development pods', nil, nil, coerce_to_bool
+      option :warn_for_multiple_pod_sources, BOOLEAN, 'false', 'Whether installation should warn when a pod is found in multiple sources', nil, nil, coerce_to_bool
+
+      options.freeze
+      options.each do |o|
+        attr_reader o.name
+        alias_method :"#{o.name}?", o.name if o.type == BOOLEAN
+      end
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # @!visibility private
+            def initialize(
+              #{options.map { |o| "#{o.name}: (begin (#{o.default}); rescue => e; e; end)" }.join(', ')}
+              )
+                #{options.map { |o| "@#{o.name} = #{o.name}" }.join('; ')}
+            end
+      RUBY
+
+      # @return [Hash<Symbol,Object>] the configuration hash parsed from the given file
+      #
+      # @param  [Pathname] path
+      #
+      # @raises [Informative] if the file does not exist or is not a YAML hash
+      #
+      def self.from_file(path)
+        raise Informative, "No cocoapods-generate configuration found at #{UI.path path}" unless path.file?
+        require 'yaml'
+        yaml = YAML.load_file(path)
+        unless yaml.is_a?(Hash)
+          unless path.read.strip.empty?
+            raise Informative, "Hash not found in configuration at #{UI.path path} -- got #{yaml.inspect}"
+          end
+          yaml = {}
+        end
+        yaml = yaml.with_indifferent_access
+
+        Dir.chdir(path.dirname) do
+          options.each_with_object({}) do |option, config|
+            next unless yaml.key?(option.name)
+            config[option.name] = option.coerce yaml[option.name]
+          end
+        end
+      end
+
+      # @return [Hash<Symbol,Object>] the configuration hash parsed from the env
+      #
+      # @param  [ENV,Hash<String,String>] env
+      #
+      def self.from_env(env = ENV)
+        options.each_with_object({}) do |option, config|
+          next unless (value = env["COCOAPODS_GENERATE_#{option.name.upcase}"])
+          config[option.name] = option.coerce(value)
+        end
+      end
+
+      # @return [Array<String>] errors in the configuration
+      #
+      def validate
+        hash = to_h
+        self.class.options.map do |option|
+          option.validate(hash[option.name])
+        end.compact
+      end
+
+      # @return [Configuration] a new configuration object with the given changes applies
+      #
+      # @param  [Hash<Symbol,Object>] changes
+      #
+      def with_changes(changes)
+        self.class.new(**to_h.merge(changes))
+      end
+
+      # @return [Hash<Symbol,Object>]
+      #         a hash where the keys are option names and values are the non-nil set values
+      #
+      def to_h
+        self.class.options.each_with_object({}) do |option, hash|
+          value = send(option.name)
+          next if value.nil?
+          hash[option.name] = value
+        end
+      end
+
+      # @return [Boolean] whether this configuration is equivalent to other
+      #
+      def ==(other)
+        self.class == other.class &&
+          to_h == other.to_h
+      end
+
+      # @return [String] a string describing the configuration, suitable for UI presentation
+      #
+      def to_s
+        hash = to_h
+        hash.delete(:pod_config)
+        hash.each_with_index.each_with_object('`pod gen` configuration {'.dup) do |((k, v), i), s|
+          s << ',' unless i.zero?
+          s << "\n" << '  ' << k.to_s << ': ' << v.to_s.gsub(/:0x\h+/, '')
+        end << ' }'
+      end
+
+      # @return [Pathname] the directory for installation of the generated workspace
+      #
+      # @param  [String] name the name of the pod
+      #
+      def gen_dir_for_pod(name)
+        gen_directory.join(name)
+      end
+
+      # @return [Boolean] whether gen should install with dynamic frameworks
+      #
+      def use_frameworks?
+        !use_libraries?
+      end
+
+      # @return [Array<Specification>] the podspecs found at the given paths.
+      #         This method will download specs from URLs and traverse a directory's children.
+      #
+      # @param  [Array<Pathname,URI>] paths
+      #         the paths to search for podspecs
+      #
+      def self.podspecs_from_paths(paths)
+        paths = [Pathname('.')] if paths.empty?
+        paths.flat_map do |path|
+          if path.is_a?(URI)
+            require 'cocoapods/open-uri'
+            begin
+              contents = open(path.to_s).read
+            rescue StandardError => e
+              next e
+            end
+            begin
+                Pod::Specification.from_string contents, path.to_s
+              rescue StandardError
+                $ERROR_INFO
+              end
+          elsif path.directory?
+            glob = Pathname.glob(path + '*.podspec{.json,}')
+            next StandardError.new "no specs found in #{UI.path path}" if glob.empty?
+            glob.map { |f| Pod::Specification.from_file(f) }
+          else
+            Pod::Specification.from_file(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generate/installer.rb

@@ -0,0 +1,315 @@
+module Pod
+  module Generate
+    # Responsible for creating a workspace for a single specification,
+    # given a configuration and a generated podfile.
+    #
+    class Installer
+      # A subclass of the CocoaPods installer that vends analyzer classes
+      # that skip validating podfiles
+      #
+      class InstallerNoValidatePodfile < ::Pod::Installer
+        def create_analyzer(*)
+          super.tap do |analyzer|
+            def analyzer.validate_podfile!; end
+          end
+        end
+      end
+      private_constant :InstallerNoValidatePodfile
+
+      # @return [Configuration]
+      #         the configuration to use when installing
+      #
+      attr_reader :configuration
+
+      # @return [Specification]
+      #         the spec whose workspace is being created
+      #
+      attr_reader :spec
+
+      # @return [Podfile]
+      #         the podfile to install
+      #
+      attr_reader :podfile
+
+      def initialize(configuration, spec, podfile)
+        @configuration = configuration
+        @spec = spec
+        @podfile = podfile
+      end
+
+      # @return [Pathname]
+      #         The directory that pods will be installed into
+      #
+      def install_directory
+        @install_directory ||= podfile.defined_in_file.dirname
+      end
+
+      # Installs the {podfile} into the {install_directory}
+      #
+      # @return [void]
+      #
+      def install!
+        UI.title "Generating #{spec.name} in #{UI.path install_directory}" do
+          clean! if configuration.clean?
+          install_directory.mkpath
+
+          UI.message 'Creating stub application' do
+            create_app_project
+          end
+
+          UI.message 'Writing Podfile' do
+            podfile.defined_in_file.open('w') { |f| f << podfile.to_yaml }
+          end
+
+          installer = nil
+          UI.section 'Installing...' do
+            configuration.pod_config.with_changes(installation_root: install_directory, podfile: podfile, lockfile: configuration.lockfile, sandbox: nil, sandbox_root: install_directory, podfile_path: podfile.defined_in_file, silent: !configuration.pod_config.verbose?, verbose: false, lockfile_path: nil) do
+              installer = InstallerNoValidatePodfile.new(configuration.pod_config.sandbox, podfile, configuration.lockfile)
+              installer.use_default_plugins = configuration.use_default_plugins
+              installer.install!
+            end
+          end
+
+          UI.section 'Performing post-installation steps' do
+            perform_post_install_steps(open_app_project, installer)
+          end
+
+          print_post_install_message
+        end
+      end
+
+      private
+
+      # Removes the {install_directory}
+      #
+      # @return [void]
+      #
+      def clean!
+        UI.message 'Cleaning gen install directory' do
+          FileUtils.rm_rf install_directory
+        end
+      end
+
+      def open_app_project(recreate: false)
+        app_project_path = install_directory.join("#{spec.name}.xcodeproj")
+        if !recreate && app_project_path.exist?
+          Xcodeproj::Project.open(app_project_path)
+        else
+          Xcodeproj::Project.new(app_project_path)
+        end
+      end
+
+      # Creates an app project that CocoaPods will integrate into
+      #
+      # @return [Xcodeproj::Project]
+      #
+      def create_app_project
+        app_project = open_app_project(recreate: true)
+
+        spec.available_platforms.map do |platform|
+          consumer = spec.consumer(platform)
+          target_name = "App-#{Platform.string_name(consumer.platform_name)}"
+          Pod::Generator::AppTargetHelper.add_app_target(app_project, consumer.platform_name, deployment_target(consumer), target_name)
+        end
+            .tap do
+              app_project.recreate_user_schemes do |scheme, target|
+                scheme.set_launch_target(target)
+              end
+            end
+            .each do |target|
+              Xcodeproj::XCScheme.share_scheme(app_project.path, target.name)
+            end
+
+        app_project.save
+      end
+
+      def deployment_target(consumer)
+        deployment_target = consumer.spec.deployment_target(consumer.platform_name)
+        if consumer.platform_name == :ios && configuration.use_frameworks?
+          minimum = Version.new('8.0')
+          deployment_target = [Version.new(deployment_target), minimum].max.to_s
+        end
+        deployment_target
+      end
+
+      def perform_post_install_steps(app_project, installer)
+        app_project.native_targets.each do |native_app_target|
+          remove_script_phase_from_target(native_app_target, 'Check Pods Manifest.lock')
+
+          pod_target = installer.pod_targets.find { |pt| pt.platform.name == native_app_target.platform_name && pt.pod_name == spec.name }
+          raise "unable to find a pod target for #{native_app_target} / #{spec}" unless pod_target
+
+          if (app_host_source_dir = configuration.app_host_source_dir)
+            files = Pathname.glob(app_host_source_dir + '**/*')
+                            .map { |f| f.relative_path_from(app_host_source_dir) }
+            app_host_source_dir = app_host_source_dir.relative_path_from(installer.sandbox.root)
+            group = app_project.new_group(native_app_target.name, app_host_source_dir)
+            source_file_refs = files.map { |source_file| group.new_file(source_file) }
+            native_app_target.add_file_references(source_file_refs)
+          elsif Pod::Generator::AppTargetHelper.method(:add_app_project_import).arity == -5 # CocoaPods >= 1.6
+            Pod::Generator::AppTargetHelper.add_app_project_import(app_project, native_app_target, pod_target, pod_target.platform.name, native_app_target.name)
+          else
+            Pod::Generator::AppTargetHelper.add_app_project_import(app_project, native_app_target, pod_target, pod_target.platform.name, pod_target.requires_frameworks?, native_app_target.name)
+          end
+
+          # Set `PRODUCT_BUNDLE_IDENTIFIER`
+          native_app_target.build_configurations.each do |bc|
+            bc.build_settings['PRODUCT_BUNDLE_IDENTIFIER'] = 'org.cocoapods-generate.${PRODUCT_NAME:rfc1034identifier}'
+          end
+
+          case native_app_target.platform_name
+          when :ios
+            make_ios_app_launchable(installer, app_project, native_app_target)
+          end
+
+          Pod::Generator::AppTargetHelper.add_swift_version(native_app_target, pod_target.swift_version) unless pod_target.swift_version.blank?
+          if installer.pod_targets.any? { |pt| pt.spec_consumers.any? { |c| c.frameworks.include?('XCTest') } }
+            Pod::Generator::AppTargetHelper.add_xctest_search_paths(native_app_target)
+          end
+
+          # 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 File.exist?(installer.pods_project.path + pod_target.label)
+
+          add_test_spec_schemes_to_app_scheme(installer, app_project)
+        end
+
+        app_project.save
+      end
+
+      def remove_script_phase_from_target(native_target, script_phase_name)
+        script_phase = native_target.shell_script_build_phases.find { |bp| bp.name && bp.name.end_with?(script_phase_name) }
+        return unless script_phase.present?
+        native_target.build_phases.delete(script_phase)
+      end
+
+      def add_test_spec_schemes_to_app_scheme(installer, app_project)
+        test_native_targets =
+          if installer.respond_to?(:target_installation_results) # CocoaPods >= 1.6
+            installer
+              .target_installation_results
+              .pod_target_installation_results
+              .values
+              .flatten(1)
+              .select { |installation_result| installation_result.target.pod_name == spec.root.name }
+          else
+            installer
+              .pod_targets
+              .select { |pod_target| pod_target.pod_name == spec.root.name }
+          end
+          .flat_map(&:test_native_targets)
+          .group_by(&:platform_name)
+
+        Xcodeproj::Plist.write_to_path(
+          { 'IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded' => false },
+          app_project.path.sub_ext('.xcworkspace').join('xcshareddata').tap(&:mkpath).join('WorkspaceSettings.xcsettings')
+        )
+
+        test_native_targets.each do |platform_name, test_targets|
+          app_scheme_path = Xcodeproj::XCScheme.shared_data_dir(app_project.path).join("App-#{Platform.string_name(platform_name)}.xcscheme")
+          raise "Missing app scheme for #{platform_name}: #{app_scheme_path.inspect}" unless app_scheme_path.file?
+
+          app_scheme = Xcodeproj::XCScheme.new(app_scheme_path)
+          test_action = app_scheme.test_action
+          existing_test_targets = test_action.testables.flat_map(&:buildable_references).map(&:target_name)
+
+          test_targets.sort_by(&:name).each do |target|
+            next if existing_test_targets.include?(target.name)
+
+            testable = Xcodeproj::XCScheme::TestAction::TestableReference.new(target)
+            testable.buildable_references.each do |buildable|
+              buildable.xml_element.attributes['ReferencedContainer'] = 'container:Pods.xcodeproj'
+            end
+            test_action.add_testable(testable)
+          end
+
+          app_scheme.save!
+        end
+      end
+
+      def make_ios_app_launchable(installer, app_project, native_app_target)
+        platform_name = Platform.string_name(native_app_target.platform_name)
+        generated_source_dir = installer.sandbox.root.join('App', platform_name).tap(&:mkpath)
+
+        # Add `LaunchScreen.storyboard`
+        launch_storyboard = generated_source_dir.join('LaunchScreen.storyboard')
+        launch_storyboard.write <<-XML.strip_heredoc
+              <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+              <document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" systemVersion="17A277" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+                <dependencies>
+                  <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+                  <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+                  <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+                </dependencies>
+                <scenes>
+                  <!--View Controller-->
+                  <scene sceneID="EHf-IW-A2E">
+                    <objects>
+                      <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                        <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                          <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                          <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                          <color key="backgroundColor" red="1" green="1" blue="1" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
+                          <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        </view>
+                      </viewController>
+                      <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+                    </objects>
+                    <point key="canvasLocation" x="53" y="375"/>
+                  </scene>
+                </scenes>
+              </document>
+            XML
+
+        # Add & wire `Info.plist`
+        info_plist_contents = {
+          'CFBundleDevelopmentRegion' => '$(DEVELOPMENT_LANGUAGE)',
+          'CFBundleExecutable' => '$(EXECUTABLE_NAME)',
+          'CFBundleIdentifier' => '$(PRODUCT_BUNDLE_IDENTIFIER)',
+          'CFBundleInfoDictionaryVersion' => '6.0',
+          'CFBundleName' => '$(PRODUCT_NAME)',
+          'CFBundlePackageType' => 'APPL',
+          'CFBundleShortVersionString' => '1.0',
+          'CFBundleVersion' => '1',
+          'LSRequiresIPhoneOS' => true,
+          'UILaunchStoryboardName' => 'LaunchScreen',
+          'UIRequiredDeviceCapabilities' => [
+            'armv7'
+          ],
+          'UISupportedInterfaceOrientations' => %w[
+            UIInterfaceOrientationPortrait
+            UIInterfaceOrientationLandscapeLeft
+            UIInterfaceOrientationLandscapeRight
+          ],
+          'UISupportedInterfaceOrientations~ipad' => %w[
+            UIInterfaceOrientationPortrait
+            UIInterfaceOrientationPortraitUpsideDown
+            UIInterfaceOrientationLandscapeLeft
+            UIInterfaceOrientationLandscapeRight
+          ]
+        }
+        info_plist_path = generated_source_dir.join('Info.plist')
+        Xcodeproj::Plist.write_to_path(info_plist_contents, info_plist_path)
+
+        native_app_target.build_configurations.each do |bc|
+          bc.build_settings['INFOPLIST_FILE'] = "${SRCROOT}/App/#{platform_name}/Info.plist"
+        end
+
+        group = app_project.main_group.find_subpath("App-#{platform_name}", true)
+        group.new_file(info_plist_path)
+        native_app_target.resources_build_phase.add_file_reference group.new_file(launch_storyboard)
+      end
+
+      def print_post_install_message
+        workspace_path = install_directory.join(podfile.workspace_path)
+
+        if configuration.auto_open?
+          configuration.pod_config.with_changes(verbose: true) do
+            Executable.execute_command 'open', [workspace_path]
+          end
+        else
+          UI.info "Open #{UI.path workspace_path} to work on #{spec.name}"
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods/generate/podfile_generator.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+module Pod
+  module Generate
+    # Generates podfiles for pod specifications given a configuration.
+    #
+    class PodfileGenerator
+      # @return [Configuration]
+      #         the configuration used when generating podfiles
+      #
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      # @return [Hash<Specification, Podfile>]
+      #         a hash of specifications to generated podfiles
+      #
+      def podfiles_by_spec
+        Hash[configuration.podspecs.map do |spec|
+          [spec, podfile_for_spec(spec)]
+        end]
+      end
+
+      # @return [Podfile] a podfile suitable for installing the given spec
+      #
+      # @param  [Specification] spec
+      #
+      def podfile_for_spec(spec)
+        generator = self
+        dir = configuration.gen_dir_for_pod(spec.name)
+
+        Pod::Podfile.new do
+          project "#{spec.name}.xcodeproj"
+          workspace "#{spec.name}.xcworkspace"
+
+          plugin 'cocoapods-generate'
+
+          install! 'cocoapods',
+                   deterministic_uuids: generator.configuration.deterministic_uuids?,
+                   share_schemes_for_development_pods: generator.configuration.share_schemes_for_development_pods?,
+                   warn_for_multiple_pod_sources: generator.configuration.warn_for_multiple_pod_sources?
+
+          use_frameworks!(generator.configuration.use_frameworks?)
+
+          # Explicitly set sources
+          generator.configuration.sources.each do |source_url|
+            source(source_url)
+          end
+
+          self.defined_in_file = dir.join('Podfile.yaml')
+
+          test_specs = spec.recursive_subspecs.select(&:test_specification)
+
+          # Stick all of the transitive dependencies in an abstract target.
+          # This allows us to force CocoaPods to use the versions / sources / external sources
+          # that we want.
+          # By using an abstract target,
+          abstract_target 'Transitive Dependencies' do
+            pods_for_transitive_dependencies = [spec.name]
+                                               .concat(test_specs.map(&:name))
+                                               .concat(test_specs.flat_map { |ts| ts.dependencies.flat_map(&:name) })
+
+            dependencies = generator
+                           .transitive_dependencies_by_pod
+                           .values_at(*pods_for_transitive_dependencies)
+                           .compact
+                           .flatten(1)
+                           .uniq
+                           .sort_by(&:name)
+                           .reject { |d| d.root_name == spec.root.name }
+
+            dependencies.each do |dependency|
+              pod_args = generator.pod_args_for_dependency(self, dependency)
+              pod(*pod_args)
+            end
+          end
+
+          # Add platform-specific concrete targets that inherit the
+          # `pod` declaration for the local pod
+          spec.available_platforms.map(&:string_name).sort.each do |platform_name|
+            target "App-#{platform_name}" do
+              current_target_definition.swift_version = generator.swift_version if generator.swift_version
+            end
+          end
+
+          # this block hash to come _before_ inhibit_all_warnings! / use_modular_headers!,
+          # and the local `pod` declaration
+          current_target_definition.instance_exec do
+            transitive_dependencies = children.find { |c| c.name == 'Transitive Dependencies' }
+
+            %w[use_modular_headers inhibit_warnings].each do |key|
+              value = transitive_dependencies.send(:internal_hash).delete(key)
+              next if value.blank?
+              set_hash_value(key, value)
+            end
+          end
+
+          inhibit_all_warnings! if generator.inhibit_all_warnings?
+          use_modular_headers! if generator.use_modular_headers?
+
+          # This is the pod declaration for the local pod,
+          # it will be inherited by the concrete target definitions below
+          pod spec.name,
+              path: spec.defined_in_file.relative_path_from(dir).to_s,
+              testspecs: test_specs.map { |s| s.name.sub(%r{^#{Regexp.escape spec.root.name}/}, '') }.sort,
+              **generator.dependency_compilation_kwargs(spec.name)
+        end
+      end
+
+      # @return [Boolean]
+      #         whether all warnings should be inhibited
+      #
+      def inhibit_all_warnings?
+        return false unless configuration.use_podfile?
+        target_definition_list.all? do |target_definition|
+          target_definition.send(:inhibit_warnings_hash)['all']
+        end
+      end
+
+      # @return [Boolean]
+      #         whether all pods should use modular headers
+      #
+      def use_modular_headers?
+        return false unless configuration.use_podfile?
+        target_definition_list.all? do |target_definition|
+          target_definition.use_modular_headers_hash['all']
+        end
+      end
+
+      # @return [Hash]
+      #         a hash with "compilation"-related dependency options for the `pod` DSL method
+      #
+      # @param  [String] pod_name
+      #
+      def dependency_compilation_kwargs(pod_name)
+        options = {}
+        options[:inhibit_warnings] = inhibit_warnings?(pod_name) if inhibit_warnings?(pod_name) != inhibit_all_warnings?
+        options[:modular_headers] = modular_headers?(pod_name) if modular_headers?(pod_name) != use_modular_headers?
+        options
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         the transitive dependency objects dependency upon by each pod
+      #
+      def transitive_dependencies_by_pod
+        return {} unless configuration.use_lockfile?
+        @transitive_dependencies_by_pod ||= begin
+          lda = ::Pod::Installer::Analyzer::LockingDependencyAnalyzer
+          dependency_graph = Molinillo::DependencyGraph.new
+          configuration.lockfile.dependencies.each do |dependency|
+            dependency_graph.add_vertex(dependency.name, dependency, true)
+          end
+          add_to_dependency_graph = if lda.method(:add_to_dependency_graph).parameters.size == 4 # CocoaPods < 1.6.0
+                                      ->(pod) { lda.add_to_dependency_graph(pod, [], dependency_graph, []) }
+                                    else
+                                      ->(pod) { lda.add_to_dependency_graph(pod, [], dependency_graph, [], Set.new) }
+                                    end
+          configuration.lockfile.internal_data['PODS'].each(&add_to_dependency_graph)
+
+          transitive_dependencies_by_pod = Hash.new { |hash, key| hash[key] = [] }
+          dependency_graph.each do |v|
+            transitive_dependencies_by_pod[v.name].concat v.recursive_successors.map(&:payload) << v.payload
+          end
+
+          transitive_dependencies_by_pod.each_value(&:uniq!)
+          transitive_dependencies_by_pod
+        end
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         dependencies in the podfile grouped by root name
+      #
+      def podfile_dependencies
+        return {} unless configuration.use_podfile?
+        @podfile_dependencies ||= configuration.podfile.dependencies.group_by(&:root_name).tap { |h| h.default = [] }
+      end
+
+      # @return [Hash<String,String>]
+      #         versions in the lockfile keyed by pod name
+      #
+      def lockfile_versions
+        return {} unless configuration.use_lockfile_versions?
+        @lockfile_versions ||= Hash[configuration.lockfile.pod_names.map { |name| [name, "= #{configuration.lockfile.version(name)}"] }]
+      end
+
+      # @return [Hash<String,Array<Dependency>>]
+      #         returns the arguments that should be passed to the Podfile DSL's
+      #         `pod` method for the given podfile and dependency
+      #
+      # @param  [Podfile] podfile
+      #
+      # @param  [Dependency] dependency
+      #
+      def pod_args_for_dependency(podfile, dependency)
+        dependency = podfile_dependencies[dependency.root_name]
+                     .map { |dep| dep.dup.tap { |d| d.name = dependency.name } }
+                     .push(dependency)
+                     .reduce(&:merge)
+
+        options = dependency_compilation_kwargs(dependency.name)
+        options[:source] = dependency.podspec_repo if dependency.podspec_repo
+        options.update(dependency.external_source) if dependency.external_source
+        %i[path podspec].each do |key|
+          next unless (path = options[key])
+          options[key] = Pathname(path)
+                         .expand_path(configuration.podfile.defined_in_file.dirname)
+                         .relative_path_from(podfile.defined_in_file.dirname)
+                         .to_s
+        end
+        args = [dependency.name]
+        if dependency.external_source.nil?
+          requirements = dependency.requirement.as_list
+          if (version = lockfile_versions[dependency.name])
+            requirements << version
+          end
+          args.concat requirements.uniq
+        end
+        args << options unless options.empty?
+        args
+      end
+
+      def swift_version
+        @swift_version ||= target_definition_list.map(&:swift_version).compact.max
+      end
+
+      private
+
+      # @return [Array<Podfile::TargetDefinition>]
+      #         a list of all target definitions to consider from the podfile
+      #
+      def target_definition_list
+        return [] unless configuration.use_podfile?
+        @target_definition_list ||= begin
+          list = configuration.podfile.target_definition_list
+          list.reject!(&:abstract?) unless list.all?(&:abstract?)
+          list
+        end
+      end
+
+      # @return [Boolean]
+      #         whether warnings should be inhibited for the given pod
+      #
+      # @param  [String] pod_name
+      #
+      def inhibit_warnings?(pod_name)
+        return false unless configuration.use_podfile?
+        target_definitions_for_pod(pod_name).all? do |target_definition|
+          target_definition.inhibits_warnings_for_pod?(pod_name)
+        end
+      end
+
+      # @return [Boolean]
+      #         whether modular headers should be enabled for the given pod
+      #
+      # @param  [String] pod_name
+      #
+      def modular_headers?(pod_name)
+        return false unless configuration.use_podfile?
+        target_definitions_for_pod(pod_name).all? do |target_definition|
+          target_definition.build_pod_as_module?(pod_name)
+        end
+      end
+
+      # @return [Podfile::TargetDefinition]
+      #
+      # @param  [String] pod_name
+      #
+      def target_definitions_for_pod(pod_name)
+        target_definitions = target_definition_list.reject { |td| td.dependencies.none? { |d| d.name == pod_name } }
+        target_definitions.empty? ? target_definition_list : target_definitions
+      end
+    end
+  end
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if Pod::VERSION >= '1.5.0'
+  require 'cocoapods/command/gen'
+else
+  Pod::UI.warn 'cocoapods-generate requires CocoaPods >= 1.5.0'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-generate
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Samuel Giddins
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.16'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: |
+  pod gen allows you to keep your Podfile and podspecs as the single source of
+  truth for pods under development. By generating throw-away workspaces capable of
+  building, running, and testing a pod, you can focus on library development
+  without worrying about other code or managing an Xcode project.
+  pod gen works particularly well for monorepo projects, since it is capable of
+  using your existing settings when generating the workspace, making each gen'ed
+  project truly a small slice of the larger application.
+email:
+- segiddins@squareup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- README.md
+- VERSION
+- lib/cocoapods/command/gen.rb
+- lib/cocoapods/generate.rb
+- lib/cocoapods/generate/configuration.rb
+- lib/cocoapods/generate/installer.rb
+- lib/cocoapods/generate/podfile_generator.rb
+- lib/cocoapods_plugin.rb
+homepage: https://github.com/square/cocoapods-generate
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Generates Xcode workspaces from a podspec.
+test_files: []