cocoapods-bazel 0.1.1

data/README.md

@@ -0,0 +1,53 @@
+# Cocoapods::Bazel
+![](https://github.com/ob/cocoapods-bazel/workflows/master/badge.svg)
+
+
+Cocoapods::Bazel is a Cocoapods plugin that makes it easy to use [Bazel](https://bazel.build) instead of Xcode to build your iOS project. It automatically generates Bazel's `BUILD.bazel` files. It uses [`rules_ios`](https://github.com/ob/rules_ios) so you need to set up the `WORKSPACE` file following the instructions in the [`README`](https://github.com/ob/rules_ios/blob/master/README.md).
+
+> :warning: **This is alpha software.** We are developing this plugin in the open so you should only use it if you know what you are doing and are willing to help develop it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cocoapods-bazel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cocoapods-bazel
+
+## Usage
+
+This plugin will run extra steps after post_install to generate BUILD.bazel files for Bazel.
+
+To enable the plugin, simply add the following section to your `Podfile`
+
+```
+plugin 'cocoapods-bazel', {
+  rules: {
+    'apple_framework' => { load: '@build_bazel_rules_ios//rules:framework.bzl', rule: 'apple_framework' }.freeze,
+    'ios_application' => { load: '@build_bazel_rules_ios//rules:app.bzl', rule: 'ios_application' }.freeze,
+    'ios_unit_test' => { load: '@build_bazel_rules_ios//rules:test.bzl', rule: 'ios_unit_test' }.freeze
+  }.freeze,
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `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.rb`, 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/ob/cocoapods-bazel.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+namespace :spec do
+  RSpec::Core::RakeTask.new(:unit) do |t|
+    t.rspec_opts = %w[--format progress]
+  end
+
+  desc 'Run integration specs'
+  task :integration do
+    sh 'bundle', 'exec', 'bacon', 'spec/integration.rb', '-q'
+  end
+
+  namespace :integration do
+    desc 'Update integration spec fixtures'
+    task :update do
+      rm_rf 'spec/integration/tmp'
+      sh('bin/rake', 'spec:integration') {}
+      # Copy the files to the files produced by the specs to the after folders
+      FileList['spec/integration/tmp/*/transformed'].each do |source|
+        walk_dir = lambda do |d|
+          Dir.each_child(d) do |c|
+            child = File.join(d, c)
+            walk_dir[child] if File.directory?(child)
+          end
+          Dir.delete(d) if Dir.empty?(d)
+        end
+        walk_dir[source]
+
+        name = source.match(%r{tmp/([^/]+)/transformed$})[1]
+        destination = "spec/integration/#{name}/after"
+        rm_rf destination
+        mv source, destination
+      end
+    end
+  end
+end
+
+desc 'Run all specs'
+task spec: %w[spec:unit spec:integration]
+
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'cocoapods/bazel'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/pod

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'pod' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('cocoapods', 'pod')

data/bin/pod_install_bazel_build

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+ARGV.replace %w[install]
+
+load Gem.bin_path('cocoapods', 'pod')
+
+exec 'bazelisk', '--ignore_all_rc_files', 'build', '--verbose_failures', '...'

data/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path('bundle', __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rake', 'rake')

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cocoapods-bazel.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/cocoapods/bazel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cocoapods-bazel'
+  spec.version       = Pod::Bazel::VERSION
+  spec.authors       = ['Shawn Chen', 'Samuel Giddins']
+  spec.email         = ['swchen@linkedin.com', 'segiddins@squareup.com']
+
+  spec.summary       = 'A plugin for CocoaPods that generates Bazel build files for pods'
+  spec.homepage      = 'https://github.com/ob/cocoapods-bazel'
+  spec.license       = 'apache2'
+
+  spec.metadata['allowed_push_host'] = "https://rubygems.org/"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '>= 2.1'
+
+  spec.add_runtime_dependency 'starlark_compiler', '~> 0.3'
+
+  spec.required_ruby_version = '>= 2.6'
+end

data/lib/cocoapods/bazel.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'starlark_compiler/build_file'
+require 'cocoapods/bazel/config'
+require 'cocoapods/bazel/target'
+require 'cocoapods/bazel/xcconfig_resolver'
+require 'cocoapods/bazel/util'
+
+module Pod
+  module Bazel
+    def self.post_install(installer:)
+      return unless (config = Config.from_podfile(installer.podfile))
+
+      default_xcconfigs = config.default_xcconfigs.transform_values do |xcconfig|
+        _name, xcconfig = XCConfigResolver.resolve_xcconfig(xcconfig)
+        xcconfig
+      end
+
+      UI.titled_section 'Generating Bazel files' do
+        workspace = installer.config.installation_root
+        sandbox = installer.sandbox
+        build_files = Hash.new { |h, k| h[k] = StarlarkCompiler::BuildFile.new(workspace: workspace, package: k) }
+        installer.pod_targets.each do |pod_target|
+          package = sandbox.pod_dir(pod_target.pod_name).relative_path_from(workspace).to_s
+          if package.start_with?('..')
+            raise Informative, <<~MSG
+              Bazel does not support Pod located outside of current workspace: \"#{package}\".
+              To fix this, you can move the Pod into workspace,
+              or you can symlink the Pod inside the workspace by running `ln -s <path_to_pod> .` at workspace root
+              Then change path declared in Podfile to `./<pod_name>`
+              Current workspace: #{workspace}
+            MSG
+          end
+
+          build_file = build_files[package]
+
+          bazel_targets = [Target.new(installer, pod_target, nil, default_xcconfigs)] +
+                          pod_target.file_accessors.reject { |fa| fa.spec.library_specification? }.map { |fa| Target.new(installer, pod_target, fa.spec, default_xcconfigs) }
+
+          bazel_targets.each do |t|
+            load = config.load_for(macro: t.type)
+            build_file.add_load(of: load[:rule], from: load[:load])
+            build_file.add_target StarlarkCompiler::AST::FunctionCall.new(load[:rule], **t.to_rule_kwargs)
+          end
+        end
+
+        build_files.each_value(&:save!)
+        format_files(build_files: build_files, buildifier: config.buildifier, workspace: workspace)
+
+        cocoapods_bazel_path = File.join(sandbox.root, 'cocoapods-bazel')
+        FileUtils.mkdir_p cocoapods_bazel_path
+
+        write_cocoapods_bazel_build_file(cocoapods_bazel_path, workspace, config)
+        write_non_empty_default_xcconfigs(cocoapods_bazel_path, default_xcconfigs)
+      end
+    end
+
+    def self.write_cocoapods_bazel_build_file(path, workspace, config)
+      FileUtils.touch(File.join(path, 'BUILD.bazel'))
+
+      cocoapods_bazel_pkg = Pathname.new(path).relative_path_from Pathname.new(workspace)
+      configs_build_file = StarlarkCompiler::BuildFile.new(workspace: workspace, package: cocoapods_bazel_pkg)
+
+      configs_build_file.add_load(of: 'string_flag', from: '@bazel_skylib//rules:common_settings.bzl')
+      configs_build_file.add_target StarlarkCompiler::AST::FunctionCall.new('string_flag', name: 'config', build_setting_default: 'debug', visibility: ['//visibility:public'])
+      configs_build_file.add_target StarlarkCompiler::AST::FunctionCall.new('config_setting', name: 'debug', flag_values: { ':config' => 'debug' })
+      configs_build_file.add_target StarlarkCompiler::AST::FunctionCall.new('config_setting', name: 'release', flag_values: { ':config' => 'release' })
+
+      configs_build_file.save!
+      format_files(build_files: { cocoapods_bazel_pkg => configs_build_file }, buildifier: config.buildifier, workspace: workspace)
+    end
+
+    def self.write_non_empty_default_xcconfigs(path, default_xcconfigs)
+      return if default_xcconfigs.empty?
+
+      hash = StarlarkCompiler::AST.new(toplevel: [StarlarkCompiler::AST::Dictionary.new(default_xcconfigs)])
+
+      File.open(File.join(path, 'default_xcconfigs.bzl'), 'w') do |f|
+        f << <<~STARLARK
+          """
+          Default xcconfigs given as options to cocoapods-bazel.
+          """
+
+        STARLARK
+        f << 'DEFAULT_XCCONFIGS = '
+        StarlarkCompiler::Writer.write(ast: hash, io: f)
+      end
+    end
+
+    def self.format_files(build_files:, buildifier:, workspace:)
+      return if build_files.empty?
+
+      args = []
+      case buildifier
+      when true
+        return unless Pod::Executable.which('buildifier')
+
+        args = ['buildifier']
+      when String, Array
+        args = Array(buildifier)
+      else
+        return
+      end
+      args += %w[-type build]
+
+      executable, *args = args
+      Pod::Executable.execute_command executable,
+                                      args + build_files.each_key.map { |d| File.join workspace, d, 'BUILD.bazel' },
+                                      true
+    end
+  end
+end

data/lib/cocoapods/bazel/config.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pod
+  module Bazel
+    class Config
+      PLUGIN_KEY = 'cocoapods-bazel'
+      private_constant :PLUGIN_KEY
+      DEFAULTS = {
+        rules: {
+          'apple_framework' => { load: '@build_bazel_rules_ios//rules:framework.bzl', rule: 'apple_framework' }.freeze,
+          'ios_application' => { load: '@build_bazel_rules_ios//rules:app.bzl', rule: 'ios_application' }.freeze,
+          'ios_unit_test' => { load: '@build_bazel_rules_ios//rules:test.bzl', rule: 'ios_unit_test' }.freeze
+        }.freeze,
+        overrides: {}.freeze,
+        buildifier: true,
+        default_xcconfigs: {}.freeze
+      }.with_indifferent_access.freeze
+      private_constant :DEFAULTS
+
+      attr_reader :to_h
+
+      def self.enabled_in_podfile?(podfile)
+        podfile.plugins.key?(PLUGIN_KEY)
+      end
+
+      def self.from_podfile(podfile)
+        return unless enabled_in_podfile?(podfile)
+
+        from_podfile_options(podfile.plugins[PLUGIN_KEY])
+      end
+
+      def self.from_podfile_options(options)
+        new(DEFAULTS.merge(options) do |_key, old_val, new_val|
+          case old_val
+          when Hash
+            old_val.merge(new_val) # intentionally only 1 level deep of merging
+          else
+            new_val
+          end
+        end)
+      end
+
+      def initialize(to_h)
+        @to_h = to_h
+      end
+
+      def buildifier
+        to_h[:buildifier]
+      end
+
+      def load_for(macro:)
+        to_h.dig('rules', macro) || raise("no rule configured for #{macro}")
+      end
+
+      def default_xcconfigs
+        to_h[:default_xcconfigs]
+      end
+    end
+  end
+end

data/lib/cocoapods/bazel/target.rb

@@ -0,0 +1,630 @@
+# frozen_string_literal: true
+
+require_relative 'xcconfig_resolver'
+
+module Pod
+  module Bazel
+    class Target
+      class RuleArgs
+        attr_reader :kwargs
+
+        def initialize
+          @kwargs = {}
+
+          yield self if block_given?
+        end
+
+        def add(name, value, defaults: nil)
+          return self if defaults&.include?(value)
+
+          raise 'Duplicate' if kwargs.key?(name)
+
+          kwargs[name] = value
+
+          self
+        end
+      end
+
+      include XCConfigResolver
+
+      attr_reader :installer, :pod_target, :file_accessors, :non_library_spec, :label, :package, :default_xcconfigs, :resolved_xconfig_by_config
+      private :installer, :pod_target, :file_accessors, :non_library_spec, :label, :package, :default_xcconfigs, :resolved_xconfig_by_config
+
+      def initialize(installer, pod_target, non_library_spec = nil, default_xcconfigs = {})
+        @installer = installer
+        @pod_target = pod_target
+        @file_accessors = non_library_spec ? pod_target.file_accessors.select { |fa| fa.spec == non_library_spec } : pod_target.file_accessors.select { |fa| fa.spec.library_specification? }
+        @non_library_spec = non_library_spec
+        @label = (non_library_spec ? pod_target.non_library_spec_label(non_library_spec) : pod_target.label)
+        @package_dir = installer.sandbox.pod_dir(pod_target.pod_name)
+        @package = installer.sandbox.pod_dir(pod_target.pod_name).relative_path_from(installer.config.installation_root).to_s
+        @default_xcconfigs = default_xcconfigs
+        @resolved_xconfig_by_config = {}
+      end
+
+      def bazel_label(relative_to: nil)
+        package_basename = File.basename(package)
+        if package == relative_to
+          ":#{label}"
+        elsif package_basename == label
+          "//#{package}"
+        else
+          "//#{package}:#{label}"
+        end
+      end
+
+      def build_settings_label(config)
+        relative_sandbox_root = @installer.sandbox.root.relative_path_from(@installer.config.installation_root).to_s
+        cocoapods_bazel_path = File.join(relative_sandbox_root, 'cocoapods-bazel')
+
+        "//#{cocoapods_bazel_path}:#{config}"
+      end
+
+      def test_host
+        unless (app_host_info = pod_target.test_app_hosts_by_spec_name[non_library_spec.name])
+          return
+        end
+
+        app_spec, app_target = *app_host_info
+        Target.new(installer, app_target, app_spec)
+      end
+
+      def type
+        platform = pod_target.platform.name
+        case non_library_spec&.spec_type
+        when nil
+          'apple_framework'
+        when :app
+          "#{platform}_application"
+        when :test
+          "#{platform}_#{non_library_spec.test_type}_test"
+        else
+          raise "Unhandled: #{non_library_spec.spec_type}"
+        end
+      end
+
+      def dependent_targets_by_config
+        targets =
+          case non_library_spec&.spec_type
+          when nil
+            pod_target.dependent_targets_by_config
+          when :app
+            pod_target.app_dependent_targets_by_spec_name_by_config[non_library_spec.name].transform_values { |v| v + [pod_target] }
+          when :test
+            pod_target.test_dependent_targets_by_spec_name_by_config[non_library_spec.name].transform_values { |v| v + [pod_target] }
+          else
+            raise "Unhandled: #{non_library_spec.spec_type}"
+          end
+
+        targets.transform_values { |v| v.uniq.map { |target| self.class.new(installer, target) } }
+      end
+
+      def product_module_name
+        name = resolved_value_by_build_setting('PRODUCT_MODULE_NAME') || resolved_value_by_build_setting('PRODUCT_NAME') ||
+               if non_library_spec
+                 label.tr('-', '_')
+               else
+                 pod_target.product_module_name
+               end
+
+        raise 'The product module name must be the same for both debug and release.' unless name.is_a? String
+
+        name.gsub(/^([0-9])/, '_\1').gsub(/[^a-zA-Z0-9_]/, '_')
+      end
+
+      def swift_objc_bridging_header
+        resolved_value_by_build_setting('SWIFT_OBJC_BRIDGING_HEADER')
+      end
+
+      def uses_swift?
+        file_accessors.any? { |fa| fa.source_files.any? { |s| s.extname == '.swift' } }
+      end
+
+      def pod_target_xcconfig_by_build_setting
+        debug_xcconfig = resolved_xcconfig(configuration: :debug)
+        release_xcconfig = resolved_xcconfig(configuration: :release)
+        debug_only_xcconfig = debug_xcconfig.reject { |k, v| release_xcconfig[k] == v }
+        release_only_xcconfig = release_xcconfig.reject { |k, v| debug_xcconfig[k] == v }
+
+        xconfig_by_build_setting = {}
+        xconfig_by_build_setting[build_settings_label(:debug)] = debug_only_xcconfig unless debug_only_xcconfig.empty?
+        xconfig_by_build_setting[build_settings_label(:release)] = release_only_xcconfig unless release_only_xcconfig.empty?
+        xconfig_by_build_setting
+      end
+
+      def common_pod_target_xcconfig
+        debug_xcconfig = resolved_xcconfig(configuration: :debug)
+        release_xcconfig = resolved_xcconfig(configuration: :release)
+        common_xcconfig = debug_xcconfig.select { |k, v| release_xcconfig[k] == v }
+        # If the value is an array, merge it into a string.
+        common_xcconfig.map do |k, v|
+          [k, v.is_a?(Array) ? v.shelljoin : v]
+        end.to_h
+      end
+
+      def resolved_xcconfig(configuration:)
+        unless resolved_xconfig_by_config[configuration]
+          xcconfig = pod_target_xcconfig(configuration: configuration)
+          resolved_xconfig_by_config[configuration] = resolve_xcconfig(xcconfig)[1]
+        end
+        resolved_xconfig_by_config[configuration].clone
+      end
+
+      def pod_target_xcconfig(configuration:)
+        pod_target
+          .build_settings_for_spec(non_library_spec || pod_target.root_spec, configuration: configuration)
+          .merged_pod_target_xcconfigs
+          .to_h
+          .merge(
+            'CONFIGURATION' => configuration.to_s.capitalize,
+            'PODS_TARGET_SRCROOT' => ':',
+            'SRCROOT' => ':',
+            'SDKROOT' => '__BAZEL_XCODE_SDKROOT__'
+          )
+      end
+
+      def resolved_value_by_build_setting(setting, additional_settings: {}, is_label_argument: false)
+        debug_settings = pod_target_xcconfig(configuration: :debug).merge(additional_settings)
+        debug_value = resolved_build_setting_value(setting, settings: debug_settings)
+        release_settings = pod_target_xcconfig(configuration: :release).merge(additional_settings)
+        release_value = resolved_build_setting_value(setting, settings: release_settings)
+        if debug_value == release_value
+          debug_value&.empty? && is_label_argument ? nil : debug_value
+        else
+          value_by_build_setting = {
+            build_settings_label(:debug) => debug_value.empty? && is_label_argument ? nil : debug_value,
+            build_settings_label(:release) => release_value.empty? && is_label_argument ? nil : release_value
+          }
+          StarlarkCompiler::AST::FunctionCall.new('select', value_by_build_setting)
+        end
+      end
+
+      def pod_target_xcconfig_header_search_paths(configuration)
+        settings = pod_target_xcconfig(configuration: configuration).merge('PODS_TARGET_SRCROOT' => @package)
+        resolved_build_setting_value('HEADER_SEARCH_PATHS', settings: settings) || []
+      end
+
+      def pod_target_xcconfig_user_header_search_paths(configuration)
+        settings = pod_target_xcconfig(configuration: configuration).merge('PODS_TARGET_SRCROOT' => @package)
+        resolved_build_setting_value('USER_HEADER_SEARCH_PATHS', settings: settings) || []
+      end
+
+      def pod_target_copts(type)
+        setting =
+          case type
+          when :swift then 'OTHER_SWIFT_FLAGS'
+          when :objc then 'OTHER_CFLAGS'
+          else raise "#Unsupported type #{type}"
+          end
+        copts = resolved_value_by_build_setting(setting)
+        copts = [copts] if copts&.is_a?(String)
+
+        debug_copts = copts_for_search_paths_by_config(type, :debug)
+        release_copts = copts_for_search_paths_by_config(type, :release)
+        copts_for_search_paths =
+          if debug_copts.sort == release_copts.sort
+            debug_copts
+          else
+            copts_by_build_setting = {
+              build_settings_label(:debug) => debug_copts,
+              build_settings_label(:release) => release_copts
+            }
+            StarlarkCompiler::AST::FunctionCall.new('select', copts_by_build_setting)
+          end
+
+        if copts
+          if copts.is_a?(Array)
+            if copts_for_search_paths.is_a?(Array)
+              copts + copts_for_search_paths
+            else
+              starlark { copts_for_search_paths + copts }
+            end
+          elsif copts_for_search_paths.is_a?(Array) && copts_for_search_paths.empty?
+            copts
+          else
+            starlark { copts + copts_for_search_paths }
+          end
+        else
+          copts_for_search_paths
+        end
+      end
+
+      def copts_for_search_paths_by_config(type, configuration)
+        additional_flag =
+          case type
+          when :swift then '-Xcc'
+          when :objc then nil
+          else raise "#Unsupported type #{type}"
+          end
+
+        copts = []
+        pod_target_xcconfig_header_search_paths(configuration).each do |path|
+          iquote = "-I#{path}"
+          copts << additional_flag if additional_flag
+          copts << iquote
+        end
+
+        pod_target_xcconfig_user_header_search_paths(configuration).each do |path|
+          iquote = "-iquote#{path}"
+          copts << additional_flag if additional_flag
+          copts << iquote
+        end
+        copts
+      end
+
+      def pod_target_infoplists_by_build_setting
+        debug_plist = resolved_build_setting_value('INFOPLIST_FILE', settings: pod_target_xcconfig(configuration: :debug))
+        release_plist = resolved_build_setting_value('INFOPLIST_FILE', settings: pod_target_xcconfig(configuration: :release))
+        if debug_plist == release_plist
+          []
+        else
+          plist_by_build_setting = {}
+          plist_by_build_setting[build_settings_label(:debug)] = [debug_plist] if debug_plist
+          plist_by_build_setting[build_settings_label(:release)] = [release_plist] if release_plist
+          plist_by_build_setting
+        end
+      end
+
+      def common_pod_target_infoplists(additional_plist: nil)
+        debug_plist = resolved_build_setting_value('INFOPLIST_FILE', settings: pod_target_xcconfig(configuration: :debug))
+        release_plist = resolved_build_setting_value('INFOPLIST_FILE', settings: pod_target_xcconfig(configuration: :release))
+        if debug_plist == release_plist
+          [debug_plist, additional_plist].compact
+        else
+          [additional_plist].compact
+        end
+      end
+
+      def to_rule_kwargs
+        kwargs = RuleArgs.new do |args|
+          args
+            .add(:name, label)
+            .add(:module_name, product_module_name, defaults: [label])
+            .add(:module_map, !non_library_spec && file_accessors.map(&:module_map).find(&:itself)&.relative_path_from(@package_dir)&.to_s, defaults: [nil, false]).
+
+            # public headers
+            add(:public_headers, glob(attr: :public_headers, sorted: false).yield_self { |f| case f when Array then f.reject { |path| path.include? '.framework/' } else f end }, defaults: [[]])
+            .add(:private_headers, glob(attr: :private_headers).yield_self { |f| case f when Array then f.reject { |path| path.include? '.framework/' } else f end }, defaults: [[]])
+            .add(:pch, glob(attr: :prefix_header, return_files: true).first, defaults: [nil])
+            .add(:data, glob(attr: :resources, exclude_directories: 0), defaults: [[]])
+            .add(:resource_bundles, {}, defaults: [{}])
+            .add(:swift_version, uses_swift? && pod_target.swift_version, defaults: [nil, false])
+            .add(:swift_objc_bridging_header, swift_objc_bridging_header, defaults: [nil])
+
+          # xcconfigs
+          resolve_xcconfig(common_pod_target_xcconfig, default_xcconfigs: default_xcconfigs).tap do |name, xcconfig|
+            args
+              .add(:default_xcconfig_name, name, defaults: [nil])
+              .add(:xcconfig, xcconfig, defaults: [{}])
+          end
+          # xcconfig_by_build_setting
+          args.add(:xcconfig_by_build_setting, pod_target_xcconfig_by_build_setting, defaults: [{}])
+        end.kwargs
+
+        file_accessors.group_by { |fa| fa.spec_consumer.requires_arc.class }.tap do |fa_by_arc|
+          srcs = Hash.new { |h, k| h[k] = [] }
+          non_arc_srcs = Hash.new { |h, k| h[k] = [] }
+          expand = ->(g) { expand_glob(g, extensions: %w[h hh m mm swift c cc cpp]) }
+
+          Array(fa_by_arc[TrueClass]).each do |fa|
+            srcs[fa.spec_consumer.exclude_files] += fa.spec_consumer.source_files.flat_map(&expand)
+          end
+          Array(fa_by_arc[FalseClass]).each do |fa|
+            non_arc_srcs[fa.spec_consumer.exclude_files] += fa.spec_consumer.source_files.flat_map(&expand)
+          end
+          (Array(fa_by_arc[Array]) + Array(fa_by_arc[String])).each do |fa|
+            arc_globs = Array(fa.spec_consumer.requires_arc).flat_map(&expand)
+            globs = fa.spec_consumer.source_files.flat_map(&expand)
+
+            srcs[fa.spec_consumer.exclude_files] += arc_globs
+            non_arc_srcs[fa.spec_consumer.exclude_files + arc_globs] += globs
+          end
+
+          m = lambda do |h|
+            h.delete_if do |_, v|
+              v.delete_if { |g| g.include?('.framework/') }
+              v.empty?
+            end
+            return [] if h.empty?
+
+            h.map do |excludes, globs|
+              excludes = excludes.empty? ? {} : { exclude: excludes.flat_map(&method(:expand_glob)) }
+              starlark { function_call(:glob, globs.uniq, **excludes) }
+            end.reduce(&:+)
+          end
+
+          kwargs[:srcs] = m[srcs]
+          kwargs[:non_arc_srcs] = m[non_arc_srcs]
+        end
+
+        file_accessors.each_with_object({}) do |fa, bundles|
+          fa.spec_consumer.resource_bundles.each do |name, file_patterns|
+            bundle = bundles[name] ||= {}
+            patterns_by_exclude = bundle[fa.spec_consumer.exclude_files] ||= []
+            patterns_by_exclude.concat(file_patterns.flat_map { |g| expand_glob(g, expand_directories: true) })
+          end
+        end.tap do |bundles|
+          kwargs[:resource_bundles] = bundles.map do |bundle_name, patterns_by_excludes|
+            patterns_by_excludes.delete_if { |_, v| v.empty? }
+            # resources implicitly have dirs expanded by CocoaPods
+            resources = patterns_by_excludes.map do |excludes, globs|
+              excludes = excludes.empty? ? {} : { exclude: excludes.flat_map(&method(:expand_glob)) }
+              starlark { function_call(:glob, globs.uniq, exclude_directories: 0, **excludes) }
+            end.reduce(&:+)
+            [bundle_name, resources]
+          end.to_h
+        end
+
+        # non-propagated stuff for a target that should build.
+        if pod_target.should_build?
+          kwargs[:swift_copts] = pod_target_copts(:swift)
+          kwargs[:objc_copts] = pod_target_copts(:objc)
+          linkopts = resolved_value_by_build_setting('OTHER_LDFLAGS')
+          linkopts = [linkopts] if linkopts.is_a? String
+          kwargs[:linkopts] = linkopts || []
+        end
+
+        # propagated
+        kwargs[:defines] = []
+        kwargs[:other_inputs] = []
+        kwargs[:linking_style] = nil
+        kwargs[:runtime_deps] = []
+        kwargs[:sdk_dylibs] = file_accessors.flat_map { |fa| fa.spec_consumer.libraries }.sort.uniq
+        kwargs[:sdk_frameworks] = file_accessors.flat_map { |fa| fa.spec_consumer.frameworks }.sort.uniq
+        kwargs[:sdk_includes] = []
+        kwargs[:weak_sdk_frameworks] = file_accessors.flat_map { |fa| fa.spec_consumer.weak_frameworks }.sort.uniq
+
+        kwargs[:vendored_static_frameworks] = glob(attr: :vendored_static_frameworks, return_files: true)
+        kwargs[:vendored_dynamic_frameworks] = glob(attr: :vendored_dynamic_frameworks, return_files: true)
+        kwargs[:vendored_static_libraries] = glob(attr: :vendored_static_libraries, return_files: true)
+        kwargs[:vendored_dynamic_libraries] = glob(attr: :vendored_dynamic_libraries, return_files: true)
+        kwargs[:vendored_xcframeworks] = vendored_xcframeworks
+
+        # any compatible provider: CCProvider, SwiftInfo, etc
+        kwargs[:deps] = deps_by_config
+
+        case non_library_spec&.spec_type
+        when :test
+          kwargs.merge!(test_kwargs)
+        when :app
+          kwargs.merge!(app_kwargs)
+        when nil
+          kwargs.merge!(framework_kwargs)
+        end
+
+        defaults = self.defaults
+        kwargs.delete_if { |k, v| defaults[k] == v }
+        kwargs
+      end
+
+      def defaults
+        {
+          module_name: label,
+          module_map: nil,
+          srcs: [],
+          non_arc_srcs: [],
+          hdrs: [],
+          pch: nil,
+          data: [],
+          resource_bundles: {},
+
+          swift_copts: [],
+          objc_copts: [],
+          cc_copts: [],
+          defines: [],
+          linkopts: [],
+          other_inputs: [],
+          linking_style: nil,
+          runtime_deps: [],
+          sdk_dylibs: [],
+          sdk_frameworks: [],
+          sdk_includes: [],
+          weak_sdk_frameworks: [],
+
+          bundle_id: nil,
+          env: {},
+          infoplists_by_build_setting: [],
+          infoplists: [],
+          minimum_os_version: nil,
+          test_host: nil,
+          platforms: {},
+
+          app_icons: [],
+          bundle_name: nil,
+          entitlements: nil,
+          entitlements_validation: nil,
+          extensions: [],
+          frameworks: [],
+          ipa_post_processor: nil,
+          launch_images: [],
+          launch_storyboard: nil,
+          provisioning_profile: nil,
+          resources: [],
+          settings_bundle: [],
+          strings: [],
+          version: [],
+          watch_application: [],
+
+          vendored_static_frameworks: [],
+          vendored_dynamic_frameworks: [],
+          vendored_static_libraries: [],
+          vendored_dynamic_libraries: [],
+          vendored_xcframeworks: [],
+
+          deps: []
+        }
+      end
+
+      def deps_by_config
+        debug_targets = dependent_targets_by_config[:debug]
+        release_targets = dependent_targets_by_config[:release]
+
+        debug_labels = debug_targets.map { |dt| dt.bazel_label(relative_to: package) }
+        release_labels = release_targets.map { |dt| dt.bazel_label(relative_to: package) }
+        shared_labels = (debug_labels & release_labels).uniq
+
+        debug_only_labels = debug_labels - shared_labels
+        release_only_labels = release_labels - shared_labels
+
+        sorted_debug_labels = Pod::Bazel::Util.sort_labels(debug_only_labels)
+        sorted_release_labels = Pod::Bazel::Util.sort_labels(release_only_labels)
+        sorted_shared_labels = Pod::Bazel::Util.sort_labels(shared_labels)
+
+        labels_by_config = {}
+
+        if !sorted_debug_labels.empty? || !sorted_release_labels.empty?
+          labels_by_config[build_settings_label(:debug)] = sorted_debug_labels
+          labels_by_config[build_settings_label(:release)] = sorted_release_labels
+        end
+
+        if labels_by_config.empty? # no per-config dependency
+          sorted_shared_labels
+        elsif sorted_shared_labels.empty? # per-config dependencies exist, avoiding adding an empty array
+          StarlarkCompiler::AST::FunctionCall.new('select', labels_by_config)
+        else # both per-config and shared dependencies exist
+          starlark { StarlarkCompiler::AST::FunctionCall.new('select', labels_by_config) + sorted_shared_labels }
+        end
+      end
+
+      def glob(attr:, return_files: !pod_target.sandbox.local?(pod_target.pod_name), sorted: true, excludes: [], exclude_directories: 1)
+        if !return_files
+          case attr
+          when :public_headers then attr = :public_header_files
+          when :private_headers then attr = :private_header_files
+          end
+
+          globs = file_accessors.map(&:spec_consumer).flat_map(&attr).flat_map { |g| expand_glob(g, expand_directories: exclude_directories != 1) }
+          excludes += file_accessors.map(&:spec_consumer).flat_map(&:exclude_files).flat_map { |g| expand_glob(g) }
+          excludes = excludes.empty? ? {} : { exclude: excludes }
+          excludes[:exclude_directories] = exclude_directories unless exclude_directories == 1
+          if globs.empty?
+            []
+          else
+            starlark { function_call(:glob, globs, **excludes) }
+          end
+        else
+          file_accessors.flat_map(&attr)
+                        .compact
+                        .map { |path| path.relative_path_from(@package_dir).to_s }
+                        .yield_self { |paths| sorted ? paths.sort : paths }
+                        .uniq
+        end
+      end
+
+      def expand_glob(glob, extensions: nil, expand_directories: false)
+        if (m = glob.match(/\{([^\{\}]+)\}/))
+          m[1].split(',').flat_map do |alt|
+            expand_glob("#{m.pre_match}#{alt}#{m.post_match}")
+          end.uniq
+        elsif (m = glob.match(/\[([^\[\]]+)\]/))
+          m[1].each_char.flat_map do |alt|
+            expand_glob("#{m.pre_match}#{alt}#{m.post_match}")
+          end.uniq
+        elsif extensions && File.extname(glob).empty?
+          glob = glob.chomp('**/*') # If we reach here and the glob ends with **/*, we need to avoid duplicating it (we do not want to end up with **/*/**/*)
+          if File.basename(glob) == '*'
+            extensions.map { |ext| "#{glob}.#{ext}" }
+          else
+            extensions.map do |ext|
+              File.join(glob, '**', "*.#{ext}")
+            end
+          end
+        elsif expand_directories
+          if glob.end_with?('/**/*')
+            [glob]
+          elsif glob.end_with?('/*')
+            [glob.sub(%r{/\*$}, '/**/*')]
+          else
+            [glob, glob.chomp('/') + '/**/*']
+          end
+        else
+          [glob]
+        end
+      end
+
+      def framework_kwargs
+        {
+          visibility: ['//visibility:public'],
+          platforms: { pod_target.platform.string_name.downcase => pod_target.platform.deployment_target.to_s }
+        }
+      end
+
+      def test_kwargs
+        {
+          bundle_id: resolved_value_by_build_setting('PRODUCT_BUNDLE_IDENTIFIER'),
+          env: pod_target.scheme_for_spec(non_library_spec).fetch(:environment_variables, {}),
+          infoplists_by_build_setting: pod_target_infoplists_by_build_setting,
+          infoplists: common_pod_target_infoplists(additional_plist: nil_if_empty(non_library_spec.consumer(pod_target.platform).info_plist)),
+          minimum_os_version: pod_target.deployment_target_for_non_library_spec(non_library_spec),
+          test_host: test_host&.bazel_label(relative_to: package) || file_accessors.any? { |fa| fa.spec_consumer.requires_app_host? } || nil
+        }
+      end
+
+      def app_kwargs
+        # maps to kwargs listed for https://github.com/bazelbuild/rules_apple/blob/master/doc/rules-ios.md#ios_application
+        {
+          app_icons: [],
+          bundle_id: resolved_value_by_build_setting('PRODUCT_BUNDLE_IDENTIFIER') || "org.cocoapods.#{label}",
+          bundle_name: nil,
+          entitlements: resolved_value_by_build_setting('CODE_SIGN_ENTITLEMENTS', is_label_argument: true),
+          entitlements_validation: nil,
+          extensions: [],
+          families: app_targeted_device_families,
+          frameworks: [],
+          infoplists_by_build_setting: pod_target_infoplists_by_build_setting,
+          infoplists: common_pod_target_infoplists(additional_plist: nil_if_empty(non_library_spec.consumer(pod_target.platform).info_plist)),
+          ipa_post_processor: nil,
+          launch_images: [],
+          launch_storyboard: nil,
+          minimum_os_version: pod_target.deployment_target_for_non_library_spec(non_library_spec),
+          provisioning_profile: nil,
+          resources: [],
+          settings_bundle: [],
+          strings: [],
+          version: [],
+          watch_application: []
+        }
+      end
+
+      def app_targeted_device_families
+        # Reads the targeted device families from xconfig TARGETED_DEVICE_FAMILY. Supports both iphone and ipad by default.
+        device_families = resolved_value_by_build_setting('TARGETED_DEVICE_FAMILY') || '1,2'
+        raise 'TARGETED_DEVICE_FAMILY must be the same for both debug and release.' unless device_families.is_a? String
+
+        device_families.split(',').map do |device_family|
+          case device_family
+          when '1' then 'iphone'
+          when '2' then 'ipad'
+          else raise "Unsupported device family: #{device_family}"
+          end
+        end
+      end
+
+      def vendored_xcframeworks
+        pod_target.xcframeworks.values.flatten(1).uniq.map do |xcframework|
+          {
+            'name' => xcframework.name,
+            'slices' => xcframework.slices.map do |slice|
+              {
+                'identifier' => slice.identifier,
+                'platform' => slice.platform.name.to_s,
+                'platform_variant' => slice.platform_variant.to_s,
+                'supported_archs' => slice.supported_archs,
+                'path' => slice.path.relative_path_from(@package_dir).to_s,
+                'build_type' => { 'linkage' => slice.build_type.linkage.to_s, 'packaging' => slice.build_type.packaging.to_s }
+              }
+            end
+          }
+        end
+      end
+
+      def nil_if_empty(arr)
+        arr.empty? ? nil : arr
+      end
+
+      def starlark(&blk)
+        StarlarkCompiler::AST.build(&blk)
+      end
+    end
+  end
+end