xcoder 0.1.1 → 0.1.2

data/lib/xcode/resource.rb

@@ -0,0 +1,203 @@
+require 'xcode/core_ext/string'
+
+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.underscore 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
+      
+      self.class.send :define_method, "#{name.underscore}=" do |new_value|
+        @properties[name] = new_value
+      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.properties(@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
+    
+    
+    #
+    # Saves the current resource back to the registry. This is necessary as
+    # any changes made are not automatically saved back into the registry.
+    # 
+    def save!
+      @registry.set_object(self)
+      self
+    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.to_xcplist}\"" }.join("; ") } }
+        
+      }
+    end
+    
+  end
+  
+end

data/lib/xcode/scheme.rb

@@ -0,0 +1,36 @@
+require 'nokogiri'
+
+module Xcode
+  
+  # Schemes are an XML file that describe build, test, launch and profile actions
+  # For the purposes of Xcoder, we want to be able to build and test
+  # The scheme's build action only describes a target, so we need to look at launch for the config
+  class Scheme
+    attr_reader :project, :path, :name, :launch, :test
+    def initialize(project, path)
+      @project = project
+      @path = File.expand_path(path)
+      @name = File.basename(path).gsub(/\.xcscheme$/,'')
+      doc = Nokogiri::XML(open(@path))
+      
+      @launch = parse_action(doc, 'launch')
+      @test = parse_action(doc, 'test')
+    end
+    
+    def builder
+      Xcode::Builder.new(self)
+    end
+    
+    private 
+    
+    def parse_action(doc, action_name)
+      action = doc.xpath("//#{action_name.capitalize}Action").first
+      buildableReference = action.xpath('BuildableProductRunnable/BuildableReference').first
+      return nil if buildableReference.nil?
+      
+      target_name = buildableReference['BlueprintName']
+      @project.target(target_name).config(action['buildConfiguration'])
+    end
+
+  end
+end

data/lib/xcode/shell.rb

@@ -0,0 +1,22 @@
+module Xcode
+  module Shell
+    
+    def self.execute(bits, show_output=true)
+      out = []
+      cmd = bits.is_a?(Array) ? bits.join(' ') : bits
+      
+      puts "EXECUTE: #{cmd}"
+      IO.popen (cmd) do |f| 
+        f.each do |line|
+          puts line if show_output
+          yield(line) if block_given?
+          out << line
+        end 
+      end
+      #Process.wait
+      raise "Error (#{$?.exitstatus}) executing '#{cmd}'\n\n  #{out.join("  ")}" if $?.exitstatus>0
+      #puts "RETURN: #{out.inspect}"
+      out
+    end
+  end
+end

data/lib/xcode/simple_identifier_generator.rb

@@ -0,0 +1,17 @@
+module SimpleIdentifierGenerator
+  extend self
+  
+  #
+  # Generate an identifier string
+  # 
+  # @example identifier string
+  # 
+  #     "E21EB9EE14E359840058122A"
+  # 
+  # @return [String] a 24-length string that contains only hexadecimal characters.
+  # 
+  def generate
+    range = ('A'..'F').to_a + (0..9).to_a
+    24.times.inject("") {|ident| "#{ident}#{range.sample}" }
+  end
+end

data/lib/xcode/target.rb

@@ -0,0 +1,204 @@
+require_relative 'build_file'
+
+module Xcode
+  
+  #
+  # Within a project a user may define a number of targets. These targets may
+  # be to generate the application, generate a universal framework, or execute
+  # tests.
+  # 
+  # 
+  # @example Target as Hash
+  # 
+  #    E21D8AA914E0F817002E56AA /* newtarget */ = {
+  #        isa = PBXNativeTarget;
+  #        buildConfigurationList = E21D8ABD14E0F817002E56AA /* Build configuration list for PBXNativeTarget "newtarget" */;
+  #        buildPhases = (
+  #          E21D8AA614E0F817002E56AA /* Sources */,
+  #          E21D8AA714E0F817002E56AA /* Frameworks */,
+  #          E21D8AA814E0F817002E56AA /* Resources */,
+  #        );
+  #        buildRules = (
+  #        );
+  #        dependencies = (
+  #        );
+  #        name = newtarget;
+  #        productName = newtarget;
+  #        productReference = E21D8AAA14E0F817002E56AA /* newtarget.app */;
+  #        productType = "com.apple.product-type.application";
+  #      };
+  #   
+  # @todo provide more targets, based on the properties hash generated from Xcode
+  # 
+  module Target
+    
+    #
+    # This is a generic properties hash for an ios target
+    # @todo this target should create by default the sources, frameworks, and 
+    #   resources build phases.
+    # 
+    def self.ios
+      { 'isa' => 'PBXNativeTarget',
+        'buildConfigurationList' => nil,
+        'buildPhases' => [],
+        'buildRules' => [],
+        'dependencies' => [],
+        'name' => '',
+        'productName' => '',
+        'productReference' => '',
+        'productType' => 'com.apple.product-type.application' }
+    end
+    
+    # A reference to the project for which these targets reside.
+    attr_accessor :project
+    
+    #
+    # @return [PBXBuildConfiguration] the configurations that this target supports.
+    #   these are generally 'Debug' or 'Release' but may be custom designed
+    #   configurations.
+    # 
+    def configs
+      build_configuration_list.build_configurations.map do |config|
+        config.target = self
+        config
+      end
+    end
+    
+    #
+    # Return a specific build configuration. When one is not found to match,
+    # an exception is raised.
+    # 
+    # @param [String] name of a configuration to return
+    # @return [PBXBuildConfiguration] a specific build configuration that 
+    #   matches the specified name.
+    #
+    def config(name)
+      config = configs.select {|config| config.name == name.to_s }.first
+      raise "No such config #{name}, available configs are #{configs.map {|c| c.name}.join(', ')}" if config.nil?
+      yield config if block_given?
+      config
+    end
+    
+    #
+    # Create a configuration for the target.
+    # 
+    # @example debug configuration
+    # 
+    #   target.create_config 'Debug' do |config|
+    #     # configuration the new debug config.
+    #   end
+    # 
+    # @param [String] name of the configuration to create
+    # @return [BuildConfiguration] that is created
+    #
+    def create_configuration(name)
+      # To create a configuration, we need to create or retrieve the configuration list
+      
+      created_config = build_configuration_list.create_config(name) do |config|
+        yield config if block_given?
+      end
+      
+      created_config
+    end
+
+    def create_configurations(*configuration_names)
+      
+      configuration_names.compact.flatten.map do |config_name|
+        created_config = create_configuration config_name do |config|
+          yield config if block_given?
+        end
+        
+        created_config.save!
+      end
+      
+    end
+    
+    # 
+    # @return [BuildPhase] the framework specific build phase of the target.
+    # 
+    def framework_build_phase
+      build_phase 'PBXFrameworksBuildPhase'
+    end
+    
+    #
+    # @return [BuildPhase] the sources specific build phase of the target.
+    # 
+    def sources_build_phase
+      build_phase 'PBXSourcesBuildPhase'
+    end
+    
+    #
+    # @return [BuildPhase] the resources specific build phase of the target.
+    # 
+    def resources_build_phase
+      build_phase 'PBXResourcesBuildPhase'
+    end
+    
+    def build_phase(type,&block)
+      found_build_phase = build_phases.find {|phase| phase.isa == type }
+      found_build_phase.instance_eval(&block) if block_given?
+      found_build_phase
+    end
+    #
+    # @example building the three main phases for a target.
+    # 
+    #     target.create_build_phase :sources
+    # 
+    #     target.create_build_phase :resources do |phase|
+    #       # each phase that is created.
+    #     end
+    # 
+    # @param [String] phase_name the name of the phase to add to the target
+    # @return [BuildPhase] the BuildPhase that is created
+    def create_build_phase(phase_name)
+      
+      # Register a BuildPhase with the default properties specified by the name.
+      build_phase = @registry.add_object(BuildPhase.send("#{phase_name}"))
+      
+      # Add the build phase to the list of build phases for this target.
+      # @todo this is being done commonly in the application in multiple places
+      #   and it bugs me. Perhaps some special module could be mixed into the
+      #   Array of results that are returned.
+      @properties['buildPhases'] << build_phase.identifier
+      
+      yield build_phase if block_given?
+      
+      build_phase.save!
+    end
+    
+    # 
+    # Create multiple build phases at the same time.
+    # 
+    # @param [Array<String,Symbol>] base_phase_names are the names of the phases
+    #   that you want to create for a target.
+    # 
+    # @return [Array] the phases created. 
+    #
+    def create_build_phases *base_phase_names
+      
+      base_phase_names.compact.flatten.map do |phase_name|
+        build_phase = create_build_phase phase_name do |build_phase|
+          yield build_phase if block_given?
+        end
+        
+        build_phase.save!
+      end
+      
+    end
+    
+    #
+    # Create a product reference file and add it to the product. This is by
+    # default added to the 'Products' group.
+    # 
+    # @param [String] name of the product reference to add to the product
+    # @return [Resource] the product created
+    #
+    def create_product_reference(name)
+      product = project.products_group.create_product_reference(name)
+      product_reference = product.identifier
+      product
+    end
+    
+  end
+  
+end