xcsim 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7001c7d48bafa2526204efa6fe004587f6881890
+  data.tar.gz: 364f09686a392b1d893f3c3dcde0a3ea12be1974
+SHA512:
+  metadata.gz: 1409c1748ae77efb92f9d8ce41fdd7b12b9a6569eb3880428e406ab9b46354e0d41ca34ffaefc76192e18ea69cda43e26aea67ec092cedad688a8df1a96e8b41
+  data.tar.gz: 188424f9644888129ecaea27b6c6c497885bf458af282558f9f98f3422c9649fd880f42b3f76869d6afe69f962e19c9b1c3dcfd70baae06b83273b2c162a59f3

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Egor Chiglintsev.
+
+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,37 @@
+# xcsim
+
+xcsim is a command-line utility to simplify opening iOS Simulator application directories in Finder.
+iOS Simulator uses UUIDs heavily for naming its directories, which makes them not really readable
+by human eye. Consider for example:
+
+    /Users/User/Library/Developer/CoreSimulator/Devices/FC138577-990F-4069-9AB1-6D847B8529BD/data/
+    Containers/Data/Application/E34BF950-B343-4C73-B50F-EEEA0E34BFAC
+
+Suppose you have an iOS application with bundle ID `com.yourcompany.appname` and want to peek
+into its Documents folder, which is stored in iPhone 5s (iOS 9.2) simulator. Finding the right
+directory could be a tedious task. With xcsim it is as easy as
+
+    xcsim --os "iOS 9.2" --device "iPhone 5s" com.yourcompany.appname
+
+or even as just
+
+    xcsim com.yourcompany.appname
+
+if it happens that default OS and device values are enough for your needs.
+
+In case you're not sure which exact simulator your app is installed on, you can use xcsim to list
+all present simulators by OS type, device name and view bundle IDs of the applications installed
+on them.
+
+By default xcsim invokes the `open` command to open the application data directory in Finder. By
+providing the `--app` option you can open application bundle directory instead. Using `--echo`
+option will print the full path to the selected directory instead of opening Finder.
+
+Usage: `xcsim [options] [bundleID]`
+
+    -l, --list [OS], [DEVICE]        List simulator OS, devices, app bundle IDs
+    -o, --os 'TYPE VERSION'          Select simulator OS (default: 'iOS 9.2')
+    -d, --device 'TYPE'              Select simulator device (default: 'iPhone 5s')
+    -a, --app                        Select application container directory instead of data directory
+    -e, --echo                       Echo the selected directory instead of opening it
+    -h, --help [OPTION]              Print this message / help for individual options

data/bin/xcsim

@@ -0,0 +1,252 @@
+#!/usr/bin/ruby
+require 'optparse'
+
+begin
+  require 'cfpropertylist'
+rescue LoadError
+  puts "require 'cfpropertylist' failed! Consider running 'gem install CFPropertyList'"
+  exit
+end
+
+require 'xcsim'
+
+def banner
+<<-END_BANNER
+xcsim is a command-line utility to simplify opening iOS Simulator application directories in Finder.
+iOS Simulator uses UUIDs heavily for naming its directories, which makes them not really readable
+by human eye. Consider for example:
+
+    /Users/User/Library/Developer/CoreSimulator/Devices/FC138577-990F-4069-9AB1-6D847B8529BD/data/
+    Containers/Data/Application/E34BF950-B343-4C73-B50F-EEEA0E34BFAC
+
+Suppose you have an iOS application with bundle ID 'com.yourcompany.appname' and want to peek
+into its Documents folder, which is stored in iPhone 5s (iOS 9.2) simulator. Finding the right
+directory could be a tedious task. With xcsim it is as easy as
+
+    xcsim --os "iOS 9.2" --device "iPhone 5s" com.yourcompany.appname
+
+or even as just
+
+    xcsim com.yourcompany.appname
+
+if it happens that default OS and device values are enough for your needs.
+
+In case you're not sure which exact simulator your app is installed on, you can use xcsim to list
+all present simulators by OS type, device name and view bundle IDs of the applications installed
+on them.
+
+By default xcsim invokes the `open` command to open the application data directory in Finder. By
+providing the `--app` option you can open application bundle directory instead. Using `--echo`
+option will print the full path to the selected directory instead of opening Finder.
+
+Usage: xcsim [options] [bundleID]
+
+END_BANNER
+end
+
+
+
+def help_list
+<<-END_LIST_HELP
+Usage: xcsim --list [OS], [DEVICE]
+
+List option allows listing available simulators/OS versions or bundle IDs of installed apps.
+Actual output of the list option depends on the parameters provided. Both parameters are optional,
+and if both present, should be separated by a comma.
+
+Without parameters `xcsim --list` prints all iOS simulator OS versions available with respective
+count of installed devices for each of the OS:
+
+  xcsim --list
+
+    iOS 8.0 (6 devices)
+    iOS 8.3 (5 devices)
+    iOS 9.0 (6 devices)
+    iOS 9.1 (4 devices)
+    iOS 9.2 (10 devices)
+
+Both OS and DEVICE parameters can be used to partially match existing simulators and print the
+matching results. Considering the example above, we could receive the following outputs:
+
+  xcsim --list 9                      # note partial match on OS version
+
+    iOS 9.0 (6 devices)
+    iOS 9.1 (4 devices)
+    iOS 9.2 (10 devices)
+
+  xcsim --list 9.1                    # exact match yields list of devices for the given OS version
+
+    iPhone 4s
+    iPhone 5s
+    iPhone 6 Plus
+    iPhone 6s Plus
+
+  xcsim --list iPad                   # partial match on device type, lists devices with OS versions
+
+    iPad 2 (iOS 8.0)
+    iPad Air (iOS 8.0)
+    iPad Air (iOS 8.3)
+    iPad Air (iOS 9.0)
+    iPad 2 (iOS 9.2)
+    iPad Air (iOS 9.2)
+    iPad Air 2 (iOS 9.2)
+
+  xcsim --list iOS 9.2, iPad Air 2    # exact device match lists bundle IDs of installed apps
+
+    com.yourcompany.helloapp
+    com.yourcompany.otherapp
+END_LIST_HELP
+end
+
+
+def help_os
+<<-END_OS_HELP
+Usage: xcsim --os "iOS 9.2" com.yourcompany.appname
+
+Sets the OS version to work with when searching for bundle ID (needs to be an exact match, i.e.
+partial matches such as "iOS" or "iOS 9" are not allowed)
+
+If omitted, a default OS will be used instead (#{XCSim::defaultOSName})
+END_OS_HELP
+end
+
+
+def help_device
+<<-END_DEVICE_HELP
+Usage: xcsim --device "iPhone 5s" com.yourcompany.appname
+
+Sets the device type to work with when searching for bundle ID (needs to be an exact match, i.e.
+partial matches such as "iPhone" are not allowed)
+
+If omitted, a default device will be used instead (#{XCSim::defaultDeviceName})
+END_DEVICE_HELP
+end
+
+
+def help_app
+<<-END_APP_HELP
+Usage: xcsim --app com.yourcompany.appname
+
+Selects application bundle directory instead of application data directory (which is default).
+END_APP_HELP
+end
+
+
+def help_echo
+<<-END_ECHO_HELP
+Usage: xcsim --echo com.yourcompany.appname
+
+Prints the selected directory path instead of opening it.
+END_ECHO_HELP
+end
+
+
+parser = OptionParser.new do |opts|
+  opts.banner = banner
+
+  opts.on_tail("-h", "--help [OPTION]", "Print this message / help for individual options") do |v|
+    if v == "l" || v == "list"
+      puts help_list
+    elsif v == "o" || v == "os"
+      puts help_os
+    elsif v == "d" || v == "device"
+      puts help_device
+    elsif v == "a" || v == "app"
+      puts help_app
+    elsif v == "e" || v == "echo"
+      puts help_echo
+    else
+      puts opts
+    end
+    exit
+  end
+
+  opts.on("-l", "--list [OS], [DEVICE]",
+    "List simulator OS, devices, app bundle IDs") do |v|
+      @command = :list
+      @argument = ([v] + ARGV).join(" ")
+  end
+
+  opts.on("-o", "--os 'TYPE VERSION'",
+    "Select simulator OS (default: '#{XCSim::defaultOSName}')") do |v|
+      @argument ||= {}
+      @argument[:os] = v
+  end
+
+  opts.on("-d", "--device 'TYPE'",
+    "Select simulator device (default: '#{XCSim::defaultDeviceName}')") do |v|
+      @argument ||= {}
+      @argument[:device] = v
+  end
+
+  opts.on("-a", "--app", "Select application container directory instead of data directory") do |v|
+    @argument ||= {}
+    @argument[:dir] = :app
+  end
+
+  opts.on("-e", "--echo", "Echo the selected directory instead of opening it") do |v|
+    @argument ||= {}
+    @argument[:output] = :echo
+  end
+end
+
+parser.parse!
+
+begin
+  if @command == nil
+    if ARGV.count > 1
+      raise ArgumentError
+    end
+
+    @command ||= :bundle
+    @argument ||= {}
+
+    @argument[:bundleID] ||= ARGV.first
+  end
+
+  result = xcsim(@command, @argument)
+
+  case @command
+  when :list
+    unless result.empty?
+      puts XCSim::reportFromDeviceList(result)
+    else
+      puts "ERROR: Could not find simulators matching '#{@argument}'!\n"
+      puts parser
+      exit 1
+    end
+
+  when :bundle
+    path = (@argument[:dir] == :app) ? result.bundlePath : result.dataPath
+
+    if @argument[:output] == :echo
+      puts path
+    else
+      `open #{path}`
+    end
+  end
+
+  exit
+
+rescue XCSim::NonUniqueBundleIDError => error
+  puts "ERROR: Multiple data directories matching bundle ID '#{error.bundleID}' on #{error.deviceID} " +
+       "found:"
+  puts error.directories
+  exit 1
+
+rescue XCSim::OSNotFoundError => error
+  puts "ERROR: Unknown OS '#{error.name}'"
+  exit 1
+
+rescue XCSim::DeviceNotFoundError => error
+  puts "ERROR: Unknown device '#{error.name}' for OS '#{error.os.id}'"
+  exit 1
+
+rescue XCSim::BundleNotFoundError => error
+  puts "Unknown bundle ID '#{error.bundleID}' on #{error.device.name} (#{error.os.id})"
+  exit 1
+
+rescue ArgumentError
+  puts parser
+  exit
+end

data/lib/xcsim/rbAppBundles.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+
+require 'cfpropertylist'
+require_relative 'rbBundleInfo'
+
+module XCSim
+
+  # An error raised by XCSim::findBundleDataPath function when multiple directories matching
+  # the given bundle ID are found on the same simulator device.
+  class NonUniqueBundleIDError < RuntimeError
+
+    # A DeviceID object representing the iOS Simulator on which the error has occurred
+    attr_reader :deviceID
+
+    # A bundle ID string, which caused the error
+    attr_reader :bundleID
+
+    # An array of strings containing absolute paths for directories matching the given bundle ID
+    attr_reader :directories
+
+    # Initializes a NonUniqueBundleIDError object with the given parameters
+    def initialize(deviceID, bundleID, directories)
+      @bundleID = bundleID
+      @deviceID = deviceID
+      @directories = directories
+    end
+  end
+
+
+
+  # call-seq:
+  #    findBundleDataPath(deviceID, bundleID) => String
+  #
+  # +deviceID+:: A DeviceID object representing the device simulator on which the application
+  #              is installed
+  # +bundleID+:: Bundle ID of the application to search for
+  #
+  # Finds an absolute path for application data directory of an application with a given bundle ID
+  # installed on a given device.
+  #
+  # Searches for directories matching +bundleID+ inside the application data directory of the
+  # device. Raises a NonUniqueBundleIDError if multiple matching directories
+  # are found (bundle IDs are expected to be unique). Returns the found directory or +nil+
+  # otherwise.
+  def self.findBundleDataPath(deviceID, bundleID)
+    path = deviceID.appDataPath
+    subdirs = Dir.entries(path).select do |entry|
+      File.directory? File.join(path, entry) and !(entry =='.' || entry == '..')
+    end
+
+    metadataPairs = subdirs.map do |dir|
+      metadataPath = "#{path}/#{dir}/#{BUNDLE_METADATA_PLIST}"
+
+      if File.exists? metadataPath
+        plist = CFPropertyList::List.new(:file => metadataPath)
+        plist = CFPropertyList.native_types(plist.value)
+
+        { :plist => plist, :dir => "#{path}/#{dir}" }
+      else
+        nil
+      end
+    end
+    .select{ |pair| pair != nil }
+
+    result = metadataPairs.select{ |pair| pair[:plist][METADATA_ID] == bundleID }
+
+    if result.count > 1
+      raise NonUniqueBundleIDError.new(deviceID, bundleID, result.map{|pair| pair[:dir]})
+    elsif result.empty?
+      return nil
+    else
+      result.first[:dir]
+    end
+  end
+
+
+
+  # call-seq:
+  #    parseInstalledBundles(deviceID) => Hash
+  #
+  # +deviceID+:: A DeviceID object to search installed app bundles for
+  #
+  # Searches the given iOS Simulator device for installed application bundles (excluding the
+  # system applications such as Safari) and returns a Hash of <tt>bundle ID string =>
+  # BundleInfo</tt> containing BundleInfo instances corresponding the found bundles.
+  #
+  # May raise a NonUniqueBundleIDError if multiple data directories are found for one
+  # of the bundles.
+  def self.parseInstalledBundles(deviceID)
+    path = deviceID.appBundlesPath
+    subdirs = Dir.entries(path).select do |entry|
+      File.directory? File.join(path, entry) and !(entry =='.' || entry == '..')
+    end
+
+    bundlePlists = subdirs.map do |dir|
+      plistPath = "#{path}/#{dir}/#{BUNDLE_METADATA_PLIST}"
+
+      if File.exists? plistPath
+        plist = CFPropertyList::List.new(:file => plistPath)
+        plist = CFPropertyList.native_types(plist.value)
+
+        { :plist => plist, :dir => "#{path}/#{dir}" }
+      else
+        nil
+      end
+    end
+    .select { |plist| plist != nil }
+
+    bundleInfos = bundlePlists.map do |pair|
+      bundleID = pair[:plist][METADATA_ID]
+      bundlePath = pair[:dir]
+      dataPath = findBundleDataPath(deviceID, bundleID)
+      BundleInfo.new(bundleID, bundlePath, dataPath)
+    end
+
+    bundleInfosHash = {}
+    bundleInfos.each{ |info| bundleInfosHash[info.bundleID] = info }
+
+    bundleInfosHash
+  end
+
+end # module XCSim
+
+# eof

data/lib/xcsim/rbBundleInfo.rb

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+
+module XCSim
+  # An error, which is raised by GetBundle class when iOS Simulator OS version specified by
+  # the +:os+ option could not be found.
+  class OSNotFoundError < RuntimeError
+
+    # Name of the OS provided in +:os+ option
+    attr_reader :name
+
+    # Initializes an OSNotFoundError instance with the given OS name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+
+
+  # An error, which is raised by GetBundle class when iOS Simulator device model specified by
+  # the +:device+ option could not be found.
+  class DeviceNotFoundError < RuntimeError
+
+    # An OSDevices object corresponding to the OS version, which was used when searching
+    # for the device
+    attr_reader :os
+
+    # Device name specified in the +:device+ option
+    attr_reader :name
+
+    # Initializes a DeviceNotFoundError instance with a given os and name
+    def initialize(os, name)
+      @os = os
+      @name = name
+    end
+  end
+
+
+
+  # An error, which is raised by GetBundle class when bundle ID specified by +:bundleID+ option
+  # has not been found (even with partial match) on the device
+  class BundleNotFoundError < RuntimeError
+
+    # An OSDevices object corresponding to the OS version, which was used when searching
+    # for the application bundle
+    attr_reader :os
+
+    # A DeviceID object corresponding to the device, which was used when searching for the
+    # application bundle
+    attr_reader :device
+
+    # Bundle ID provided in +:bundleID+ option
+    attr_reader :bundleID
+
+    # Initializes a BundleNotFoundError instance with a given os, device and bundleID
+    def initialize(os, device, bundleID)
+      @os = os
+      @device = device
+      @bundleID = bundleID
+    end
+  end
+
+
+
+  # Contains information about a certain application bundle
+  class BundleInfo
+
+    # Bundle ID of the application
+    attr_reader :bundleID
+
+    # Absolute path for the application bundle directory
+    attr_reader :bundlePath
+
+    # Absolute path for the application data directory
+    attr_reader :dataPath
+
+    # Initializes a BundleInfo instance with a given +bundleID+, +bundlePath+, +dataPath+
+    def initialize(bundleID, bundlePath, dataPath)
+      @bundleID = bundleID
+      @bundlePath = bundlePath
+      @dataPath = dataPath
+    end
+
+    # Returns +bundleID+
+    def inspect
+      @bundleID
+    end
+
+    # Same as #inspect
+    def to_s
+      inspect
+    end
+  end
+
+
+
+  # A class encapsulating logic of searching for an applciation bundle in #xcsim function
+  # (i.e. implementation of #xcsim bundle mode)
+  class GetBundle
+    # Initializes a GetBundle instance with a given device set of OSDevices type
+    def initialize(deviceSet)
+      @deviceSet = deviceSet
+    end
+
+    # Performs search for the application bundle matching the provided options.
+    # See #xcsim description (Bundle Mode section) for more info.
+    #
+    # Returns a BundleInfo object
+    def withOptions(options)
+      bundleID = options[:bundleID]
+
+      if bundleID == nil
+        raise ArgumentError
+      end
+
+      os = osNamed(options[:os] || XCSim::defaultOSName)
+      device = deviceNamed(os, options[:device] || XCSim::defaultDeviceName)
+      bundles = XCSim::parseInstalledBundles(device).values
+
+      matchingBundles = bundles.select { |bundle| bundle.bundleID.end_with? bundleID }
+
+      if matchingBundles.count > 1
+        raise NonUniqueBundleIDError.new(device, bundleID, matchingBundles.map { |b| b.bundleID })
+      elsif matchingBundles.empty?
+        raise BundleNotFoundError.new(os, device, bundleID)
+      else
+        return matchingBundles.first
+      end
+    end
+
+    private
+    def osNamed(name)
+      @deviceSet[OSID.fromString(name)] || (raise OSNotFoundError.new(name))
+    end
+
+    def deviceNamed(os, name)
+      os.devices[name] || (raise DeviceNotFoundError.new(os, name))
+    end
+
+  end
+end # module XCSim
+
+# eof

data/lib/xcsim/rbConstants.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+# XCSim module contains utility for parsing iOS Simulator metadata plist files
+# and providing access to the bundle and data directories of the applications
+# installed on iOS Simulator.
+module XCSim
+
+  # Absolute path of the directory, which stores all of thr iOS Simulator data
+  SIMULATORS_ROOT = File.expand_path("~/Library/Developer/CoreSimulator/Devices")
+
+  # Path for the application bundles directory relative to a concrete iOS Simulator device dir
+  DEVICE_APP_BUNDLES_RELATIVE_PATH = "data/Containers/Bundle/Application"
+
+  # Path for the application data directory relative to a concrete iOS Simulator device dir
+  DEVICE_APP_DATA_RELATIVE_PATH = "data/Containers/Data/Application"
+
+  # Name of the +device_set.plist+ file
+  DEVICE_SET_PLIST = "device_set.plist"
+
+  # Name of the plist file containing a certain application's metadata
+  BUNDLE_METADATA_PLIST = ".com.apple.mobile_container_manager.metadata.plist"
+
+  # A key in application metadata plist file, which corresponds to the bundle ID of the application
+  METADATA_ID = "MCMMetadataIdentifier"
+
+end
+
+# eof

data/lib/xcsim/rbDeviceID.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'rbConstants'
+
+module XCSim
+
+  # DeviceID is a pair of device name string and a +GUID+, which identifies
+  # the concrete iOS Simulator in the file system. DeviceID provides access
+  # to the application bundle and application documents paths.
+  class DeviceID
+
+    # Name of the device (e.g. <tt>'iPhone 5s'</tt>)
+    attr_reader :name
+
+    # Creates a DeviceID instance from a string prefixed by a standard
+    # prefix encountered in +device_set.plist+ (+com.apple.CoreSimulator.SimDeviceType.+)
+    #
+    # Does not perform any additional validation other than checking the prefix.
+    def self.fromPrefixedString(string, guid)
+      unless string.start_with? @@PREFIX
+        return nil
+      end
+
+      name = string.sub(@@PREFIX, "").gsub("-", " ")
+        return DeviceID.new(name, guid)
+    end
+
+    # Initializes a DeviceID instance with a given name and +GUID+.
+    def initialize(name, guid)
+      @name = name
+      @guid = guid
+    end
+
+    # Returns an absolute path for application bundles directory
+    # corresponding to the given device.
+    def appBundlesPath
+      "#{SIMULATORS_ROOT}/#{@guid}/#{DEVICE_APP_BUNDLES_RELATIVE_PATH}"
+    end
+
+    # Returns an absolute path for application data directory
+    # corresponding to the given device
+    def appDataPath
+      "#{SIMULATORS_ROOT}/#{@guid}/#{DEVICE_APP_DATA_RELATIVE_PATH}"
+    end
+
+    # Returns device name
+    def inspect
+      @name
+    end
+
+    # Same as #inspect
+    def to_s
+      inspect
+    end
+
+    # Returns a string used for indexing device definitions in +device_set.plist+
+    # in +com.apple.CoreSimulator.SimDeviceType.iPad-2+ format.
+    def key
+      "#{@@PREFIX}#{@name.gsub(" ","-")}"
+    end
+
+    # Returns +inspect.hash+
+    def hash
+      inspect.hash
+    end
+
+    # Checks equality by <tt>@name</tt>
+    def eql?(other)
+      @name.eql?(other.name)
+    end
+
+    private
+    @@PREFIX = "com.apple.CoreSimulator.SimDeviceType."
+  end # class DeviceID
+
+end # module XCSim
+
+# eof

data/lib/xcsim/rbDeviceSet.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+
+require 'cfpropertylist'
+
+require_relative 'rbOSID'
+require_relative 'rbDeviceID'
+require_relative 'rbOSDevices'
+
+module XCSim
+
+  # call-seq:
+  #    parseDeviceSet(absolutePath) => Hash
+  #
+  # Parses a +device_set.plist+ file located at the given +path+
+  #
+  # Returns a Hash of <tt>OSID => OSDevices</tt> for iOS Simulator OSes,
+  # which have at least one device simulator installed.
+  def self.parseDeviceSet(path)
+    plist = CFPropertyList::List.new(:file => path)
+    plist = CFPropertyList.native_types(plist.value)
+    defaultDevices = plist["DefaultDevices"]
+
+    osIDs = defaultDevices
+      .keys
+      .map{|s| OSID.fromPrefixedString(s) }
+      .select{|id| id != nil}
+
+    oses = osIDs.map do |id|
+      osDevices = defaultDevices[id.key]
+      devices = osDevices
+        .keys
+        .map{ |s| DeviceID.fromPrefixedString(s, osDevices[s])}
+        .select{ |device| device != nil }
+        .select{ |device| File.directory? device.appBundlesPath }
+
+        (devices.count > 0) ? OSDevices.new(id, devices) : nil
+    end
+    .select{ |os| os != nil }
+
+    osHash = {}
+    oses.each{ |os| osHash[os.id] = os }
+
+    osHash
+  end
+
+  # Returns default device set of OSDevices class (as parsed by #parseDeviceSet with default
+  # iOS Simulators path)
+  def self.deviceSet
+    @@deviceSet
+  end
+
+  # Returns default OS name for use in #xcsim bundle mode when no +:os+ option is provided.
+  # Selects the OS with the highest version number as the default.
+  def self.defaultOSName
+    @@deviceSet.keys.max.to_s
+  end
+
+  # Returns the default device name for use in #xcsim bundle mode when no +:device+
+  # option is provided.
+  def self.defaultDeviceName
+    "iPhone 5s"
+  end
+
+  @@deviceSet = parseDeviceSet("#{XCSim::SIMULATORS_ROOT}/#{XCSim::DEVICE_SET_PLIST}")
+end # module XCSim
+
+# eof

data/lib/xcsim/rbList.rb

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'rbAppBundles'
+
+module XCSim
+  # An aggregate object containing information on a single iOS Simulator device
+  # returned by GetDeviceList#withPattern or GetDeviceList#allDevices
+  class DeviceListItem
+
+    # An OSDevices object corresponding to the device OS version
+    attr_reader :os
+
+    # A DeviceID object corresponding to the device
+    attr_reader :device
+
+    # An array of BundleInfo objects corresponding to the applications installed on the
+    # simulator in question
+    attr_reader :bundles
+
+    # Initializes a DeviceListItem instance with a given os, device and bundles array
+    def initialize(os, device, bundles)
+      @os = os
+      @device = device
+      @bundles = bundles
+    end
+
+    # Returns a string in <tt>"iPhone 5s (iOS 9.2)"</tt> format
+    def fullName
+      "#{device.name} (#{os.id})"
+    end
+
+    # Returns device name
+    def shortName
+      device.name
+    end
+
+    # Same as #fullName
+    def inspect
+      fullName
+    end
+
+    # Same as #inspect
+    def to_s
+      inspect
+    end
+  end
+
+
+  # A class encapsulating logic of searching available OS verions / device models / installed apps
+  # in #xcsim function (i.e. implementation of #xcsim list mode)
+  class GetDeviceList
+
+    # Initializes a GetDeviceList instance with a given device set of OSDevices class
+    def initialize(deviceSet)
+      @deviceSet = deviceSet
+    end
+
+    # Performs search for the iOS simulators matching the provided pattern.
+    # See #xcsim description (List Mode section) for more info.
+    #
+    # Returns an array of DeviceListItem
+    def withPattern(pattern)
+      if pattern.length == 0
+        return allDevices
+      else
+        pattern = parsePattern(pattern)
+        matchingOSes = getMatchingOSList(pattern[:os])
+
+        devicePairs = matchingOSes
+          .map{ |os| os.devices.values.map{ |d| {:os => os, :device => d} } }
+          .flatten
+
+        # try finding a strict match first (disambiguate "iPad Air" from "iPad Air 2")
+        # find partial matches otherwise
+        matchingDevices =
+          strictDeviceMatches(devicePairs, pattern[:device]) ||
+          partialDeviceMatches(devicePairs, pattern[:device]) ||
+          []
+
+        return matchingDevices.map do |pair|
+          DeviceListItem.new(pair[:os], pair[:device],
+            XCSim::parseInstalledBundles(pair[:device]).values)
+        end
+        .flatten
+      end
+    end
+
+    # Returns an array of DeviceListItem corresponding to all installed iOS Simulators
+    def allDevices
+      @deviceSet.values.map do |os|
+        os.devices.values.map do |device|
+          DeviceListItem.new(os, device, XCSim::parseInstalledBundles(device).values)
+        end
+      end
+      .flatten
+    end
+
+    private
+    def parsePattern(pattern)
+      components = pattern.split(",").map{ |s| s.strip }
+
+      case components.count
+      when 2
+        # assume first pattern is always for OS,
+        # second - for device
+        osPattern = components.first
+        devicePattern = components.last
+
+      when 1
+        # we don't know whether the pattern is for OS or device,
+        # try OS first
+        osPattern = components.first
+        devicePattern = nil
+        matchingOSes = getMatchingOSList(osPattern)
+
+        # if no OSes match, assume the pattern is for device
+        if matchingOSes.empty?
+          osPattern = nil
+          matchingOSes = nil
+          devicePattern = components.first
+        end
+
+      else
+        raise ArgumentError
+      end
+
+      { :os => osPattern, :device => devicePattern }
+    end
+
+    def strictDeviceMatches(osDevicePairs, pattern)
+      matches = osDevicePairs.select{ |p| p[:device].name == pattern }
+      matches.empty? ? nil : matches
+    end
+
+    def partialDeviceMatches(osDevicePairs, pattern)
+      matches = osDevicePairs.select{ |p| p[:device].name.include? (pattern || "") }
+      matches.empty? ? nil : matches
+    end
+
+    def getMatchingOSList(pattern)
+      return @deviceSet.values.select{ |os| os.id.to_s.include? (pattern || "") }
+    end
+
+  end # class GetDeviceList
+
+end # module XCSim
+
+# eof

data/lib/xcsim/rbOSDevices.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+module XCSim
+
+  # A collection of DeviceID objects related to a given iOS Simulator OS version
+  class OSDevices
+
+    # An OSID of the iOS Simulator OS version related to the OSDevices collection
+    attr_reader :id
+
+    # A hash of <tt>deviceName => DeviceID</tt>
+    attr_reader :devices
+
+    # Initializes an OSDevices instance with a given OSID and a collection of devices
+    # +id+::      OSID to associate with the OSDevices object
+    # +devices+:: A collection of DeviceID objects. Should support #each method for enumeration.
+    def initialize(id, devices)
+      @id = id
+
+      devicesHash = {}
+      devices.each{ |d| devicesHash[d.name] = d }
+
+      @devices = devicesHash
+    end
+
+    # Returns a string in <tt>'iOS 9.0 (5 devices)'</tt> format
+    def inspect
+      "#{@id.inspect} (#{@devices.count} devices)"
+    end
+
+    # Same as #inspect
+    def to_s
+      inspect
+    end
+
+    include Comparable
+
+    # Compares by +id+
+    def <=>(other)
+      @id <=> other.id
+    end
+
+  end # class OSDevicess
+
+end # module XCSim
+
+# eof

data/lib/xcsim/rbOSID.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+module XCSim
+
+  # OSID is used to uniquely identify an iOS Simulator operating system
+  # (including watchOS and tvOS operating systems) and is basically
+  # a pair of OS type string ('iOS', 'watchOS', 'tvOS') and version string
+  # ('9.0', '9.1' etc.)
+  class OSID
+    # Simulated OS type string ('iOS', 'watchOS', 'tvOS')
+    attr_reader :type
+
+    # Simulated OS version string ('7.0', '8.0', '9.0' etc.)
+    attr_reader :version
+
+    # Creates an OSID instance from a string prefixed by a standard
+    # prefix encountered in +device_set.plist+ (+com.apple.CoreSimulator.SimRuntime.+)
+    #
+    # Does not perform any additional validation other than checking the prefix.
+    def self.fromPrefixedString(string)
+      unless string.start_with? @@PREFIX
+        return nil
+      end
+
+      components = string.sub(@@PREFIX, "").split("-")
+      type = components.first
+      version = components[1..-1].join(".")
+
+      return OSID.new(type, version)
+    end
+
+    # Creates an OSID instance from a non-prefixed string. Assumes 'iOS 9.2' format
+    # where components are separated by whitespace and the first component represents
+    # OS type while all others are concatenated and assumed to represent OS version.
+    def self.fromString(string)
+      components = string.split(" ")
+      type = components.first
+      version = components[1..-1].join(".")
+
+      return OSID.new(type, version)
+    end
+
+    # Creates an OSID instance with a given type and version.
+    def initialize(type, version)
+      @type = type
+      @version = version
+    end
+
+    # Returns a string in <tt>'iOS 9.2'</tt> format
+    def inspect
+      "#{@type} #{@version}"
+    end
+
+    # Same as #inspect
+    def to_s
+      inspect
+    end
+
+    # Returns a string used for indexing OS definitions in +device_set.plist+
+    # in +com.apple.CoreSimulator.SimRuntime.iOS-7-1+ format.
+    def key
+      "#{@@PREFIX}#{@type}-#{@version.gsub(".","-")}"
+    end
+
+    include Comparable
+
+    # Uses @version for comparison (allows using <tt>Array#max</tt> on arrays of OSID
+    # for selecting max version)
+    def <=>(other)
+      @version <=> other.version
+    end
+
+    # Returns +inspect.hash+
+    def hash
+      inspect.hash
+    end
+
+    # Checks attribute-wise equality (compares @type and @version)
+    def eql?(other)
+      @type.eql?(other.type) && @version.eql?(other.version)
+    end
+
+    private
+    @@PREFIX = "com.apple.CoreSimulator.SimRuntime."
+  end # class OSID
+
+end # module XCSim
+
+# eof

data/lib/xcsim/rbReports.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+
+module XCSim
+
+  # Prepares a more human-readable report from an array of DeviceListItem objects.
+  #
+  # Depending on the unique OS versions and device models referenced by the +list+ items,
+  # may return one of the following results:
+  #
+  # List of application bundles:: When +list+ contains a single item
+  # List of device names::        When +list+ contains multiple devices from a single OS version
+  # List of OS version strings::  When +list+ contains a multiple devices from multiple OS version
+  def self.reportFromDeviceList(list)
+    uniqueOSes = list.map{ |item| item.os.id }.uniq
+    uniqueDevices = list.map { |item| item.device.name }.uniq
+
+    countByOS = {}
+    list.each do |item|
+      count = countByOS[item.os.id] || 0
+      countByOS[item.os.id] = count+1
+    end
+
+    if uniqueOSes.empty? || uniqueDevices.empty?
+      raise ArgumentError
+
+    elsif uniqueOSes.count == 1 && uniqueDevices.count == 1
+      list.first.bundles
+
+    elsif uniqueOSes.count == 1
+      list.map{ |item| item.device.name }
+
+    elsif false == (countByOS.values.include? 1)
+      countByOS.map { |id, count| "#{id} (#{count} devices)"}
+
+    else
+      list
+    end
+  end
+
+end # module XCSim
+
+#eof

data/lib/xcsim/rbXCSim.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'rbConstants'
+require_relative 'rbDeviceSet'
+require_relative 'rbList'
+
+# call-seq:
+#    xcsim(:list, pattern) => Array of DeviceListItem
+#    xcsim(:bundle, options) => BundleInfo
+#
+# Main function to call when using xcsim gem. #xcsim works in two modes: list mode and bundle
+# mode. List mode is for getting information about installed iOS Simulators, available OS versions
+# and bundle IDs of the applications installed on these smiulators. Bundle mode focuses on
+# individual applications and provides means of getting absolute paths for the application's data
+# or bundle directories.
+#
+# == List mode
+#
+# List mode is invoked by calling
+#
+#    xcsim(:list, pattern)
+#
+# Pattern is expected to be a String containing partial match for iOS version / device model pair
+# in <tt>'iOS 9.2, iPhone 5s'</tt> format. Both of the patterns are optional and coult be omitted,
+# i.e. the following calls are all valid:
+#
+#    xcsim(:list, "iOS 9.2, iPhone 5s") # exact match for both iOS version and device
+#    xcsim(:list, "iOS 9.2")            # match only iOS version
+#    xcsim(:list, "iPhone 5s")          # match only device
+#    xcsim(:list, "iOS")                # partial match for iOS version (all iOS simulators)
+#    xcsim(:list, "9.2")                # partial match for iOS version (including watchOS, tvOS etc.)
+#    xcsim(:list, "iPad")               # partial match for device model (all iPads)
+#    xcsim(:list, "9, iPhone")          # partial match for both iOS version and device model
+#
+# In list mode #xcsim function returns an array of DeviceListItem object representing
+# iOS Simulators found, which match the pattern provided. Partial matches are processed
+# in a case-sensitive manner (basically, it finds all devices, whose OS version has the provided
+# OS version pattern as a substring and whose device model contains the provided device model
+# pattern as a substring).
+#
+# Each DeviceListItem will contain info about applications installed on the corresponding
+# Simulator, excluding system apps (Safari et al.)
+#
+# Note that since #xcsim signature is
+#
+#     def xcsim(*args)
+#
+# multiple arguments may be provided to the function. In list mode all arguments are concatenated
+# into a single +pattern+ string by using single whitespace as a separator.
+#
+# == Bundle mode
+#
+# Bundle mode is invoked by calling
+#
+#    xcsim(:bundle, options)
+#
+# Options is expected to be a Hash with the following keys:
+#
+# +:bundleID+::  Specifies the bundle ID of the application in question. #xcsim will then try
+#                to locate the bundle with the ID provided and return the corresponding BundleInfo.
+#                This is the only required option.
+#
+#                Bundle ID can be partially matched. Actual bundle IDs of the applications found
+#                in the iOS Simulator are checked for having the provided bundle ID suffix, so
+#                passing <tt>"application"</tt> as the +:bundleID+ option will match bundle ID
+#                <tt>"com.yourcompany.application"</tt> for example. If multiple matches are found,
+#                the result is ambiguous and #xcsim will raise an error. See Errors section for more
+#                info.
+#
+# +:os+::        Specifies, which iOS version to use when searching in <tt>"iOS 9.2"</tt> format.
+#                If omitted, #xcsim will default the OS version to the latest one found in the
+#                parsed +device_set.plist+
+#
+# +:device+::    Specifies, which device model to use when searching in <tt>"iPad Air 2"</tt>
+#                format. If omitted, #xcsim will default the device model to <tt>"iPhone 5s"</tt>
+#
+# Note that the +:os+ and +:device+ options do not perform partial matching to the contrary of
+# what the list mode does.
+#
+# #xcsim will return a BundleInfo instance for bundle matching the options or raise an error.
+#
+# == Errors
+#
+# #xcsim may raise errors of several types when matching its results:
+#
+# ArgumentError::          An ArgumentError is raised if the parameters provided do not make sense
+#                          as described above. That is, if in list mode multiple comma-separated
+#                          components are found in the pattern string, or in bundle mode +:bundleID+
+#                          parameter is not found, an ArgumentError will be raised.
+#
+# NonUniqueBundleIDError:: XCSim::NonUniqueBundleIDError is raised when multiple data or bundle
+#                          directories are found matching the same bundle ID (should not generally
+#                          happen since bundle IDs are unique in iOS Simulator) or when partial
+#                          match of bundle ID in bundle mode finds multiple results.
+#
+# OSNotFoundError::        XCSim::OSNotFoundError is raised in bundle mode when OS version specified
+#                          by the +:os+ option cannot be found in installed iOS simulators list.
+#
+# DeviceNotFoundError::    XCSim::DeviceNotFoundError is raised in bundle mode when device model
+#                          specified by the +:device+ option cannot be found in installed iOS
+#                          simulators list for the selected OS version.
+#
+# BundleNotFoundError::    XCSim::BundleNotFoundError is raised in bundle mode when the bundle ID
+#                          specified by the +:bundleID+ option does not match any application
+#                          installed on the selected iOS Simulator.
+#
+def xcsim(*args)
+  case args.first
+  when :list
+    return XCSim::GetDeviceList.new(XCSim.deviceSet).withPattern(args[1..-1].join(" "))
+
+  when :bundle
+    raise ArgumentError if args.count != 2
+    return XCSim::GetBundle.new(XCSim.deviceSet).withOptions(args.last)
+
+  else
+    raise ArgumentError
+  end
+end
+
+# eof

data/lib/xcsim.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+begin
+  require 'cfpropertylist'
+rescue LoadError
+  puts "require 'cfpropertylist' failed! Consider running 'gem install CFPropertyList'"
+  exit
+end
+
+require_relative 'xcsim/rbXCSim'
+require_relative 'xcsim/rbReports'
+
+# eof

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: xcsim
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Egor Chiglintsev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: CFPropertyList
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: |
+  xcsim is a command-line utility to simplify opening iOS Simulator application/data directories. It's as simple as running `xcsim com.yourcompany.application`.
+email: egor.chiglintsev@gmail.com
+executables:
+- xcsim
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/xcsim
+- lib/xcsim.rb
+- lib/xcsim/rbAppBundles.rb
+- lib/xcsim/rbBundleInfo.rb
+- lib/xcsim/rbConstants.rb
+- lib/xcsim/rbDeviceID.rb
+- lib/xcsim/rbDeviceSet.rb
+- lib/xcsim/rbList.rb
+- lib/xcsim/rbOSDevices.rb
+- lib/xcsim/rbOSID.rb
+- lib/xcsim/rbReports.rb
+- lib/xcsim/rbXCSim.rb
+homepage: https://github.com/wanderwaltz/xcsim
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Open iOS Simulator application/data directories by bundle ID
+test_files: []