xcodeproj 0.2.0 → 0.3.0

data/lib/xcodeproj/config.rb

@@ -7,12 +7,12 @@ module Xcodeproj
     # @param [Hash, File, String] xcconfig_hash_or_file  Initial data.
     require 'set'
 
-    attr_accessor :attributes, :frameworks ,:libraries
+    attr_accessor :attributes, :frameworks, :weak_frameworks ,:libraries
 
     def initialize(xcconfig_hash_or_file = {})
       @attributes = {}
       @includes = []
-      @frameworks, @libraries = Set.new, Set.new
+      @frameworks, @weak_frameworks, @libraries = Set.new, Set.new, Set.new
       merge!(extract_hash(xcconfig_hash_or_file))
     end
 
@@ -23,6 +23,7 @@ module Xcodeproj
       flags = flags.dup.strip
       flags << libraries.to_a.sort.reduce('')  {| memo, l | memo << " -l#{l}" }
       flags << frameworks.to_a.sort.reduce('') {| memo, f | memo << " -framework #{f}" }
+      flags << weak_frameworks.to_a.sort.reduce('') {| memo, f | memo << " -weak_framework #{f}" }
       hash['OTHER_LDFLAGS'] = flags.strip
       hash.delete('OTHER_LDFLAGS') if flags.strip.empty?
       hash
@@ -63,6 +64,7 @@ module Xcodeproj
         @attributes.merge!(xcconfig.attributes) { |key, v1, v2| "#{v1} #{v2}" }
         @libraries.merge   xcconfig.libraries
         @frameworks.merge  xcconfig.frameworks
+        @weak_frameworks.merge  xcconfig.weak_frameworks
       else
       @attributes.merge!(xcconfig.to_hash) { |key, v1, v2| "#{v1} #{v2}" }
       # Parse frameworks and libraries. Then remove the from the linker flags
@@ -70,12 +72,15 @@ module Xcodeproj
       return unless flags
 
       frameworks = flags.scan(/-framework\s+([^\s]+)/).map { |m| m[0] }
+      weak_frameworks = flags.scan(/-weak_framework\s+([^\s]+)/).map { |m| m[0] }
       libraries  = flags.scan(/-l ?([^\s]+)/).map { |m| m[0] }
       @frameworks.merge frameworks
+      @weak_frameworks.merge weak_frameworks
       @libraries.merge libraries
 
       new_flags = flags.dup
       frameworks.each {|f| new_flags.gsub!("-framework #{f}", "") }
+      weak_frameworks.each {|f| new_flags.gsub!("-weak_framework #{f}", "") }
       libraries.each  {|l| new_flags.gsub!("-l#{l}", ""); new_flags.gsub!("-l #{l}", "") }
       @attributes['OTHER_LDFLAGS'] = new_flags.gsub("\w*", ' ').strip
       end

data/lib/xcodeproj/project/association/reflection.rb

@@ -1,5 +1,3 @@
-require 'xcodeproj/inflector'
-
 module Xcodeproj
   class Project
     module Object

data/lib/xcodeproj/project/object/configuration.rb

@@ -13,9 +13,6 @@ module Xcodeproj
             'ALWAYS_SEARCH_USER_PATHS'          => 'NO',
             'GCC_C_LANGUAGE_STANDARD'           => 'gnu99',
             'INSTALL_PATH'                      => "$(BUILT_PRODUCTS_DIR)",
-            'GCC_WARN_ABOUT_MISSING_PROTOTYPES' => 'YES',
-            'GCC_WARN_ABOUT_RETURN_TYPE'        => 'YES',
-            'GCC_WARN_UNUSED_VARIABLE'          => 'YES',
             'OTHER_LDFLAGS'                     => '',
             'COPY_PHASE_STRIP'                  => 'YES',
           }.freeze,
@@ -35,7 +32,6 @@ module Xcodeproj
           :osx => {
             'ARCHS'                             => "$(ARCHS_STANDARD_64_BIT)",
             'GCC_ENABLE_OBJC_EXCEPTIONS'        => 'YES',
-            'GCC_WARN_64_TO_32_BIT_CONVERSION'  => 'YES',
             'GCC_VERSION'                       => 'com.apple.compilers.llvm.clang.1_0',
             'MACOSX_DEPLOYMENT_TARGET'          => '10.7',
             'SDKROOT'                           => 'macosx',

data/lib/xcodeproj/project/object/group.rb

@@ -92,11 +92,31 @@ module Xcodeproj
           groups.new("name" => name)
         end
 
+        def version_groups
+          children.list_by_class(XCVersionGroup)
+        end
+
         def <<(child)
           children << child
         end
       end
 
+      class XCVersionGroup < PBXGroup
+
+        attribute :version_group_type
+        attribute :current_version
+
+        def self.new_xcdatamodel_group(project, xcdatamodel_path)
+          group = new(project, nil, 'versionGroupType' => 'wrapper.xcdatamodel')
+          file = group.files.new(
+            'path' => xcdatamodel_path.sub(/xcdatamodeld$/, 'xcdatamodel'),
+            'lastKnownFileType' => 'wrapper.xcdatamodel'
+          )
+          group.current_version = file.uuid
+          group
+        end
+      end
+
     end
   end
 end

data/lib/xcodeproj/project/object.rb

@@ -1,4 +1,4 @@
-require 'xcodeproj/inflector'
+require 'active_support/inflector'
 
 module Xcodeproj
   class Project

data/lib/xcodeproj/project.rb

@@ -167,16 +167,21 @@ module Xcodeproj
     #                             directory.
     # @return [PBXFileReference]  The file reference object.
     def add_system_framework(name)
-      group = groups.where('name' => 'Frameworks') || groups.new('name' => 'Frameworks')
-      group.files.new({
-        'name' => "#{name}.framework",
-        'path' => "System/Library/Frameworks/#{name}.framework",
-        'sourceTree' => 'SDKROOT'
-      })
+      path = "System/Library/Frameworks/#{name}.framework"
+      if file = files.where(:path => path)
+        file
+      else
+        group = groups.where('name' => 'Frameworks') || groups.new('name' => 'Frameworks')
+        group.files.new({
+          'name' => "#{name}.framework",
+          'path' => path,
+          'sourceTree' => 'SDKROOT'
+        })
+      end
     end
 
-    # @return [PBXObjectList<XCBuildConfiguration]  A list of project wide
-    #                                               build configurations.
+    # @return [PBXObjectList<XCBuildConfiguration>]  A list of project wide
+    #                                                build configurations.
     def build_configurations
       root_object.build_configuration_list.build_configurations
     end

data/lib/xcodeproj.rb

@@ -1,6 +1,6 @@
 module Xcodeproj
-  VERSION = '0.2.0'
-  
+  VERSION = '0.3.0'
+
   autoload :Config,    'xcodeproj/config'
   autoload :Project,   'xcodeproj/project'
   autoload :Workspace, 'xcodeproj/workspace'

metadata

@@ -1,27 +1,46 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: xcodeproj
-version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
-authors:
+authors: 
 - Eloy Duran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-01 00:00:00.000000000 Z
-dependencies: []
-description: Xcodeproj lets you create and modify Xcode projects from Ruby. Script
-  boring management tasks or build Xcode-friendly libraries. Also includes support
-  for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
+
+date: 2012-07-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 2
+        - 6
+        version: 3.2.6
+  type: :runtime
+  version_requirements: *id001
+description: Xcodeproj lets you create and modify Xcode projects from Ruby. Script boring management tasks or build Xcode-friendly libraries. Also includes support for Xcode workspaces (.xcworkspace) and configuration files (.xcconfig).
 email: eloy.de.enige@gmail.com
 executables: []
-extensions:
+
+extensions: 
 - ext/xcodeproj/extconf.rb
 extra_rdoc_files: []
-files:
+
+files: 
 - lib/xcodeproj/config.rb
-- lib/xcodeproj/inflector.rb
 - lib/xcodeproj/project/association/has_many.rb
 - lib/xcodeproj/project/association/has_one.rb
 - lib/xcodeproj/project/association/reflection.rb
@@ -40,31 +59,36 @@ files:
 - ext/xcodeproj/xcodeproj_ext.c
 - README.md
 - LICENSE
+has_rdoc: true
 homepage: https://github.com/cocoapods/xcodeproj
-licenses:
+licenses: 
 - MIT
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - ext
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Create and modify Xcode projects from Ruby.
 test_files: []
-has_rdoc: 
+

data/lib/xcodeproj/inflector.rb

@@ -1,453 +0,0 @@
-# encoding: utf-8
-
-# This is part of ActiveSupport, which is available under the MIT license>
-#
-# Copyright (c) 2005-2010 David Heinemeier Hansson
-#
-# From files:
-# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/inflector.rb
-# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/inflections.rb
-# * https://raw.github.com/rails/rails/2-3-stable/activesupport/lib/active_support/core_ext/string/inflections.rb
-
-require 'singleton'
-
-module Xcodeproj
-  module ActiveSupport
-    # The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
-    # and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
-    # in inflections.rb.
-    #
-    # The Rails core team has stated patches for the inflections library will not be accepted
-    # in order to avoid breaking legacy applications which may be relying on errant inflections.
-    # If you discover an incorrect inflection and require it for your application, you'll need
-    # to correct it yourself (explained below).
-    module Inflector
-      extend self
-
-      # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
-      # inflection rules. Examples:
-      #
-      #   ActiveSupport::Inflector.inflections do |inflect|
-      #     inflect.plural /^(ox)$/i, '\1\2en'
-      #     inflect.singular /^(ox)en/i, '\1'
-      #
-      #     inflect.irregular 'octopus', 'octopi'
-      #
-      #     inflect.uncountable "equipment"
-      #   end
-      #
-      # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
-      # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
-      # already have been loaded.
-      class Inflections
-        include Singleton
-
-        attr_reader :plurals, :singulars, :uncountables, :humans
-
-        def initialize
-          @plurals, @singulars, @uncountables, @humans = [], [], [], []
-        end
-
-        # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
-        # The replacement should always be a string that may include references to the matched data from the rule.
-        def plural(rule, replacement)
-          @uncountables.delete(rule) if rule.is_a?(String)
-          @uncountables.delete(replacement)
-          @plurals.insert(0, [rule, replacement])
-        end
-
-        # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
-        # The replacement should always be a string that may include references to the matched data from the rule.
-        def singular(rule, replacement)
-          @uncountables.delete(rule) if rule.is_a?(String)
-          @uncountables.delete(replacement)
-          @singulars.insert(0, [rule, replacement])
-        end
-
-        # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
-        # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
-        #
-        # Examples:
-        #   irregular 'octopus', 'octopi'
-        #   irregular 'person', 'people'
-        def irregular(singular, plural)
-          @uncountables.delete(singular)
-          @uncountables.delete(plural)
-          if singular[0,1].upcase == plural[0,1].upcase
-            plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
-            singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
-          else
-            plural(Regexp.new("#{singular[0,1].upcase}(?i)#{singular[1..-1]}$"), plural[0,1].upcase + plural[1..-1])
-            plural(Regexp.new("#{singular[0,1].downcase}(?i)#{singular[1..-1]}$"), plural[0,1].downcase + plural[1..-1])
-            singular(Regexp.new("#{plural[0,1].upcase}(?i)#{plural[1..-1]}$"), singular[0,1].upcase + singular[1..-1])
-            singular(Regexp.new("#{plural[0,1].downcase}(?i)#{plural[1..-1]}$"), singular[0,1].downcase + singular[1..-1])
-          end
-        end
-
-        # Add uncountable words that shouldn't be attempted inflected.
-        #
-        # Examples:
-        #   uncountable "money"
-        #   uncountable "money", "information"
-        #   uncountable %w( money information rice )
-        def uncountable(*words)
-          (@uncountables << words).flatten!
-        end
-
-        # Specifies a humanized form of a string by a regular expression rule or by a string mapping.
-        # When using a regular expression based replacement, the normal humanize formatting is called after the replacement.
-        # When a string is used, the human form should be specified as desired (example: 'The name', not 'the_name')
-        #
-        # Examples:
-        #   human /_cnt$/i, '\1_count'
-        #   human "legacy_col_person_name", "Name"
-        def human(rule, replacement)
-          @humans.insert(0, [rule, replacement])
-        end
-
-        # Clears the loaded inflections within a given scope (default is <tt>:all</tt>).
-        # Give the scope as a symbol of the inflection type, the options are: <tt>:plurals</tt>,
-        # <tt>:singulars</tt>, <tt>:uncountables</tt>, <tt>:humans</tt>.
-        #
-        # Examples:
-        #   clear :all
-        #   clear :plurals
-        def clear(scope = :all)
-          case scope
-            when :all
-              @plurals, @singulars, @uncountables = [], [], []
-            else
-              instance_variable_set "@#{scope}", []
-          end
-        end
-      end
-
-      # Yields a singleton instance of Inflector::Inflections so you can specify additional
-      # inflector rules.
-      #
-      # Example:
-      #   ActiveSupport::Inflector.inflections do |inflect|
-      #     inflect.uncountable "rails"
-      #   end
-      def inflections
-        if block_given?
-          yield Inflections.instance
-        else
-          Inflections.instance
-        end
-      end
-
-      # Returns the plural form of the word in the string.
-      #
-      # Examples:
-      #   "post".pluralize             # => "posts"
-      #   "octopus".pluralize          # => "octopi"
-      #   "sheep".pluralize            # => "sheep"
-      #   "words".pluralize            # => "words"
-      #   "CamelOctopus".pluralize     # => "CamelOctopi"
-      def pluralize(word)
-        result = word.to_s.dup
-
-        if word.empty? || inflections.uncountables.include?(result.downcase)
-          result
-        else
-          inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-          result
-        end
-      end
-
-      # The reverse of +pluralize+, returns the singular form of a word in a string.
-      #
-      # Examples:
-      #   "posts".singularize            # => "post"
-      #   "octopi".singularize           # => "octopus"
-      #   "sheep".singluarize            # => "sheep"
-      #   "word".singularize             # => "word"
-      #   "CamelOctopi".singularize      # => "CamelOctopus"
-      def singularize(word)
-        result = word.to_s.dup
-
-        if inflections.uncountables.any? { |inflection| result =~ /#{inflection}\Z/i }
-          result
-        else
-          inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-          result
-        end
-      end
-
-      # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
-      # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
-      #
-      # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-      #
-      # Examples:
-      #   "active_record".camelize                # => "ActiveRecord"
-      #   "active_record".camelize(:lower)        # => "activeRecord"
-      #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-      #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-        if first_letter_in_uppercase
-          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-        else
-          lower_case_and_underscored_word[0,1].downcase + camelize(lower_case_and_underscored_word)[1..-1]
-        end
-      end
-
-      # Capitalizes all the words and replaces some characters in the string to create
-      # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-      # used in the Rails internals.
-      #
-      # +titleize+ is also aliased as as +titlecase+.
-      #
-      # Examples:
-      #   "man from the boondocks".titleize # => "Man From The Boondocks"
-      #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
-      def titleize(word)
-        humanize(underscore(word)).gsub(/\b('?[a-z])/) { $1.capitalize }
-      end
-
-      # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-      #
-      # Changes '::' to '/' to convert namespaces to paths.
-      #
-      # Examples:
-      #   "ActiveRecord".underscore         # => "active_record"
-      #   "ActiveRecord::Errors".underscore # => active_record/errors
-      def underscore(camel_cased_word)
-        camel_cased_word.to_s.gsub(/::/, '/').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          tr("-", "_").
-          downcase
-      end
-
-      # Replaces underscores with dashes in the string.
-      #
-      # Example:
-      #   "puni_puni" # => "puni-puni"
-      def dasherize(underscored_word)
-        underscored_word.gsub(/_/, '-')
-      end
-
-      # Capitalizes the first word and turns underscores into spaces and strips a
-      # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
-      #
-      # Examples:
-      #   "employee_salary" # => "Employee salary"
-      #   "author_id"       # => "Author"
-      def humanize(lower_case_and_underscored_word)
-        result = lower_case_and_underscored_word.to_s.dup
-
-        inflections.humans.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-        result.gsub(/_id$/, "").gsub(/_/, " ").capitalize
-      end
-
-      # Removes the module part from the expression in the string.
-      #
-      # Examples:
-      #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-      #   "Inflections".demodulize                                       # => "Inflections"
-      def demodulize(class_name_in_module)
-        class_name_in_module.to_s.gsub(/^.*::/, '')
-      end
-
-      # Create a class name from a plural table name like Rails does for table names to models.
-      # Note that this returns a string and not a Class. (To convert to an actual class
-      # follow +classify+ with +constantize+.)
-      #
-      # Examples:
-      #   "egg_and_hams".classify # => "EggAndHam"
-      #   "posts".classify        # => "Post"
-      #
-      # Singular names are not handled correctly:
-      #   "business".classify     # => "Busines"
-      def classify(table_name)
-        # strip out any leading schema name
-        camelize(singularize(table_name.to_s.sub(/.*\./, '')))
-      end
-
-      # Turns a number into an ordinal string used to denote the position in an
-      # ordered sequence such as 1st, 2nd, 3rd, 4th.
-      #
-      # Examples:
-      #   ordinalize(1)     # => "1st"
-      #   ordinalize(2)     # => "2nd"
-      #   ordinalize(1002)  # => "1002nd"
-      #   ordinalize(1003)  # => "1003rd"
-      def ordinalize(number)
-        if (11..13).include?(number.to_i % 100)
-          "#{number}th"
-        else
-          case number.to_i % 10
-            when 1; "#{number}st"
-            when 2; "#{number}nd"
-            when 3; "#{number}rd"
-            else    "#{number}th"
-          end
-        end
-      end
-    end
-
-    Inflector.inflections do |inflect|
-      inflect.plural(/$/, 's')
-      inflect.plural(/s$/i, 's')
-      inflect.plural(/(ax|test)is$/i, '\1es')
-      inflect.plural(/(octop|vir)us$/i, '\1i')
-      inflect.plural(/(alias|status)$/i, '\1es')
-      inflect.plural(/(bu)s$/i, '\1ses')
-      inflect.plural(/(buffal|tomat)o$/i, '\1oes')
-      inflect.plural(/([ti])um$/i, '\1a')
-      inflect.plural(/sis$/i, 'ses')
-      inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
-      inflect.plural(/(hive)$/i, '\1s')
-      inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
-      inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
-      inflect.plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
-      inflect.plural(/([m|l])ouse$/i, '\1ice')
-      inflect.plural(/^(ox)$/i, '\1en')
-      inflect.plural(/(quiz)$/i, '\1zes')
-
-      inflect.singular(/s$/i, '')
-      inflect.singular(/(n)ews$/i, '\1ews')
-      inflect.singular(/([ti])a$/i, '\1um')
-      inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
-      inflect.singular(/(^analy)ses$/i, '\1sis')
-      inflect.singular(/([^f])ves$/i, '\1fe')
-      inflect.singular(/(hive)s$/i, '\1')
-      inflect.singular(/(tive)s$/i, '\1')
-      inflect.singular(/([lr])ves$/i, '\1f')
-      inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
-      inflect.singular(/(s)eries$/i, '\1eries')
-      inflect.singular(/(m)ovies$/i, '\1ovie')
-      inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
-      inflect.singular(/([m|l])ice$/i, '\1ouse')
-      inflect.singular(/(bus)es$/i, '\1')
-      inflect.singular(/(o)es$/i, '\1')
-      inflect.singular(/(shoe)s$/i, '\1')
-      inflect.singular(/(cris|ax|test)es$/i, '\1is')
-      inflect.singular(/(octop|vir)i$/i, '\1us')
-      inflect.singular(/(alias|status)es$/i, '\1')
-      inflect.singular(/^(ox)en/i, '\1')
-      inflect.singular(/(vert|ind)ices$/i, '\1ex')
-      inflect.singular(/(matr)ices$/i, '\1ix')
-      inflect.singular(/(quiz)zes$/i, '\1')
-      inflect.singular(/(database)s$/i, '\1')
-
-      inflect.irregular('person', 'people')
-      inflect.irregular('man', 'men')
-      inflect.irregular('child', 'children')
-      inflect.irregular('sex', 'sexes')
-      inflect.irregular('move', 'moves')
-      inflect.irregular('cow', 'kine')
-
-      inflect.uncountable(%w(equipment information rice money species series fish sheep jeans))
-    end
-  end
-end
-
-# String inflections define new methods on the String class to transform names for different purposes.
-class String
-  include Xcodeproj::ActiveSupport
-
-  # Returns the plural form of the word in the string.
-  #
-  #   "post".pluralize             # => "posts"
-  #   "octopus".pluralize          # => "octopi"
-  #   "sheep".pluralize            # => "sheep"
-  #   "words".pluralize            # => "words"
-  #   "the blue mailman".pluralize # => "the blue mailmen"
-  #   "CamelOctopus".pluralize     # => "CamelOctopi"
-  def pluralize
-    Inflector.pluralize(self)
-  end
-
-  # The reverse of +pluralize+, returns the singular form of a word in a string.
-  #
-  #   "posts".singularize            # => "post"
-  #   "octopi".singularize           # => "octopus"
-  #   "sheep".singularize            # => "sheep"
-  #   "word".singularize             # => "word"
-  #   "the blue mailmen".singularize # => "the blue mailman"
-  #   "CamelOctopi".singularize      # => "CamelOctopus"
-  def singularize
-    Inflector.singularize(self)
-  end
-
-  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
-  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
-  #
-  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
-  #
-  #   "active_record".camelize                # => "ActiveRecord"
-  #   "active_record".camelize(:lower)        # => "activeRecord"
-  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
-  def camelize(first_letter = :upper)
-    case first_letter
-      when :upper then Inflector.camelize(self, true)
-      when :lower then Inflector.camelize(self, false)
-    end
-  end
-  alias_method :camelcase, :camelize
-
-  # Capitalizes all the words and replaces some characters in the string to create
-  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
-  # used in the Rails internals.
-  #
-  # +titleize+ is also aliased as +titlecase+.
-  #
-  #   "man from the boondocks".titleize # => "Man From The Boondocks"
-  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
-  def titleize
-    Inflector.titleize(self)
-  end
-  alias_method :titlecase, :titleize
-
-  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
-  # 
-  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
-  #
-  #   "ActiveRecord".underscore         # => "active_record"
-  #   "ActiveRecord::Errors".underscore # => active_record/errors
-  def underscore
-    Inflector.underscore(self)
-  end
-
-  # Replaces underscores with dashes in the string.
-  #
-  #   "puni_puni" # => "puni-puni"
-  def dasherize
-    Inflector.dasherize(self)
-  end
-
-  # Removes the module part from the constant expression in the string.
-  #
-  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
-  #   "Inflections".demodulize                                       # => "Inflections"
-  def demodulize
-    Inflector.demodulize(self)
-  end
-
-  # Create a class name from a plural table name like Rails does for table names to models.
-  # Note that this returns a string and not a class. (To convert to an actual class
-  # follow +classify+ with +constantize+.)
-  #
-  #   "egg_and_hams".classify # => "EggAndHam"
-  #   "posts".classify        # => "Post"
-  #
-  # Singular names are not handled correctly.
-  #
-  #   "business".classify # => "Busines"
-  def classify
-    Inflector.classify(self)
-  end
-  
-  # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
-  # Like +titleize+, this is meant for creating pretty output.
-  #
-  #   "employee_salary" # => "Employee salary" 
-  #   "author_id"       # => "Author"
-  def humanize
-    Inflector.humanize(self)
-  end
-end