cocoapods-alexandria 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e638279de826395aa7ac4b217a85b16fb8fe255161a418d1c185157594715339
+  data.tar.gz: b42e571938bd4f2ae2f701c393d0f7518ef53169c89db75419e5b40627b7367b
+SHA512:
+  metadata.gz: 86d6d34039cafc3dab302c23d86d96c36fdb1c4b63b8f337432fc1bc0f7bb39b41cad86ed9ecab0bf2ee4d684d65c81379193b8793d318a912833aefa19402de
+  data.tar.gz: b0aedadd56ae7a45bfef37197c92ccf2c0292d2e180c711c709abc9b54bd0cbed310257f7a7cc251e99d4893e9950ab2f3e722754d4ebe42d9bacd2e2ce7efdf

data/lib/cocoapods-alexandria.rb

@@ -0,0 +1 @@
+require 'cocoapods-alexandria/gem_version'

data/lib/cocoapods-alexandria/env_ci/post_install.rb

@@ -0,0 +1,28 @@
+module PodAlexandria
+  class CIPostInstallHook
+    attr_reader :installer_context, :pods_project, :cache, :options
+
+    def initialize(installer_context, user_options)
+      @installer_context = installer_context
+      @pods_project = installer_context.pods_project
+      @cache = FrameworkCache.new(installer_context)
+      @options = UserOptions.new(installer_context, user_options)
+    end
+
+    def run
+      Pod::UI.title "Compile dependencies"
+      
+      if options.force_bitcode
+        Pod::UI.puts "Forcing bitcode generation"
+        pods_project.force_bitcode_generation
+      end
+      cache.delete_changed_frameworks
+      cache.build_frameworks
+      cache.cache_lockfile
+
+      Pod::UI.title "Generating project using XcodeGen"
+      XcodeGen::generate_dependencies(installer_context, options)
+      XcodeGen::generate
+    end
+  end
+end

data/lib/cocoapods-alexandria/env_ci/pre_install.rb

@@ -0,0 +1,29 @@
+module PodAlexandria
+  class CIPreInstallHook
+    attr_reader :podfile, :options
+
+    def initialize(installer_context, user_options)
+      @podfile = installer_context.podfile
+      @options = UserOptions.new(installer_context, user_options)
+    end
+
+    def run
+      Pod::UI.puts "Cocoapods Alexandria running in CI mode."
+
+      Pod::UI.title "Preparing environment..."
+      podfile.prepare_for_xcodegen
+      podfile.disable_integration
+      delete_workspace
+
+      Pod::UI.title "Continuing with normal CocoaPods"
+    end
+
+    private
+
+    def delete_workspace
+      Dir['*.xcworkspace'].each do |workspace|
+        FileUtils.remove_dir(workspace, force: true)
+      end
+    end
+  end
+end

data/lib/cocoapods-alexandria/env_local/post_install.rb

@@ -0,0 +1,38 @@
+module PodAlexandria
+  class LocalPostInstallHook
+    attr_reader :pods_project, :sandbox_root, :umbrella_targets, :options
+
+    def initialize(installer_context, user_options)
+      @pods_project = installer_context.pods_project
+      @sandbox_root = installer_context.sandbox_root
+      @umbrella_targets = installer_context.umbrella_targets
+      @options = UserOptions.new(installer_context, user_options)
+    end
+
+    def run
+      Pod::UI.title "Tweaking CocoaPods for XcodeGen..."
+      pods_project.fix_deployment_target_warnings
+      include_user_configs_in_pods_xcconfigs
+    end
+
+    private
+
+    def include_user_configs_in_pods_xcconfigs
+      umbrella_targets.each do |target|
+        pods_project.configurations.each do |config|
+          config_path = options.environment_configs_for(target.cocoapods_target_label)[config]
+          append_include_to_config(target, config, config_path)
+        end
+      end
+    end
+
+    def append_include_to_config(target, config, include)
+      xcconfig = "#{sandbox_root}/Target Support Files/#{target.cocoapods_target_label}/#{target.cocoapods_target_label}.#{config.downcase}.xcconfig"
+      
+      File.open(xcconfig, 'a') do |f|
+        f.puts ''
+        f.puts "#include \"../../../#{include}\""
+      end
+    end
+  end
+end

data/lib/cocoapods-alexandria/env_local/pre_install.rb

@@ -0,0 +1,24 @@
+module PodAlexandria
+  class LocalPreInstallHook
+    attr_reader :podfile, :options
+
+    def initialize(installer_context, user_options)
+      @podfile = installer_context.podfile
+      @options = UserOptions.new(installer_context, user_options)
+    end
+
+    def run
+      Pod::UI.puts "Cocoapods Alexandria running in local mode."
+
+      Pod::UI.title "Generating project using XcodeGen"
+      XcodeGen::cleanupRome
+      XcodeGen::clearDependencies(options.xcodegen_dependencies_file)
+      XcodeGen::generate
+
+      Pod::UI.title "Preparing environment..."
+      podfile.prepare_for_xcodegen
+
+      Pod::UI.title "Continuing with normal CocoaPods"
+    end
+  end
+end

data/lib/cocoapods-alexandria/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsAlexandria
+  VERSION = '0.1.0'
+end

data/lib/cocoapods-alexandria/helper/environment.rb

@@ -0,0 +1,3 @@
+def is_ci?
+  !ENV['CI'].nil?
+end

data/lib/cocoapods-alexandria/helper/podfile.rb

@@ -0,0 +1,14 @@
+module Pod
+  class Podfile
+    def prepare_for_xcodegen
+      use_frameworks!
+    end
+
+    def disable_integration
+      install!(
+        'cocoapods',
+        installation_method.last.merge(:integrate_targets => false)
+      )
+    end
+  end
+end

data/lib/cocoapods-alexandria/helper/user_options.rb

@@ -0,0 +1,37 @@
+module PodAlexandria
+  class UserOptions
+    attr_reader :environment_configs
+    attr_reader :force_bitcode
+    attr_reader :xcodegen_dependencies_file
+
+    def initialize(installer_context, user_options)
+      @environment_configs = user_options.fetch('environment_configs', default_configurations(installer_context))
+      @force_bitcode = user_options.fetch('force_bitcode', true)
+      @xcodegen_dependencies_file = user_options.fetch('xcodegen_dependencies_file', 'projectDependencies.yml')
+    end
+
+    def environment_configs_for(target)
+      environment_configs[normalize_target(target)]
+    end
+
+    private
+
+    def default_configurations(installer_context)
+      if installer_context.respond_to? :umbrella_targets
+        installer_context.umbrella_targets.map { |target|
+          target_name = normalize_target(target.cocoapods_target_label)
+          configs = installer_context.pods_project.configurations
+            .map { |config| [config, "Supporting Files/Settings-#{config.gsub('-', ' ').split[0]}.xcconfig"] }
+            .to_h
+          [target_name, configs]
+        }.to_h
+      else
+        {}
+      end
+    end
+
+    def normalize_target(target)
+      target.sub(/^Pods-/, '')
+    end
+  end
+end

data/lib/cocoapods-alexandria/helper/xcodeproj.rb

@@ -0,0 +1,27 @@
+module Xcodeproj
+  class Project
+    def configurations
+      build_configurations
+        .map(&:name)
+        .reject { |c| ['Debug', 'Release'].include? c }
+    end
+
+    def fix_deployment_target_warnings
+      targets.each do |target|
+        target.build_configurations.each do |config|
+          config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '9.0' if config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] == '8.0'
+        end
+      end
+      save
+    end
+
+    def force_bitcode_generation
+      targets.each do |target|
+        target.build_configurations.each do |config|
+          config.build_settings['BITCODE_GENERATION_MODE'] = 'bitcode'
+        end
+      end
+      save
+    end
+  end
+end

data/lib/cocoapods-alexandria/main.rb

@@ -0,0 +1,18 @@
+require_relative 'helper/environment'
+require_relative 'helper/podfile'
+require_relative 'helper/user_options'
+require_relative 'helper/xcodeproj'
+require_relative 'rome/compiler'
+require_relative 'rome/framework_cache'
+require_relative 'rome/lockfile'
+require_relative 'xcodegen/dependencies_generator'
+require_relative 'xcodegen/dependency'
+require_relative 'xcodegen/xcodegen'
+
+require_relative 'env_ci/post_install'
+require_relative 'env_ci/pre_install'
+require_relative 'env_local/post_install'
+require_relative 'env_local/pre_install'
+
+
+require_relative 'register_hooks'

data/lib/cocoapods-alexandria/register_hooks.rb

@@ -0,0 +1,15 @@
+Pod::HooksManager.register("cocoapods-alexandria", :pre_install) do |installer_context, user_options|
+  if is_ci?
+    PodAlexandria::CIPreInstallHook.new(installer_context, user_options).run
+  else
+    PodAlexandria::LocalPreInstallHook.new(installer_context, user_options).run
+  end
+end
+
+Pod::HooksManager.register("cocoapods-alexandria", :post_install) do |installer_context, user_options|
+  if is_ci?
+    PodAlexandria::CIPostInstallHook.new(installer_context, user_options).run
+  else
+    PodAlexandria::LocalPostInstallHook.new(installer_context, user_options).run
+  end
+end

data/lib/cocoapods-alexandria/rome/compiler.rb

@@ -0,0 +1,70 @@
+module PodAlexandria
+  class Compiler
+    attr_reader :sandbox, :build_dir, :destination, :configuration, :flags
+
+    def initialize(sandbox, build_dir, destination, configuration, flags)
+      @sandbox = sandbox
+      @build_dir = build_dir
+      @destination = destination
+      @configuration = configuration
+      @flags = flags
+    end
+
+    def build(target)
+      sdk = platform_sdk[target.platform_name]
+      deployment_target = target.platform_deployment_target
+      target_label = target.cocoapods_target_label
+
+      # build each dependency of target
+      spec_names = target.specs.map { |spec| [spec.root.name, spec.root.module_name] }.uniq
+      
+      spec_names.map { |root_name, module_name|
+        next if skip_build?(root_name, module_name, sdk)
+        if File.directory?(build_path(target, module_name, sdk))
+          build_path(target, module_name, sdk)
+        else
+          xcodebuild(root_name, module_name, sdk, deployment_target)
+        end
+      }.compact
+    end
+
+    private
+
+    def platform_sdk
+      { :ios => 'iphoneos', :osx => 'macosx', :tvos => 'appletvos', :watchos => 'watchos' }
+    end
+
+    def skip_build?(target, module_name, sdk)
+      File.directory?(destination_path(module_name)) ||
+        !is_native_target?(target)
+    end
+
+    def is_native_target?(target_name)
+      project.targets
+        .find { |t| t.name == target_name }
+        .is_a?(Xcodeproj::Project::Object::PBXNativeTarget)
+    end
+
+    def xcodebuild(target, module_name, sdk, deployment_target)
+      args = %W(-project #{sandbox.project_path.realdirpath} -scheme #{target} -configuration #{configuration} -sdk #{sdk})
+      args += flags unless flags.nil? 
+      
+      Pod::UI.puts "Building '#{target}' for #{sdk}..."
+      Pod::Executable.execute_command 'xcodebuild', args, true
+
+      build_path(target, module_name, sdk)
+    end
+
+    def project
+      @project ||= Xcodeproj::Project.open(sandbox.project_path)
+    end
+
+    def build_path(target, module_name, sdk)
+      "#{build_dir}/#{configuration}-#{sdk}/#{target}/#{module_name}.framework"
+    end
+
+    def destination_path(module_name)
+      "#{destination}/#{module_name}.framework"
+    end
+  end
+end

data/lib/cocoapods-alexandria/rome/framework_cache.rb

@@ -0,0 +1,117 @@
+module PodAlexandria
+  class FrameworkCache
+    attr_reader :configuration, :flags, :sandbox, :sandbox_root, :project_dir, :build_dir, :destination, :umbrella_targets
+
+    def initialize(installer_context)
+      @configuration = 'Release'
+      @flags = []
+      @sandbox_root = Pathname(installer_context.sandbox_root)
+      @sandbox = Pod::Sandbox.new(sandbox_root)
+      @project_dir = sandbox_root.parent
+      @build_dir = project_dir + 'build'
+      @destination = project_dir + 'Rome'
+      @umbrella_targets = installer_context.umbrella_targets
+    end
+
+    def podfile_lock
+      @podfile_lock ||= Lockfile.new(project_dir + 'Podfile.lock')
+    end
+
+    def cached_podfile_lock
+      @cached_podfile_lock ||= Lockfile.new(sandbox_root + 'Rome-Podfile.lock')
+    end
+
+    def delete_changed_frameworks
+      # if first run (no cache), make sure we nuke partials
+      if !cached_podfile_lock.exists?
+        Pod::UI.info 'No cached lockfile, deleting all cached frameworks'
+        delete_all
+        return
+      end
+
+      # return early if identical
+      return unless podfile_lock.exists? and cached_podfile_lock.exists?
+      if podfile_lock.matches? cached_podfile_lock
+        Pod::UI.info 'Podfile.lock did not change, leaving frameworks as is'
+        return
+      end
+
+      Pod::UI.info '⚠️  Podfile.lock did change, deleting updated frameworks'
+      changed = podfile_lock.changed_specs(cached_podfile_lock)
+      affected = podfile_lock.specs_affected_by(changed)
+
+      # delete affected frameworks
+      Pod::UI.info "Affected frameworks: #{affected.sort.join(', ')}" unless affected.empty?
+      affected.each { |pod| delete(pod) }
+    end
+
+    def build_frameworks
+      compiler = Compiler.new(sandbox, build_dir, destination, configuration, flags)
+      frameworks = umbrella_targets.select { |t| t.specs.any? }.flat_map { |target|
+        compiler.build(target)
+      }
+
+      Pod::UI.info "🔥  Built #{frameworks.count} #{'frameworks'.pluralize(frameworks.count)}" unless frameworks.empty?
+
+      FileUtils.mkdir_p destination
+      collect_files(frameworks).each do |file|
+        FileUtils.cp_r file, destination, :remove_destination => true
+      end
+
+      build_dir.rmtree if build_dir.directory?
+    end
+
+    def cache_lockfile
+      if podfile_lock.exists?
+        Pod::UI.info "Caching new Podfile.lock"
+        podfile_lock.copy_to(cached_podfile_lock)
+      else
+        Pod::UI.info "Deleting cached Podfile.lock"
+        cached_podfile_lock.delete
+      end
+    end
+
+    private
+
+    def spec_modules
+      @spec_modules ||= umbrella_targets.map { |t|
+        t.specs.map { |spec| [spec.root.name, spec.root.module_name] }
+      }.flatten(1).uniq.to_h
+    end
+
+    def module_name(spec)
+      spec.gsub(/^([0-9])/, '_\1').gsub(/[^a-zA-Z0-9_]/, '_')
+    end
+
+    def delete_all
+      FileUtils.remove_dir(build_dir, true)
+      FileUtils.remove_dir(destination, true)
+    end
+
+    def delete(spec)
+      name = spec_modules[spec] || module_name(spec)
+      path = "#{destination}/#{name}.framework"
+      
+      if File.directory?(path)
+        FileUtils.remove_dir(path, true)
+      else
+        Pod::UI.warning "🤔  Could not delete #{path}, it does not exist! (this is normal for newly added pods)"
+      end
+    end
+
+    def collect_files(frameworks)
+      resources = []
+
+      umbrella_targets.each do |target|
+        target.specs.each do |spec|
+          consumer = spec.consumer(target.platform_name)
+          file_accessor = Pod::Sandbox::FileAccessor.new(sandbox.pod_dir(spec.root.name), consumer)
+          frameworks += file_accessor.vendored_libraries + file_accessor.vendored_frameworks
+          resources += file_accessor.resources
+        end
+      end
+      
+      frameworks.uniq + resources.uniq
+    end
+  end
+end

data/lib/cocoapods-alexandria/rome/lockfile.rb

@@ -0,0 +1,68 @@
+module PodAlexandria
+  class Lockfile
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def exists?
+      File.file?(path)
+    end
+
+    def matches?(lockfile)
+      FileUtils.identical?(path, lockfile.path)
+    end
+
+    # collect changed specs (changed checksum, checkout or deleted pod)
+    def changed_specs(lockfile)
+      changed_checksums = spec_checksums.select { |k,v| v != lockfile.spec_checksums[k] }.keys
+      changed_checkout = checkout_options.select { |k,v| v != lockfile.checkout_options[k] }.keys
+      deleted_specs = lockfile.spec_checksums.keys - spec_checksums.keys
+
+      changed_checksums.to_set.merge(changed_checksums).merge(deleted_specs)
+    end
+
+    # collect affected frameworks (and filter out subspecs)
+    def specs_affected_by(specs)
+      affected = specs
+
+      loop do
+        items = pods.select { |s|
+          s.is_a?(Hash) && s.values.flatten.any? { |ss| affected.include? ss.split.first }
+        }.map { |s| s.keys.first.split.first }
+
+        break if affected.superset? (affected + items)
+        affected.merge(items)
+      end
+
+      affected = affected & spec_checksums.keys
+    end
+
+    def copy_to(lockfile)
+      FileUtils.copy_file(path, lockfile.path)
+    end
+
+    def delete
+      FileUtils.remove_file(path, true)
+    end
+
+    protected
+
+    def contents
+      @contents ||= YAML.load_file(path)
+    end
+
+    def spec_checksums
+      contents.fetch('SPEC CHECKSUMS', {})
+    end
+
+    def checkout_options
+      contents.fetch('CHECKOUT OPTIONS', {})
+    end
+
+    def pods
+      contents.fetch('PODS', [])
+    end
+  end
+end

data/lib/cocoapods-alexandria/xcodegen/dependencies_generator.rb

@@ -0,0 +1,51 @@
+require 'yaml'
+
+module PodAlexandria
+  class XcodeGen
+    # Generate the project dependencies file, adding frameworks to the right targets
+    # and also checking if they are linked dynamically or not.
+    def self.generate_dependencies(installer_context, options)
+      targets = installer_context.umbrella_targets.map { |target|
+        generate_for_target(installer_context, target, options.environment_configs_for(target.cocoapods_target_label))
+      }.to_h
+
+      File.open(options.xcodegen_dependencies_file, 'w') { |file|
+        YAML::dump({ 'targets' => targets }, file)
+      }
+    end
+
+    private
+
+    def self.generate_for_target(installer_context, target, configurations)
+      target_name = target.cocoapods_target_label.sub(/^Pods-/, '')
+      xcconfig = config_file_for_target(installer_context, target)
+
+      [
+        target_name,
+        {
+          'configFiles' => configurations,
+          'dependencies' => get_dependencies_from_xcconfig(xcconfig).map { |dependency|
+            if dependency.exists?
+              { 'framework' => dependency.path, 'embed' => dependency.is_dynamic? }
+            else
+              { 'sdk' => dependency.sdk }
+            end
+          }
+        }
+      ]
+    end
+
+    def self.config_file_for_target(installer_context, target)
+      Dir["#{installer_context.sandbox_root}/Target Support Files/#{target.cocoapods_target_label}/#{target.cocoapods_target_label}.*.xcconfig"]
+        .first
+    end
+
+    def self.get_dependencies_from_xcconfig(file)
+      File.readlines(file).select { |line| line.start_with?('OTHER_LDFLAGS') }.first
+        .split('=')[1].tr('"', '') # get value (and remove quotes)
+        .gsub('-framework', '').gsub('-ObjC', '') # remove unneeded flags
+        .split.drop(1) # remove inherited
+        .map { |d| Dependency.new(d) }
+    end
+  end
+end

data/lib/cocoapods-alexandria/xcodegen/dependency.rb

@@ -0,0 +1,54 @@
+module PodAlexandria
+  class Dependency
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def path
+      binary = Dir["Rome/*.{framework,xcframework}/**/#{binary_name}"].first
+      binary&.split(File::SEPARATOR)&.first(2)&.join(File::SEPARATOR)
+    end
+
+    def sdk
+      if is_library?
+        "lib#{module_name}.tbd"
+      else
+        "#{value}.framework"
+      end
+    end
+
+    def exists?
+      path != nil
+    end
+
+    def is_dynamic?
+      if path.end_with? 'xcframework'
+        any_arch = Dir["#{path}/*/*.framework"].first
+        binary = "#{any_arch}/#{value}"
+      else
+        binary = "#{path}/#{value}"
+      end
+      !%x(file #{binary} | grep dynamic).to_s.strip.empty?
+    end
+
+    private
+
+    def is_library?
+      value.start_with? '-l'
+    end
+
+    def binary_name
+      if is_library?
+        "lib#{module_name}.a"
+      else
+        module_name
+      end
+    end
+
+    def module_name
+      value.delete_prefix('-l')
+    end
+  end
+end

data/lib/cocoapods-alexandria/xcodegen/xcodegen.rb

@@ -0,0 +1,21 @@
+module PodAlexandria
+  class XcodeGen
+    def self.cleanupRome
+      FileUtils.remove_dir('build', force: true)
+      FileUtils.remove_dir('dSYM', force: true)
+      FileUtils.remove_dir('Rome', force: true)
+    end
+
+    def self.clearDependencies(xcodegen_dependencies_file)
+      File.truncate(xcodegen_dependencies_file, 0)
+    end
+
+    def self.generate
+      unless system('which xcodegen > /dev/null')
+        abort 'XcodeGen is not installed. Visit https://github.com/yonaskolb/XcodeGen to learn more.'
+      end
+
+      system('xcodegen')
+    end
+  end
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1 @@
+require 'cocoapods-alexandria/main'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: cocoapods-alexandria
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Jennes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- david.jennes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cocoapods-alexandria.rb
+- lib/cocoapods-alexandria/env_ci/post_install.rb
+- lib/cocoapods-alexandria/env_ci/pre_install.rb
+- lib/cocoapods-alexandria/env_local/post_install.rb
+- lib/cocoapods-alexandria/env_local/pre_install.rb
+- lib/cocoapods-alexandria/gem_version.rb
+- lib/cocoapods-alexandria/helper/environment.rb
+- lib/cocoapods-alexandria/helper/podfile.rb
+- lib/cocoapods-alexandria/helper/user_options.rb
+- lib/cocoapods-alexandria/helper/xcodeproj.rb
+- lib/cocoapods-alexandria/main.rb
+- lib/cocoapods-alexandria/register_hooks.rb
+- lib/cocoapods-alexandria/rome/compiler.rb
+- lib/cocoapods-alexandria/rome/framework_cache.rb
+- lib/cocoapods-alexandria/rome/lockfile.rb
+- lib/cocoapods-alexandria/xcodegen/dependencies_generator.rb
+- lib/cocoapods-alexandria/xcodegen/dependency.rb
+- lib/cocoapods-alexandria/xcodegen/xcodegen.rb
+- lib/cocoapods_plugin.rb
+homepage: https://github.com/appwise-labs/Alexandria
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Alexandria allows for easier integration with XcodeGen, and automatically
+  switches to a 'Rome' mode on CI (pre-compile frameworks)
+test_files: []