motion-support 0.0.3 → 0.1.0

data/lib/motion-support/array.rb

@@ -0,0 +1,23 @@
+class Array
+  def empty?
+    self.length < 1
+  end
+
+  # If any item in the array has the key == `key` true, otherwise false.
+  # Of good use when writing specs.
+  def has_hash_key?(key)
+    self.each do |entity|
+      return true if entity.has_key? key
+    end
+    return false
+  end
+
+  # If any item in the array has the value == `key` true, otherwise false
+  # Of good use when writing specs.
+  def has_hash_value?(key)
+    self.each do |entity|
+      entity.each_pair{|hash_key, value| return true if value == key}
+    end
+    return false
+  end
+end

data/lib/motion-support/hash.rb

@@ -18,4 +18,14 @@ class Hash
   def symbolize_keys!
     replace(symbolize_keys)
   end
+
+  def empty?
+    self.length < 1
+  end
+
+  # Returns the contents of the hash, with the exception
+  # of the keys specified in the keys array.
+  def except(*keys)
+    self.dup.reject{|k, v| keys.include?(k)}
+  end
 end

data/lib/motion-support/inflector.rb

@@ -0,0 +1,156 @@
+# Inflector is a singleton class that helps
+# singularize, pluralize and other-thing-ize
+# words. It is very much based on the Rails
+# ActiveSupport implementation or Inflector
+class Inflector
+  def self.instance #nodoc
+    @__instance__ ||= new
+  end
+
+  def initialize #nodoc
+    reset
+  end
+
+  def reset
+    # Put singular-form to plural form transformations here
+    @plurals = [
+      [/^person$/, 'people'],
+      [/^man$/, 'men'],
+      [/^child$/, 'children'],
+      [/^sex$/, 'sexes'],
+      [/^move$/, 'moves'],
+      [/^cow$/, 'kine'],
+      [/^zombie$/, 'zombies'],
+      [/(quiz)$/i, '\1zes'],
+      [/^(oxen)$/i, '\1'],
+      [/^(ox)$/i, '\1en'],
+      [/^(m|l)ice$/i, '\1ice'],
+      [/^(m|l)ouse$/i, '\1ice'],
+      [/(matr|vert|ind)(?:ix|ex)$/i, '\1ices'],
+      [/(x|ch|ss|sh)$/i, '\1es'],
+      [/([^aeiouy]|qu)y$/i, '\1ies'],
+      [/(hive)$/i, '\1s'],
+      [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'],
+      [/sis$/i, 'ses'],
+      [/([ti])a$/i, '\1a'],
+      [/([ti])um$/i, '\1a'],
+      [/(buffal|tomat)o$/i, '\1oes'],
+      [/(bu)s$/i, '\1ses'],
+      [/(alias|status)$/i, '\1es'],
+      [/(octop|vir)i$/i, '\1i'],
+      [/(octop|vir|alumn)us$/i, '\1i'],
+      [/^(ax|test)is$/i, '\1es'],
+      [/s$/i, 's'],
+      [/$/, 's']
+    ]
+
+    # Put plural-form to singular form transformations here
+    @singulars = [
+      [/^people$/, 'person'],
+      [/^men$/, 'man'],
+      [/^children$/, 'child'],
+      [/^sexes$/, 'sex'],
+      [/^moves$/, 'move'],
+      [/^kine$/, 'cow'],
+      [/^zombies$/, 'zombie'],
+      [/(database)s$/i, '\1'],
+      [/(quiz)zes$/i, '\1'],
+      [/(matr)ices$/i, '\1ix'],
+      [/(vert|ind)ices$/i, '\1ex'],
+      [/^(ox)en/i, '\1'],
+      [/(alias|status)(es)?$/i, '\1'],
+      [/(octop|vir|alumn)(us|i)$/i, '\1us'],
+      [/^(a)x[ie]s$/i, '\1xis'],
+      [/(cris|test)(is|es)$/i, '\1is'],
+      [/(shoe)s$/i, '\1'],
+      [/(o)es$/i, '\1'],
+      [/(bus)(es)?$/i, '\1'],
+      [/^(m|l)ice$/i, '\1ouse'],
+      [/(x|ch|ss|sh)es$/i, '\1'],
+      [/(m)ovies$/i, '\1ovie'],
+      [/(s)eries$/i, '\1eries'],
+      [/([^aeiouy]|qu)ies$/i, '\1y'],
+      [/([lr])ves$/i, '\1f'],
+      [/(tive)s$/i, '\1'],
+      [/(hive)s$/i, '\1'],
+      [/([^f])ves$/i, '\1fe'],
+      [/(^analy)(sis|ses)$/i, '\1sis'],
+      [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis'],
+      [/([ti])a$/i, '\1um'],
+      [/(n)ews$/i, '\1ews'],
+      [/(ss)$/i, '\1'],
+      [/s$/i, '']
+    ]
+
+    @irregulars = [
+    ]
+
+    @uncountables = [
+      'equipment',
+      'information',
+      'rice',
+      'money',
+      'species',
+      'series',
+      'fish',
+      'sheep',
+      'jeans',
+      'police'
+    ]
+  end
+
+  attr_reader :plurals, :singulars, :uncountables, :irregulars
+
+  def self.inflections
+    if block_given?
+      yield Inflector.instance
+    else
+      Inflector.instance
+    end
+  end
+
+  def uncountable(word)
+    @uncountables << word
+  end
+
+  def singular(rule, replacement)
+    @singulars << [rule, replacement]
+  end
+
+  def plural(rule, replacement)
+    @plurals << [rule, replacement]
+  end
+
+  def irregular(rule, replacement)
+    @irregulars << [rule, replacement]
+  end
+
+  def uncountable?(word)
+    return word if @uncountables.include?(word.downcase)
+    false
+  end
+
+  def inflect(word, direction) #nodoc
+    return word if uncountable?(word)
+
+    subject = word.dup
+
+    @irregulars.each do |rule|
+      return subject if subject.gsub!(rule.first, rule.last)
+    end
+
+    sense_group = direction == :singularize ? @singulars : @plurals
+    sense_group.each do |rule|
+      return subject if subject.gsub!(rule.first, rule.last)
+    end
+    subject
+  end
+
+  def singularize(word)
+     inflect word, :singularize
+  end
+
+  def pluralize(word)
+    inflect word, :pluralize
+  end
+end

data/lib/motion-support/nilclass.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def blank?
+    true
+  end
+end

data/lib/motion-support/{blank.rb → object.rb}

@@ -15,10 +15,3 @@ class Object
     !blank?
   end
 end
-
-class NilClass
-  # nil is always blank. See Object#blank?
-  def blank?
-    true
-  end
-end

data/lib/motion-support/string.rb

@@ -1,27 +1,71 @@
 class String
-  # Returns a pluralized version of the string, if it is not already pluralized. This implementation
-  # is rather naive, as it only appends an 's' to the string, unless it already ends with 's'.
+  def humanize
+    self.gsub(/(_|-)+/, ' ').strip
+  end
+
+  def titleize
+    self.humanize.split(' ').map { |word| word.capitalize }.join(' ')
+  end
+
+  def dasherize
+    self.underscore.humanize.split(' ').join('-')
+  end
+
+  def empty?
+    self.length < 1
+  end
+
+  def blank?
+    self.strip.empty?
+  end
+
   def pluralize
-    if self[-1] == 's'
-      self
-    else
-      self + "s"
-    end
+    Inflector.inflections.pluralize self
   end
 
-  # Returns a singularized version of the string, if it is not already pluralized. This implementation
-  # is rather naive, as it only removes a trailing 's' from the string, unless it does not end in 's'.
   def singularize
-    if self[-1] == 's'
-      self[0..-2]
+    Inflector.inflections.singularize self
+  end
+
+  def camelize(uppercase_first_letter = true)
+    string = self.dup
+    string.gsub!(/(?:_|-|(\/))([a-z\d]*)/i) do
+      new_word = $2.downcase
+      new_word[0] = new_word[0].upcase
+      new_word = "/#{new_word}" if $1 == '/'
+      new_word
+    end
+    if uppercase_first_letter && uppercase_first_letter != :lower
+      string[0] = string[0].upcase
     else
-      self
+      string[0] = string[0].downcase
     end
+    string.gsub!('/', '::')
+    string
   end
-  
-  # This method makes a string look like a class name. This means an under_scored string will become
-  # a CamelizedString, also it will be singularized, if it is plural.
+
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  # Make a string *named* like a class name. This means
+  # an under_scored string will become a CamelizedString, also it
+  # will be singularized, if it is plural.
   def classify
     singularize.camelize
   end
+
+  # This method looks up a class name in the ObjectSpace's constants
+  # allowing you to do something like this:
+  #
+  # "under_scored".classify.contantize.new
+  def constantize
+    Object.const_get(self)
+  end
 end

data/lib/motion-support/version.rb

@@ -1,3 +1,3 @@
 module MotionSupport
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/spec/motion-support/array_spec.rb

@@ -0,0 +1,21 @@
+describe 'array' do
+  it 'determines when an array is empty' do
+    [1, 2, 3].should.not.be.empty
+    [].should.be.empty
+  end
+
+  it 'finds hash values' do
+    array_of_hashes = [
+      {
+        line1: 3,
+        line2: 5
+      },
+      {
+        line3: 7,
+        line4: 9
+      }
+    ]
+    array_of_hashes.has_hash_value?(5).should.be.true
+    array_of_hashes.has_hash_value?(4).should.not.be.true
+  end
+end

data/spec/motion-support/hash_spec.rb

@@ -1,15 +1,31 @@
 describe "hash" do
-  it "should return copy with symbolized keys" do
-    { 'foo' => 'bar', 'bla' => 'blub' }.symbolize_keys.should == { :foo => 'bar', :bla => 'blub' }
+  describe "symbolize_keys" do
+    it "should return copy with symbolized keys" do
+      { 'foo' => 'bar', 'bla' => 'blub' }.symbolize_keys.should == { :foo => 'bar', :bla => 'blub' }
+    end
+
+    it "should not modify keys that can not be symbolized" do
+      { :foo => 'bar', 1 => 'blub' }.symbolize_keys.should == { :foo => 'bar', 1 => 'blub' }
+    end
+
+    it "should symbolize keys in place" do
+      hash = { 'foo' => 'bar', 'bla' => 'blub' }
+      hash.symbolize_keys!
+      hash.should == { :foo => 'bar', :bla => 'blub' }
+    end
   end
-  
-  it "should not modify keys that can not be symbolized" do
-    { :foo => 'bar', 1 => 'blub' }.symbolize_keys.should == { :foo => 'bar', 1 => 'blub' }
+
+  describe "empty?" do
+    it "reports an empty hash using empty?" do
+      {:key => 'value'}.empty?.should.not.be.true
+      {}.empty?.should.be.true
+    end
   end
   
-  it "should symbolize keys in place" do
-    hash = { 'foo' => 'bar', 'bla' => 'blub' }
-    hash.symbolize_keys!
-    hash.should == { :foo => 'bar', :bla => 'blub' }
+  describe "except" do
+    it "creates sub-hashes using except" do
+      {:a => 'a', :b => 'b'}.except(:b)[:b].should.be.nil
+      {:a => 'a', :b => 'b'}.except(:b).length.should == 1
+    end
   end
 end

data/spec/motion-support/inflector_spec.rb

@@ -0,0 +1,65 @@
+describe 'Extensions' do
+  describe 'Pluralization' do
+    it 'pluralizes a normal word: dog' do
+      Inflector.inflections.pluralize('dog').should == 'dogs'
+    end
+
+    it 'pluralizes words that end in "s": pass' do
+      Inflector.inflections.pluralize('pass').should == 'passes'
+    end
+
+    it "pluralizes words that end in 'us'" do
+      Inflector.inflections.pluralize('alumnus').should == 'alumni'
+    end
+
+    it "pluralizes words that end in 'ee'" do
+      Inflector.inflections.pluralize('attendee').should == 'attendees'
+    end
+
+    it "pluralizes words that end in 'e'" do
+      Inflector.inflections.pluralize('article').should == 'articles'
+    end
+  end
+
+  describe 'Singularization' do
+    it 'singularizes a normal word: "dogs"' do
+      Inflector.inflections.singularize('dogs').should == 'dog'
+    end
+
+    it "singualarizes a word that ends in 's': passes" do
+      Inflector.inflections.singularize('passes').should == 'pass'
+    end
+
+    it "singualarizes a word that ends in 'ee': assignees" do
+      Inflector.inflections.singularize('assignees').should == 'assignee'
+    end
+
+    it "singualarizes words that end in 'us'" do
+      Inflector.inflections.singularize('alumni').should == 'alumnus'
+    end
+
+    it "singualarizes words that end in 'es'" do
+      Inflector.inflections.singularize('articles').should == 'article'
+    end
+  end
+
+  describe 'Irregular Patterns' do
+    it "handles person to people singularizing" do
+      Inflector.inflections.singularize('people').should == 'person'
+    end
+
+    it "handles person to people pluralizing" do
+      Inflector.inflections.pluralize('person').should == 'people'
+    end
+  end
+
+  describe 'Adding Rules to Inflector' do
+    it 'accepts new rules' do
+      Inflector.inflections.irregular /^foot$/, 'feet'
+      Inflector.inflections.irregular /^feet$/, 'foot'
+      Inflector.inflections.pluralize('foot').should == 'feet'
+      Inflector.inflections.singularize('feet').should == 'foot'
+    end
+  end
+end
+

data/spec/motion-support/nilclass_spec.rb

@@ -0,0 +1,5 @@
+describe 'nilclass' do
+  it 'is blank if nil' do
+    nil.should.be.blank
+  end
+end

data/spec/motion-support/{blank_spec.rb → object_spec.rb}

@@ -1,5 +1,5 @@
-describe "blank" do
-  describe "Object" do
+describe "Object" do
+  describe "blank?" do
     it "should be blank when responds to empty and is empty" do
       [].respond_to?(:empty?).should == true
       [].blank?.should == true
@@ -9,7 +9,9 @@ describe "blank" do
       "Teststring".respond_to?(:empty?).should == true
       "Teststring".blank?.should == false
     end
-    
+  end
+  
+  describe "present?" do
     it "should be present if not blank" do
       "Hello".present?.should == true
     end
@@ -19,7 +21,7 @@ describe "blank" do
     end
   end
   
-  describe "common objects" do
+  describe "common blank objects" do
     it "should be blank for empty array" do
       [].blank?.should == true
     end

data/spec/motion-support/string_spec.rb

@@ -1,43 +1,145 @@
 describe "string" do
+  describe "humanize" do
+    it "handles dashes in text" do
+      'text-with-dashes'.humanize.should == 'text with dashes'
+    end
+
+    it "doesn't add junk at end if trailing character is a dash" do
+      'text-with-trailing-dash-'.humanize.should == 'text with trailing dash'
+    end
+
+    it "doesn't prepend junk if starting character is a dash" do
+      '-text-with-leading-dash'.humanize.should == 'text with leading dash'
+    end
+
+    it "condenses multiple dashes to one space" do
+      'text--with-multiple--dashes'.humanize.should == 'text with multiple dashes'
+    end
+  end
+
+  describe "titleize" do
+    it "translates text to title case" do
+      'text-to-translate'.titleize.should == 'Text To Translate'
+    end
+  end
+
+  describe "dasherize" do
+    it 'handles strings with spaces' do
+      'a normal string'.dasherize.should == 'a-normal-string'
+    end
+
+    it 'handles CamelCase strings' do
+      'MyClass'.dasherize.should == 'my-class'
+    end
+
+    it 'handles snake_case strings' do
+      'my_class'.dasherize.should == 'my-class'
+    end
+  end
+
+  describe "empty?" do
+    it "an empty string is detected by empty?" do
+      ''.empty?.should.be.true
+    end
+
+    it "a non-empty string is false according to empty?" do
+      'something'.empty?.should.not.be.true
+    end
+
+    it "a blank string is false according to empty?" do
+      ' '.empty?.should.not.be.true
+    end
+  end
+
+  describe "blank?" do
+    it "an empty string should be blank" do
+      ''.should.be.blank
+    end
+
+    it "a string containing only whitespace should be blank" do
+      '  '.should.be.blank
+    end
+
+    it "a string with content is not blank" do
+      'abc'.should.not.be.blank
+    end
+  end
+
+  describe "camelize" do
+    it 'a dashed string should convert to CamelCase' do
+      'my-class'.camelize.should == 'MyClass'
+    end
+
+    it 'a snake_case string should convert to CamelCase' do
+      'my_class'.camelize.should == 'MyClass'
+    end
+
+    it 'a conversion can be specified with lowercase first letter' do
+      'my_cocoa_var'.camelize(false).should == 'myCocoaVar'
+    end
+  end
+
+  describe "underscore" do
+    it 'a camel-cased string can be converted to snake-case' do
+      'MyClass'.underscore.should == 'my_class'
+    end
+
+    it 'a module scoped class is properly underscored' do
+      'MyModule::MyClass'.underscore.should == 'my_module/my_class'
+    end
+
+    it 'properly underscores lowercase initial letter' do
+      'aCocoaVariable'.underscore.should == 'a_cocoa_variable'
+    end
+  end
+
   describe "pluralize" do
     it "should return self if string is already plural" do
       "houses".pluralize.should == "houses"
       "trains".pluralize.should == "trains"
     end
-    
+
     it "should return plural version for singular string" do
       "house".pluralize.should == "houses"
       "train".pluralize.should == "trains"
     end
   end
-  
+
   describe "singularize" do
     it "should return self if string is already singular" do
       "house".singularize.should == "house"
       "train".singularize.should == "train"
     end
-    
+
     it "should return singular version for plural string" do
       "houses".singularize.should == "house"
       "trains".singularize.should == "train"
     end
   end
-  
+
   describe "classify" do
-    it "should return classified string for underscored singular string" do
+    it "should return classified version of underscored singular string" do
       "search_controller".classify.should == "SearchController"
     end
-    
-    it "should return classified string for underscored plural string" do
+
+    it "should return classified version of underscored plural string" do
       "search_controllers".classify.should == "SearchController"
     end
-    
-    it "should return classified string for camelized singular string" do
+
+    it "should return classified version of camelized singular string" do
       "SearchController".classify.should == "SearchController"
     end
-    
-    it "should return classified string for camelized plural string" do
+
+    it "should return classified version of camelized plural string" do
       "SearchControllers".classify.should == "SearchController"
     end
   end
+
+  describe "constantize" do
+    class SearchController; end
+
+    it "makes a constant class name from a suitable string" do
+      "SearchControllers".classify.constantize.should == SearchController
+    end
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: motion-support
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Thomas Kadauke
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-12-31 00:00:00 Z
+date: 2013-03-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bubble-wrap
@@ -50,22 +50,28 @@ files:
 - Rakefile
 - app/app_delegate.rb
 - lib/motion-support.rb
-- lib/motion-support/blank.rb
+- lib/motion-support/array.rb
 - lib/motion-support/cattr_accessor.rb
 - lib/motion-support/class_inheritable_accessor.rb
 - lib/motion-support/class_inheritable_array.rb
 - lib/motion-support/hash.rb
+- lib/motion-support/inflector.rb
 - lib/motion-support/logger.rb
 - lib/motion-support/metaclass.rb
+- lib/motion-support/nilclass.rb
+- lib/motion-support/object.rb
 - lib/motion-support/string.rb
 - lib/motion-support/version.rb
 - motion-support.gemspec
-- spec/motion-support/blank_spec.rb
+- spec/motion-support/array_spec.rb
 - spec/motion-support/cattr_accessor_spec.rb
 - spec/motion-support/class_inheritable_accessor_spec.rb
 - spec/motion-support/class_inheritable_array_spec.rb
 - spec/motion-support/hash_spec.rb
+- spec/motion-support/inflector_spec.rb
 - spec/motion-support/metaclass_spec.rb
+- spec/motion-support/nilclass_spec.rb
+- spec/motion-support/object_spec.rb
 - spec/motion-support/string_spec.rb
 homepage: https://github.com/tkadauke/motion-support
 licenses: []
@@ -80,7 +86,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -760150939951472099
+      hash: -605165508006699025
       segments: 
       - 0
       version: "0"
@@ -89,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -760150939951472099
+      hash: -605165508006699025
       segments: 
       - 0
       version: "0"
@@ -101,10 +107,13 @@ signing_key:
 specification_version: 3
 summary: Commonly useful extensions to the standard library for RubyMotion
 test_files: 
-- spec/motion-support/blank_spec.rb
+- spec/motion-support/array_spec.rb
 - spec/motion-support/cattr_accessor_spec.rb
 - spec/motion-support/class_inheritable_accessor_spec.rb
 - spec/motion-support/class_inheritable_array_spec.rb
 - spec/motion-support/hash_spec.rb
+- spec/motion-support/inflector_spec.rb
 - spec/motion-support/metaclass_spec.rb
+- spec/motion-support/nilclass_spec.rb
+- spec/motion-support/object_spec.rb
 - spec/motion-support/string_spec.rb