cocoapods-hmap-prebuilt 0.0.2 → 0.0.3

data/lib/cocoapods-hmap-prebuilt/hmap_helper.rb

@@ -1,85 +0,0 @@
-
-require 'cocoapods'
-
-module HMap
-  # A collection of Helper functions used throughout cocoapods-hmap-prebuilt.
-  module Helper
-    # A collection of PodHelper functions used throughout cocoapods-hmap-prebuilt.
-    module PodHelper
-      HEADER_EXTENSIONS = Pod::Sandbox::FileAccessor::HEADER_EXTENSIONS
-      
-      def self.pod_analyze(config)
-        podfile = Pod::Podfile.from_file(config.podfile_path)
-        lockfile = Pod::Lockfile.from_file(config.lockfile_path)
-        Pod::Installer::Analyzer.new(config.sandbox, podfile, lockfile).analyze
-      end
-
-      # @!group Private helpers
-
-      # Returns the list of the paths founds in the file system for the
-      # attribute with given name. It takes into account any dir pattern and
-      # any file excluded in the specification.
-      #
-      # @param  [Symbol] attribute
-      #         the name of the attribute.
-      #
-      # @return [Array<Pathname>] the paths.
-      #
-      def self.paths_for_attribute(key, attribute, include_dirs: false)
-        file_patterns = key.spec_consumer.send(attribute)
-        options = {
-          exclude_patterns: key.spec_consumer.exclude_files,
-          dir_pattern: Pod::Sandbox::FileAccessor::GLOB_PATTERNS[attribute],
-          include_dirs: include_dirs
-        }
-        extensions = HEADER_EXTENSIONS
-        key.path_list.relative_glob(file_patterns, options).map do |f|
-          [f, key.path_list.root.join(f)] if extensions.include?(f.extname)
-        end.compact
-      end
-
-      def self.header_mappings(file_accessor, headers, target)
-        consumer = file_accessor.spec_consumer
-        header_mappings_dir = consumer.header_mappings_dir
-        dir = target.headers_sandbox
-        dir_h = Pathname.new(target.product_module_name)
-        dir += consumer.header_dir if consumer.header_dir
-        mappings = {}
-        headers.each do |header|
-          next if header.to_s.include?('.framework/')
-
-          sub_dir = [dir, dir_h]
-          if header_mappings_dir
-            relative_path = header.relative_path_from(file_accessor.path_list.root + header_mappings_dir)
-            sub_dir << dir + relative_path.dirname
-            sub_dir << dir_h + relative_path.dirname
-          else
-            relative_path = header.relative_path_from(file_accessor.path_list.root)
-            sub_dir << relative_path.dirname
-          end
-          mappings[header] ||= []
-          sub_dir.uniq.each do |d|
-            mappings[header] << d + header.basename
-          end
-          mappings[header] << header.basename
-        end
-        mappings
-      end
-
-      def self.pod_target_source_header(target, hmap_t)
-        target.header_mappings_by_file_accessor.keys.flat_map do |key|
-          paths_for_attribute(key, hmap_t)
-        end
-      end
-
-      def self.pod_target_source_header_map(target, hmap_t)
-        pod_target_source_header(target, hmap_t).each_with_object({}) do |f, sum|
-          file = f[1]
-          key = f[0].to_s
-          r_key = file.basename.to_s
-          sum[r_key] = [key, r_key].uniq
-        end
-      end
-    end
-  end
-end

data/lib/cocoapods-hmap-prebuilt/hmap_struct.rb

@@ -1,264 +0,0 @@
-
-module HMap
-    HEADER_CONST = {
-      HMAP_HEADER_MAGIC_NUMBER: 0x686d6170,
-      HMAP_HEADER_VERSION: 0x0001,
-      HMAP_EMPTY_BUCKT_KEY: 0,
-      HMAP_SWAPPED_MAGIC: 0x70616d68,
-      HMAP_SWAPPED_VERSION: 0x0100
-    }.freeze
-  
-    # A general purpose pseudo-structure.
-    # @abstract
-    class HMapStructure
-      # The String#unpack format of the data structure.
-      # @return [String] the unpacking format
-      # @api private
-      FORMAT = ''
-  
-      # The size of the data structure, in bytes.
-      # @return [Integer] the size, in bytes
-      # @api private
-      SIZEOF = 0
-  
-      SWAPPED = true
-  
-      # @return [Integer] the size, in bytes, of the represented structure.
-      def self.bytesize
-        self::SIZEOF
-      end
-  
-      def self.format
-        self::FORMAT
-      end
-  
-      def self.swapped?
-        self::SWAPPED
-      end
-  
-      # @param swapped [Bool] the swapped of the mapfile
-      # @param bin [String] the string to be unpacked into the new structure
-      # @return [HMap::HMapStructure] the resulting structure
-      # @api private
-      def self.new_from_bin(swapped, bin)
-        format = Utils.specialize_format(self::FORMAT, swapped)
-        new(*bin.unpack(format))
-      end
-  
-      def serialize
-        [].pack(format)
-      end
-  
-      # @return [Hash] a hash representation of this {HMapStructure}.
-      def to_h
-        {
-          'structure' => {
-            'format' => self.class::FORMAT,
-            'bytesize' => self.class.bytesize
-          }
-        }
-      end
-    end
-  
-    # HMapHeader structure.
-    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
-    # @abstract
-    class HMapHeader < HMapStructure
-      # @return [HMap::HMapView, nil] the raw view associated with the load command,
-      # or nil if the HMapHeader was created via {create}.
-      attr_reader :num_entries, :magic, :version, :reserved, :strings_offset, :num_buckets, :max_value_length
-  
-      FORMAT = 'L=1S=2L4'
-      # @see HMapStructure::SIZEOF
-      # @api private
-      SIZEOF = 24
-  
-      # @api private
-      def initialize(magic, version, reserved, strings_offset, num_entries, num_buckets, max_value_length)
-        @magic = magic
-        @version = version
-        @reserved = reserved
-        @strings_offset = strings_offset
-        @num_entries = num_entries
-        @num_buckets = num_buckets
-        @max_value_length = max_value_length
-        super()
-      end
-  
-      # @return [String] the serialized fields of the mafile
-      def serialize
-        format = Utils.specialize_format(FORMAT, SWAPPED)
-        [magic, version, reserved, strings_offset, num_entries, num_buckets, max_value_length].pack(format)
-      end
-  
-      def description
-        <<-DESC
-          Hash bucket count: #{@num_buckets}
-          String table entry count: #{@num_entries}
-          Max value length: #{@max_value_length}
-        DESC
-      end
-  
-      def to_h
-        {
-          'magic' => magic,
-          'version' => version,
-          'reserved' => reserved,
-          'strings_offset' => strings_offset,
-          'num_entries' => num_entries,
-          'num_buckets' => num_buckets,
-          'max_value_length' => max_value_length
-        }.merge super
-      end
-    end
-  
-    # HMapBucketStr => HMapBucket.
-    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
-    # @abstract
-    class HMapBucketStr
-      attr_reader :uuid, :key, :perfix, :suffix
-  
-      def initialize(key, perfix, suffix)
-        @uuid = Utils.string_downcase_hash(key)
-        @key = key
-        @perfix = perfix
-        @suffix = suffix
-        @str_ins = {}
-      end
-  
-      def bucket_to_string(headers, index)
-        bucket = [key, perfix, suffix]
-        bucket.inject('') do |sum, arg|
-          if headers[arg].nil?
-            headers[arg] = sum.length + index
-            sum += "#{Utils.safe_encode(arg, 'ASCII-8BIT')}\0"
-          end
-          @str_ins[arg] = headers[arg]
-          sum
-        end
-      end
-  
-      def bucket
-        HMapBucket.new(@str_ins[@key], @str_ins[@perfix], @str_ins[@suffix])
-      end
-  
-      # @return [String] the serialized fields of the mafile
-      def serialize
-        bucket.serialize
-      end
-  
-      def description
-        <<-DESC
-          Key #{@key} -> Prefix #{@perfix}, Suffix #{@suffix}
-        DESC
-      end
-  
-      def to_h
-        {
-          'key' => { 'index' => str_ins[@key], 'key' => @key },
-          'perfix' => { 'index' => str_ins[@perfix], 'perfix' => @perfix },
-          'suffix' => { 'index' => str_ins[@suffix], 'suffix' => @suffix }
-        }
-      end
-    end
-  
-    # HMapBucket structure.
-    # @see https://clang.llvm.org/doxygen/structclang_1_1HMapHeader.html
-    # @abstract
-    class HMapBucket < HMapStructure
-      attr_accessor :key, :perfix, :suffix
-  
-      SIZEOF = 12
-
-      FORMAT = 'L=3'
-  
-      def initialize(key, perfix, suffix)
-        @key = key
-        @perfix = perfix
-        @suffix = suffix
-        super()
-      end
-  
-      # @return [String] the serialized fields of the mafile
-      def serialize
-        format = Utils.specialize_format(FORMAT, SWAPPED)
-        [key, perfix, suffix].pack(format)
-      end
-  
-      def to_a
-        [key, perfix, suffix]
-      end
-  
-      def to_h
-        {
-          'key' => key,
-          'perfix' => perfix,
-          'suffix' => suffix
-        }.merge super
-      end
-    end
-  
-    # HMap blobs.
-    class HMapData
-      def initialize(buckets)
-        super()
-        count = buckets.count
-        nums = num_buckets(count, Utils.next_power_of_two(count))
-        entries = entries(count, nums)
-        @header = populate_hmap_header(nums, entries)
-        @buckets = add_bucket(buckets, nums)
-      end
-      
-      def num_buckets(count, pow2)
-        if count < 8
-          pow2 <<= 1 if count * 4 >= pow2 * 3
-          pow2 < 8 ? 8 : pow2
-        else
-          index = count > 341 ? 2 : -3
-          padding = count / 85 % 7 + index
-          Utils.next_power_of_two(count * 3 + padding)
-        end
-      end
-  
-      def entries(count, nums)
-        return count if nums == 8
-  
-        last_pow = nums >> 1
-        index = last_pow < 1024 ? 3 : -2
-        count - (last_pow + 1 + index) / 3 + 1 + last_pow
-      end
-  
-      # @return [String] the serialized fields of the mafile
-      def serialize
-        @header.serialize + @buckets.inject('') do |sum, bucket|
-          sum += if bucket.nil?
-                    empty_b = [HEADER_CONST[:HMAP_EMPTY_BUCKT_KEY]]*3
-                    empty_b.pack('L<3')
-                 else
-                   bucket
-                 end
-          sum
-        end
-      end
-  
-      def add_bucket(buckets, num)
-        buckets.each_with_object(Array.new(num)) do |bucket, sum|
-          serialize = bucket.serialize
-          i = Utils.index_of_range(bucket.uuid, num)
-          loop do
-            sum[i] = serialize if sum[i].nil?
-            break if serialize == sum[i]
-  
-            i = Utils.index_of_range(i += 1, num)
-          end
-        end
-      end
-  
-      def populate_hmap_header(num_buckets, entries)
-        strings_offset = HMapHeader.bytesize + HMapBucket.bytesize * num_buckets
-        HMapHeader.new(HEADER_CONST[:HMAP_HEADER_MAGIC_NUMBER],
-                       HEADER_CONST[:HMAP_HEADER_VERSION], 0, strings_offset, entries, num_buckets, 0)
-      end
-    end
-  end
-  

data/lib/cocoapods-hmap-prebuilt/hmap_utils.rb

@@ -1,136 +0,0 @@
-require 'cocoapods'
-
-module HMap
-  # A collection of utility functions used throughout cocoapods-hmap-prebuilt.
-  module Utils
-    HEADER_EXTENSIONS = Pod::Sandbox::FileAccessor::HEADER_EXTENSIONS
-
-    def self.index_of_range(num, range)
-      num &= range - 1
-      num
-    end
-
-    def self.power_of_two?(num)
-      num != 0 && (num & (num - 1)).zero?
-    end
-
-    def self.next_power_of_two(num)
-      num |= (num >> 1)
-      num |= (num >> 2)
-      num |= (num >> 4)
-      num |= (num >> 8)
-      num |= (num >> 16)
-      num |= (num >> 32)
-      num + 1
-    end
-
-    def self.hash_set_value(hash, *args)
-      args.each do |arg|
-        hash.merge(arg)
-      end
-      hash
-    end
-
-    def self.specialize_format(format, swapped)
-      modifier = swapped ? '<' : '>'
-      format.tr('=', modifier)
-    end
-
-    def self.string_downcase_hash(str)
-      str.downcase.bytes.inject(0) do |sum, value|
-        sum += value * 13
-        sum
-      end
-    end
-
-    def self.update_changed_file(path, contents)
-      if path.exist?
-        content_stream = StringIO.new(contents)
-        identical = File.open(path, 'rb') { |f| FileUtils.compare_stream(f, content_stream) }
-        return if identical
-      end
-      path.dirname.mkpath
-      File.open(path, 'w') { |f| f.write(contents) }
-    end
-
-    def self.swapped_magic?(magic, version)
-      magic.eql?(HEADER_CONST[:HMAP_SWAPPED_MAGIC]) && version.eql?(HEADER_CONST[:HMAP_SWAPPED_VERSION])
-    end
-
-    def self.magic?(magic)
-      magic.eql?(HEADER_CONST[:HMAP_SWAPPED_MAGIC]) || magic.eql?(HEADER_CONST[:HMAP_HEADER_MAGIC_NUMBER])
-    end
-
-    def self.safe_encode(string, target_encoding)
-      string.encode(target_encoding)
-    rescue Encoding::InvalidByteSequenceError
-      string.force_encoding(target_encoding)
-    rescue Encoding::UndefinedConversionError
-      string.encode(target_encoding, fallback: lambda { |c|
-        c.force_encoding(target_encoding)
-      })
-    end
-
-    def self.clean_target_build_setting(targets, build_setting)
-      target_xcconfig_path(targets) do |xc|
-        clean_build_setting_to_xcconfig(xc, build_setting)
-      end
-    end
-
-    def self.target_xcconfig_path(targets)
-      targets.each do |target|
-        raise ClassIncludedError.new(target.class, Pod::Target) unless target.is_a?(Pod::Target)
-
-        config_h = Pod::Target.instance_method(:build_settings).bind(target).call
-        config_h.each_key do |configuration_name|
-          xcconfig = target.xcconfig_path(configuration_name)
-          yield(xcconfig) if block_given?
-        end
-      end
-    end
-
-    def self.change_xcconfig_header_search_path(xcconfig, hmap_h, use_headermap: true, save_origin: true)
-      hmap_header_serach_paths = hmap_h.inject('') do |sum, hmap_n|
-        hmap_pod_root_path = "${PODS_ROOT}/Headers/#{HMAP_DIR_NAME}/#{hmap_n}"
-        sum + "\"#{hmap_pod_root_path}\" "
-      end
-      save_build_setting_to_xcconfig(xcconfig, hmap_header_serach_paths, HEAD_SEARCH_PATHS, save_origin: save_origin) do |xc|
-        xc.attributes['USE_HEADERMAP'] = 'NO' unless use_headermap
-      end
-    end
-
-    def self.save_build_setting_to_xcconfig(path, value, build_setting, save_origin: true)
-      xc = Xcodeproj::Config.new(path)
-      save_origin_build_setting = "SAVE_#{build_setting}"
-      hmap_build_setting = "HMAP_PREBUILT_#{build_setting}"
-      origin_build_setting = xc.attributes[build_setting]
-
-      if !origin_build_setting.nil? && !origin_build_setting.include?(hmap_build_setting)
-        xc.attributes[save_origin_build_setting] =
-          origin_build_setting
-      end
-
-      save_origin_build_setting_value = xc.attributes[save_origin_build_setting]
-      value = "#{value} ${#{save_origin_build_setting}}" if save_origin && !save_origin_build_setting_value.nil?
-      xc.attributes[hmap_build_setting] = value
-      xc.attributes[build_setting] = "${#{hmap_build_setting}}"
-      yield(xc) if block_given?
-      xc.save_as(path)
-    end
-
-    def self.clean_build_setting_to_xcconfig(path, build_setting)
-      xc = Xcodeproj::Config.new(path)
-      save_origin_build_setting = "SAVE_#{build_setting}"
-      hmap_build_setting = "HMAP_PREBUILT_#{build_setting}"
-      return if xc.attributes[hmap_build_setting].nil?
-
-      xc.attributes[build_setting] = xc.attributes[save_origin_build_setting]
-      xc.attributes.delete(save_origin_build_setting)
-      xc.attributes.delete(hmap_build_setting)
-      xc.attributes['USE_HEADERMAP'] = 'YES'
-      xc.attributes.delete(build_setting) if xc.attributes[build_setting].nil?
-      xc.save_as(path)
-      puts "\t -xcconfig path: #{path} clean finish."
-    end
-  end
-end