burke-monkeysupport 0.0.7 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.1.1

data/ext/monkeysupport_c/src/activesupport_inflector.c

@@ -7,10 +7,11 @@
 #include "activesupport_inflector.h"
 #include "ruby.h"
 
+//rb_raise(rb_eTypeError, "Non-ASCII String");
+
 VALUE activesupport_inflector_underscore(VALUE self, VALUE rstr)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(rstr, T_STRING);
+  Check_Type(rstr, T_STRING);
 
   VALUE  ret  = rb_str_new("", 0);
   char * ip   = StringValuePtr(rstr);
@@ -44,18 +45,24 @@ VALUE activesupport_inflector_underscore(VALUE self, VALUE rstr)
 
 VALUE activesupport_inflector_parameterize(VALUE self, VALUE str, VALUE sep)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(str, T_STRING);
-  // Check_Type(sep, T_STRING);
+  Check_Type(str, T_STRING);
+  Check_Type(sep, T_STRING);
+  
+  VALUE mActiveSupport = rb_define_module("ActiveSupport");
+  VALUE mInflector     = rb_define_module_under(mActiveSupport, "Inflector");
+  VALUE transliterated = rb_funcall(mInflector, rb_intern("transliterate"), 1, str);
+
+  Check_Type(transliterated, T_STRING); // You never know...
 
   VALUE  ret       = rb_str_new("", 0);
   int    sep_len   = RSTRING_LEN(sep);
-  int    ilen      = RSTRING_LEN(str);
-  char * ip        = RSTRING_PTR(str);
+  int    ilen      = RSTRING_LEN(transliterated);
+  char * ip        = RSTRING_PTR(transliterated);
   bool   separated = true;
   int    i;
   char   tmp;
-  
+
+
   for (i = 0; i < ilen; i++, ip++) {
     if (isalnum(*ip) || *ip == '-' || *ip == '_' || *ip == '+') { // normal char
       separated = false;
@@ -83,8 +90,7 @@ VALUE activesupport_inflector_parameterize(VALUE self, VALUE str, VALUE sep)
 
 VALUE activesupport_inflector_dasherize(VALUE self, VALUE str)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(str, T_STRING);
+  Check_Type(str, T_STRING);
   
   char * out = ALLOC_N(char, RSTRING_LEN(str) + 1);
   char * ip  = RSTRING_PTR(str);
@@ -105,8 +111,7 @@ VALUE activesupport_inflector_dasherize(VALUE self, VALUE str)
 
 VALUE activesupport_inflector_demodulize(VALUE self, VALUE rstr)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(rstr, T_STRING);
+  Check_Type(rstr, T_STRING);
 
   char * str       = RSTRING_PTR(rstr);
   char * ip        = str;
@@ -129,8 +134,7 @@ VALUE activesupport_inflector_demodulize(VALUE self, VALUE rstr)
 
 VALUE activesupport_inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(str, T_STRING);
+  Check_Type(str, T_STRING);
   
   VALUE  ret      = rb_str_new("", 0);
   bool   cap_next = RTEST(first_letter_uppercase);
@@ -161,8 +165,7 @@ VALUE activesupport_inflector_camelize(VALUE self, VALUE str, VALUE first_letter
 
 VALUE activesupport_inflector_foreign_key(VALUE self, VALUE str, VALUE use_underscore)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(str, T_STRING);
+  Check_Type(str, T_STRING);
 
   VALUE ret = activesupport_inflector_underscore(self, activesupport_inflector_demodulize(self, str));
 
@@ -203,8 +206,7 @@ static char * itoa(int n)
 
 VALUE activesupport_inflector_ordinalize(VALUE self, VALUE rn)
 {
-  // This is handled in the calling code. Every bit counts...
-  // Check_Type(rn, T_FIXNUM);
+  Check_Type(rn, T_FIXNUM);
   
   int   n   = FIX2INT(rn);
   VALUE ret = rb_str_new2(itoa(n));

data/lib/monkeysupport/activesupport/inflector.rb

@@ -1,4 +1,3 @@
-
 module ActiveSupport
   module Inflector
 
@@ -29,87 +28,16 @@ module ActiveSupport
                    :activesupport_inflector_demodulize,
                    [:string]) # class_name_in_module
 
-=begin
+    monkey_c_proxy(:ordinalize,
+                   :activesupport_inflector_ordinalize,
+                   [:fixnum]) # number
+    
     # TODO: Transliterate
     monkey_c_proxy(:parameterize,
                    :activesupport_inflector_parameterize,
                    [:string,         # string
                     [:string, '-']]) # separator
 
-    # TODO: .to_i
-    monkey_c_proxy(:ordinalize,
-                   :activesupport_inflector_ordinalize,
-                   [:fixnum]) # number
-
-    alias_method :__camelize, :camelize
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if MonkeySupport::TypeChecks.is_ascii_string?(lower_case_and_underscored_word)
-        MonkeySupport::C.activesupport_inflector_camelize(lower_case_and_underscored_word.to_s, first_letter_in_uppercase)
-      else
-        __camelize(lower_case_and_underscored_word, first_letter_in_uppercase)
-      end
-    end
-
-    alias_method :__underscore, :underscore
-    def underscore(camel_cased_word)
-      if MonkeySupport::TypeChecks.is_ascii_string?(camel_cased_word)
-        MonkeySupport::C.activesupport_inflector_underscore(camel_cased_word)
-      else 
-        __underscore(camel_cased_word)
-      end
-    end
-    
-    alias_method :__dasherize, :dasherize
-    def dasherize(underscored_word)
-      if MonkeySupport::TypeChecks.is_ascii_string?(underscored_word)
-        MonkeySupport::C.activesupport_inflector_dasherize(underscored_word)
-      else
-        __dasherize(underscored_word)
-      end
-    end
-    
-    alias_method :__demodulize, :demodulize
-    def demodulize(class_name_in_module)
-      if MonkeySupport::TypeChecks.is_ascii_string?(class_name_in_module)
-        MonkeySupport::C.activesupport_inflector_demodulize(class_name_in_module)
-      else
-        __demodulize(class_name_in_module)
-      end
-    end
-
-    alias_method :__foreign_key, :foreign_key
-    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-      if MonkeySupport::TypeChecks.is_ascii_string?(class_name)
-        MonkeySupport::C.activesupport_inflector_foreign_key(class_name, separate_class_name_and_id_with_underscore)
-      else
-        __foreign_key(class_name, separate_class_name_and_id_with_underscore)
-      end
-    end
-
-=end
-    
-    alias_method :__parameterize, :parameterize
-    def parameterize(string, sep = '-')
-      parameterized_string = transliterate(string)
-      if (MonkeySupport::TypeChecks.is_ascii_string?(parameterized_string) \
-          && MonkeySupport::TypeChecks.is_ascii_string?(sep))
-        
-        MonkeySupport::C.activesupport_inflector_parameterize(parameterized_string.to_s, sep)
-      else
-        __parameterize(string, sep)
-      end
-    end
-    
-    alias_method :__ordinalize, :ordinalize
-    def ordinalize(number)
-      x = number.to_i
-      if (x.class == Fixnum)
-        MonkeySupport::C.activesupport_inflector_ordinalize(x)
-      else 
-        __ordinalize(number)
-      end
-    end
-
   end
 end
 

data/lib/monkeysupport/c_proxy.rb

@@ -16,35 +16,24 @@ module MonkeySupport
     # 
     # alias_method :__demodulize, :demodulize
     # def demodulize(arg0)
-    #   if ((MonkeySupport::TypeChecks.valid_string?(arg0)))
+    #   begin
     #     MonkeySupport::C.activesupport_inflector_demodulize(arg0)
-    #   else
+    #   rescue TypeError
     #     __demodulize(arg0)
     #   end
     # end
     def monkey_c_proxy(ruby_name, c_name, args)
-      checklist                = Util::checklist(args)
       arglist_with_defaults    = Util::arglist(args, true)
       arglist_without_defaults = Util::arglist(args, false)
 
-      if checklist
-        body = <<-EOS
-          if #{checklist}
-            MonkeySupport::C.#{c_name}(#{arglist_without_defaults})
-          else
-            __#{ruby_name}(#{arglist_without_defaults})
-          end
-        EOS
-      else
-        body = <<-EOS
-          MonkeySupport::C.#{c_name}(#{arglist_without_defaults})
-        EOS
-      end
-          
       function = <<-EOS
         alias_method :__#{ruby_name}, :#{ruby_name}
         def #{ruby_name}(#{arglist_with_defaults})
-          #{body}
+          begin
+            MonkeySupport::C.#{c_name}(#{arglist_without_defaults})
+          rescue TypeError
+            __#{ruby_name}(#{arglist_without_defaults})
+          end
         end
       EOS
 
@@ -52,22 +41,11 @@ module MonkeySupport
     end
 
     module Util
-      def self.checklist(args)
-        checklist = []
-        args.each_with_index do |x, i|
-          arg = ((x.class == Array) ? x[0] : x) # support [:bool, true] notation.
-          if [:string, :fixnum].include?(arg)
-            checklist << "(MonkeySupport::TypeChecks.valid_#{arg}?(arg#{i}))"
-          end
-        end
-        return (checklist.empty? ? nil : "(#{checklist.join(' && ')})")
-      end
-      
       def self.arglist(args, include_defaults)
         arglist = []
         args.each_with_index do |arg, i|
           if (arg.class == Array && include_defaults)
-            arglist << "arg#{i} = #{arg[1]}"
+            arglist << "arg#{i} = #{arg[1].inspect}"
           else
             arglist << "arg#{i}"
           end

data/lib/monkeysupport/type_checks.rb

@@ -1,10 +1,12 @@
 module MonkeySupport
   module TypeChecks
 
+    # Disclaimer: I may have been writing too much lisp lately.
+    
     # NOTE: This exists, but it'll still be a lot faster to just call
     # obj.class == Fixnum in the calling code, rather than resolving
     # MonkeySupport::TypeChecks.is_fixnum? each time.
-    def self.valid_fixnum?(obj)
+    def self.valid_fixnum?(obj, string=false)
       obj.class == Fixnum
     end
 
@@ -19,17 +21,17 @@ module MonkeySupport
     if '1.9'.respond_to?(:force_encoding)
       ASCII_ENCODING = Encoding.find("ASCII-8BIT")
       if Encoding.default_external == ASCII_ENCODING
-        def self.valid_string?(obj)
+        def self.valid_string?(obj, string=false)
           (obj.class == String) && obj.encoding == ASCII_ENCODING
         end
       else
-        def self.valid_string?(obj)
+        def self.valid_string?(obj, string=false)
           #TODO: Check ascii_only? and force_encoding here.
           (obj.class == String) && obj.encoding == ASCII_ENCODING
         end
       end
     else # <1.9
-      def self.valid_string?(obj)
+      def self.valid_string?(obj, string=false)
         obj.class == String
       end
     end

data/monkeysupport.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{monkeysupport}
-  s.version = "0.0.7"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Burke Libbey"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: burke-monkeysupport
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.1.1
 platform: ruby
 authors: 
 - Burke Libbey