xcoder 0.0.21 → 0.1.0

data/lib/xcode/info_plist.rb

@@ -2,6 +2,10 @@ require 'plist'
 require 'pp'
 
 module Xcode
+  
+  #
+  # @see https://developer.apple.com/library/ios/#documentation/general/Reference/InfoPlistKeyReference/Articles/AboutInformationPropertyListFiles.html
+  # 
   class InfoPlist
     def initialize(config, plist_location)
       @config = config

data/lib/xcode/parsers/plutil_project_parser.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'plist'
+
+module Xcode
+  
+  module PLUTILProjectParser
+    extend self
+  
+    #
+    # Using the sytem tool plutil, the specified project file is parsed and 
+    # converted to XML, and then converted into a ruby hash object.
+    # 
+    def parse path
+      xml = `plutil -convert xml1 -o - "#{path}"`
+      Plist::parse_xml(xml)
+    end
+  
+  end
+  
+end

data/lib/xcode/project.rb

@@ -1,43 +1,132 @@
-require 'json'
+require 'plist'
+require 'xcode/parsers/plutil_project_parser'
+require 'xcode/resource'
 require 'xcode/target'
 require 'xcode/configuration'
 require 'xcode/scheme'
-require 'plist'
+require 'xcode/group'
+require 'xcode/file_reference'
+require 'xcode/registry'
+require 'xcode/build_phase'
+require 'xcode/variant_group'
 
 module Xcode
   class Project 
-    attr_reader :name, :targets, :sdk, :path, :schemes, :groups
+    
+    attr_reader :name, :sdk, :path, :schemes, :registry
+    
+    #
+    # Initialized with a specific path and sdk.
+    # 
+    # This initialization is not often used. Instead projects are generated
+    # through the Xcode#project method.
+    # 
+    # @see Xcode
+    #
+    # @param [String] path of the project to open.
+    # @param [String] sdk the sdk value of the project. This will default to 
+    #   `iphoneos`.
+    # 
     def initialize(path, sdk=nil)
       @sdk = sdk || "iphoneos"  # FIXME: should support OSX/simulator too
       @path = File.expand_path path
-      @targets = []
       @schemes = []
       @groups = []
       @name = File.basename(@path).gsub(/\.xcodeproj/,'')
-
-      parse_pbxproj
-      parse_schemes
-#      parse_configurations
+      
+      # Parse the Xcode project file and create the registry
+      
+      @registry = parse_pbxproj
+      @project = Xcode::Resource.new registry.root, @registry
+      
+      @schemes = parse_schemes
     end
     
-    def group(name)
-      
+    #
+    # Returns the main group of the project where all the files reside.
+    # 
+    # @return [PBXGroup]
+    # @see PBXGroup
+    # 
+    def groups
+      @project.mainGroup
+    end
+    
+    # 
+    # Save the current project at the current path that it exists.
+    # 
+    def save!
+      save @path
     end
     
-    def save
-      # Save modified groups/f
+    #
+    # Saves the current project at the specified path.
+    # 
+    # @note currently this does not support saving the workspaces associated 
+    #   with the project to their new location.
+    # 
+    # @param [String] path the path to save the project
+    #
+    def save(path)
+      Dir.mkdir(path) unless File.exists?(path)
+      
+      project_filepath = "#{path}/project.pbxproj"
+      
+      # @toodo Save the workspace when the project is saved
+      # FileUtils.cp_r "#{path}/project.xcworkspace", "#{path}/project.xcworkspace"
+      
+      File.open(project_filepath,'w') do |file|
+        
+        # The Hash#to_xcplist saves a semi-colon at the end which needs to be removed
+        # to ensure the project file can be opened.
+        
+        file.puts %{// !$*UTF8*$!"\n#{@registry.to_xcplist.gsub(/\};\s*\z/,'}')}}
+        
+      end
     end
     
+    
+    #
+    # Return the scheme with the specified name. Raises an error if no schemes 
+    # match the specified name.
+    # 
+    # @note if two schemes match names, the first matching scheme is return.
+    # 
+    # @param [String] name of the specific scheme
+    # @return [Scheme] the specific scheme that matches the name specified
+    #
     def scheme(name)
       scheme = @schemes.select {|t| t.name == name.to_s}.first
       raise "No such scheme #{name}, available schemes are #{@schemes.map {|t| t.name}.join(', ')}" if scheme.nil?
       yield scheme if block_given?
       scheme
     end
-        
+    
+    #
+    # All the targets specified within the project.
+    # 
+    # @return [Array<PBXNativeTarget>] an array of all the available targets for
+    #   the specific project.
+    # 
+    def targets
+      @project.targets.map do |target|
+        target.project = self
+        target
+      end
+    end
+    
+    #
+    # Return the target with the specified name. Raises an error if no targets
+    # match the specified name.
+    # 
+    # @note if two targets match names, the first matching target is returned.
+    # 
+    # @param [String] name of the specific target
+    # @return [PBXNativeTarget] the specific target that matches the name specified
+    #
     def target(name)
-      target = @targets.select {|t| t.name == name.to_s}.first
-      raise "No such target #{name}, available targets are #{@targets.map {|t| t.name}.join(', ')}" if target.nil?
+      target = targets.select {|t| t.name == name.to_s}.first
+      raise "No such target #{name}, available targets are #{targets.map {|t| t.name}.join(', ')}" if target.nil?
       yield target if block_given?
       target
     end
@@ -59,32 +148,42 @@ module Xcode
     
     private
   
+    #
+    # Parse all the scheme files that can be found within the project. Schemes
+    # can be defined as `shared` schemes and then `user` specific schemes. Parsing
+    # the schemes will load the shared ones and then the current acting user's
+    # schemes.
+    # 
     def parse_schemes
-      # schemes are in project/**/xcschemes/*.xcscheme
-      Dir["#{@path}/**/xcschemes/*.xcscheme"].each do |scheme|
-        @schemes << Xcode::Scheme.new(self, scheme)
+      shared_schemes = Dir["#{@path}/xcshareddata/xcschemes/*.xcscheme"]
+      user_specific_schemes = Dir["#{@path}/xcuserdata/#{ENV['USER']}.xcuserdatad/xcschemes/*.xcscheme"]
+      
+      (shared_schemes + user_specific_schemes).map do |scheme|
+        Xcode::Scheme.new(self, scheme)
       end
     end
   
+    #
+    # Using the sytem tool plutil, the specified project file is parsed and 
+    # converted to JSON, which is then converted to a hash object.
+    # 
+    # This content contains all the data within the project file and is used
+    # to create the Registry.
+    # 
+    # @return [Resource] a resource mapped to the root resource within the project
+    #   this is generally the project file which contains details about the main
+    #   group, targets, etc.
+    # 
+    # @see Registry
+    # 
     def parse_pbxproj
-      xml = `plutil -convert xml1 -o - "#{@path}/project.pbxproj"`
-      # json = JSON.parse()
-      json = Plist::parse_xml(xml)
+      registry = Xcode::PLUTILProjectParser.parse "#{@path}/project.pbxproj"
       
-      root = json['objects'][json['rootObject']]
-
-      root['targets'].each do |target_id|
-        target = Xcode::Target.new(self, json['objects'][target_id])
-        
-        buildConfigurationList = json['objects'][target_id]['buildConfigurationList']
-        buildConfigurations = json['objects'][buildConfigurationList]['buildConfigurations']
-        
-        buildConfigurations.each do |buildConfiguration|
-          target.configs << Xcode::Configuration.new(target, json['objects'][buildConfiguration])
-        end
-                
-        @targets << target
+      class << registry
+        include Xcode::Registry
       end
+      
+      registry
     end
 
   end

data/lib/xcode/registry.rb

@@ -0,0 +1,120 @@
+module Xcode
+  
+  #
+  # The Registry represents the parsed data from the Xcode Project file. Namely
+  # the registry is a Hash that provides additional functionality to allow the 
+  # the ability to query, add, and remove resources from the object hash.
+  # 
+  # Opening the Xcode project file in a text-editor you'll notice that it is a
+  # big hash/plist with a file core keys. The most important key is the 'objects'
+  # dictionary which maintains the master-list of Identifiers to properties. All 
+  # objects are represented here and all other resources use the reference
+  # to make the connection to the objects.
+  # 
+  # @see Project
+  # 
+  module Registry
+    
+    #
+    # This method is used internally to determine if the value that is being 
+    # retrieved is an identifier.
+    # 
+    # @todo this should likely be moved to the Regsitry which knows much more
+    #   about identifiers and what makes them valid.
+    # @param [String] value is the specified value in the form of an identifier
+    #
+    def self.is_identifier? value
+      value =~ /^[0-9A-F]{24}$/
+    end
+
+    #
+    # Objects within the registry contain an `isa` property, which translates
+    # to modules which can be mixed in to provide additional functionality.
+    # 
+    # @param [String] isa the type of the object.
+    #
+    def self.isa_to_module isa
+
+      { 'XCBuildConfiguration' => Configuration,
+        'PBXFileReference' => FileReference,
+        'PBXGroup' => Group,
+        'PBXNativeTarget' => Target,
+        'PBXAggregateTarget' => Target,
+        'PBXFrameworksBuildPhase' => BuildPhase,
+        'PBXSourcesBuildPhase' => BuildPhase,
+        'PBXResourcesBuildPhase' => BuildPhase,
+        'PBXBuildFile' => BuildFile,
+        'PBXVariantGroup' => VariantGroup }[isa]
+    
+    end
+    
+    #
+    # This is the root object of the project. This is generally an identifier
+    # pointing to a project.
+    # 
+    def root
+      self['rootObject']
+    end
+    
+    
+    #
+    # This is a hash of all the objects within the project. The keys are the
+    # unique identifiers which are 24 length hexadecimal strings. The values
+    # are the objects that the keys represent.
+    # 
+    # @return [Hash] that contains all the objects in the project. 
+    # 
+    def objects
+      self['objects']
+    end
+    
+    #
+    # 
+    # @return [String] the object associated with this identifier; nil if no 
+    #   object matches the identifier.
+    # 
+    def object(identifier)
+      objects[identifier]
+    end
+    
+    #
+    # Provides a method to generically add objects to the registry. This will
+    # create a unqiue identifier and add the specified parameters to the 
+    # registry. As all objecst within a the project maintain a reference to this
+    # registry they can immediately query for newly created items.
+    # 
+    # @note generally this method should not be called directly and instead 
+    #   resources should provide the ability to assist with generating the 
+    #   correct objects for the registry.
+    # 
+    # @param [Hash] object_properties a hash that contains all the properties
+    #   that are known for the particular item.
+    # 
+    def add_object(object_properties)
+      # define a new group within the object list
+      # add it as a child
+      
+      range = ('A'..'F').to_a + (0..9).to_a
+      
+      new_identifier = 24.times.inject("") {|ident| "#{ident}#{range.sample}" }
+      
+      # TODO ensure identifier does not collide with other identifiers
+      
+      objects[new_identifier] = object_properties
+      
+      new_identifier
+    end
+
+    #
+    # @note removing an item from the regitry does not remove all references
+    #   to the item within the project. At this time, this could leave resources
+    #   with references to resources that are invalid.
+    # 
+    # @param [String] identifier of the object to remove from the registry.
+    #
+    def remove_object(identifier)
+      objects.delete identifier
+    end
+    
+  end
+end

data/lib/xcode/resource.rb

@@ -0,0 +1,187 @@
+
+module Xcode
+  
+  #
+  # Resources are not represented as a true entity within an Xcode project.
+  # When traversing through groups, targets, configurations, etc. you will find
+  # yourself interacting with these objects. As they represent a class that
+  # acts as a shim around the hash data is parsed from the project.
+  # 
+  # A resource do some things that should be explained:
+  # 
+  # When a resource is created it requires an identifier and an instance of
+  # of the Registry. It finds the properties hash of that given identifier 
+  # within the registry and creates a bunch of read-only methods that allow for 
+  # easy access to those elements. This is not unlike an OpenStruct.
+  # 
+  # @example of accessing the contents of a file reference
+  # 
+  #     file_resource.properties # => 
+  # 
+  #     { 'isa' => 'PBXFileReference',
+  #       'lastKnownFileType' => 'sourcecode.c.h',
+  #       'path' => IOSAppDelegate.h', 
+  #       'sourceTree' => "<group>" }
+  # 
+  #     file_resource.isa # => 'PBXFileReference'
+  #     file_resource.sourceTree # => "<group>"
+  #
+  # 
+  # To provide additional convenience when traversing through the
+  # various objects, the read-only method will check to see if the value
+  # being returned matches that of a unique identifier. If it does, instead of
+  # providing that identifier as a result and then having additional code to
+  # perform the look up, it does it automatically.
+  # 
+  # @example of how this would have to been done without this indirection
+  # 
+  #     project = Xcode.project('MyProject')
+  #     main_group = project.groups
+  #     child_identifier = group.children.first
+  #     subgroup = project.registry['objects'][child_identifier]
+  #     
+  # @example of hot this works currently because of this indirection
+  # 
+  #     group = Xcode.project('MyProject.xcodeproj').mainGroup
+  #     subgroup = group.group('Models')
+  # 
+  # 
+  # Next, as most every one of these objects is a Hash that contain the properties
+  # instead of objects it would likely be better to encapsulate these resources
+  # within specific classes that provide additional functionality. So that when 
+  # a group resource or a file resource is returned you can perform unique 
+  # functionality with it automatically.
+  # 
+  # This is done by using the 'isa' property field which contains the type of
+  # content object. Instead of creating an object and encapsulating if a module
+  # that matches the name of the 'isa', that module of functionality is 
+  # automatically mixed-in to provide that functionality.
+  # 
+  class Resource
+    
+    # The unique identifier for this resource
+    attr_accessor :identifier
+    
+    # The properties hash that is known about the resource
+    attr_accessor :properties
+    
+    # The registry of all objects within the project file which all resources
+    # have a reference to so that they can retrieve any items they may own that
+    # are simply referenced by identifiers.
+    attr_accessor :registry
+    
+    #
+    # Definiing a property allows the creation of an alias to the actual value.
+    # This level of indirection allows for the replacement of values which are
+    # identifiers with a resource representation of it.
+    # 
+    # @note This is used internally by the resource when it is created.
+    # 
+    # @param [String] name of the property
+    # @param [String] value of the property
+    # 
+    def define_property name, value
+      
+      # Save the properties within the resource within a custom hash. This 
+      # provides access to them without the indirection that we are about to
+      # set up.
+      
+      @properties[name] = value
+      
+      # Generate a getter method for this property based on the given name.
+      
+      self.class.send :define_method, name do
+        
+        # Retrieve the value that is current stored for this name.
+        
+        raw_value = @properties[name]
+        
+        # If the value is an array then we want to examine each element within
+        # the array to see if any of them are identifiers that we should replace
+        # finally returning all of the items as their resource representations
+        # or as their raw values.
+        # 
+        # If the value is not an array then we want to examine that item and
+        # return the resource representation or the raw value.
+        
+        if raw_value.is_a?(Array)
+          
+          Array(raw_value).map do |sub_value|
+            
+            if Registry.is_identifier? sub_value 
+              Resource.new sub_value, @registry
+            else
+              sub_value
+            end
+          end
+          
+        else 
+          
+          if Registry.is_identifier? raw_value
+            Resource.new raw_value, @registry
+          else 
+            raw_value
+          end
+          
+        end
+
+      end
+      
+    end
+
+    #
+    # Within the code, a single resource is created and that is with the root
+    # projet object. All other resources are created through the indirecation of
+    # the above property methods.
+    # 
+    # @param [String] identifier the unique identifier for this resource.
+    # @param [Types] details Description
+    #
+    def initialize identifier, details
+      @registry = details
+      @properties = {}
+      @identifier = identifier
+      
+      # Create property methods for all of the key-value pairs found in the
+      # registry for specified identifier.
+      
+      Array(details.object(@identifier)).each do |key,value| 
+        send :define_property, key, value
+      end
+      
+      #  
+      # Based on the `isa` property find if there is a constant within
+      # the Xcode module that matches and if it does, then we want to 
+      # automatically include module into the Resource object.
+      # 
+      constant = Registry.isa_to_module(isa)
+        
+      self.extend(constant) if constant
+      
+    end
+    
+    #
+    # @return [String] a representation with the identifier and the properties 
+    #   for this resource.
+    # 
+    def to_s
+      "#{isa} #{@identifier} #{@properties}"
+    end
+    
+    #
+    # This will generate the resource in the format that is supported by the
+    # Xcode project file. Which requires each key value pair to be represented.
+    # 
+    # @return [String] a string representation of the object so that it can
+    #   be persisted to an Xcode project file.
+    # 
+    def to_xcplist
+      %{
+        #{@identifier} = { #{ @properties.map {|k,v| "#{k} = \"#{v}\"" }.join("; ") } }
+        
+      }
+    end
+    
+  end
+  
+end