xcres 0.4.0

data/lib/xcres/analyzer/resources_analyzer/base_resources_analyzer.rb

@@ -0,0 +1,133 @@
+require 'xcres/analyzer/analyzer'
+require 'set'
+
+module XCRes
+  module ResourcesAnalyzer
+
+    # A +BaseResourcesAnalyzer+ scans the project for resources,
+    # which should be included in the output file.
+    #
+    class BaseResourcesAnalyzer < Analyzer
+
+      FILTER_WORDS = ['icon', 'image']
+
+      # Get a list of all files in a directory
+      #
+      # @param  [Pathname] dir
+      #         the directory
+      #
+      # @return [Array<Pathname>]
+      #         the file paths relative to the given dir
+      #
+      def find_files_in_dir dir
+        unless dir.exist?
+          warn "Can't find files in dir %s as it doesn't exist!",
+            dir.relative_path_from(project.path + '..').to_s
+          return []
+        end
+        Dir.chdir dir do
+          Dir['**/*'].map { |path| Pathname(path) }
+        end
+      end
+
+      # Build a section for image resources
+      #
+      # @param  [Array<String>] image_files
+      #
+      # @param  [Hash] options
+      #         see #build_section_data
+      #
+      # @return [Hash{String => Pathname}]
+      #
+      def build_images_section_data image_file_paths, options={}
+        image_file_paths = filter_exclusions(image_file_paths)
+        image_file_paths = filter_device_specific_image_paths(image_file_paths)
+        build_section_data(image_file_paths, options)
+      end
+
+      # Filter out device scale and idiom specific images (retina, ipad),
+      # but ensure the base exist once
+      #
+      # @param  [Array<Pathname>] file_paths
+      #         the file paths to filter
+      #
+      # @return [Array<String>]
+      #         the filtered file paths
+      #
+      def filter_device_specific_image_paths file_paths
+        file_paths.map do |path|
+          path.to_s.gsub /(@2x)?(~(iphone|ipad))?(?=\.\w+$)/, ''
+        end.to_set.to_a
+      end
+
+      # Find image files in a given list of file paths
+      #
+      # @param  [Array<Pathname>] file_paths
+      #         the list of files
+      #
+      # @return [Array<Pathname>]
+      #         the filtered list
+      #
+      def find_image_files file_paths
+        file_paths.select { |path| path.to_s.match /\.(png|jpe?g|gif)$/ }
+      end
+
+      # Build a keys to paths mapping
+      #
+      # @param  [Array<Pathname>] file_paths
+      #         the file paths, which will be the values of the mapping
+      #
+      # @param  [Hash] options
+      #         valid options are:
+      #         * [Bool] :use_basename?
+      #           if set, it will only use the basename of the path for the key
+      #
+      # @return [Hash{String => Pathname}]
+      #
+      def build_section_data file_paths, options={}
+        options = { use_basename?: false }.merge options
+
+        # Transform image file paths to keys
+        keys_to_paths = {}
+        for path in file_paths
+          path = options[:use_basename?] ? File.basename(path) : path.to_s
+          key = key_from_path(path)
+          keys_to_paths[key] = path
+        end
+
+        keys_to_paths
+      end
+
+      # Derive a key from a resource path
+      #
+      # @param  [String] path
+      #         the path to the resource
+      #
+      # @return [String]
+      #
+      def key_from_path path
+        key = path.to_s
+
+        # Get rid of the file extension
+        key = key.sub /#{File.extname(path)}$/, ''
+
+        # Graphical assets tend to contain words, which you want to strip.
+        # Because we want to list the words to ignore only in one variant,
+        # we have to ensure that the icon name is prepared for that, without
+        # loosing word separation if camel case was used.
+        key = key.underscore.downcase
+
+        for filter_word in FILTER_WORDS do
+          key.gsub! filter_word, ''
+        end
+
+        # Remove unnecessary underscores
+        key = key.gsub(/^_*|_*$|(_)_+/, '\1')
+
+        return key
+      end
+
+    end
+
+  end
+end

data/lib/xcres/analyzer/resources_analyzer/bundle_resources_analyzer.rb

@@ -0,0 +1,68 @@
+require 'xcres/analyzer/resources_analyzer/base_resources_analyzer'
+
+module XCRes
+  module ResourcesAnalyzer
+
+    # A +BundleResourcesAnalyzer+ scans the project for bundles, whose resources
+    # should be included in the output file.
+    #
+    class BundleResourcesAnalyzer < BaseResourcesAnalyzer
+
+      def analyze
+        @sections = build_sections_for_bundles.compact
+      end
+
+      # Build a section for each bundle if it contains any resources
+      #
+      # @return [Array<Section>]
+      #         the built sections
+      #
+      def build_sections_for_bundles
+        bundle_file_refs = find_bundle_file_refs
+
+        log "Found #%s resource bundles in project.", bundle_file_refs.count
+
+        bundle_file_refs.map do |file_ref|
+          section = build_section_for_bundle(file_ref)
+          log 'Add section for %s with %s elements', section.name, section.items.count unless section.nil?
+          section
+        end.compact
+      end
+
+      # Discover all references to resources bundles in project
+      #
+      # @return [Array<PBXFileReference>]
+      #
+      def find_bundle_file_refs
+        find_file_refs_by_extname '.bundle'
+      end
+
+      # Build a section for a resources bundle
+      #
+      # @param  [PBXFileReference] bundle_file_ref
+      #         the file reference to the resources bundle file
+      #
+      # @return [Section?]
+      #         a section or nil
+      #
+      def build_section_for_bundle bundle_file_ref
+        bundle_files = find_files_in_dir(bundle_file_ref.real_path)
+        image_files = find_image_files(bundle_files)
+
+        log "Found bundle %s with #%s image files of #%s total files.", bundle_file_ref.path, image_files.count, bundle_files.count
+
+        return nil if image_files.empty?
+
+        section_data = build_images_section_data(image_files)
+
+        return nil if section_data.empty?
+
+        section_name = basename_without_ext(bundle_file_ref.path)
+
+        new_section(section_name, section_data)
+      end
+
+    end
+
+  end
+end

data/lib/xcres/analyzer/resources_analyzer/loose_resources_analyzer.rb

@@ -0,0 +1,39 @@
+require 'xcres/analyzer/resources_analyzer/base_resources_analyzer'
+
+module XCRes
+  module ResourcesAnalyzer
+
+    # A +LooseResourcesAnalyzer+ scans the project for resources, which are
+    # loosely placed in the project or in a group and should be included in the
+    # output file.
+    #
+    class LooseResourcesAnalyzer < BaseResourcesAnalyzer
+
+      def analyze
+        @sections = [build_section_for_loose_images].compact
+      end
+
+      def exclude_file_patterns
+        super + ['Default.*', 'Default@2x.*', 'Default-568h@2x.*']
+      end
+
+      # Build a section for loose image resources in the project
+      #
+      # @return [Section?]
+      #
+      def build_section_for_loose_images
+        image_files = find_image_files(resources_files.map(&:path))
+
+        log "Found #%s image files in project.", image_files.count
+
+        return nil if image_files.empty?
+
+        data = build_images_section_data(image_files, use_basename?: true)
+
+        new_section('Images', data)
+      end
+
+    end
+
+  end
+end

data/lib/xcres/analyzer/resources_analyzer/xcassets_analyzer.rb

@@ -0,0 +1,62 @@
+require 'xcres/analyzer/resources_analyzer/base_resources_analyzer'
+require 'xcres/model/xcassets/bundle'
+
+module XCRes
+  module ResourcesAnalyzer
+
+    # A +XCAssetsAnalyzer+ scans the project for asset catalogs,
+    # which should be included in the output file.
+    #
+    class XCAssetsAnalyzer < BaseResourcesAnalyzer
+
+      def analyze
+        sections = []
+        sections += build_sections_for_xcassets
+        @sections = sections.compact
+      end
+
+      # Build a section for each asset catalog if it contains any resources
+      #
+      # @return [Array<Section>]
+      #         the built sections
+      #
+      def build_sections_for_xcassets
+        file_refs = find_file_refs_by_extname '.xcassets'
+
+        log "Found #%s asset catalogs in project.", file_refs.count
+
+        file_refs.map do |file_ref|
+          bundle = XCAssets::Bundle.open(file_ref.real_path)
+          section = build_section_for_xcassets(bundle)
+          log 'Add section for %s with %s elements', section.name, section.items.count unless section.nil?
+          section
+        end.compact
+      end
+
+      # Build a section for a asset catalog
+      #
+      # @param  [XCAssets::Bundle] xcassets_bundle
+      #         the file reference to the resources bundle file
+      #
+      # @return [Section?]
+      #         a section or nil
+      #
+      def build_section_for_xcassets bundle
+        log "Found asset catalog %s with #%s image files.",
+          bundle.path.basename, bundle.resources.count
+
+        return nil if bundle.resources.empty?
+
+        section_data = build_images_section_data(bundle.resources.map(&:name))
+
+        return nil if section_data.empty?
+
+        section_name = "#{basename_without_ext(bundle.path)}Assets"
+
+        new_section(section_name, section_data)
+      end
+
+    end
+
+  end
+end

data/lib/xcres/analyzer/strings_analyzer.rb

@@ -0,0 +1,255 @@
+require 'xcres/analyzer/analyzer'
+require 'json'
+
+module XCRes
+
+  # A +StringsAnalyzer+ scans the project for resources,
+  # which should be included in the output file.
+  #
+  class StringsAnalyzer < Analyzer
+
+    # @return [String]
+    #         optional two-letter language code conforming ISO 639-1
+    attr_accessor :default_language
+
+    # Initialize a new analyzer
+    #
+    # @param [Xcodeproj::Project] project
+    #        see #project.
+    #
+    # @param [Hash] options
+    #        Possible options:
+    #        * :default_language => see #default_language.
+    #
+    def initialize(project=nil, options={})
+      super
+      self.default_language = options[:default_language]
+    end
+
+    def analyze
+      log 'Strings files in project: %s', strings_file_refs.map(&:path)
+      log 'Native development languages: %s', native_dev_languages.to_a
+      log 'Used languages for .strings files: %s', used_languages.to_a
+      log 'Preferred languages: %s', languages.to_a
+      log 'Strings files after language selection: %s', selected_strings_file_refs.map(&:path)
+
+      @sections = [build_section]
+    end
+
+    # Build the section
+    #
+    # @return [Section]
+    #
+    def build_section
+      selected_file_refs = selected_strings_file_refs
+
+      # Apply ignore list
+      file_paths = filter_exclusions(selected_file_refs.map(&:path))
+      filtered_file_refs = selected_file_refs.select { |file_ref| file_paths.include? file_ref.path }
+      rel_file_paths = filtered_file_refs.map { |p| p.real_path.relative_path_from(Pathname.pwd) }
+
+      log 'Non-ignored .strings files: %s', rel_file_paths.map(&:to_s)
+
+      keys_by_file = {}
+      for path in rel_file_paths
+        keys_by_file[path] = keys_by_file(path)
+      end
+      items = keys_by_file.values.reduce({}, :merge)
+
+      new_section('Strings', items)
+    end
+
+    # Discover all references to .strings files in project (e.g. Localizable.strings)
+    #
+    # @return [Array<PBXFileReference>]
+    #
+    def strings_file_refs
+      @strings_file_refs ||= find_file_refs_by_extname '.strings'
+    end
+
+    # Select strings files by language
+    #
+    # @return [Array<PBXFileReference>]
+    #
+    def selected_strings_file_refs
+      @selected_strings_file_refs ||= strings_file_refs.select { |file_ref| languages.include? file_ref.name }
+    end
+
+    # Derive the used languages from given strings files
+    #
+    # @param [Array<PBXFileReference>] strings_file_refs
+    #
+    # @return [Set<String>]
+    #
+    def derive_used_languages(strings_file_refs)
+      strings_file_refs.map(&:name).to_set
+    end
+
+    # All used languages in the project
+    #
+    # @return [Set<String>]
+    #
+    def used_languages
+      @used_languages ||= derive_used_languages(strings_file_refs)
+    end
+
+    # Find preferred languages, which is:
+    #   - either only the default_language, if specified
+    #   - or the intersection of native development and used languages
+    #   - or all used languages
+    #
+    # @return [Set<String>]
+    #
+    def languages
+      if default_language != nil
+        # Use specified default language as primary language
+        [default_language]
+      else
+        # Calculate the intersection of native development and used languages,
+        # fallback to the latter only, if it is empty
+        languages = native_dev_languages & used_languages
+        if languages.empty?
+          used_languages
+        else
+          languages
+        end
+      end
+    end
+
+    # Discover Info.plist files by build settings of the application target
+    #
+    # @return [Set<Pathname>]
+    #         the relative paths to the .plist-files
+    #
+    def info_plist_paths
+      @info_plist_paths ||= target.build_configurations.map do |config|
+        config.build_settings['INFOPLIST_FILE']
+      end.compact.map { |file| Pathname(file) }.flatten.to_set
+    end
+
+    # Absolute file paths to Info.plist files by build settings.
+    # See #info_plist_paths.
+    #
+    # @return [Set<Pathname>]
+    #         the absolute paths to the .plist-files
+    #
+    def absolute_info_plist_paths
+      info_plist_paths.map do |path|
+        absolute_project_file_path(path)
+      end.select do |path|
+        if path.to_s.include?('$')
+          warn "Couldn't resolve all placeholders in INFOPLIST_FILE %s.", path.to_s
+          false
+        else
+          true
+        end
+      end
+    end
+
+    # Find the native development languages by trying to use the
+    # "Localization native development region" from Info.plist
+    #
+    # @return [Set<String>]
+    #
+    def native_dev_languages
+      @native_dev_languages ||= absolute_info_plist_paths.map do |path|
+        read_plist_key(path, :CFBundleDevelopmentRegion)
+      end.to_set
+    end
+
+    # Extracts a given key from a plist file given as a path
+    #
+    # @param  [Pathname] path
+    #         the path of the plist file
+    #
+    # @param  [String] key
+    #         the key, whose value should been extracted
+    #
+    # @return [String]
+    #
+    def read_plist_key(path, key)
+      raise ArgumentError, 'Path is required, but nil' if path.nil?
+      raise ArgumentError, 'Key is required, but nil' if key.nil?
+      out = `/usr/libexec/PlistBuddy -c "Print :#{key}" #{path}`.chomp
+      raise ArgumentError, out unless $?.success?
+      out
+    end
+
+    # Read a .strings file given as a path
+    #
+    # @param [Pathname] path
+    #        the path of the strings file
+    #
+    # @return [Hash]
+    #
+    def read_strings_file(path)
+      raise ArgumentError, "File '#{path}' doesn't exist" unless path.exist?
+      raise ArgumentError, "File '#{path}' is not a file" unless path.file?
+      error = `plutil -lint -s "#{path}"`
+      return warn "File %s is malformed:\n#{error}", path.to_s unless $?.success?
+      json_or_error = `plutil -convert json "#{path}" -o -`.chomp
+      return warn "File %s couldn't be converted to JSON.\n#{json_or_error}", path.to_s unless $?.success?
+      JSON.parse(json_or_error.force_encoding('UTF-8'))
+    rescue EncodingError => e
+      raise StandardError, "Encoding error in #{path}: #{e}"
+    end
+
+    # Calculate the absolute path for a file path given relative to the
+    # project / its `$SRCROOT`.
+    #
+    # We need either absolute paths or relative paths to our current location.
+    # Xcodeproj provides this for +PBXFileReference+, but this doesn't work
+    # for file references in build settings.
+    #
+    # @param  [String|Pathname] file_path
+    #         the path relative to the project.
+    #
+    # @return [Pathname]
+    #
+    def absolute_project_file_path(file_path)
+      source_root = (project.path + '..').realpath
+      if file_path.to_s.include?('$')
+        Pathname(file_path.to_s.gsub(/\$[({]?SRCROOT[)}]?/, source_root.to_s))
+      else
+        source_root + file_path
+      end
+    end
+
+    # Get relative file paths
+    #
+    # @return [Array<Pathname>]
+    #
+    def strings_file_paths
+      project_dir = project.path + '..'
+      project_dir_realpath = project_dir.realpath
+      strings_file_refs.map(&:real_path).map do |path|
+        project_dir + path.relative_path_from(project_dir_realpath) rescue path
+      end
+    end
+
+    # Read a file and collect all its keys
+    #
+    # @param  [Pathname] path
+    #         the path to the .strings file to read
+    #
+    # @return [Hash{String => Hash}]
+    #
+    def keys_by_file(path)
+      begin
+        # Load strings file contents
+        strings = read_strings_file(path)
+
+        keys = Hash[strings.map do |key, value|
+          [key, { value: key, comment: value.gsub(/[\r\n]/, ' ') }]
+        end]
+
+        log 'Found %s keys in file %s', keys.count, path
+
+        keys
+      rescue ArgumentError => error
+        raise ArgumentError, 'Error while reading %s: %s' % [path, error]
+      end
+    end
+
+  end
+end

data/lib/xcres/builder/file_builder.rb

@@ -0,0 +1,61 @@
+require 'colored'
+require 'xcres/builder/string_builder'
+
+class XCRes::FileBuilder
+
+  attr_accessor :output_path
+  attr_accessor :logger
+
+  def prepare_output_path!
+    # Ensure that the given directory exists
+    output_dir = File.dirname output_path
+    unless Dir.exist? output_dir
+      logger.success 'Directory did not exist. Will been created.'
+      Dir.mkdir output_dir
+    end
+
+    # Replace an already existing file, by deleting it and rebuilding from scratch
+    if File.exist? output_path
+      raise ArgumentError.new 'Output path is a directory!' if Dir.exist? output_path
+      logger.warn "Output path already exists. Will be replaced."
+    end
+  end
+
+  def build
+    prepare_output_path!
+  end
+
+  def build_contents &block
+    # Pass a new string builder to given block
+    builder = XCRes::StringBuilder.new
+    block.call builder
+    builder.result
+  end
+
+  def write_file_eventually file_path, contents
+    # Check if the file already exists and touch it only if the contents changed
+    if File.exist? file_path
+      tmp_dir_path = `/usr/bin/mktemp -d -t xcres`
+      tmp_file_path = tmp_dir_path + File.basename(file_path)
+
+      # Write temp file
+      write_file tmp_file_path, contents
+
+      # Diff current version and temporary file
+      if FileUtils.compare_file(tmp_file_path, file_path)
+        logger.success "Existing file is up-to-date. Don't touch."
+        return
+      end
+    end
+
+    write_file file_path, contents
+  end
+
+  def write_file file_path, contents
+    # Write file
+    File.open file_path, 'w' do |file|
+      file.write contents
+    end
+  end
+
+end