cocoapods-tt 0.0.1

data/lib/cocoapods-tt/native/external_sources/abstract_external_source.rb

@@ -0,0 +1,205 @@
+module Pod
+  module ExternalSources
+    # Abstract class that defines the common behaviour of external sources.
+    #
+    class AbstractExternalSource
+      # @return [String] the name of the Pod described by this external source.
+      #
+      attr_reader :name
+
+      # @return [Hash{Symbol => String}] the hash representation of the
+      #         external source.
+      #
+      attr_reader :params
+
+      # @return [String] the path where the podfile is defined to resolve
+      #         relative paths.
+      #
+      attr_reader :podfile_path
+
+      # @return [Boolean] Whether the source is allowed to touch the cache.
+      #
+      attr_reader :can_cache
+      alias_method :can_cache?, :can_cache
+
+      # Initialize a new instance
+      #
+      # @param [String] name @see #name
+      # @param [Hash] params @see #params
+      # @param [String] podfile_path @see #podfile_path
+      # @param [Boolean] can_cache @see #can_cache
+      #
+      def initialize(name, params, podfile_path, can_cache = true)
+        @name = name
+        @params = params
+        @podfile_path = podfile_path
+        @can_cache = can_cache
+      end
+
+      # @return [Bool] whether an external source source is equal to another
+      #         according to the {#name} and to the {#params}.
+      #
+      def ==(other)
+        return false if other.nil?
+        name == other.name && params == other.params
+      end
+
+      public
+
+      # @!group Subclasses hooks
+
+      # Fetches the external source from the remote according to the params.
+      #
+      # @param  [Sandbox] _sandbox
+      #         the sandbox where the specification should be stored.
+      #
+      # @return [void]
+      #
+      def fetch(_sandbox)
+        raise 'Abstract method'
+      end
+
+      # @return [String] a string representation of the source suitable for UI.
+      #
+      def description
+        raise 'Abstract method'
+      end
+
+      protected
+
+      # Return the normalized path for a podspec for a relative declared path.
+      #
+      # @param  [String] declared_path
+      #         The path declared in the podfile.
+      #
+      # @return [String] The uri of the podspec appending the name of the file
+      #         and expanding it if necessary.
+      #
+      # @note   If the declared path is expanded only if the represents a path
+      #         relative to the file system.
+      #
+      def normalized_podspec_path(declared_path)
+        extension = File.extname(declared_path)
+        if extension == '.podspec' || extension == '.json'
+          path_with_ext = declared_path
+        else
+          path_with_ext = "#{declared_path}/#{name}.podspec"
+        end
+        podfile_dir = File.dirname(podfile_path || '')
+        File.expand_path(path_with_ext, podfile_dir)
+      end
+
+      private
+
+      # @! Subclasses helpers
+
+      # Pre-downloads a Pod passing the options to the downloader and informing
+      # the sandbox.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the Pod should be downloaded.
+      #
+      # @note   To prevent a double download of the repository the pod is
+      #         marked as pre-downloaded indicating to the installer that only
+      #         clean operations are needed.
+      #
+      # @todo  The downloader configuration is the same of the
+      #        #{PodSourceInstaller} and it needs to be kept in sync.
+      #
+      # @return [void]
+      #
+      def pre_download(sandbox)
+        title = "Pre-downloading: `#{name}` #{description}"
+        UI.titled_section(title,  :verbose_prefix => '-> ') do
+          target = sandbox.pod_dir(name)
+          begin
+            download_result = Downloader.download(download_request, target, :can_cache => can_cache)
+          rescue Pod::DSLError => e
+            raise Informative, "Failed to load '#{name}' podspec: #{e.message}"
+          rescue => e
+            raise Informative, "Failed to download '#{name}': #{e.message}"
+          end
+
+          spec = download_result.spec
+          raise Informative, "Unable to find a specification for '#{name}'." unless spec
+
+          # since the podspec might be cleaned, we want the checksum to refer
+          # to the json in the sandbox
+          spec.defined_in_file = nil
+
+          store_podspec(sandbox, spec)
+          sandbox.store_pre_downloaded_pod(name)
+          sandbox.store_checkout_source(name, download_result.checkout_options)
+        end
+      end
+
+      def download_request
+        Downloader::Request.new(
+          :name => name,
+          :params => params,
+        )
+      end
+
+      # Stores the podspec in the sandbox and marks it as from an external
+      # source.
+      #
+      # @param  [Sandbox] sandbox
+      #         The sandbox where the specification should be stored.
+      #
+      # @param  [Pathname, String, Specification] spec
+      #         The path of the specification or its contents.
+      #
+      # @note   All the concrete implementations of #{fetch} should invoke this
+      #         method.
+      #
+      # @note   The sandbox ensures that the podspec exists and that the names
+      #         match.
+      #
+      # @return [void]
+      #
+      def store_podspec(sandbox, spec, json = false)
+        begin
+          spec = case spec
+                 when Pathname
+                   Specification.from_file(spec)
+                 when String
+                   path = "#{name}.podspec"
+                   path << '.json' if json
+                   Specification.from_string(spec, path).tap { |s| s.defined_in_file = nil }
+                 when Specification
+                   spec.dup
+                 else
+                   raise "Unknown spec type: #{spec}"
+                 end
+        rescue Pod::DSLError => e
+          raise Informative, "Failed to load '#{name}' podspec: #{e.message}"
+        end
+
+        validate_podspec(spec)
+        sandbox.store_podspec(name, spec, true, true)
+      end
+
+      def validate_podspec(podspec)
+        defined_in_file = podspec.defined_in_file
+        podspec.defined_in_file = nil
+
+        validator = validator_for_podspec(podspec)
+        validator.quick = true
+        validator.allow_warnings = true
+        validator.ignore_public_only_results = true
+        Config.instance.with_changes(:silent => true) do
+          validator.validate
+        end
+        unless validator.validated?
+          raise Informative, "The `#{name}` pod failed to validate due to #{validator.failure_reason}:\n#{validator.results_message}"
+        end
+      ensure
+        podspec.defined_in_file = defined_in_file
+      end
+
+      def validator_for_podspec(podspec)
+        Validator.new(podspec, [], [])
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/external_sources/downloader_source.rb

@@ -0,0 +1,30 @@
+module Pod
+  module ExternalSources
+    # Provides support for fetching a specification file from a source handled
+    # by the downloader. Supports all the options of the downloader
+    #
+    # @note The podspec must be in the root of the repository and should have a
+    #       name matching the one of the dependency.
+    #
+    class DownloaderSource < AbstractExternalSource
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        pre_download(sandbox)
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        strategy = Downloader.strategy_from_options(params)
+        options = params.dup
+        url = options.delete(strategy)
+        result = "from `#{url}`"
+        options.each do |key, value|
+          result << ", #{key} `#{value}`"
+        end
+        result
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/external_sources/path_source.rb

@@ -0,0 +1,55 @@
+module Pod
+  module ExternalSources
+    # Provides support for fetching a specification file from a path local to
+    # the machine running the installation.
+    #
+    class PathSource < AbstractExternalSource
+      # @see  AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        title = "Fetching podspec for `#{name}` #{description}"
+        UI.section(title, '-> ') do
+          podspec = podspec_path
+          unless podspec.exist?
+            raise Informative, "No podspec found for `#{name}` in " \
+              "`#{declared_path}`"
+          end
+          store_podspec(sandbox, podspec, podspec.extname == '.json')
+          is_absolute = absolute?(declared_path)
+          sandbox.store_local_path(name, podspec, is_absolute)
+          sandbox.remove_checkout_source(name)
+        end
+      end
+
+      # @see  AbstractExternalSource#description
+      #
+      def description
+        "from `#{declared_path}`"
+      end
+
+      private
+
+      # @!group Helpers
+
+      # @return [String] The path as declared by the user.
+      #
+      def declared_path
+        result = params[:path]
+        result.to_s if result
+      end
+
+      # @return [Pathname] The absolute path of the podspec.
+      #
+      def podspec_path
+        path = Pathname(normalized_podspec_path(declared_path))
+        path.exist? ? path : Pathname("#{path}.json")
+      end
+
+      # @return [Bool]
+      #
+      def absolute?(path)
+        Pathname(path).absolute? || path.to_s.start_with?('~')
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/external_sources/podspec_source.rb

@@ -0,0 +1,54 @@
+module Pod
+  module ExternalSources
+    # Provides support for fetching a specification file from an URL. Can be
+    # http, file, etc.
+    #
+    class PodspecSource < AbstractExternalSource
+      # @see AbstractExternalSource#fetch
+      #
+      def fetch(sandbox)
+        title = "Fetching podspec for `#{name}` #{description}"
+        UI.titled_section(title,  :verbose_prefix => '-> ') do
+          podspec_path = Pathname(podspec_uri)
+          is_json = podspec_path.extname == '.json'
+          if podspec_path.exist?
+            store_podspec(sandbox, podspec_path, is_json)
+          else
+            require 'cocoapods/open-uri'
+            begin
+              OpenURI.open_uri(podspec_uri) { |io| store_podspec(sandbox, io.read, is_json) }
+            rescue OpenURI::HTTPError => e
+              status = e.io.status.join(' ')
+              raise Informative, "Failed to fetch podspec for `#{name}` at `#{podspec_uri}`.\n Error: #{status}"
+            end
+          end
+        end
+      end
+
+      # @see AbstractExternalSource#description
+      #
+      def description
+        "from `#{params[:podspec]}`"
+      end
+
+      private
+
+      # @!group Helpers
+
+      # @return [String] The uri of the podspec appending the name of the file
+      #         and expanding it if necessary.
+      #
+      # @note   If the declared path is expanded only if the represents a path
+      #         relative to the file system.
+      #
+      def podspec_uri
+        declared_path = params[:podspec].to_s
+        if declared_path =~ %r{^.+://}
+          declared_path
+        else
+          normalized_podspec_path(declared_path)
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/external_sources.rb

@@ -0,0 +1,57 @@
+require 'cocoapods/external_sources/abstract_external_source'
+require 'cocoapods/external_sources/downloader_source'
+require 'cocoapods/external_sources/path_source'
+require 'cocoapods/external_sources/podspec_source'
+
+module Pod
+  # Provides support for initializing the correct concrete class of an external
+  # source.
+  #
+  module ExternalSources
+    # Instantiate a matching {AbstractExternalSource} for a given dependency.
+    #
+    # @param  [Dependency] dependency
+    #         the dependency
+    #
+    # @param  [String] podfile_path
+    #         @see AbstractExternalSource#podfile_path
+    #
+    # @param  [Boolean] can_cache
+    #         @see AbstractExternalSource#can_cache
+    #
+    # @return [AbstractExternalSource] an initialized instance of the concrete
+    #         external source class associated with the option specified in the
+    #         hash.
+    #
+    def self.from_dependency(dependency, podfile_path, can_cache)
+      from_params(dependency.external_source, dependency, podfile_path, can_cache)
+    end
+
+    def self.from_params(params, dependency, podfile_path, can_cache)
+      name = dependency.root_name
+      if klass = concrete_class_from_params(params)
+        klass.new(name, params, podfile_path, can_cache)
+      else
+        msg = "Unknown external source parameters for `#{name}`: `#{params}`"
+        raise Informative, msg
+      end
+    end
+
+    # Get the class to represent the defined source type of a dependency
+    #
+    # @param  [Array<Symbol>] params
+    #         the source params of the dependency
+    #
+    # @return [Class]
+    #
+    def self.concrete_class_from_params(params)
+      if params.key?(:podspec)
+        PodspecSource
+      elsif params.key?(:path)
+        PathSource
+      elsif Downloader.strategy_from_options(params)
+        DownloaderSource
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/gem_version.rb

@@ -0,0 +1,5 @@
+module Pod
+  # The version of the CocoaPods command line tool.
+  #
+  VERSION = '1.11.3'.freeze unless defined? Pod::VERSION
+end

data/lib/cocoapods-tt/native/generator/acknowledgements/markdown.rb

@@ -0,0 +1,44 @@
+module Pod
+  module Generator
+    class Markdown < Acknowledgements
+      def self.path_from_basepath(path)
+        Pathname.new(path.dirname + "#{path.basename}.markdown")
+      end
+
+      def save_as(path)
+        file = File.new(path, 'w')
+        file.write(licenses)
+        file.close
+      end
+
+      # @return [String] The contents of the acknowledgements in Markdown format.
+      #
+      def generate
+        licenses
+      end
+
+      def title_from_string(string, level)
+        unless string.empty?
+          '#' * level << " #{string}"
+        end
+      end
+
+      def string_for_spec(spec)
+        if (license_text = license_text(spec))
+          "\n" << title_from_string(spec.name, 2) << "\n\n" << license_text << "\n"
+        end
+      end
+
+      def licenses
+        licenses_string = "#{title_from_string(header_title, 1)}\n#{header_text}\n"
+        specs.each do |spec|
+          if (license = string_for_spec(spec))
+            license = license.force_encoding('UTF-8') if license.respond_to?(:force_encoding)
+            licenses_string += license
+          end
+        end
+        licenses_string += "#{title_from_string(footnote_title, 2)}#{footnote_text}\n"
+      end
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/acknowledgements/plist.rb

@@ -0,0 +1,94 @@
+require 'stringio'
+
+module Pod
+  module Generator
+    class Plist < Acknowledgements
+      def self.path_from_basepath(path)
+        Pathname.new(path.dirname + "#{path.basename}.plist")
+      end
+
+      def save_as(path)
+        Xcodeproj::Plist.write_to_path(plist_hash, path)
+      end
+
+      # @return [String] The contents of the plist
+      #
+      def generate
+        plist = Nanaimo::Plist.new(plist_hash, :xml)
+        contents = StringIO.new
+        Nanaimo::Writer::XMLWriter.new(plist, :pretty => true, :output => contents, :strict => false).write
+        contents.string
+      end
+
+      def plist_hash
+        {
+          :Title => plist_title,
+          :StringsTable => plist_title,
+          :PreferenceSpecifiers => licenses,
+        }
+      end
+
+      def plist_title
+        'Acknowledgements'
+      end
+
+      def licenses
+        licences_array = [header_hash]
+        specs.each do |spec|
+          if (hash = hash_for_spec(spec))
+            licences_array << hash
+          end
+        end
+        licences_array << footnote_hash
+      end
+
+      def hash_for_spec(spec)
+        if (license = license_text(spec))
+          hash =  {
+            :Type => 'PSGroupSpecifier',
+            :Title => sanitize_encoding(spec.name),
+            :FooterText => sanitize_encoding(license),
+          }
+          hash[:License] = sanitize_encoding(spec.license[:type]) if spec.license[:type]
+
+          hash
+        end
+      end
+
+      def header_hash
+        {
+          :Type => 'PSGroupSpecifier',
+          :Title => sanitize_encoding(header_title),
+          :FooterText => sanitize_encoding(header_text),
+        }
+      end
+
+      def footnote_hash
+        {
+          :Type => 'PSGroupSpecifier',
+          :Title => sanitize_encoding(footnote_title),
+          :FooterText => sanitize_encoding(footnote_text),
+        }
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # !@group Private methods
+
+      # Returns the sanitized text with UTF-8 invalid characters eliminated.
+      #
+      # @param  [String] text
+      #         the text we want to sanitize.
+      #
+      # @return [String] The sanitized UTF-8 text.
+      #
+      def sanitize_encoding(text)
+        text.encode('UTF-8', :invalid => :replace, :undef => :replace, :replace => '')
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end

data/lib/cocoapods-tt/native/generator/acknowledgements.rb

@@ -0,0 +1,107 @@
+module Pod
+  module Generator
+    class Acknowledgements
+      # @return [Array<Class>] The classes of the acknowledgements generator
+      #         subclasses.
+      #
+      def self.generators
+        [Plist, Markdown]
+      end
+
+      # @return [Array<Sandbox::FileAccessor>] the list of the file accessors
+      #         for the specs of the target that needs to generate the
+      #         acknowledgements.
+      #
+      attr_reader :file_accessors
+
+      # @param [Array<Sandbox::FileAccessor>] @see file_accessors.
+      #
+      def initialize(file_accessors)
+        @file_accessors = file_accessors
+      end
+
+      #-----------------------------------------------------------------------#
+
+      # !@group Configuration
+
+      # @return [String] The title of the acknowledgements file.
+      #
+      def header_title
+        'Acknowledgements'
+      end
+
+      # @return [String] A text to present before listing the acknowledgements.
+      #
+      def header_text
+        'This application makes use of the following third party libraries:'
+      end
+
+      # @return [String] The title of the foot notes.
+      #
+      def footnote_title
+        ''
+      end
+
+      # @return [String] the foot notes.
+      #
+      def footnote_text
+        'Generated by CocoaPods - https://cocoapods.org'
+      end
+
+      #-----------------------------------------------------------------------#
+
+      private
+
+      # !@group Private methods
+
+      # @return [Array<Specification>] The root specifications for which the
+      #         acknowledgements should be generated.
+      #
+      def specs
+        file_accessors.map { |accessor| accessor.spec.root }.uniq
+      end
+
+      # Returns the text of the license for the given spec.
+      #
+      # @param  [Specification] spec
+      #         the specification for which license is needed.
+      #
+      # @return [String] The text of the license.
+      # @return [Nil] If no license text could be found.
+      #
+      def license_text(spec)
+        return nil unless spec.license
+        text = spec.license[:text]
+        unless text
+          if license_file = spec.license[:file]
+            license_path = file_accessor(spec).root + license_file
+            if File.exist?(license_path)
+              text = IO.read(license_path)
+            else
+              UI.warn "Unable to read the license file `#{license_file}` " \
+              "for the spec `#{spec}`"
+            end
+          elsif license_file = file_accessor(spec).license
+            text = IO.read(license_file)
+          end
+        end
+        text
+      end
+
+      protected
+
+      # Returns the file accessor for the given spec.
+      #
+      # @param  [Specification] spec
+      #         the specification for which the file accessor is needed.
+      #
+      # @return [Sandbox::FileAccessor] The file accessor.
+      #
+      def file_accessor(spec)
+        file_accessors.find { |accessor| accessor.spec.root == spec }
+      end
+
+      #-----------------------------------------------------------------------#
+    end
+  end
+end