cocoapods-generate-minlison 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a7c911d9b5f53ae4a8ae418965e638901f93f6b11ea44996043771b2856046e8
+  data.tar.gz: a53b6c9a1f70684ef0e283fa558ba426ce7ecd5a760ac0ca3a1b58cfb0a55909
+SHA512:
+  metadata.gz: ffa21baf0cfcec3474430ce033331db762aa9bf654ababc844aa5ef7412cad8d95a6d4074a892c3b0b749ac045cb196fdd4a669ee402100e026b7b2e4d88d801
+  data.tar.gz: a11298fa62d3702675871604b4c9a38a2b0de00f543fff85e99c306e4b2ca126c2ff072d10130bc10f8e392544f255109403a3ef5b6dd8231894631030b46d99

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/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019
+
+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,131 @@
+# `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-podfile-plugins                  Whether plugins should be copied from the
+                                           podfile
+    --use-lockfile                         Whether the lockfile should be used to
+                                           discover transitive dependencies
+    --use-lockfile-versions                Whether versions from the lockfile should
+                                           be used
+    --use-libraries                        Whether to use libraries instead of
+                                           frameworks
+    --generate-multiple-pod-projects       Whether to generate multiple Xcode projects
+    --incremental-installation             Whether to use incremental installation
+    --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 dependent
+                                           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.
+    --local-sources=SOURCE1,SOURCE2        Paths from which to find local podspecs for
+                                           transitive dependencies. Multiple
+                                           local-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
+    --use-modular-headers                  Whether the target should be generated as a
+                                           clang module, treating dependencies as
+                                           modules, as if `use_modular_headers!` were
+                                           specified. Will error if both this option
+                                           and a podfile are specified
+```
+<!-- 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.5.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,342 @@
+# 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
+
+      # @visibility private
+      #
+      # Implements `===` to do type checking against a hash.
+      #
+      class HashOf
+        attr_reader :key_types, :value_types
+
+        def initialize(keys:, values:)
+          @key_types = keys
+          @value_types = values
+        end
+
+        def to_s
+          "Hash<#{key_types.join('|')} => #{value_types.join('|')}}>"
+        end
+
+        # @return [Boolean] whether the given object is a hash with elements all of the given types
+        #
+        def ===(other)
+          other.is_a?(Hash) && other.all? do |key, value|
+            key_types.any? { |t| t === key } &&
+              value_types.any? { |t| t === value }
+          end
+        end
+      end
+      private_constant :HashOf
+
+      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 :use_podfile_plugins, BOOLEAN, 'use_podfile', 'Whether plugins should be copied from the podfile', nil, nil, coerce_to_bool
+      option :podfile_plugins, HashOf.new(keys: [String], values: [NilClass, HashOf.new(keys: [String], values: [TrueClass, FalseClass, NilClass, String, Hash, Array])]),
+             '(use_podfile && podfile) ? podfile.plugins : {}',
+             nil,
+             nil,
+             nil,
+             ->(hash) { Hash[hash] }
+
+      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 :generate_multiple_pod_projects, BOOLEAN, 'false', 'Whether to generate multiple Xcode projects', nil, nil, coerce_to_bool
+      option :incremental_installation, BOOLEAN, 'false', 'Whether to use incremental installation', 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 dependent 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 :local_sources, ArrayOf.new(String),
+             [],
+             'Paths from which to find local podspecs for transitive dependencies. Multiple local-sources must be comma-delimited.',
+             'SOURCE1,SOURCE2',
+             ->(_) { nil },
+             ->(local_sources) { Array(local_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
+      option :use_modular_headers, BOOLEAN, 'false', 'Whether the target should be generated as a clang module, treating dependencies as modules, as if `use_modular_headers!` were specified. Will error if both this option and a podfile are specified', 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