cocoapods-binary-ht 1.0.0

data/lib/cocoapods-binary-ht/pod-binary/integration/alter_specs.rb

@@ -0,0 +1,150 @@
+module Pod
+  class Installer
+    def alter_specs_for_prebuilt_pods
+      cache = []
+
+      @original_specs = analysis_result.specifications
+        .map { |spec| [spec.name, Pod::Specification.from_file(spec.defined_in_file)] }
+        .to_h
+
+      analysis_result.specifications
+        .select { |spec| should_integrate_prebuilt_pod?(spec.root.name) }
+        .group_by(&:root)
+        .each do |_, specs|
+          first_subspec_or_self = specs.find(&:subspec?) || specs[0]
+          specs.each do |spec|
+            alterations = {
+              :source_files => true,
+              :resources => true,
+              :license => true,
+              :vendored_framework => spec == first_subspec_or_self
+            }
+            alter_spec(spec, alterations, cache)
+          end
+        end
+    end
+
+    private
+
+    def metadata_of_target(name)
+      @metadata_by_target ||= {}
+      metadata = @metadata_by_target[name]
+      return metadata unless metadata.nil?
+
+      framework_path = sandbox.prebuild_sandbox.framework_folder_path_for_target_name(name)
+      metadata = PodPrebuild::Metadata.in_dir(framework_path)
+      @metadata_by_target[name] = metadata
+      metadata
+    end
+
+    def alter_spec(spec, alterations, cache)
+      metadata = metadata_of_target(spec.root.name)
+      targets = Pod.fast_get_targets_for_pod_name(spec.root.name, pod_targets, cache)
+      platforms = targets.map { |target| target.platform.name.to_s }.uniq
+
+      if alterations[:vendored_framework]
+        targets.each do |target|
+          # Use the prebuilt frameworks as vendered frameworks.
+          # The framework_file_path rule is decided in `install_for_prebuild`,
+          # as to compitable with older version and be less wordy.
+          framework_file_path = target.framework_name
+          framework_file_path = target.name + "/" + framework_file_path if targets.count > 1
+          framework_file_path = PodPrebuild.config.prebuilt_path(path: framework_file_path)
+          add_vendered_framework(spec, target.platform.name.to_s, framework_file_path)
+        end
+      end
+
+      empty_source_files(spec, platforms) if alterations[:source_files]
+      if alterations[:resources]
+        if metadata.static_framework?
+          tweak_resources_for_xib(spec, platforms)
+          tweak_resources_for_resource_bundles(spec, platforms)
+        else
+          # For dynamic frameworks, resources & resource bundles are already bundled inside the framework.
+          # We need to empty resources & resource bundles. Otherwise, there will be duplications
+          # (resources locating in both app bundle and framework bundle)
+          empty_resources(spec, platforms)
+        end
+      end
+      empty_liscence(spec) if alterations[:license]
+    end
+
+    def empty_resources(spec, platforms)
+      spec.attributes_hash["resources"] = nil
+      spec.attributes_hash["resource_bundles"] = nil
+      platforms.each do |platform|
+        next if spec.attributes_hash[platform].nil?
+
+        spec.attributes_hash[platform]["resources"] = nil
+        spec.attributes_hash[platform]["resource_bundles"] = nil
+      end
+    end
+
+    def tweak_resources_for_xib(spec, platforms)
+      # This is a workaround for prebuilt static framework that has `*.xib` files in the resources
+      # (declared by `spec.resources = ...`)
+      # ---------------------------------------------------------------
+      # In the prebuild stage, a XIB file is compiled as a NIB file in the framework.
+      # In the integration stage, this file is added to the script `Pods-<Target>-resources.sh`:
+      #   - If it's a XIB, it's installed to the target bundle by `ibtool`
+      #   - If it's a NIB, it's copied directly to the target bundle
+      # Since the one embedded in the prebuilt framework is a NIB (already compiled)
+      # --> We need to alter the spec so that this file will be copied to the target bundle
+      change_xib_to_nib = ->(path) { path.sub(".xib", ".nib") }
+      update_resources = lambda do |resources|
+        if resources.is_a?(String)
+          change_xib_to_nib.call(resources)
+        elsif resources.is_a?(Array)
+          resources.map { |item| change_xib_to_nib.call(item) }
+        end
+      end
+      spec.attributes_hash["resources"] = update_resources.call(spec.attributes_hash["resources"])
+      platforms.each do |platform|
+        next if spec.attributes_hash[platform].nil?
+
+        platform_resources = spec.attributes_hash[platform]["resources"]
+        spec.attributes_hash[platform]["resources"] = update_resources.call(platform_resources)
+      end
+    end
+
+    def tweak_resources_for_resource_bundles(spec, platforms)
+      add_resource_bundles_to_resources = lambda do |attributes|
+        return if attributes.nil?
+
+        resource_bundles = attributes["resource_bundles"] || {}
+        resource_bundle_names = resource_bundles.keys
+        attributes["resource_bundles"] = nil
+        attributes["resources"] ||= []
+        attributes["resources"] = [attributes["resources"]] if attributes["resources"].is_a?(String)
+        attributes["resources"] += resource_bundle_names.map do |name|
+          PodPrebuild.config.prebuilt_path(path: "#{name}.bundle")
+        end
+      end
+
+      add_resource_bundles_to_resources.call(spec.attributes_hash)
+      platforms.each do |platform|
+        add_resource_bundles_to_resources.call(spec.attributes_hash[platform])
+      end
+    end
+
+    def add_vendered_framework(spec, platform, added_framework_file_path)
+      spec.attributes_hash[platform] = {} if spec.attributes_hash[platform].nil?
+      vendored_frameworks = spec.attributes_hash[platform]["vendored_frameworks"] || []
+      vendored_frameworks = [vendored_frameworks] if vendored_frameworks.is_a?(String)
+      vendored_frameworks += [added_framework_file_path]
+      spec.attributes_hash[platform]["vendored_frameworks"] = vendored_frameworks
+    end
+
+    def empty_source_files(spec, platforms)
+      spec.attributes_hash["source_files"] = []
+      platforms.each do |platform|
+        spec.attributes_hash[platform]["source_files"] = [] unless spec.attributes_hash[platform].nil?
+      end
+    end
+
+    def empty_liscence(spec)
+      spec.attributes_hash["license"] = {}
+      spec.root.attributes_hash["license"] = {}
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/patch/embed_framework_script.rb

@@ -0,0 +1,36 @@
+# A fix in embeded frameworks script.
+#
+# The framework file in pod target folder is a symblink. The EmbedFrameworksScript use `readlink`
+# to read the read path. As the symlink is a relative symlink, readlink cannot handle it well. So
+# we override the `readlink` to a fixed version.
+#
+module Pod
+  module Generator
+    class EmbedFrameworksScript
+      old_method = instance_method(:script)
+      define_method(:script) do
+        script = old_method.bind(self).call
+        patch = <<-SH.strip_heredoc
+          #!/bin/sh
+          # ---- this is added by cocoapods-binary ---
+          # Readlink cannot handle relative symlink well, so we override it to a new one
+          # If the path isn't an absolute path, we add a realtive prefix.
+          old_read_link=`which readlink`
+          readlink () {
+            path=`$old_read_link "$1"`;
+            if [ $(echo "$path" | cut -c 1-1) = '/' ]; then
+              echo $path;
+            else
+              echo "`dirname $1`/$path";
+            fi
+          }
+          # ---
+        SH
+
+        # patch the rsync for copy dSYM symlink
+        script = script.gsub "rsync --delete", "rsync --copy-links --delete"
+        patch + script
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/patch/resolve_dependencies.rb

@@ -0,0 +1,20 @@
+# Let cocoapods use the prebuild framework files in install process.
+#
+# the code only effect the second pod install process.
+#
+module Pod
+  class Installer
+    # Modify specification to use only the prebuild framework after analyzing
+    original_resolve_dependencies = instance_method(:resolve_dependencies)
+    define_method(:resolve_dependencies) do
+      original_resolve_dependencies.bind(self).call
+
+      # check the pods
+      # Although we have did it in prebuild stage, it's not sufficient.
+      # Same pod may appear in another target in form of source code.
+      # Prebuild.check_one_pod_should_have_only_one_target(prebuilt_pod_targets)
+      validate_every_pod_only_have_one_form
+      alter_specs_for_prebuilt_pods
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/patch/sandbox_analyzer_state.rb

@@ -0,0 +1,29 @@
+module Pod
+  class Installer
+    class Analyzer
+      class SandboxAnalyzer
+        original_analyze = instance_method(:analyze)
+        define_method(:analyze) do
+          state = original_analyze.bind(self).call
+          state = alter_state(state)
+          state
+        end
+
+        private
+
+        def alter_state(state)
+          return state if PodPrebuild.config.tracked_prebuilt_pod_names.empty?
+
+          prebuilt = PodPrebuild.config.tracked_prebuilt_pod_names
+          Pod::UI.message "Alter sandbox state: treat prebuilt frameworks as added: #{prebuilt.to_a}"
+          SpecsState.new(
+            :added => (state.added + prebuilt).uniq,
+            :changed => state.changed - prebuilt,
+            :removed => state.deleted - prebuilt,
+            :unchanged => state.unchanged - prebuilt
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/patch/source_installation.rb

@@ -0,0 +1,55 @@
+require_relative "../source_installer"
+
+module Pod
+  class Installer
+    # Override the download step to skip download and prepare file in target folder
+    alias original_create_pod_installer create_pod_installer
+    def create_pod_installer(name)
+      if should_integrate_prebuilt_pod?(name)
+        create_prebuilt_source_installer(name)
+      else
+        create_normal_source_installer(name)
+      end
+    end
+
+    private
+
+    def create_normal_source_installer(name)
+      original_create_pod_installer(name)
+    end
+
+    def original_specs_by_platform(name)
+      specs_for_pod(name).map do |platform, specs|
+        specs_ = specs.map { |spec| @original_specs[spec.name] }
+        [platform, specs_]
+      end.to_h
+    end
+
+    def create_prebuilt_source_installer(name)
+      # A source installer needs to install with the original spec (instead of the altered spec).
+      # Otherwise, the cache will be corrupted because CocoaPods packs necessary dirs/files from temp dir
+      # to the cache dir based on the spec.
+      source_installer = PodSourceInstaller.new(sandbox, podfile, original_specs_by_platform(name))
+      pod_installer = PrebuiltSourceInstaller.new(
+        sandbox,
+        podfile,
+        specs_for_pod(name),
+        source_installer: source_installer
+      )
+      pod_installers << pod_installer
+      pod_installer
+    end
+
+    def should_integrate_prebuilt_pod?(name)
+      if PodPrebuild.config.prebuild_job? && PodPrebuild.config.targets_to_prebuild_from_cli.empty?
+        # In a prebuild job, at the integration stage, all prebuilt frameworks should be
+        # ready for integration regardless of whether there was any cache miss or not.
+        # Those that are missed were prebuilt in the prebuild stage.
+        PodPrebuild.state.cache_validation.include?(name)
+      else
+        prebuilt = PodPrebuild.state.cache_validation.hit + PodPrebuild.config.targets_to_prebuild_from_cli
+        prebuilt.include?(name)
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/source_installer.rb

@@ -0,0 +1,114 @@
+module Pod
+  class Installer
+    class PrebuiltSourceInstaller < PodSourceInstaller
+      def initialize(*args, **kwargs)
+        @source_installer = kwargs.delete(:source_installer)
+        super(*args, **kwargs)
+      end
+
+      def prebuild_sandbox
+        @prebuild_sandbox ||= Pod::PrebuildSandbox.from_standard_sandbox(sandbox)
+      end
+
+      def install!
+        @source_installer.install!
+        install_prebuilt_framework!
+      end
+
+      private
+
+      def install_prebuilt_framework!
+        return if !PodPrebuild.config.dev_pods_enabled? && sandbox.local?(name)
+
+        # make a symlink to target folder
+        # TODO (bang): Unify to 1 sandbox to optimize and avoid inconsistency
+        # if spec used in multiple platforms, it may return multiple paths
+        target_names = prebuild_sandbox.existed_target_names_for_pod_name(name)
+        target_names.each do |name|
+          real_file_folder = prebuild_sandbox.framework_folder_path_for_target_name(name)
+
+          # If have only one platform, just place int the root folder of this pod.
+          # If have multiple paths, we use a sperated folder to store different
+          # platform frameworks. e.g. AFNetworking/AFNetworking-iOS/AFNetworking.framework
+          target_folder = sandbox.pod_dir(self.name)
+          target_folder += real_file_folder.basename if target_names.count > 1
+          target_folder += PodPrebuild.config.prebuilt_path
+          target_folder.rmtree if target_folder.exist?
+          target_folder.mkpath
+
+          walk(real_file_folder) do |child|
+            source = child
+            # only make symlink to file and `.framework` folder
+            if child.directory? && [".framework", ".xcframework", ".dSYM"].include?(child.extname)
+              if [".framework", ".xcframework"].include?(child.extname)
+                mirror_with_symlink(source, real_file_folder, target_folder)
+              end
+              # Ignore dsym here to avoid cocoapods from adding install_dsym to buildphase-script
+              # That can cause duplicated output files error in Xcode 11 (warning in Xcode 10)
+              # We need more setup to support local debuging with prebuilt dSYM
+              next false # Don't go deeper
+            elsif child.file?
+              mirror_with_symlink(source, real_file_folder, target_folder)
+              next true
+            else
+              next true
+            end
+          end
+
+          # symbol link copy resource for static framework
+          metadata = PodPrebuild::Metadata.in_dir(real_file_folder)
+          next unless metadata.static_framework?
+
+          metadata.resources.each do |path|
+            target_file_path = Pathname(path)
+              .sub("${PODS_ROOT}", sandbox.root.to_path)
+              .sub("${PODS_CONFIGURATION_BUILD_DIR}", sandbox.root.to_path)
+            next if target_file_path.exist?
+
+            real_file_path = real_file_folder + metadata.framework_name + File.basename(path)
+
+            # TODO (thuyen): Fix https://github.com/pandaleecn/cocoapods-binary-ht/issues/45
+
+            case File.extname(path)
+            when ".xib"
+              # https://github.com/pandaleecn/cocoapods-binary-ht/issues/7
+              # When ".xib" files are compiled in a framework, it becomes ".nib" files
+              # --> We need to correct the path extension
+              real_file_path = real_file_path.sub_ext(".nib")
+              target_file_path = target_file_path.sub(".xib", ".nib")
+            when ".bundle"
+              next if metadata.resource_bundles.include?(File.basename(path))
+
+              real_file_path = real_file_folder + File.basename(path) unless real_file_path.exist?
+            end
+            make_link(real_file_path, target_file_path)
+          end
+        end
+      end
+
+      def walk(path, &action)
+        return unless path.exist?
+
+        path.children.each do |child|
+          result = action.call(child, &action)
+          if child.directory?
+            walk(child, &action) if result
+          end
+        end
+      end
+
+      def make_link(source, target)
+        source = Pathname.new(source)
+        target = Pathname.new(target)
+        target.rmtree if target.exist?
+        target.parent.mkpath unless target.parent.exist?
+        relative_source = source.relative_path_from(target.parent)
+        FileUtils.ln_sf(relative_source, target)
+      end
+
+      def mirror_with_symlink(source, basefolder, target_folder)
+        make_link(source, target_folder + source.relative_path_from(basefolder))
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration/validation.rb

@@ -0,0 +1,20 @@
+module Pod
+  class Installer
+    def validate_every_pod_only_have_one_form
+      multi_targets_pods = pod_targets
+        .group_by(&:pod_name)
+        .select do |_, targets|
+          is_multi_targets = targets.map { |t| t.platform.name }.uniq.count > 1
+          is_multi_forms = targets.map { |t| prebuilt_pod_targets.include?(t) }.uniq.count > 1
+          is_multi_targets && is_multi_forms
+        end
+      return if multi_targets_pods.empty?
+
+      warnings = "One pod can only be prebuilt or not prebuilt. These pod have different forms in multiple targets:\n"
+      warnings += multi_targets_pods
+        .map { |name, targets| "         #{name}: #{targets.map { |t| t.platform.name }}" }
+        .join("\n")
+      raise Informative, warnings
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/integration.rb

@@ -0,0 +1,11 @@
+require_relative "helper/podfile_options"
+require_relative "helper/prebuild_sandbox"
+require_relative "helper/sandbox"
+require_relative "helper/names"
+require_relative "helper/target_checker"
+require_relative "integration/alter_specs"
+require_relative "integration/validation"
+require_relative "integration/patch/embed_framework_script"
+require_relative "integration/patch/sandbox_analyzer_state"
+require_relative "integration/patch/resolve_dependencies"
+require_relative "integration/patch/source_installation"

data/lib/cocoapods-binary-ht/pod-binary/prebuild.rb

@@ -0,0 +1,166 @@
+require "fileutils"
+require_relative "../prebuild_output/output"
+require_relative "../helper/lockfile"
+require_relative "helper/target_checker"
+require_relative "helper/build"
+
+module Pod
+  class PrebuildInstaller < Installer # rubocop:disable Metrics/ClassLength
+    attr_reader :lockfile_wrapper
+
+    def initialize(options)
+      super(options[:sandbox], options[:podfile], options[:lockfile])
+      @cache_validation = options[:cache_validation]
+      @lockfile_wrapper = lockfile && PodPrebuild::Lockfile.new(lockfile)
+    end
+
+    def installation_options
+      # Skip integrating user targets for prebuild Pods project.
+      @installation_options ||= Pod::Installer::InstallationOptions.new(
+        super.to_h.merge(:integrate_targets => false)
+      )
+    end
+
+    def run_code_gen!(targets)
+      return if PodPrebuild.config.prebuild_code_gen.nil?
+
+      Pod::UI.title("Running code generation...") do
+        PodPrebuild.config.prebuild_code_gen.call(self, targets)
+      end
+    end
+
+    def prebuild_output
+      @prebuild_output ||= PodPrebuild::Output.new(sandbox)
+    end
+
+    def targets_to_prebuild
+      to_build = PodPrebuild.config.targets_to_prebuild_from_cli
+      if to_build.empty?
+        to_build = PodPrebuild.config.prebuild_all_pods? ? @cache_validation.all : @cache_validation.missed
+      end
+      pod_targets.select { |target| to_build.include?(target.name) }
+    end
+
+    def prebuild_frameworks!
+      existed_framework_folder = sandbox.generate_framework_path
+      sandbox_path = sandbox.root
+      targets = targets_to_prebuild
+      Pod::UI.puts "Prebuild frameworks (total #{targets.count}): #{targets.map(&:name)}".magenta
+
+      run_code_gen!(targets)
+
+      PodPrebuild.remove_build_dir(sandbox_path)
+      PodPrebuild.build(
+        sandbox: sandbox_path,
+        targets: targets,
+        configuration: PodPrebuild.config.prebuild_config,
+        output_path: sandbox.generate_framework_path,
+        bitcode_enabled: PodPrebuild.config.bitcode_enabled?,
+        device_build_enabled: PodPrebuild.config.device_build_enabled?,
+        disable_dsym: PodPrebuild.config.disable_dsym?,
+        log_path: PodPrebuild.config.xcodebuild_log_path,
+        args: PodPrebuild.config.build_args
+      )
+      PodPrebuild.remove_build_dir(sandbox_path)
+
+      targets.each do |target|
+        collect_metadata(target, sandbox.framework_folder_path_for_target_name(target.name))
+      end
+
+      # copy vendored libraries and frameworks
+      targets.each do |target|
+        root_path = sandbox.pod_dir(target.name)
+        target_folder = sandbox.framework_folder_path_for_target_name(target.name)
+
+        # If target shouldn't build, we copy all the original files
+        # This is for target with only .a and .h files
+        unless target.should_build?
+          FileUtils.cp_r(root_path, target_folder, :remove_destination => true)
+          next
+        end
+
+        target.spec_consumers.each do |consumer|
+          file_accessor = Sandbox::FileAccessor.new(root_path, consumer)
+          lib_paths = file_accessor.vendored_frameworks || []
+          lib_paths += file_accessor.vendored_libraries
+          # @TODO dSYM files
+          lib_paths.each do |lib_path|
+            relative = lib_path.relative_path_from(root_path)
+            destination = target_folder + relative
+            destination.dirname.mkpath unless destination.dirname.exist?
+            FileUtils.cp_r(lib_path, destination, :remove_destination => true)
+          end
+        end
+      end
+
+      # save the pod_name for prebuild framwork in sandbox
+      targets.each do |target|
+        sandbox.save_pod_name_for_target target
+      end
+
+      # Remove useless files
+      # remove useless pods
+      all_needed_names = pod_targets.map(&:name).uniq
+      useless_target_names = sandbox.exsited_framework_target_names.reject do |name|
+        all_needed_names.include? name
+      end
+      useless_target_names.each do |name|
+        Pod::UI.message "Remove: #{name}"
+        path = sandbox.framework_folder_path_for_target_name(name)
+        path.rmtree if path.exist?
+      end
+
+      if PodPrebuild.config.dont_remove_source_code?
+        # just remove the tmp files
+        path = sandbox.root + "Manifest.lock.tmp"
+        path.rmtree if path.exist?
+      else
+        # only keep manifest.lock and framework folder in _Prebuild
+        to_remain_files = ["Manifest.lock", File.basename(existed_framework_folder)]
+        to_delete_files = sandbox_path.children.reject { |file| to_remain_files.include?(File.basename(file)) }
+        to_delete_files.each { |file| file.rmtree if file.exist? }
+      end
+
+      prebuild_output.write_delta_file(
+        updated: targets.map { |target| target.label.to_s },
+        deleted: useless_target_names
+      )
+    end
+
+    def clean_delta_file
+      prebuild_output.clean_delta_file
+    end
+
+    def collect_metadata(target, output_path)
+      metadata = PodPrebuild::Metadata.in_dir(output_path)
+      metadata.framework_name = target.framework_name
+      metadata.static_framework = target.static_framework?
+      resource_paths = target.resource_paths
+      metadata.resources = resource_paths.is_a?(Hash) ? resource_paths.values.flatten : resource_paths
+      metadata.resource_bundles = target
+        .file_accessors
+        .map { |f| f.resource_bundles.keys }
+        .flatten
+        .map { |name| "#{name}.bundle" }
+      metadata.build_settings = pods_project.targets
+        .detect { |native_target| native_target.name == target.name }
+        .build_configurations
+        .detect { |config| config.name == PodPrebuild.config.prebuild_config }
+        .build_settings
+      metadata.source_hash = @lockfile_wrapper && @lockfile_wrapper.dev_pod_hash(target.name)
+
+      # Store root path for code-coverage support later
+      # TODO: update driver code-coverage logic to use path stored here
+      project_root = PathUtils.remove_last_path_component(@sandbox.standard_sanbox_path.to_s)
+      metadata.project_root = project_root
+      metadata.save!
+    end
+
+    # patch the post install hook
+    old_method2 = instance_method(:run_plugins_post_install_hooks)
+    define_method(:run_plugins_post_install_hooks) do
+      old_method2.bind(self).call
+      prebuild_frameworks! if PodPrebuild::Env.prebuild_stage?
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/prebuild_dsl.rb

@@ -0,0 +1,10 @@
+module Pod
+  class Podfile
+    module DSL
+      def config_cocoapods_binary_cache(options)
+        PodPrebuild.config.dsl_config = options
+        PodPrebuild.config.validate_dsl_config
+      end
+    end
+  end
+end

data/lib/cocoapods-binary-ht/pod-binary/prebuild_hook.rb

@@ -0,0 +1,10 @@
+require_relative "helper/podfile_options"
+require_relative "helper/prebuild_sandbox"
+
+Pod::HooksManager.register("cocoapods-binary-ht", :pre_install) do |installer_context|
+  PodPrebuild::PreInstallHook.new(installer_context).run
+end
+
+Pod::HooksManager.register("cocoapods-binary-ht", :post_install) do |installer_context|
+  PodPrebuild::PostInstallHook.new(installer_context).run
+end

data/lib/cocoapods-binary-ht/pod-rome/LICENSE.txt

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