mack_ruby_core_extensions 0.0.1

data/lib/extensions/symbol.rb

@@ -0,0 +1,7 @@
+class Symbol
+  
+  def methodize
+    self.to_s.methodize
+  end
+  
+end

data/lib/mack_ruby_core_extensions.rb

@@ -0,0 +1,7 @@
+[:inflector, :inflections].each do |k|
+  require "utils/#{k}"
+end
+
+[:array, :class, :dir, :float, :hash, :kernel, :logger, :math, :method_not_implemented, :module, :nil, :object, :string, :symbol].each do |k|
+  require "extensions/#{k}"
+end

data/lib/utils/inflections.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), "inflector")
+# Default inflections. This is taken from Jeremy McAnally's great Rails plugin, acts_as_good_speeler. Thanks Jeremy! http://www.jeremymcanally.com/
+Mack::Utils::Inflector.inflections do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(stimul|hippopotam|octop|vir|syllab|foc|alumn|fung|radi)us$/i, '\1i')
+  inflect.plural(/(ax|test)is$/i, '\1es')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(buffal|tomat|torped)o$/i, '\1oes')
+  inflect.plural(/([dti])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|append|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/([m|l])ouse$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/(quiz)$/i, '\1zes')
+  inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+  inflect.plural(/^(?!(.*hu|.*ger|.*sha))(.*)(wom|m)an$/i, '\2\3en')
+  inflect.plural(/(curricul|bacteri|medi)um$/i, '\1a')
+  inflect.plural(/(nebul|formul|vit|vertebr|alg|alumn)a$/i, '\1ae')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([dti])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|cri|empha)ses$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/(bus)es$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(test|ax)es$/i, '\1is')
+  inflect.singular(/(stimul|hippopotam|octop|vir|syllab|foc|alumn|fung|radi)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|append)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+  inflect.singular(/(phenomen|criteri)a$/i, '\1on')
+  inflect.singular(/(.*)(wo|m)en$/i, '\1\2an')
+  inflect.singular(/(medi|curricul|bacteri)a$/i, '\1um')
+  inflect.singular(/(nebula|formula|vita|vertebra|alga|alumna)e$/i, '\1')
+  inflect.singular(/^(.*)ookies$/, '\1ookie')
+  inflect.singular(/(.*)ss$/, '\1ss')
+  inflect.singular(/(.*)ies$/, '\1y')
+  
+  inflect.irregular('person', 'people')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+  inflect.irregular('tooth', 'teeth')
+  inflect.irregular('die', 'dice')
+  inflect.irregular('talisman', 'talismans')
+  inflect.irregular('penis', 'penises')
+  
+  inflect.uncountable(%w(pokemon pokémon equipment information rice money species series fish sheep deer offspring))
+end

data/lib/utils/inflector.rb

@@ -0,0 +1,129 @@
+require 'singleton'
+module Mack
+  module Utils
+    # This class is used to deal with inflection strings. This means taken a string and make it plural, or singular, etc...
+    # Inflection rules can be added very easy, and are checked from the bottom up. This means that the last rule is the first
+    # rule to be matched. The exception to this, kind of, is 'irregular' and 'uncountable' rules. The 'uncountable' rules are
+    # always checked first, then the 'irregular' rules, and finally either the 'singular' or 'plural' rules, depending on what
+    # you're trying to do. Within each of these sets of rules, the last rule in is the first rule matched.
+    # 
+    # Example:
+    #   Mack::Utils::Inflector.inflections do |inflect|
+    #     inflect.plural(/$/, 's')
+    #     inflect.plural(/^(ox)$/i, '\1en')
+    #     inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+    #   
+    #     inflect.singular(/s$/i, '')
+    #     inflect.singular(/(n)ews$/i, '\1ews')
+    #     inflect.singular(/^(.*)ookies$/, '\1ookie')
+    #   
+    #     inflect.irregular('person', 'people')
+    #     inflect.irregular('child', 'children')
+    #   
+    #     inflect.uncountable(%w(fish sheep deer offspring))
+    #   end
+    class Inflector
+      include Singleton
+      
+      def initialize # :nodoc:
+        @plural_rules = []
+        @singular_rules = []
+        @irregular_rules = []
+        @uncountable_rules = []
+      end
+      
+      # Adds a plural rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.plural(/$/, 's')
+      #     inflect.plural(/^(ox)$/i, '\1en')
+      #     inflect.plural(/(phenomen|criteri)on$/i, '\1a')
+      #   end
+      def plural(rule, replacement)
+        @plural_rules << {:rule => rule, :replacement => replacement}
+      end
+      
+      # Adds a singular rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.singular(/s$/i, '')
+      #     inflect.singular(/(n)ews$/i, '\1ews')
+      #     inflect.singular(/^(.*)ookies$/, '\1ookie')
+      #   end
+      def singular(rule, replacement)
+        @singular_rules << {:rule => rule, :replacement => replacement}
+      end
+      
+      # Adds a irregular rule to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.irregular('person', 'people')
+      #     inflect.irregular('child', 'children')
+      #   end
+      def irregular(rule, replacement)
+        @irregular_rules << {:rule => rule, :replacement => replacement}
+        # do the reverse so you get:
+        # person => people
+        # people => person
+        @irregular_rules << {:rule => replacement, :replacement => rule}
+      end
+      
+      # Adds a uncountable word, or words, to the system.
+      # 
+      # Example:
+      #   Mack::Utils::Inflector.inflections do |inflect|
+      #     inflect.uncountable(%w(fish sheep deer offspring))
+      #   end
+      def uncountable(*args)
+        [args].flatten.each do |word|
+          @uncountable_rules << word.downcase
+        end
+      end
+      
+      # Returns the singular version of the word, if possible.
+      # 
+      # Examples:
+      #   Mack::Utils::Inflector.instance.singularize("armies") # => "army"
+      #   Mack::Utils::Inflector.instance.singularize("people") # => "person"
+      #   Mack::Utils::Inflector.instance.singularize("boats") # => "boat"
+      def singularize(word)
+        do_work(word, @singular_rules)
+      end
+      
+      # Returns the singular version of the word, if possible.
+      # 
+      # Examples:
+      #   Mack::Utils::Inflector.instance.pluralize("army") # => "armies"
+      #   Mack::Utils::Inflector.instance.pluralize("person") # => "people"
+      #   Mack::Utils::Inflector.instance.pluralize("boat") # => "boats"
+      def pluralize(word)
+        do_work(word, @plural_rules)
+      end
+      
+      private
+      def do_work(word, specific_rules)
+        return word if @uncountable_rules.include?(word.downcase)
+        w = word.dup
+        [specific_rules, @irregular_rules].flatten.reverse.each do |rule_hash|
+          return w if w.gsub!(rule_hash[:rule], rule_hash[:replacement])
+        end
+        # if all else fails, return the word:
+        return word
+      end
+      
+      public
+      class << self
+        
+        # Yields up Mack::Utils::Inflector.instance
+        def inflections
+          yield Mack::Utils::Inflector.instance
+        end
+        
+      end
+      
+    end # Inflection
+  end # Utils
+end # Mack

data/test/extensions/array_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class ArrayTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/class_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class Fruit
+end
+
+class Citrus < Fruit
+end
+
+class Orange < Citrus
+end
+
+class ClassTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def test_class_is_a
+    assert !Orange.class_is_a?(Array)
+    assert Orange.class_is_a?(Orange)
+    assert Orange.class_is_a?(Citrus)
+    assert Orange.class_is_a?(Fruit)
+    assert !Fruit.class_is_a?(Orange)
+  end
+  
+end

data/test/extensions/dir_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class DirTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/float_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class FloatTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/hash_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class HashTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  def test_minus
+    h = {:a => "aaa", :b => "bbb", :c => "ccc"}
+    assert_equal({:b => "bbb", :c => "ccc"}, (h - :a))
+    
+    h = {:a => "aaa", :b => "bbb", :c => "ccc"}
+    assert_equal({:b => "bbb", :c => "ccc"}, (h - [:a]))
+    
+    h = {:a => "aaa", :b => "bbb", :c => "ccc"}
+    assert_equal({:c => "ccc"}, (h - [:a, :b]))
+    
+    h = {:a => "aaa", :b => "bbb", :c => "ccc"}
+    assert_equal({:a => "aaa", :b => "bbb", :c => "ccc"}, (h - [:d, :e]))
+    
+    h = {:a => "aaa", :b => "bbb", :c => "ccc"}
+    assert_equal({:a => "aaa", :b => "bbb", :c => "ccc"}, (h - :d))
+  end
+  
+  def test_join
+    h = {:rel => "nofollow", :alt => "pickles"}
+    # assert_equal "rel=\"nofollow\" alt=\"pickles\"", h.join("%s=\"%s\"", " ")
+    assert ("rel=\"nofollow\" alt=\"pickles\"" == h.join("%s=\"%s\"", " ") || "alt=\"pickles\" rel=\"nofollow\"" == h.join("%s=\"%s\"", " "))
+  end
+  
+end

data/test/extensions/kernel_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class KernelTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/logger_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class LoggerTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/math_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class MathTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/method_not_implemented_test.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class MethodNotImplementedTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  # replace this with tests of your own.
+  def test_truth
+    assert true
+  end
+end

data/test/extensions/module_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class ModuleTest < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def teardown
+  end
+  
+  module ConvertMyMethodsPlease
+    def foo
+    end
+    
+    def bar
+    end
+  end
+  
+  module IncludeMeSafelyPlease
+    def foo
+    end
+    
+    def bar
+    end
+  end
+  
+  class LikeToBeSafe
+  end
+  
+  def test_convert_security_of_methods 
+    assert ConvertMyMethodsPlease.public_instance_methods.include?("foo")
+    assert ConvertMyMethodsPlease.public_instance_methods.include?("bar")
+    ConvertMyMethodsPlease.convert_security_of_methods
+    assert !ConvertMyMethodsPlease.public_instance_methods.include?("foo")
+    assert !ConvertMyMethodsPlease.public_instance_methods.include?("bar")
+    assert ConvertMyMethodsPlease.protected_instance_methods.include?("foo")
+    assert ConvertMyMethodsPlease.protected_instance_methods.include?("bar")
+    ConvertMyMethodsPlease.convert_security_of_methods(:protected, :private)
+    assert !ConvertMyMethodsPlease.protected_instance_methods.include?("foo")
+    assert !ConvertMyMethodsPlease.protected_instance_methods.include?("bar")
+    assert ConvertMyMethodsPlease.private_instance_methods.include?("foo")
+    assert ConvertMyMethodsPlease.private_instance_methods.include?("bar")
+  end
+  
+  def test_include_safely_into
+    assert IncludeMeSafelyPlease.public_instance_methods.include?("foo")
+    assert IncludeMeSafelyPlease.public_instance_methods.include?("bar")
+    assert !LikeToBeSafe.public_instance_methods.include?("foo")
+    assert !LikeToBeSafe.public_instance_methods.include?("bar")
+    IncludeMeSafelyPlease.include_safely_into(LikeToBeSafe)
+    assert !LikeToBeSafe.public_instance_methods.include?("foo")
+    assert !LikeToBeSafe.public_instance_methods.include?("bar")
+    assert LikeToBeSafe.protected_instance_methods.include?("foo")
+    assert LikeToBeSafe.protected_instance_methods.include?("bar")
+  end
+  
+end