cocoapods-core 0.30.0 → 1.15.2

data/lib/cocoapods-core/specification/json.rb

@@ -1,12 +1,18 @@
 module Pod
   class Specification
     module JSONSupport
-
       # @return [String] the json representation of the specification.
       #
       def to_json(*a)
         require 'json'
-        to_hash.to_json(*a)
+        JSON.dump(to_hash, *a) << "\n"
+      end
+
+      # @return [String] the pretty json representation of the specification.
+      #
+      def to_pretty_json(*a)
+        require 'json'
+        JSON.pretty_generate(to_hash, *a) << "\n"
       end
 
       #-----------------------------------------------------------------------#
@@ -16,17 +22,29 @@ module Pod
       #
       def to_hash
         hash = attributes_hash.dup
-        unless subspecs.empty?
-          hash["subspecs"] = subspecs.map { |spec| spec.to_hash }
+        if root? || available_platforms != parent.available_platforms
+          platforms = Hash[available_platforms.map { |p| [p.name.to_s, p.deployment_target && p.deployment_target.to_s] }]
+          hash['platforms'] = platforms
         end
-        hash
-      end
+        specs_by_type = subspecs.group_by(&:spec_type)
+        all_appspecs = specs_by_type[:app] || []
+        all_testspecs = specs_by_type[:test] || []
+        all_subspecs = specs_by_type[:library] || []
 
-      # @return [Bool] Whether the specification can be converted to a hash
-      #         without loss of information.
-      #
-      def safe_to_hash?
-        pre_install_callback.nil? && post_install_callback.nil?
+        hash.delete('testspecs')
+        hash['testspecs'] = all_testspecs.map(&:to_hash) unless all_testspecs.empty?
+        hash.delete('appspecs')
+        hash['appspecs'] = all_appspecs.map(&:to_hash) unless all_appspecs.empty?
+        hash.delete('subspecs')
+        hash['subspecs'] = all_subspecs.map(&:to_hash) unless all_subspecs.empty?
+
+        # Since CocoaPods 1.7 version the DSL has changed to be pluralized. When we serialize a podspec to JSON with
+        # 1.7, ensure that we also include the singular version in the hash to maintain backwards compatibility with
+        # < 1.7 versions. We also delete this key and re-add it to ensure it gets added at the end.
+        hash.delete('swift_version')
+        hash['swift_version'] = swift_version.to_s unless swift_version.nil?
+
+        hash
       end
     end
 
@@ -38,33 +56,56 @@ module Pod
     #
     # @return [Specification] the specification
     #
-    def self.from_json(json)
+    def self.from_json(json, path="")
       require 'json'
-      hash = JSON.parse(json)
-      from_hash(hash)
+      begin
+        hash = JSON.parse(json)
+        from_hash(hash)
+      rescue JSON::ParserError => e
+        if path != ""
+          raise e.class, "Failed to parse JSON at file: '#{path}'.\n\n#{e.message}"
+        else raise
+        end
+      end      
     end
 
     # Configures a new specification from the given hash.
     #
-    # @param  [Hash] the hash which contains the information of the
+    # @param  [Hash] hash the hash which contains the information of the
     #         specification.
     #
+    # @param  [Specification] parent the parent of the specification unless the
+    #         specification is a root.
+    #
     # @return [Specification] the specification
     #
-    def self.from_hash(hash, parent = nil)
-      spec = Spec.new(parent)
+    def self.from_hash(hash, parent = nil, test_specification: false, app_specification: false)
       attributes_hash = hash.dup
+      spec = Spec.new(parent, nil, test_specification, :app_specification => app_specification)
       subspecs = attributes_hash.delete('subspecs')
+      testspecs = attributes_hash.delete('testspecs')
+      appspecs = attributes_hash.delete('appspecs')
+
+      ## backwards compatibility with 1.3.0
+      spec.test_specification = !attributes_hash['test_type'].nil?
+
       spec.attributes_hash = attributes_hash
-      if subspecs
-        spec.subspecs = subspecs.map do |s_hash|
-          Specification.from_hash(s_hash, spec)
-        end
-      end
+      spec.subspecs.concat(subspecs_from_hash(spec, subspecs, false, false))
+      spec.subspecs.concat(subspecs_from_hash(spec, testspecs, true, false))
+      spec.subspecs.concat(subspecs_from_hash(spec, appspecs, false, true))
+
       spec
     end
 
-    #-----------------------------------------------------------------------#
+    def self.subspecs_from_hash(spec, subspecs, test_specification, app_specification)
+      return [] if subspecs.nil?
+      subspecs.map do |s_hash|
+        Specification.from_hash(s_hash, spec,
+                                :test_specification => test_specification,
+                                :app_specification => app_specification)
+      end
+    end
 
+    #-----------------------------------------------------------------------#
   end
 end

data/lib/cocoapods-core/specification/linter/analyzer.rb

@@ -0,0 +1,218 @@
+require 'cocoapods-core/specification/linter/result'
+
+module Pod
+  class Specification
+    class Linter
+      class Analyzer
+        def initialize(consumer, results)
+          @consumer = consumer
+          @results = results
+          @results.consumer = @consumer
+        end
+
+        # Analyzes the consumer adding a {Result} for any failed check to
+        # the {#results} object.
+        #
+        # @return [Results] the results of the analysis.
+        #
+        def analyze
+          check_attributes
+          validate_file_patterns
+          check_if_spec_is_empty
+          results
+        end
+
+        private
+
+        attr_reader :consumer
+
+        attr_reader :results
+
+        # @return [Array<String>] Keys that are valid but have been deprecated.
+        #
+        DEPRECATED_KEYS = ['swift_version'].freeze
+
+        # @return [Array<String>] Keys that are only used for internal purposes.
+        #
+        INTERNAL_KEYS = ['configuration_pod_whitelist'].freeze
+
+        # Checks the attributes hash for any unknown key which might be the
+        # result of a misspelling in a JSON file.
+        #
+        # @note Sub-keys are not checked per-platform as
+        #       there is no attribute supporting this combination.
+        #
+        # @note The keys of sub-keys are not checked as they are only used by
+        #       the `source` attribute and they are subject
+        #       to change according to the support in the
+        #       `cocoapods-downloader` gem.
+        #
+        def check_attributes
+          attributes_keys = Pod::Specification::DSL.attributes.keys.map(&:to_s)
+          platform_keys = Specification::DSL::PLATFORMS.map(&:to_s)
+          valid_keys = attributes_keys + platform_keys + DEPRECATED_KEYS + INTERNAL_KEYS
+          attributes_hash = consumer.spec.attributes_hash
+          keys = attributes_hash.keys
+          Specification::DSL::PLATFORMS.each do |platform|
+            if attributes_hash[platform.to_s]
+              keys += attributes_hash[platform.to_s].keys
+            end
+          end
+          unknown_keys = keys - valid_keys
+
+          unknown_keys.each do |key|
+            results.add_warning('attributes', "Unrecognized `#{key}` key.")
+          end
+
+          Pod::Specification::DSL.attributes.each do |_key, attribute|
+            declared_value = consumer.spec.attributes_hash[attribute.name.to_s]
+            validate_attribute_occurrence(attribute, declared_value)
+            validate_attribute_type(attribute, declared_value)
+            if attribute.name != :platforms
+              value = value_for_attribute(attribute)
+              validate_attribute_value(attribute, value) if value
+            end
+          end
+        end
+
+        # Checks the attributes that represent file patterns.
+        #
+        # @todo Check the attributes hash directly.
+        #
+        def validate_file_patterns
+          attributes = DSL.attributes.values.select(&:file_patterns?)
+          attributes.each do |attrb|
+            patterns = consumer.send(attrb.name)
+
+            if patterns.is_a?(Hash)
+              patterns = patterns.values.flatten(1)
+            end
+
+            if patterns.respond_to?(:each)
+              patterns.each do |pattern|
+                pattern = pattern[:paths].join if attrb.name == :on_demand_resources
+                if pattern.respond_to?(:start_with?) && pattern.start_with?('/')
+                  results.add_error('File Patterns', 'File patterns must be ' \
+                    "relative and cannot start with a slash (#{attrb.name}).")
+                end
+              end
+            end
+          end
+        end
+
+        # Check empty subspec attributes
+        #
+        def check_if_spec_is_empty
+          methods = %w( source_files on_demand_resources resources resource_bundles preserve_paths
+                        dependencies vendored_libraries vendored_frameworks )
+          empty_patterns = methods.all? { |m| consumer.send(m).empty? }
+          empty = empty_patterns && consumer.spec.subspecs.empty?
+          if empty
+            results.add_error('File Patterns', "The #{consumer.spec} spec is " \
+              'empty (no source files, resources, resource_bundles, ' \
+              'preserve paths, vendored_libraries, vendored_frameworks, ' \
+              'dependencies, nor subspecs).')
+          end
+        end
+
+        private
+
+        # Returns the own or inherited (if applicable) value of the
+        # given attribute.
+        #
+        # @param  [Spec::DSL::Attribute] attribute
+        #         The attribute.
+        #
+        # @return [mixed]
+        #
+        def value_for_attribute(attribute)
+          if attribute.root_only?
+            consumer.spec.send(attribute.name)
+          else
+            consumer.send(attribute.name) if consumer.respond_to?(attribute.name)
+          end
+        rescue => e
+          results.add_error('attributes', "Unable to validate `#{attribute.name}` (#{e}).")
+          nil
+        end
+
+        # Validates that root attributes don't occur in subspecs.
+        #
+        # @param  [Spec::DSL::Attribute] attribute
+        #         The attribute.
+
+        # @param  [Object] value
+        #         The value of the attribute.
+        #
+        def validate_attribute_occurrence(attribute, value)
+          if attribute.root_only? && !value.nil? && !consumer.spec.root?
+            results.add_error('attributes', "Can't set `#{attribute.name}` attribute for " \
+              "subspecs (in `#{consumer.spec.name}`).")
+          end
+          if attribute.test_only? && !value.nil? && !consumer.spec.test_specification?
+            results.add_error('attributes', "Attribute `#{attribute.name}` can only be set " \
+              "within test specs (in `#{consumer.spec.name}`).")
+          end
+        end
+
+        # Validates the given value for the given attribute.
+        #
+        # @param  [Spec::DSL::Attribute] attribute
+        #         The attribute.
+        #
+        # @param  [Object] value
+        #         The value of the attribute.
+        #
+        def validate_attribute_value(attribute, value)
+          if attribute.keys.is_a?(Array)
+            validate_attribute_array_keys(attribute, value)
+          elsif attribute.keys.is_a?(Hash)
+            validate_attribute_hash_keys(attribute, value)
+          end
+        end
+
+        def validate_attribute_type(attribute, value)
+          return unless value
+          types = attribute.supported_types
+          if types.none? { |klass| value.class == klass }
+            results.add_error('attributes', 'Unacceptable type ' \
+              "`#{value.class}` for `#{attribute.name}`. Allowed values: `#{types.inspect}`.")
+          end
+        end
+
+        def validate_attribute_array_keys(attribute, value)
+          unknown_keys = value.keys.map(&:to_s) - attribute.keys.map(&:to_s)
+          unknown_keys.each do |unknown_key|
+            results.add_warning('keys', "Unrecognized `#{unknown_key}` key for " \
+              "`#{attribute.name}` attribute.")
+          end
+        end
+
+        def validate_attribute_hash_keys(attribute, value)
+          unless value.is_a?(Hash)
+            results.add_error(attribute.name, "Unsupported type `#{value.class}`, expected `Hash`")
+            return
+          end
+          major_keys = value.keys & attribute.keys.keys
+          if major_keys.count.zero?
+            results.add_warning('keys', "Missing primary key for `#{attribute.name}` " \
+              'attribute. The acceptable ones are: ' \
+              "`#{attribute.keys.keys.map(&:to_s).sort.join(', ')}`.")
+          elsif major_keys.count == 1
+            acceptable = attribute.keys[major_keys.first] || []
+            unknown = value.keys - major_keys - acceptable
+            unless unknown.empty?
+              results.add_warning('keys', "Incompatible `#{unknown.sort.join(', ')}` " \
+                "key(s) with `#{major_keys.first}` primary key for " \
+                "`#{attribute.name}` attribute.")
+            end
+          else
+            sorted_keys = major_keys.map(&:to_s).sort
+            results.add_warning('keys', "Incompatible `#{sorted_keys.join(', ')}` " \
+              "keys for `#{attribute.name}` attribute.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cocoapods-core/specification/linter/result.rb

@@ -0,0 +1,128 @@
+module Pod
+  class Specification
+    class Linter
+      class Results
+        public
+
+        class Result
+          # @return [Symbol] the type of result.
+          #
+          attr_reader :type
+
+          # @return[String] the name of the attribute associated with result.
+          #
+          attr_reader :attribute_name
+
+          # @return [String] the message associated with result.
+          #
+          attr_reader :message
+
+          # @return [Boolean] whether the result only applies to public specs.
+          #
+          attr_reader :public_only
+          alias_method :public_only?, :public_only
+
+          # @param [Symbol] type    @see type
+          # @param [String] message @see message
+          #
+          def initialize(type, attribute_name, message, public_only = false)
+            @type = type
+            @attribute_name = attribute_name
+            @message = message
+            @public_only = public_only
+            @platforms = []
+          end
+
+          # @return [Array<Platform>] the platforms where this result was
+          #         generated.
+          #
+          attr_reader :platforms
+
+          # @return [String] a string representation suitable for UI output.
+          #
+          def to_s
+            r = "[#{type.to_s.upcase}] [#{attribute_name}] #{message}"
+            if platforms != Specification::PLATFORMS
+              platforms_names = platforms.uniq.map do |p|
+                Platform.string_name(p)
+              end
+              r << " [#{platforms_names * ' - '}]" unless platforms.empty?
+            end
+            r
+          end
+        end
+
+        def initialize
+          @results = []
+          @consumer = nil
+        end
+
+        include Enumerable
+
+        def each
+          results.each { |r| yield r }
+        end
+
+        def empty?
+          results.empty?
+        end
+
+        # @return [Specification::Consumer] the current consumer.
+        #
+        attr_accessor :consumer
+
+        # Adds an error result with the given message.
+        #
+        # @param  [String] message
+        #         The message of the result.
+        #
+        # @return [void]
+        #
+        def add_error(attribute_name, message, public_only = false)
+          add_result(:error, attribute_name, message, public_only)
+        end
+
+        # Adds a warning result with the given message.
+        #
+        # @param  [String] message
+        #         The message of the result.
+        #
+        # @return [void]
+        #
+        def add_warning(attribute_name, message, public_only = false)
+          add_result(:warning, attribute_name, message, public_only)
+        end
+
+        private
+
+        # @return [Array<Result>] all of the generated results.
+        #
+        attr_reader :results
+
+        # Adds a result of the given type with the given message. If there is a
+        # current platform it is added to the result. If a result with the same
+        # type and the same message is already available the current platform is
+        # added to the existing result.
+        #
+        # @param  [Symbol] type
+        #         The type of the result (`:error`, `:warning`).
+        #
+        # @param  [String] message
+        #         The message of the result.
+        #
+        # @return [void]
+        #
+        def add_result(type, attribute_name, message, public_only)
+          result = results.find do |r|
+            r.type == type && r.attribute_name == attribute_name && r.message == message && r.public_only? == public_only
+          end
+          unless result
+            result = Result.new(type, attribute_name, message, public_only)
+            results << result
+          end
+          result.platforms << @consumer.platform_name if @consumer
+        end
+      end
+    end
+  end
+end