xcunique 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83fc12d810e92304f2b2a4dffd93e6774aa2857a
+  data.tar.gz: 6083cfdbeb9ecb2c2f2407b410212390299de884
+SHA512:
+  metadata.gz: c2e39e840ef36829b57e021097a01fce015ab8d407b01670783286420823e2f9b77a13f882f2575447b2c8e5a0d5e5f437c1ca5326bd2e2db2deac77df4e5257
+  data.tar.gz: 60a34ec352da66c7e7ca1c6f01a5c529c4348a0e828a359f12c04e356f02b94497be3f19797e4d018b8f6fea81c52f77fa210697026a46cc6e315d6f75cccce4

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in xcunique.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,22 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  watch(%r{^spec/(.*)\/?(.*)_spec\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb$})      { 'test' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Paul Samuels
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# `xcunique`
+
+A tool to reduce merge conflicts with Xcode projects by creating deterministic UUIDs for every element within the `project.pbxproj` file.
+
+This is initially a fun yak shaving task as existing tools, such as [xUnique](https://github.com/truebit/xUnique), already exist. There is a vague idea that this would be a part of a very small suite of tools to help reduce the pain of managing Xcode projects.
+
+###Warning
+
+If you are not using source control then you should not be using this tool.
+
+---
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'xcunique'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install xcunique
+
+## Usage
+
+```
+Usage: xcunique PROJECT.PBXPROJ [options]
+    -f, --format=<ascii|json|xml>    ascii|json|xml
+    -v, --verbose
+```
+
+###`--format`
+The format switch has 3 options
+
+* `ascii` requires [`xcproj`](https://github.com/0xced/xcproj) to be installed. It writes the project to a plist and then touches it with [`xcproj`](https://github.com/0xced/xcproj)
+* `json` outputs to stdout - useful for debugging or using with other tools
+* `xml` writes over the project file with an XML formatted plist
+
+###`--verbose`
+
+* It's always nice to now what is happening so show some logs
+
+---
+
+## What does it even do?
+
+Good question - there is not a lot of source code to look at but I'll call out the general process.
+
+[cli.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/cli.rb) is where all the fun begins:
+https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/cli.rb
+* It uses [options.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/options.rb) to extract the command line arguments and do some basic checking to ensure you have provided valid paths etc.
+* Then it uses [uniquifier.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/uniquifier.rb) to generate the deterministic UUIDs
+* Then it uses [sorter.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/sorter.rb) to sort the groups/files alphabetically
+* The uniqued/sorted files is then written out to a JSON file
+* This JSON file is converted to an XML plist using the bundled swift script
+* This plist is then optionally converted to ascii using [`xcproj`](https://github.com/0xced/xcproj)
+
+[uniquifier.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/uniquifier.rb) coordinates the majority of the process:
+
+* It creates a [parser.rb](https://github.com/paulsamuels/xcunique/blob/master/lib/xcunique/parser.rb) that first enumerates the groups/files section of the Xcode project and then traverses from the root object in the project. The parser keeps track of UUIDs that it has already visited, which prevents getting into cycles and generating different paths if files are included in multiple targets.
+* The result of this parsing is a hash of substitutions going from old UUID to new deterministic UUID - the transforming from old UUID to new UUID is performed during a deep clone of the project object
+
+To see the format of the normalised paths before they are MD5'd check out the tests in [parser_spec.rb](https://github.com/paulsamuels/xcunique/blob/master/spec/xcunique/sorter.rb)
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/xcunique/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose    = true
+end
+
+desc "Run tests"
+task :default => :test

data/bin/xcunique

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'xcunique'
+
+Xcunique::CLI.run(ARGV)

data/lib/json2plist/json2plist

@@ -0,0 +1,21 @@
+#!/usr/bin/env xcrun swift
+
+import Foundation
+
+guard Process.arguments.count == 3 else {
+  print("Usage: json2plist path/to/input path/to/output")
+  exit(EXIT_FAILURE)
+}
+
+guard let inputData = NSData(contentsOfURL: NSURL(fileURLWithPath: Process.arguments[1])) else {
+  print("Could not load \"\(Process.arguments[1])\"")
+  exit(EXIT_FAILURE)
+}
+
+do {
+  if let data = try NSJSONSerialization.JSONObjectWithData(inputData, options: .AllowFragments) as? NSDictionary {
+    data.writeToURL(NSURL(fileURLWithPath: Process.arguments[2]), atomically: true)
+  }
+} catch {
+  print(error)
+}

data/lib/xcunique.rb

@@ -0,0 +1,23 @@
+module Xcunique
+  module Keys
+    CHILDREN     = 'children'
+    FILE_REF     = 'fileRef'
+    FILES        = 'files'
+    ISA          = 'isa'
+    MAIN_GROUP   = 'mainGroup'
+    NAME         = 'name'
+    OBJECTS      = 'objects'
+    PATH         = 'path'
+    PBXGroup     = 'PBXGroup'
+    ROOT_OBJECT  = 'rootObject'
+  end
+end
+
+require "xcunique/cli"
+require 'xcunique/hash_ext'
+require 'xcunique/helpers'
+require "xcunique/options"
+require "xcunique/parser"
+require "xcunique/sorter"
+require "xcunique/uniquifier"
+require "xcunique/version"

data/lib/xcunique/cli.rb

@@ -0,0 +1,40 @@
+require 'tmpdir'
+
+module Xcunique
+  module CLI
+    def self.run argv
+      options = Options.parse(argv)
+      
+      puts %Q{Parsing "#{options.project_path}"} if options.verbose
+      result = Sorter.new(Uniquifier.new(options.project_path).uniquify).sort
+      
+      case options.format
+      when :json
+        puts JSON.pretty_generate(result)
+      when :xml, :ascii
+        Dir.mktmpdir do |dir|
+          json_path = dir + '/project.json'
+          puts %Q{Writing uniqued JSON to "#{json_path}"} if options.verbose
+          File.open(json_path, 'w') do |file|
+            file.puts result.to_json
+          end
+          
+          json2plist = File.expand_path('../json2plist/json2plist', __dir__)
+          
+          puts %Q{Running "#{json2plist} #{json_path} #{options.project_path}"} if options.verbose
+          system File.expand_path('../json2plist/json2plist', __dir__), json_path, options.project_path
+        end
+      end
+      
+      if options.format == :ascii
+        Dir.chdir File.dirname(options.project_path) do
+          puts %Q{Running "xcproj touch" in "#{File.dirname(options.project_path)}"} if options.verbose
+          system 'xcproj', 'touch'
+        end
+      end
+      
+    rescue Options::NoProjectProvidedError, Options::UnknownFormatError, Options::MissingDependencyError => error
+      puts error.message
+    end
+  end
+end

data/lib/xcunique/hash_ext.rb

@@ -0,0 +1,25 @@
+class Hash
+  
+  # Performs a deep clone of the object with optional substitutions
+  #
+  # @param substitutions [Hash] optional mapping of substitutions. 
+  #   If provided during copying any matching substitutions.key in the original will be replaced with the substitutions.value in the clone
+  # @param object [Object] the object to duplicate. This is a recursive call and will continue until resolving to a [String] or [Numeric]
+  # @return [Hash] the deeply copyed object with any substitutions performed
+  #
+  # @example
+  #   { 'needle' => 'test' }.deep_dup(substitutions: { 'needle' => 'dog' }) #=> { 'dog' => 'test' }
+  def deep_dup substitutions: {}, object: self
+    recurse = -> object { deep_dup substitutions: substitutions, object: object }
+    
+    case object
+    when Hash
+      Hash[object.map(&recurse)]
+    when Array
+      object.map(&recurse)
+    when String, Numeric
+      substitutions[object] || object
+    end
+  end
+  
+end

data/lib/xcunique/helpers.rb

@@ -0,0 +1,26 @@
+module Xcunique
+  module Helpers
+    
+    # Returns the `name` and `path` components of a node
+    #
+    # If the object contains a `fileRef` key then this is traversed to get
+    # the `name`/`path` attributes from the reference file.
+    #
+    # @param uuid [String] the UUID of the object to resolve the attributes for
+    # @param objects [Hash] the objects collection in the project
+    # @return [String] the resolved attributes or an empty string
+    #
+    # @example Valid names are of the form
+    #   ''
+    #   (name: 'Some Name')
+    #   (path: 'Some Path')
+    #   (name: 'Some Name', path: 'Some Path')
+    def self.resolve_attributes uuid, objects
+      object = objects[objects[uuid][Keys::FILE_REF] || uuid]
+      
+      components = object.sort.select { |key, _| [ Keys::NAME, Keys::PATH ].include?(key) }.map { |key, value| "#{key}: '#{value}'" }.join(", ")
+      components.length > 0 ? %Q{(#{components})} : ''
+    end
+    
+  end
+end

data/lib/xcunique/options.rb

@@ -0,0 +1,68 @@
+require 'optparse'
+
+module Xcunique
+  
+  # Options wraps the setup/running of an `OptionParser` and store the results
+  class Options
+    
+    # Exception representing the lack of a dependency e.g. `xcproj`
+    class MissingDependencyError < StandardError; end
+    
+    # Exception representing missing/invalid first argument which should be the project file
+    class NoProjectProvidedError < StandardError; end
+    
+    # Exception representing an incorrect format has been selected
+    class UnknownFormatError     < StandardError; end
+    
+    # @!attribute format
+    #   @return [Symbol] The requested format must be ascii, json or xml - defaults to :ascii
+    # @!attribute project_path
+    #   @return [String] The path to the project.pbxproj - this will undergo file expansion
+    # @!attribute verbose
+    #   @return [Boolean] representing whether logging should be enabled - defaults to false
+    attr_accessor :format, :project_path, :verbose
+    
+    # Parse array of options provided
+    #
+    # @return [Options] an Options object that is configured with the provided command line arguments
+    def self.parse argv
+      new.tap do |options|
+        option_parser = options.send :option_parser
+        
+        option_parser.parse!(argv)
+        
+        raise NoProjectProvidedError.new(option_parser.banner) unless path = argv.first
+        
+        options.project_path = File.expand_path(path)
+        
+        raise NoProjectProvidedError.new(option_parser.banner) unless File.exist?(options.project_path)
+      end
+    end
+    
+    def initialize
+      self.format = :ascii
+    end
+    
+    private
+    
+    def option_parser
+      @option_parser ||= begin
+        OptionParser.new do |opts|
+          opts.banner = "Usage: xcunique PROJECT.PBXPROJ [options]"
+          
+          opts.on('-f', '--format=<ascii|json|xml>', 'ascii|json|xml') do |format|
+            self.format = format.chomp.to_sym
+            raise UnknownFormatError.new(%Q{Unknown format "#{format}" - please choose ascii, json or xml}) unless %i{ascii json xml}.include?(self.format)
+            raise MissingDependencyError.new("xcproj is required for converting to ascii") if self.format == :ascii && begin system("command -v xcproj 2&> /dev/null"); !$?.success? end
+          end
+          
+          opts.on('-v', '--verbose') do |verbose|
+            self.verbose = verbose
+          end
+          
+        end
+      end
+    end
+  
+  end
+end

data/lib/xcunique/parser.rb

@@ -0,0 +1,54 @@
+module Xcunique
+  
+  # Parser is responsible for traversing the project objects from the entry point provided
+  # and building a Hash of visited notes which map old UUID to path of node.
+  #
+  # Nodes that have already been visited are skipped
+  class Parser
+    
+    # @!attribute [r] visited
+    #   @return [Hash] a mapping of old UUID to the of where the node is situated
+    attr_reader :visited
+    
+    # @param project [Hash] the project to parse
+    def initialize project
+      @project = project
+      @objects = @project[Keys::OBJECTS]
+      @visited = {}
+    end
+    
+    # Recursively traverse `object` building the `visited` Hash by keeping track of the current path
+    #
+    # Objects that have already been visited are skipped to avoid cycles or modifying existing values
+    #
+    # @param object [Hash, Array, String] the current object to traverse
+    # @param path [String] the current path to this node
+    def parse object:, path: ""
+      return if visited.has_key? object
+     
+      case object
+      when Array
+        object.each do |value|
+          parse object: value, path: path
+        end
+      when Hash
+        parse object: object.values, path: path
+      when String
+        current = objects[object]
+        
+        return if current.nil? || current[Keys::ISA].nil?
+        
+        path += '/' + current[Keys::ISA] + Helpers.resolve_attributes(object, objects)
+        
+        visited[object] = path
+        
+        parse object: current, path: path
+      end
+    end
+    
+    private
+    
+    attr_accessor :objects, :project
+    
+  end
+end