xcres 0.4.0

data/spec/integration.rb

@@ -0,0 +1,86 @@
+require 'bacon'
+require 'pretty_bacon'
+require 'clintegracon'
+require File.expand_path('../spec_helper/xcodeproj_project_yaml', __FILE__)
+
+ROOT = Pathname.new(File.expand_path('../..', __FILE__))
+BIN  = ROOT + 'bin'
+
+CLIntegracon.configure do |c|
+  c.spec_path = ROOT + 'spec/integration'
+  c.temp_path = ROOT + 'tmp/integration'
+
+  c.hook_into :bacon
+
+  c.ignores '.DS_Store'
+  c.ignores '**.DS_Store'
+  c.ignores '.gitkeep'
+  c.ignores %r[/xcuserdata/]
+
+  # Transform produced project files to YAMLs
+  c.transform_produced "**/*.xcodeproj" do |path|
+    # Creates a YAML representation of the Xcodeproj files
+    # which should be used as a reference for comparison.
+    xcodeproj = Xcodeproj::Project.open(path)
+    File.open("#{path}.yaml", "w") do |file|
+      file.write xcodeproj.to_yaml
+    end
+  end
+
+  # So we don't need to compare them directly
+  c.ignores %r[\.xcodeproj/]
+end
+
+
+describe_cli 'xcres' do
+
+  subject do |s|
+    s.executable = "#{BIN}/xcres"
+    s.default_args = [
+      '--verbose',
+      '--no-ansi'
+    ]
+    s.replace_path ROOT.to_s, 'ROOT'
+  end
+
+  describe 'Build' do
+    describe 'with default settings' do
+      behaves_like cli_spec('build', '', 'build Example .')
+    end
+
+    describe 'with variable INFOPLIST_PATH' do
+      behaves_like cli_spec('build-var-infoplist', '', 'build Example .')
+    end
+
+    describe 'with resource which has a protected name' do
+      behaves_like cli_spec('build-keyword-clash', '', 'build Example .')
+    end
+  end
+
+  describe 'Install' do
+    describe 'with default template' do
+      behaves_like cli_spec('install', '', 'install Example')
+    end
+
+    describe 'with existing installation' do
+      behaves_like cli_spec('install-again', '', 'install Example')
+    end
+
+    describe 'without supporting files' do
+      behaves_like cli_spec('install-no-supporting-files', '', 'install Example')
+    end
+
+    describe 'with moved supporting files' do
+      behaves_like cli_spec('install-moved-supporting-files', '', 'install Example')
+    end
+  end
+
+  describe 'Get help' do
+    behaves_like cli_spec('help', '--help')
+  end
+
+  describe 'Get version' do
+    behaves_like cli_spec('version', 'version')
+  end
+
+end

data/spec/spec_helper/xcodeproj_project_yaml.rb

@@ -0,0 +1,26 @@
+require 'xcodeproj'
+require 'yaml'
+
+class Xcodeproj::Project::Object::PBXShellScriptBuildPhase
+  def pretty_print
+    hash = {}
+    simple_attributes.each do |attr|
+      value = attr.get_value(self)
+      hash[attr.plist_name] = value if value
+    end
+    { display_name => hash }
+  end
+end
+
+class Xcodeproj::Project
+  def to_yaml
+    pretty_print_output = pretty_print
+    sections = []
+    sorted_keys = ['File References', 'Targets', 'Build Configurations']
+    sorted_keys.each do |key|
+      yaml =  { key => pretty_print_output[key] }.to_yaml
+      sections << yaml
+    end
+    (sections * "\n\n").gsub!('---', '')
+  end
+end

data/spec/unit/analyzer/aggregate_analyzer_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'XCRes::AggregateAnalyzer' do
+
+  def subject
+    XCRes::AggregateAnalyzer
+  end
+
+  before do
+    @analyzer = subject.new
+  end
+
+  describe '#initialize' do
+    it 'should initialize #analyzers with an empty array' do
+      @analyzer.analyzers.should.be.eql?([])
+    end
+  end
+
+  describe '#analyze' do
+    it 'should return aggregated output of all child analyzers' do
+      section1 = mock()
+      @analyzer.analyzers << mock(analyze: [section1])
+
+      section2 = mock()
+      @analyzer.analyzers << mock(analyze: [section2])
+
+      @analyzer.analyze.should.be.eql?([section1, section2])
+    end
+
+    it 'should return an empty array if there are no child analyzers' do
+      @analyzer.analyze.should.be.empty?
+    end
+  end
+
+  describe '#add_with_class' do
+    it 'should init an analyzer of given class with current attributes' do
+      @analyzer = subject.new(mock('Target'))
+      @analyzer.logger = mock('Logger')
+      @analyzer.exclude_file_patterns = ['foo', 'bar']
+
+      new_analyzer = @analyzer.add_with_class(XCRes::Analyzer, {})
+      new_analyzer.should.be.an.instance_of?(XCRes::Analyzer)
+      new_analyzer.should.be.equal?(@analyzer.analyzers.last)
+      new_analyzer.target.should.be.equal?(@analyzer.target)
+      new_analyzer.logger.should.be.equal?(@analyzer.logger)
+      new_analyzer.exclude_file_patterns.should.be.equal?(@analyzer.exclude_file_patterns)
+    end
+
+    it 'should pass the options to the initializer' do
+      result = @analyzer.add_with_class(XCRes::Analyzer, the_answer: 42)
+      result.options.should.be.eql?({ the_answer: 42 })
+    end
+
+    it 'should pass the merged options to the initializer' do
+      @analyzer.options = { the_question: '6x7=?' }
+      result = @analyzer.add_with_class(XCRes::Analyzer,the_answer: 42)
+      result.options.should.be.eql?({ the_question: '6x7=?', the_answer: 42 })
+    end
+  end
+
+end

data/spec/unit/analyzer/analyzer_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'XCRes::Analyzer' do
+
+  def subject
+    XCRes::Analyzer
+  end
+
+  before do
+    @target = app_target
+    @analyzer = subject.new(@target)
+  end
+
+  describe '#new_section' do
+    describe 'without configured options' do
+      describe 'without options given as argument' do
+        it 'should return a new section' do
+          @analyzer.new_section('Name', { a: 'a' })
+            .should.be.eql? XCRes::Section.new('Name', { a: 'a' })
+        end
+      end
+
+      describe 'with options given as argument' do
+        it 'should return a new section' do
+          @analyzer.new_section('Name', { a: 'a' }, the_answer: 42)
+            .should.be.eql? XCRes::Section.new('Name', { a: 'a' }, the_answer: 42)
+        end
+      end
+    end
+
+    describe 'with configured options' do
+      before do
+        @analyzer.options = { the_answer: 42, the_question: '6x7=?' }
+      end
+
+      describe 'without options given as argument' do
+        it 'should return a new section' do
+          @analyzer.new_section('Name', { a: 'a' })
+            .should.be.eql? XCRes::Section.new('Name', { a: 'a' }, the_answer: 42,  the_question: '6x7=?')
+        end
+      end
+
+      describe 'with options given as argument' do
+        it 'should return a new section' do
+          @analyzer.new_section('Name', { a: 'a' }, the_answer: 21)
+            .should.be.eql? XCRes::Section.new('Name', { a: 'a' }, the_answer: 21, the_question: '6x7=?')
+        end
+      end
+    end
+  end
+
+  describe '#filter_exclusions' do
+    describe 'single asterisk' do
+      it 'rejects file paths on first hierarchy level' do
+        @analyzer.exclude_file_patterns = ['*.gif']
+        @analyzer.filter_exclusions(['cat.jpg', 'doge.gif']).should.be.eql?(['cat.jpg'])
+      end
+
+      it 'rejects file paths in nested directories by default' do
+        @analyzer.exclude_file_patterns = ['*.gif']
+        @analyzer.filter_exclusions(['top_doge.gif', 'sub/sub/doge.gif', 'sub/sub/doge.gif']).should.be.eql?([])
+      end
+    end
+
+    describe 'double asterisk' do
+      it 'rejects file paths in nested directories only' do
+        @analyzer.exclude_file_patterns = ['**.gif']
+        @analyzer.filter_exclusions(['top_doge.gif', 'sub/sub/doge.gif', 'sub/sub/doge.gif']).should.be.eql?([])
+      end
+    end
+
+    it 'rejects hidden files' do
+      @analyzer.exclude_file_patterns = ['.git']
+      @analyzer.filter_exclusions(['.git']).should.be.eql?([])
+    end
+  end
+
+  describe '#find_files_by_extname' do
+    it 'should return an empty list for an empty project' do
+      @analyzer.project.stubs(:files).returns([])
+      @analyzer.find_file_refs_by_extname('.bundle').should.be.eql?([])
+    end
+
+    it 'should return matching files' do
+      @bundle = stub('FileRef', path: 'the-whole.bundle')
+      @img    = stub('FileRef', path: 'awesome.jpg')
+      @target.project.stubs(:files).returns([@bundle, @img])
+
+      @analyzer.stubs(:is_file_ref_included_in_application_target?)
+        .returns(true)
+      @analyzer.find_file_refs_by_extname('.bundle').should.be.eql?([@bundle])
+    end
+
+    it 'should not return files, which do not belong to an application target' do
+      @dog_img = stub('FileRef', path: 'doge.jpg')
+      @cat_img = stub('FileRef', path: 'nyancat.jpg')
+      @target.project.stubs(:files).returns([@dog_img, @cat_img])
+
+      @analyzer.stubs(:is_file_ref_included_in_application_target?)
+        .with(@dog_img).returns(true)
+      @analyzer.stubs(:is_file_ref_included_in_application_target?)
+        .with(@cat_img).returns(false)
+      @analyzer.find_file_refs_by_extname('.jpg').should.be.eql?([@dog_img])
+    end
+  end
+
+  describe '#is_file_ref_included_in_application_target?' do
+    it 'should return true for included files' do
+      file = @target.project.files.find { |f| f.path.to_s == 'doge.jpeg' }
+      file.should.be.an.instance_of?(Xcodeproj::Project::Object::PBXFileReference)
+      @analyzer.is_file_ref_included_in_application_target?(file)
+        .should.be.true?
+    end
+
+    it 'should return false for non-included files' do
+      file = @target.project.files.find { |f| f.path.to_s == 'nyanCat.png' }
+      file.should.be.an.instance_of?(Xcodeproj::Project::Object::PBXFileReference)
+      @analyzer.is_file_ref_included_in_application_target?(file)
+        .should.be.false?
+    end
+  end
+
+end

data/spec/unit/analyzer/resources_aggregate_analyzer_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'XCRes::ResourcesAggregateAnalyzer' do
+
+  def subject
+    XCRes::ResourcesAggregateAnalyzer
+  end
+
+  before do
+    @analyzer = subject.new
+    @analyzer.logger = stub('Logger', :log)
+  end
+
+  describe '#analyze' do
+    it 'should return all sections' do
+      bundle_section_a = stub('Bundle Section A')
+      bundle_section_b = stub('Bundle Section B')
+      loose_image_section = stub('Loose Images Section')
+      xcassets_section = stub('XCAssets Section')
+
+      XCRes::ResourcesAnalyzer::BundleResourcesAnalyzer.any_instance
+        .expects(:analyze).returns([bundle_section_a, bundle_section_b])
+      XCRes::ResourcesAnalyzer::LooseResourcesAnalyzer.any_instance
+        .expects(:analyze).returns(loose_image_section)
+      XCRes::ResourcesAnalyzer::XCAssetsAnalyzer.any_instance
+        .expects(:analyze).returns(xcassets_section)
+
+      @analyzer.analyze.should.eql?([bundle_section_a, bundle_section_b, loose_image_section, xcassets_section])
+    end
+
+    it 'should return only bundle sections if there are no loose images' do
+      bundle_section = stub('Bundle Section')
+      xcassets_section = stub('XCAssets Section')
+
+      XCRes::ResourcesAnalyzer::BundleResourcesAnalyzer.any_instance
+        .expects(:analyze).returns(bundle_section)
+      XCRes::ResourcesAnalyzer::LooseResourcesAnalyzer.any_instance
+        .expects(:analyze).returns([])
+      XCRes::ResourcesAnalyzer::XCAssetsAnalyzer.any_instance
+        .expects(:analyze).returns(xcassets_section)
+
+      @analyzer.analyze.should.eql?([bundle_section, xcassets_section])
+    end
+  end
+
+end

data/spec/unit/analyzer/resources_analyzer/base_resources_analyzer_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'XCRes::ResourcesAnalyzer::BaseResourcesAnalyzer' do
+
+  def subject
+    XCRes::ResourcesAnalyzer::BaseResourcesAnalyzer
+  end
+
+  before do
+    @analyzer = subject.new
+    @analyzer.logger = stub('Logger', :log)
+  end
+
+  describe '#find_files_in_dir' do
+    # TODO: Test using fakefs, ...
+  end
+
+  describe '#build_images_section_data' do
+    it 'returns an empty hash if no files were given' do
+      @analyzer.build_images_section_data([]).should.eql?({})
+    end
+
+    describe 'option use_basename? is not given' do
+      it 'builds an items hash and keep the path' do
+        @analyzer.build_images_section_data([Pathname('b/a.m'), Pathname('b/a.gif')])
+          .should.eql?({ 'b/a' => 'b/a.gif' })
+      end
+    end
+
+    describe 'option use_basename? is given as true' do
+      it 'builds an items hash and remove the path' do
+        @analyzer.build_images_section_data([Pathname('b/a.m'), Pathname('b/a.gif')], use_basename?: true)
+          .should.eql?({ 'a' => 'a.gif' })
+      end
+    end
+  end
+
+  describe '#filter_device_specific_image_paths' do
+    it 'returns an empty list if no files were given' do
+      @analyzer.filter_device_specific_image_paths([]).should.eql?([])
+    end
+
+    it 'filters device scale specific images without doublets' do
+      @analyzer.filter_device_specific_image_paths(['a.png', 'a@2x.png']).should.eql?(['a.png'])
+    end
+
+    it 'filters device scale specifiers from image paths' do
+      @analyzer.filter_device_specific_image_paths(['a@2x.png']).should.eql?(['a.png'])
+    end
+
+    it 'filters idiom specific images without doublets' do
+      @analyzer.filter_device_specific_image_paths(['a.png', 'a~iphone.png', 'a~ipad.png']).should.eql?(['a.png'])
+    end
+
+    it 'filters idiom specifiers from image paths' do
+      @analyzer.filter_device_specific_image_paths(['a~iphone.png']).should.eql?(['a.png'])
+      @analyzer.filter_device_specific_image_paths(['a~ipad.png']).should.eql?(['a.png'])
+    end
+  end
+
+  describe '#find_image_files' do
+    it 'returns a empty list if no files were given' do
+      @analyzer.find_image_files([]).should.eql?([])
+    end
+
+    it 'matches common image formats' do
+      @analyzer.find_image_files(['a.png', 'b.jpg', 'c.jpeg', 'd.gif', 'e.txt'])
+                     .should.eql?(['a.png', 'b.jpg', 'c.jpeg', 'd.gif'])
+    end
+  end
+
+  describe '#build_section_data' do
+    before do
+      @file_paths = [Pathname('a/b')]
+    end
+
+    it 'returns an empty hash if no file paths given' do
+      @analyzer.build_section_data([]).should.be.eql?({})
+    end
+
+    it 'returns a hash with the basename if option use_basename? is enabled' do
+      @analyzer.expects(:key_from_path).with('b').returns('b')
+      @analyzer.build_section_data(@file_paths, use_basename?: true)
+        .should.be.eql?({ 'b' => 'b' })
+    end
+
+    it 'returns a hash with relative paths if option use_basename? is disabled' do
+      @analyzer.expects(:key_from_path).with('a/b').returns('a/b')
+      @analyzer.build_section_data(@file_paths, use_basename?: false)
+        .should.be.eql?({ 'a/b' => 'a/b' })
+    end
+
+    it 'returns a hash with relative paths if option use_basename? is not given' do
+      @analyzer.expects(:key_from_path).with('a/b').returns('a/b')
+      @analyzer.build_section_data(@file_paths)
+        .should.be.eql?({ 'a/b' => 'a/b' })
+    end
+  end
+
+  describe '#key_from_path' do
+    it 'should keep the path' do
+      @analyzer.key_from_path('b/a').should.be.eql?('b/a')
+    end
+
+    it 'should cut the file extension' do
+      @analyzer.key_from_path('a.gif').should.be.eql?('a')
+    end
+
+    it 'should cut only the last file extension' do
+      @analyzer.key_from_path('a.gif.gif').should.be.eql?('a.gif')
+    end
+
+    it 'should transform camel case to snake case' do
+      @analyzer.key_from_path('AbCdEf').should.be.eql?('ab_cd_ef')
+    end
+
+    it 'should filter certain words' do
+      @analyzer.key_from_path('my_icon_catImage').should.be.eql?('my_cat')
+    end
+
+    it 'should not contain unnecessary underscores' do
+      @analyzer.key_from_path('__a___b__c___').should.be.eql?('a_b_c')
+    end
+  end
+
+end

data/spec/unit/analyzer/resources_analyzer/bundle_resources_analyzer_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'XCRes::ResourcesAnalyzer::BundleResourcesAnalyzer' do
+
+  def subject
+    XCRes::ResourcesAnalyzer::BundleResourcesAnalyzer
+  end
+
+  before do
+    @analyzer = subject.new
+    @analyzer.logger = stub('Logger', :log)
+  end
+
+  describe '#build_sections_for_bundles' do
+    it 'should return an empty array if the project does not contain any resource bundles' do
+      @analyzer.expects(:find_bundle_file_refs).returns([])
+      @analyzer.build_sections_for_bundles.should.eql?([])
+    end
+
+    it 'should build sections for given bundles' do
+      mock_bundle_a = mock('BundleFileRef').stubs(path: 'A.bundle', real_path: 'b/A.bundle')
+      mock_bundle_b = mock('BundleFileRef').stubs(path: 'B.bundle', real_path: 'b/B.bundle')
+      section = XCRes::Section.new('A', { 'a' => 'a.gif' })
+      @analyzer.expects(:find_bundle_file_refs).returns([mock_bundle_a, mock_bundle_b])
+      @analyzer.expects(:build_section_for_bundle).with(mock_bundle_a).returns(section)
+      @analyzer.expects(:build_section_for_bundle).with(mock_bundle_b).returns(nil)
+      @analyzer.build_sections_for_bundles.should.be.eql?([section])
+    end
+  end
+
+  describe '#find_bundle_file_refs' do
+    # TODO: Prepare a fixture project
+  end
+
+  describe '#build_section_for_bundle' do
+    before do
+      @mock_bundle = mock('Bundle') { stubs(path: 'A.bundle', real_path: 'b/A.bundle') }
+    end
+
+    it 'should return nil if the bundle does not contain any images' do
+      @analyzer.expects(:find_files_in_dir).with(@mock_bundle.real_path).returns([Pathname('a.m')])
+      @analyzer.build_section_for_bundle(@mock_bundle).should.be.nil?
+    end
+
+    it 'should return nil if the bundle does not contain any valid images' do
+      @analyzer.expects(:find_files_in_dir).with(@mock_bundle.real_path).returns([Pathname('a.gif')])
+      @analyzer.exclude_file_patterns = ['a.gif']
+      @analyzer.build_section_for_bundle(@mock_bundle).should.be.nil?
+    end
+
+    it 'should build a new section if the bundle contain valid images' do
+      @analyzer.expects(:find_files_in_dir).with(@mock_bundle.real_path).returns([Pathname('a.gif')])
+      @analyzer.build_section_for_bundle(@mock_bundle).should.be.eql?(XCRes::Section.new('A', 'a' => 'a.gif'))
+    end
+  end
+
+end

data/spec/unit/analyzer/resources_analyzer/loose_resources_analyzer_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe 'XCRes::ResourcesAnalyzer::LooseResourcesAnalyzer' do
+
+  def subject
+    XCRes::ResourcesAnalyzer::LooseResourcesAnalyzer
+  end
+
+  before do
+    @analyzer = subject.new
+    @analyzer.logger = stub('Logger', :log)
+  end
+
+  describe '#analyze' do
+    # TODO
+  end
+
+  describe '#build_section_for_loose_images' do
+    # TODO
+  end
+
+end

data/spec/unit/analyzer/strings_analyzer_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe 'XCRes::StringsAnalyzer' do
+
+  def subject
+    XCRes::StringsAnalyzer
+  end
+
+  before do
+    @target = stub('Target', build_configurations: [])
+    @project = stub('Project', files: [], path: Pathname('.'))
+    @target.stubs(project: @project)
+
+    @analyzer = subject.new(@target)
+    @analyzer.logger = stub('Logger', :log)
+  end
+
+  describe "#initialize" do
+    it 'should set given target as attribute' do
+      @analyzer = subject.new(@target)
+      @analyzer.target.should.be.eql?(@target)
+      @analyzer.project.should.be.eql?(@project)
+    end
+
+    it 'should set option :default_language as attribute' do
+      @analyzer = subject.new(@target, default_language: 'en')
+      @analyzer.default_language.should.be.eql?('en')
+    end
+  end
+
+  describe "#analyze" do
+    it 'should return the built sections' do
+      section = mock()
+      @analyzer.expects(:build_section).returns(section)
+      @analyzer.analyze.should.be.eql?([section])
+    end
+  end
+
+  describe "#build_section" do
+    it 'should return an empty section if there are no strings files' do
+      @analyzer.stubs(:strings_file_refs).returns([])
+      @analyzer.build_section.should.be.eql?(XCRes::Section.new 'Strings', {})
+    end
+
+    it 'should return a new section if there are strings files' do
+      strings_file_ref = stub('FileRef', {
+        name:      'en',
+        path:      'Localizable.strings',
+        real_path: Pathname(File.expand_path('./en.lproj/Localizable.strings'))
+      })
+      @analyzer.stubs(:strings_file_refs).returns([strings_file_ref])
+      @analyzer.stubs(:keys_by_file)
+        .with(Pathname('en.lproj/Localizable.strings'))
+        .returns({ 'greeting' => { value: 'greeting' }})
+      @analyzer.build_section.should.be.eql?(XCRes::Section.new 'Strings', { 'greeting' => { value: 'greeting' }})
+    end
+  end
+
+  describe "#languages" do
+    it 'should return the default language if it is set' do
+      @analyzer.default_language = 'en'
+      @analyzer.languages.should.be.eql?(['en'])
+    end
+
+    it 'should return an empty array if there is no used language' do
+      @analyzer.expects(:native_dev_languages).returns(['en'].to_set).at_least_once
+      @analyzer.expects(:used_languages).returns([].to_set).at_least_once
+      @analyzer.languages.should.be.eql?([].to_set)
+    end
+
+    it 'should return the used languages if there is no matching native dev language' do
+      @analyzer.expects(:native_dev_languages).returns(['de'].to_set).at_least_once
+      @analyzer.expects(:used_languages).returns(['en', 'es'].to_set).at_least_once
+      @analyzer.languages.should.be.eql?(['en', 'es'].to_set)
+    end
+
+    it 'should return the intersection of languages if there is a common language' do
+      @analyzer.expects(:native_dev_languages).returns(['en'].to_set).at_least_once
+      @analyzer.expects(:used_languages).returns(['en', 'es'].to_set).at_least_once
+      @analyzer.languages.should.be.eql?(['en'].to_set)
+    end
+  end
+
+  describe "#find_strings_file_refs" do
+    before do
+      @target = app_target
+      @analyzer = subject.new(@target)
+    end
+
+    it 'should return the strings files of the fixture project' do
+      strings_files = @analyzer.find_file_refs_by_extname('.strings')
+      strings_files.count.should.be.eql?(3)
+      strings_files[0].path.should.be.eql?('en.lproj/InfoPlist.strings')
+      strings_files[1].path.should.be.eql?('en.lproj/Localizable.strings')
+      strings_files[2].path.should.be.eql?('de.lproj/Localizable.strings')
+    end
+  end
+
+end