cocoapods-catalyst-validator 0.1.0.beta.1

data/examples/AExample/Pods/nanopb/pb_encode.h

@@ -0,0 +1,170 @@
+/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
+ * The main function is pb_encode. You also need an output stream, and the
+ * field descriptions created by nanopb_generator.py.
+ */
+
+#ifndef PB_ENCODE_H_INCLUDED
+#define PB_ENCODE_H_INCLUDED
+
+#include "pb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Structure for defining custom output streams. You will need to provide
+ * a callback function to write the bytes to your storage, which can be
+ * for example a file or a network socket.
+ *
+ * The callback must conform to these rules:
+ *
+ * 1) Return false on IO errors. This will cause encoding to abort.
+ * 2) You can use state to store your own data (e.g. buffer pointer).
+ * 3) pb_write will update bytes_written after your callback runs.
+ * 4) Substreams will modify max_size and bytes_written. Don't use them
+ *    to calculate any pointers.
+ */
+struct pb_ostream_s
+{
+#ifdef PB_BUFFER_ONLY
+    /* Callback pointer is not used in buffer-only configuration.
+     * Having an int pointer here allows binary compatibility but
+     * gives an error if someone tries to assign callback function.
+     * Also, NULL pointer marks a 'sizing stream' that does not
+     * write anything.
+     */
+    int *callback;
+#else
+    bool (*callback)(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
+#endif
+    void *state;          /* Free field for use by callback implementation. */
+    size_t max_size;      /* Limit number of output bytes written (or use SIZE_MAX). */
+    size_t bytes_written; /* Number of bytes written so far. */
+    
+#ifndef PB_NO_ERRMSG
+    const char *errmsg;
+#endif
+};
+
+/***************************
+ * Main encoding functions *
+ ***************************/
+
+/* Encode a single protocol buffers message from C structure into a stream.
+ * Returns true on success, false on any failure.
+ * The actual struct pointed to by src_struct must match the description in fields.
+ * All required fields in the struct are assumed to have been filled in.
+ *
+ * Example usage:
+ *    MyMessage msg = {};
+ *    uint8_t buffer[64];
+ *    pb_ostream_t stream;
+ *
+ *    msg.field1 = 42;
+ *    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ */
+bool pb_encode(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+/* Same as pb_encode, but prepends the length of the message as a varint.
+ * Corresponds to writeDelimitedTo() in Google's protobuf API.
+ */
+bool pb_encode_delimited(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+/* Same as pb_encode, but appends a null byte to the message for termination.
+ * NOTE: This behaviour is not supported in most other protobuf implementations, so pb_encode_delimited()
+ * is a better option for compatibility.
+ */
+bool pb_encode_nullterminated(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+/* Encode the message to get the size of the encoded data, but do not store
+ * the data. */
+bool pb_get_encoded_size(size_t *size, const pb_field_t fields[], const void *src_struct);
+
+/**************************************
+ * Functions for manipulating streams *
+ **************************************/
+
+/* Create an output stream for writing into a memory buffer.
+ * The number of bytes written can be found in stream.bytes_written after
+ * encoding the message.
+ *
+ * Alternatively, you can use a custom stream that writes directly to e.g.
+ * a file or a network socket.
+ */
+pb_ostream_t pb_ostream_from_buffer(pb_byte_t *buf, size_t bufsize);
+
+/* Pseudo-stream for measuring the size of a message without actually storing
+ * the encoded data.
+ * 
+ * Example usage:
+ *    MyMessage msg = {};
+ *    pb_ostream_t stream = PB_OSTREAM_SIZING;
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ *    printf("Message size is %d\n", stream.bytes_written);
+ */
+#ifndef PB_NO_ERRMSG
+#define PB_OSTREAM_SIZING {0,0,0,0,0}
+#else
+#define PB_OSTREAM_SIZING {0,0,0,0}
+#endif
+
+/* Function to write into a pb_ostream_t stream. You can use this if you need
+ * to append or prepend some custom headers to the message.
+ */
+bool pb_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
+
+
+/************************************************
+ * Helper functions for writing field callbacks *
+ ************************************************/
+
+/* Encode field header based on type and field number defined in the field
+ * structure. Call this from the callback before writing out field contents. */
+bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_t *field);
+
+/* Encode field header by manually specifying wire type. You need to use this
+ * if you want to write out packed arrays from a callback field. */
+bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
+
+/* Encode an integer in the varint format.
+ * This works for bool, enum, int32, int64, uint32 and uint64 field types. */
+#ifndef PB_WITHOUT_64BIT
+bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
+#else
+bool pb_encode_varint(pb_ostream_t *stream, uint32_t value);
+#endif
+
+/* Encode an integer in the zig-zagged svarint format.
+ * This works for sint32 and sint64. */
+#ifndef PB_WITHOUT_64BIT
+bool pb_encode_svarint(pb_ostream_t *stream, int64_t value);
+#else
+bool pb_encode_svarint(pb_ostream_t *stream, int32_t value);
+#endif
+
+/* Encode a string or bytes type field. For strings, pass strlen(s) as size. */
+bool pb_encode_string(pb_ostream_t *stream, const pb_byte_t *buffer, size_t size);
+
+/* Encode a fixed32, sfixed32 or float value.
+ * You need to pass a pointer to a 4-byte wide C variable. */
+bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
+
+#ifndef PB_WITHOUT_64BIT
+/* Encode a fixed64, sfixed64 or double value.
+ * You need to pass a pointer to a 8-byte wide C variable. */
+bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
+#endif
+
+/* Encode a submessage field.
+ * You need to pass the pb_field_t array and pointer to struct, just like
+ * with pb_encode(). This internally encodes the submessage twice, first to
+ * calculate message size and then to actually write it out.
+ */
+bool pb_encode_submessage(pb_ostream_t *stream, const pb_field_t fields[], const void *src_struct);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/lib/cocoapods-catalyst-validator/cocoapods-catalyst-validator.rb

@@ -0,0 +1,110 @@
+require 'cocoapods-catalyst-validator/gem_version'
+require 'cocoapods-core'
+require 'cocoapods'
+require 'macho'
+
+
+module CocoapodsCatalystValidator
+  CATALYST_PLATFORM = 6
+  SUPPORTS_MACCATALYST = 'SUPPORTS_MACCATALYST'
+
+  class CatalystValidator
+    def self.support_catalust_for_xcframework?(path)
+      !Pathname.glob(path + '*-maccatalyst').empty?
+    end
+
+    def self.support_catalust_for_framework?(path)
+      path += '.framework' unless path.extname == '.framework'
+      name = path.basename(".framework")
+      support_catalyst?(path + name)
+    end
+
+    def self.support_catalust_for_library?(path)
+      support_catalyst?(path)
+    end
+
+    def self.support_catalyst?(path)
+      !binary_arch(path).map {|a| platform_is_catalyst?(path, a)}.include?(false)
+    end
+
+    def self.binary_arch(path)
+      `lipo -archs "#{path}"`.split(' ')
+    end
+
+    def self.platform_is_catalyst?(path, arch)
+      platform = `otool -l -arch #{arch} "#{path}" | grep platform -m 1`
+      return false unless platform =~ /platform\s+(\w*)/
+      return ['MACCATALYST', '1'].include?(platform.match(/platform\s+(\w*)/)[1])
+    end
+
+  end
+end
+
+module Pod
+  class Podfile
+    def use_catalyst_verify!(type = :warning)
+      current_target_definition.use_catalyst_verify!(type)
+    end
+
+    class TargetDefinition
+      attr_accessor :catalyst_verification
+
+      def use_catalyst_verify!(type = :warning)
+        unless [:warning, :error].include?(type)
+          raise Informative, "Unsupported catalyst verify type '#{type}', must be :warning or :error."
+        end
+        @catalyst_verification = type
+      end
+
+      def catalyst_verification
+        if root?
+          @catalyst_verification
+        else
+          @catalyst_verification || parent.catalyst_verification
+        end
+      end
+    end
+  end
+
+  class Installer
+    class Xcode
+      class TargetValidator
+        alias_method :original_validate!, :validate!
+        def validate!
+          original_validate!
+          verify_pods_vendored_artifacts_support_catalyst
+        end
+        def verify_pods_vendored_artifacts_support_catalyst
+          libs_cache = {}
+          aggregate_targets.each do |aggregate_target|
+            catalyst_verification = aggregate_target.target_definition.catalyst_verification
+            next unless [:warning, :error].include?(catalyst_verification)
+            next unless aggregate_target.platform.name == :ios
+            aggregate_target.user_targets.each do |user_target|
+              user_target.build_configurations.each do |config|
+                next unless config.build_settings[CocoapodsCatalystValidator::SUPPORTS_MACCATALYST]
+                pod_targets = aggregate_target.pod_targets_for_build_configuration(config.name)
+                verify_libraries = pod_targets.flat_map(&:file_accessors).flat_map(&:vendored_libraries)
+                verify_xcframeworks = pod_targets.flat_map(&:file_accessors).flat_map(&:vendored_xcframeworks)
+                verify_frameworks = pod_targets.flat_map(&:file_accessors).flat_map(&:vendored_frameworks) - verify_xcframeworks
+                un_support_catalyst_libs = verify_libraries.reject{ |l| libs_cache[l] ||= CocoapodsCatalystValidator::CatalystValidator.support_catalust_for_library?(l)}
+                un_support_catalyst_libs.concat verify_frameworks.reject{ |f| libs_cache[f] ||= CocoapodsCatalystValidator::CatalystValidator.support_catalust_for_framework?(f)}
+                un_support_catalyst_libs.concat verify_xcframeworks.reject{ |x| libs_cache[x] ||= CocoapodsCatalystValidator::CatalystValidator.support_catalust_for_xcframework?(x)}
+                unsupport_names = un_support_catalyst_libs.map(&:basename).map(&:to_s)
+                next if unsupport_names.empty?
+                case catalyst_verification
+                when :warning
+                  UI.puts "Catalyst verify warning: \n#{unsupport_names}".yellow
+                else :error
+                  raise Informative, "Catalyst verify error: \n#{unsupport_names}"
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/lib/cocoapods-catalyst-validator/gem_version.rb

@@ -0,0 +1,3 @@
+module CocoapodsCatalystValidator
+  VERSION = "0.1.0.beta.1"
+end

data/lib/cocoapods_plugin.rb

@@ -0,0 +1,3 @@
+require 'cocoapods-catalyst-validator/cocoapods-catalyst-validator'
+
+

data/spec/command/validator_spec.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+module Pod
+  describe Command::Validator do
+    describe 'CLAide' do
+      it 'registers it self' do
+        Command.parse(%w{ validator }).should.be.instance_of Command::Validator
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'pathname'
+ROOT = Pathname.new(File.expand_path('../../', __FILE__))
+$:.unshift((ROOT + 'lib').to_s)
+$:.unshift((ROOT + 'spec').to_s)
+
+require 'bundler/setup'
+require 'bacon'
+require 'mocha-on-bacon'
+require 'pretty_bacon'
+require 'pathname'
+require 'cocoapods'
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)
+
+require 'cocoapods_plugin'
+
+#-----------------------------------------------------------------------------#
+
+module Pod
+
+  # Disable the wrapping so the output is deterministic in the tests.
+  #
+  UI.disable_wrap = true
+
+  # Redirects the messages to an internal store.
+  #
+  module UI
+    @output = ''
+    @warnings = ''
+
+    class << self
+      attr_accessor :output
+      attr_accessor :warnings
+
+      def puts(message = '')
+        @output << "#{message}\n"
+      end
+
+      def warn(message = '', actions = [])
+        @warnings << "#{message}\n"
+      end
+
+      def print(message)
+        @output << message
+      end
+    end
+  end
+end
+
+#-----------------------------------------------------------------------------#