burke-monkeysupport 0.0.4 → 0.0.7

data/.gitignore

@@ -7,3 +7,4 @@ pkg
 *.so
 *.dll
 *.o
+Makefile

data/Rakefile

@@ -11,7 +11,7 @@ begin
     gem.homepage = "http://github.com/burke/monkeysupport"
     gem.authors = ["Burke Libbey"]
     gem.files.include '{test,lib,ext}/**/*'
-    gem.extensions = ["ext/extconf.rb"]
+    gem.extensions = ["ext/monkeysupport_c/extconf.rb"]
     gem.add_development_dependency "thoughtbot-shoulda"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.7

data/ext/monkeysupport_c/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+extension_name = 'monkeysupport_c'
+dir_config(extension_name)
+create_makefile(extension_name, 'src')

data/ext/{inflector.c → monkeysupport_c/src/activesupport_inflector.c}

@@ -4,12 +4,13 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "inflector.h"
+#include "activesupport_inflector.h"
 #include "ruby.h"
 
-VALUE inflector_underscore(VALUE self, VALUE rstr)
+VALUE activesupport_inflector_underscore(VALUE self, VALUE rstr)
 {
-  Check_Type(rstr, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(rstr, T_STRING);
 
   VALUE  ret  = rb_str_new("", 0);
   char * ip   = StringValuePtr(rstr);
@@ -41,10 +42,11 @@ VALUE inflector_underscore(VALUE self, VALUE rstr)
   return ret;
 }
 
-VALUE inflector_parameterize(VALUE self, VALUE str, VALUE sep)
+VALUE activesupport_inflector_parameterize(VALUE self, VALUE str, VALUE sep)
 {
-  Check_Type(str, T_STRING);
-  Check_Type(sep, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(str, T_STRING);
+  // Check_Type(sep, T_STRING);
 
   VALUE  ret       = rb_str_new("", 0);
   int    sep_len   = RSTRING_LEN(sep);
@@ -79,9 +81,10 @@ VALUE inflector_parameterize(VALUE self, VALUE str, VALUE sep)
   return ret;
 }
 
-VALUE inflector_dasherize(VALUE self, VALUE str)
+VALUE activesupport_inflector_dasherize(VALUE self, VALUE str)
 {
-  Check_Type(str, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(str, T_STRING);
   
   char * out = ALLOC_N(char, RSTRING_LEN(str) + 1);
   char * ip  = RSTRING_PTR(str);
@@ -100,9 +103,10 @@ VALUE inflector_dasherize(VALUE self, VALUE str)
   return rb_str_new(out, len);
 }
 
-VALUE inflector_demodulize(VALUE self, VALUE rstr)
+VALUE activesupport_inflector_demodulize(VALUE self, VALUE rstr)
 {
-  Check_Type(rstr, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(rstr, T_STRING);
 
   char * str       = RSTRING_PTR(rstr);
   char * ip        = str;
@@ -123,9 +127,10 @@ VALUE inflector_demodulize(VALUE self, VALUE rstr)
   return ret;
 }
 
-VALUE inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase)
+VALUE activesupport_inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase)
 {
-  Check_Type(str, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(str, T_STRING);
   
   VALUE  ret      = rb_str_new("", 0);
   bool   cap_next = RTEST(first_letter_uppercase);
@@ -154,11 +159,12 @@ VALUE inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase)
   return ret;
 }
 
-VALUE inflector_foreign_key(VALUE self, VALUE str, VALUE use_underscore)
+VALUE activesupport_inflector_foreign_key(VALUE self, VALUE str, VALUE use_underscore)
 {
-  Check_Type(str, T_STRING);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(str, T_STRING);
 
-  VALUE ret = inflector_underscore(self, inflector_demodulize(self, str));
+  VALUE ret = activesupport_inflector_underscore(self, activesupport_inflector_demodulize(self, str));
 
   if (RTEST(use_underscore)) {
     rb_str_cat(ret, "_id", 3);
@@ -195,9 +201,10 @@ static char * itoa(int n)
   return ret;
 }
 
-VALUE inflector_ordinalize(VALUE self, VALUE rn)
+VALUE activesupport_inflector_ordinalize(VALUE self, VALUE rn)
 {
-  Check_Type(rn, T_FIXNUM);
+  // This is handled in the calling code. Every bit counts...
+  // Check_Type(rn, T_FIXNUM);
   
   int   n   = FIX2INT(rn);
   VALUE ret = rb_str_new2(itoa(n));

data/ext/monkeysupport_c/src/activesupport_inflector.h

@@ -0,0 +1,10 @@
+#pragma once
+#include "ruby.h"
+
+VALUE activesupport_inflector_underscore(VALUE self, VALUE str);
+VALUE activesupport_inflector_parameterize(VALUE self, VALUE str, VALUE sep);
+VALUE activesupport_inflector_dasherize(VALUE self, VALUE str);
+VALUE activesupport_inflector_demodulize(VALUE self, VALUE str);
+VALUE activesupport_inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase);
+VALUE activesupport_inflector_foreign_key(VALUE self, VALUE str, VALUE use_underscore);
+VALUE activesupport_inflector_ordinalize(VALUE self, VALUE n);

data/ext/monkeysupport_c/src/monkeysupport_c.c

@@ -0,0 +1,19 @@
+#include "activesupport_inflector.h"
+
+#include "ruby.h"
+
+void
+Init_monkeysupport_c()
+{
+  VALUE mMonkeySupport = rb_define_module("MonkeySupport");
+  VALUE cMSC = rb_define_class_under(mMonkeySupport, "C", rb_cObject);
+
+  /* ActiveSupport::ASC.camelize("my_string") */
+  rb_define_singleton_method(cMSC, "activesupport_inflector_camelize",     activesupport_inflector_camelize,     2);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_demodulize",   activesupport_inflector_demodulize,   1);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_dasherize",    activesupport_inflector_dasherize,    1);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_foreign_key",  activesupport_inflector_foreign_key,  2);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_ordinalize",   activesupport_inflector_ordinalize,   1);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_parameterize", activesupport_inflector_parameterize, 2);
+  rb_define_singleton_method(cMSC, "activesupport_inflector_underscore",   activesupport_inflector_underscore,   1);
+}

data/lib/monkeysupport/activesupport/inflector.rb

@@ -0,0 +1,115 @@
+
+module ActiveSupport
+  module Inflector
+
+    extend MonkeySupport::Memoizable
+    extend MonkeySupport::CProxy
+    
+    monkey_memoize :pluralize, :singularize, :humanize
+
+    monkey_c_proxy(:camelize,
+                   :activesupport_inflector_camelize,
+                   [:string,        # lower_case_and_underscored_word
+                    [:bool, true]]) # first_letter_in_uppercase
+
+    monkey_c_proxy(:underscore,
+                   :activesupport_inflector_underscore,
+                   [:string]) # camel_cased_word
+
+    monkey_c_proxy(:dasherize,
+                   :activesupport_inflector_dasherize,
+                   [:string]) # underscored_word
+
+    monkey_c_proxy(:foreign_key,
+                   :activesupport_inflector_foreign_key,
+                   [:string,        # class_name
+                    [:bool, true]]) # separate_class_name_and_id_with_underscore
+
+    monkey_c_proxy(:demodulize,
+                   :activesupport_inflector_demodulize,
+                   [:string]) # class_name_in_module
+
+=begin
+    # 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

@@ -0,0 +1,79 @@
+module MonkeySupport
+  module CProxy
+
+    # Generates a proxy-to-C method.
+    #
+    # Parameters:
+    #   - ruby_name -- the original name of the function to override
+    #   - c_name    -- the name of the C function in MonkeySupport::C to use
+    #   - args      -- list of arguments to funtion, by type.
+    #
+    # args example: [:string, :fixnum, [:string, '-'], [:bool true]]
+    #   - takes a string, a fixnum, a string with default value '-', then a boolean
+    #     with default value true.
+    # 
+    # EXAMPLE:
+    # 
+    # alias_method :__demodulize, :demodulize
+    # def demodulize(arg0)
+    #   if ((MonkeySupport::TypeChecks.valid_string?(arg0)))
+    #     MonkeySupport::C.activesupport_inflector_demodulize(arg0)
+    #   else
+    #     __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}
+        end
+      EOS
+
+      class_eval(function)
+    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]}"
+          else
+            arglist << "arg#{i}"
+          end
+        end 
+        return arglist.join(", ")
+      end
+    end
+  end
+end 

data/lib/monkeysupport/memoizable.rb

@@ -1,9 +1,10 @@
 module MonkeySupport
   module Memoizable
-    # This is faster than AS::Memoizeable
+    # This is faster than AS::Memoizeable.
+    # Less featureful, however.
     def monkey_memoize(*methods)
       methods.each do |method|
-        class_eval( <<"END"
+        class_eval <<EOS
 
 @__#{method} = {}
 alias_method :__#{method}, :#{method}
@@ -22,8 +23,7 @@ else
   
 end
 
-END
-)
+EOS
   
       end
     end

data/lib/monkeysupport/type_checks.rb

@@ -1,24 +1,35 @@
 module MonkeySupport
   module TypeChecks
 
-    def is_fixnum?(obj)
+    # 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)
       obj.class == Fixnum
     end
 
+    # So I really don't want to deal with multiple string encodings in C.
+    # 1.8.7 doesn't support them, so it'll just check that we actually have a String.
+    # in 1.9, I need to check that the string is ascii-encoded too.
+    # It's also possible to force_encoding on a string that contains only ascii
+    # characters, but is non-ascii-encoded. I'm not currently handling that here,
+    # since this function returns a boolean, and I kind of want to keep it that way.
+    #
+    # Moral: Make sure your default string encoding in 1.9.1 is ASCII-8BIT.
     if '1.9'.respond_to?(:force_encoding)
       ASCII_ENCODING = Encoding.find("ASCII-8BIT")
       if Encoding.default_external == ASCII_ENCODING
-        def is_ascii_string?(obj)
+        def self.valid_string?(obj)
           (obj.class == String) && obj.encoding == ASCII_ENCODING
         end
       else
-        def is_ascii_string?(obj)
+        def self.valid_string?(obj)
           #TODO: Check ascii_only? and force_encoding here.
           (obj.class == String) && obj.encoding == ASCII_ENCODING
         end
       end
     else # <1.9
-      def is_ascii_string?(obj)
+      def self.valid_string?(obj)
         obj.class == String
       end
     end

data/lib/monkeysupport.rb

@@ -1,7 +1,7 @@
-module MonkeySupport
-end
+require 'monkeysupport_c'
 
 require 'monkeysupport/type_checks'
+require 'monkeysupport/c_proxy'
 require 'monkeysupport/memoizable'
-require 'active_support_c'
-require 'monkeysupport/inflector'
+
+require 'monkeysupport/activesupport/inflector'

data/monkeysupport.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{monkeysupport}
-  s.version = "0.0.4"
+  s.version = "0.0.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Burke Libbey"]
   s.date = %q{2009-09-04}
   s.description = %q{MonkeySupport provides C implementations for some of the more intensive string manipulation methods in activesupport. ActionView is up next.}
   s.email = %q{burke@burkelibbey.org}
-  s.extensions = ["ext/extconf.rb"]
+  s.extensions = ["ext/monkeysupport_c/extconf.rb"]
   s.extra_rdoc_files = [
     "LICENSE",
      "README.rdoc"
@@ -24,32 +24,20 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
-     "ext/Makefile",
-     "ext/Makefile",
-     "ext/active_support_c.c",
-     "ext/active_support_c.c",
-     "ext/core_ext/string/access.c",
-     "ext/core_ext/string/access.c",
-     "ext/core_ext/string/access.h",
-     "ext/core_ext/string/access.h",
-     "ext/core_ext/string/filters.c",
-     "ext/core_ext/string/filters.c",
-     "ext/core_ext/string/filters.h",
-     "ext/core_ext/string/filters.h",
-     "ext/core_ext/string/starts_ends_with.c",
-     "ext/core_ext/string/starts_ends_with.c",
-     "ext/core_ext/string/starts_ends_with.h",
-     "ext/core_ext/string/starts_ends_with.h",
-     "ext/extconf.rb",
-     "ext/extconf.rb",
-     "ext/inflector.c",
-     "ext/inflector.c",
-     "ext/inflector.h",
-     "ext/inflector.h",
+     "ext/monkeysupport_c/extconf.rb",
+     "ext/monkeysupport_c/extconf.rb",
+     "ext/monkeysupport_c/src/activesupport_inflector.c",
+     "ext/monkeysupport_c/src/activesupport_inflector.c",
+     "ext/monkeysupport_c/src/activesupport_inflector.h",
+     "ext/monkeysupport_c/src/activesupport_inflector.h",
+     "ext/monkeysupport_c/src/monkeysupport_c.c",
+     "ext/monkeysupport_c/src/monkeysupport_c.c",
      "lib/monkeysupport.rb",
      "lib/monkeysupport.rb",
-     "lib/monkeysupport/inflector.rb",
-     "lib/monkeysupport/inflector.rb",
+     "lib/monkeysupport/activesupport/inflector.rb",
+     "lib/monkeysupport/activesupport/inflector.rb",
+     "lib/monkeysupport/c_proxy.rb",
+     "lib/monkeysupport/c_proxy.rb",
      "lib/monkeysupport/memoizable.rb",
      "lib/monkeysupport/memoizable.rb",
      "lib/monkeysupport/type_checks.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: burke-monkeysupport
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.7
 platform: ruby
 authors: 
 - Burke Libbey
@@ -27,7 +27,7 @@ email: burke@burkelibbey.org
 executables: []
 
 extensions: 
-- ext/extconf.rb
+- ext/monkeysupport_c/extconf.rb
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
@@ -38,19 +38,13 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
-- ext/Makefile
-- ext/active_support_c.c
-- ext/core_ext/string/access.c
-- ext/core_ext/string/access.h
-- ext/core_ext/string/filters.c
-- ext/core_ext/string/filters.h
-- ext/core_ext/string/starts_ends_with.c
-- ext/core_ext/string/starts_ends_with.h
-- ext/extconf.rb
-- ext/inflector.c
-- ext/inflector.h
+- ext/monkeysupport_c/extconf.rb
+- ext/monkeysupport_c/src/activesupport_inflector.c
+- ext/monkeysupport_c/src/activesupport_inflector.h
+- ext/monkeysupport_c/src/monkeysupport_c.c
 - lib/monkeysupport.rb
-- lib/monkeysupport/inflector.rb
+- lib/monkeysupport/activesupport/inflector.rb
+- lib/monkeysupport/c_proxy.rb
 - lib/monkeysupport/memoizable.rb
 - lib/monkeysupport/type_checks.rb
 - monkeysupport.gemspec
@@ -58,7 +52,6 @@ files:
 - test/test_helper.rb
 has_rdoc: false
 homepage: http://github.com/burke/monkeysupport
-licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -79,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
 summary: Monkeypatching Rails with C since 2009

data/ext/Makefile

@@ -1,157 +0,0 @@
-
-SHELL = /bin/sh
-
-#### Start of system configuration section. ####
-
-srcdir = .
-topdir = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/universal-darwin10.0
-hdrdir = $(topdir)
-VPATH = $(srcdir):$(topdir):$(hdrdir)
-exec_prefix = $(prefix)
-prefix = $(DESTDIR)/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr
-sharedstatedir = $(prefix)/com
-mandir = $(DESTDIR)/usr/share/man
-psdir = $(docdir)
-oldincludedir = $(DESTDIR)/usr/include
-localedir = $(datarootdir)/locale
-bindir = $(exec_prefix)/bin
-libexecdir = $(exec_prefix)/libexec
-sitedir = $(DESTDIR)/Library/Ruby/Site
-htmldir = $(docdir)
-vendorarchdir = $(vendorlibdir)/$(sitearch)
-includedir = $(prefix)/include
-infodir = $(DESTDIR)/usr/share/info
-vendorlibdir = $(vendordir)/$(ruby_version)
-sysconfdir = $(prefix)/etc
-libdir = $(exec_prefix)/lib
-sbindir = $(exec_prefix)/sbin
-rubylibdir = $(libdir)/ruby/$(ruby_version)
-docdir = $(datarootdir)/doc/$(PACKAGE)
-dvidir = $(docdir)
-vendordir = $(libdir)/ruby/vendor_ruby
-datarootdir = $(prefix)/share
-pdfdir = $(docdir)
-archdir = $(rubylibdir)/$(arch)
-sitearchdir = $(sitelibdir)/$(sitearch)
-datadir = $(datarootdir)
-localstatedir = $(prefix)/var
-sitelibdir = $(sitedir)/$(ruby_version)
-
-CC = gcc
-LIBRUBY = $(LIBRUBY_SO)
-LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
-LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
-LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)
-
-RUBY_EXTCONF_H = 
-CFLAGS   =  -fno-common -arch i386 -arch x86_64 -g -Os -pipe -fno-common -DENABLE_DTRACE  -fno-common  -pipe -fno-common $(cflags) 
-INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
-DEFS     = 
-CPPFLAGS =   -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)
-CXXFLAGS = $(CFLAGS) 
-ldflags  = -L. -arch i386 -arch x86_64 
-dldflags = 
-archflag = 
-DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
-LDSHARED = cc -arch i386 -arch x86_64 -pipe -bundle -undefined dynamic_lookup
-AR = ar
-EXEEXT = 
-
-RUBY_INSTALL_NAME = ruby
-RUBY_SO_NAME = ruby
-arch = universal-darwin10.0
-sitearch = universal-darwin10.0
-ruby_version = 1.8
-ruby = /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby
-RUBY = $(ruby)
-RM = rm -f
-MAKEDIRS = mkdir -p
-INSTALL = /usr/bin/install -c
-INSTALL_PROG = $(INSTALL) -m 0755
-INSTALL_DATA = $(INSTALL) -m 644
-COPY = cp
-
-#### End of system configuration section. ####
-
-preload = 
-
-libpath = . $(libdir)
-LIBPATH =  -L. -L$(libdir)
-DEFFILE = 
-
-CLEANFILES = mkmf.log
-DISTCLEANFILES = 
-
-extout = 
-extout_prefix = 
-target_prefix = 
-LOCAL_LIBS = 
-LIBS = $(LIBRUBYARG_SHARED)  -lpthread -ldl  
-SRCS = active_support_c.c inflector.c
-OBJS = active_support_c.o inflector.o
-TARGET = active_support_c
-DLLIB = $(TARGET).bundle
-EXTSTATIC = 
-STATIC_LIB = 
-
-BINDIR        = $(bindir)
-RUBYCOMMONDIR = $(sitedir)$(target_prefix)
-RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
-RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
-
-TARGET_SO     = $(DLLIB)
-CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
-CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
-
-all:		$(DLLIB)
-static:		$(STATIC_LIB)
-
-clean:
-		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
-
-distclean:	clean
-		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
-		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
-
-realclean:	distclean
-install: install-so install-rb
-
-install-so: $(RUBYARCHDIR)
-install-so: $(RUBYARCHDIR)/$(DLLIB)
-$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
-	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
-install-rb: pre-install-rb install-rb-default
-install-rb-default: pre-install-rb-default
-pre-install-rb: Makefile
-pre-install-rb-default: Makefile
-$(RUBYARCHDIR):
-	$(MAKEDIRS) $@
-
-site-install: site-install-so site-install-rb
-site-install-so: install-so
-site-install-rb: install-rb
-
-.SUFFIXES: .c .m .cc .cxx .cpp .C .o
-
-.cc.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
-
-.cxx.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
-
-.cpp.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
-
-.C.o:
-	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
-
-.c.o:
-	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
-
-$(DLLIB): $(OBJS)
-	@-$(RM) $@
-	$(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
-
-
-
-$(OBJS): ruby.h defines.h

data/ext/active_support_c.c

@@ -1,27 +0,0 @@
-#include "inflector.h"
-#include "core_ext/string/starts_ends_with.h"
-#include "core_ext/string/access.h"
-#include "core_ext/string/filters.h"
-
-#include "ruby.h"
-
-void
-Init_active_support_c()
-{
-  VALUE mActiveSupport = rb_define_module("ActiveSupport");
-  VALUE cASC = rb_define_class_under(mActiveSupport, "ASC", rb_cObject);
-
-  /* ActiveSupport::ASC.camelize("my_string") */
-  rb_define_singleton_method(cASC, "inflector_camelize",     inflector_camelize,     2);
-  rb_define_singleton_method(cASC, "inflector_demodulize",   inflector_demodulize,   1);
-  rb_define_singleton_method(cASC, "inflector_dasherize",    inflector_dasherize,    1);
-  rb_define_singleton_method(cASC, "inflector_foreign_key",  inflector_foreign_key,  2);
-  rb_define_singleton_method(cASC, "inflector_ordinalize",   inflector_ordinalize,   1);
-  rb_define_singleton_method(cASC, "inflector_parameterize", inflector_parameterize, 2);
-  rb_define_singleton_method(cASC, "inflector_underscore",   inflector_underscore,   1);
-
-/*   rb_define_singleton_method(cASC, "core_ext_string_at",     core_ext_string_at,     1); */
-/*   rb_define_singleton_method(cASC, "core_ext_string_to",     core_ext_string_to,     1); */
-/*   rb_define_singleton_method(cASC, "core_ext_string_from",   core_ext_string_from,   1); */
-/*   rb_define_singleton_method(cASC, "core_ext_string_first",  core_ext_string_first,  1); */
-}

data/ext/core_ext/string/access.c

@@ -1,157 +0,0 @@
-#include <assert.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "access.h"
-#include "ruby.h"
-
-VALUE
-core_ext_string_at(VALUE rstr, VALUE rposition)
-{
-  Check_Type(rstr, T_STRING);
-  Check_Type(rposition, T_FIXNUM);
-  
-  int position = FIX2INT(rposition);
-  int len = RString(rstr)->len;
-  struct RString *ret;
-  
-  if (position < 0) { // Allow for negative indices
-    position += len;
-  }
-
-  if ((position < 0) || (position > len)) { // still out of bounds
-    ret->ptr = calloc(1, sizeof(char));
-    ret->len = 0;
-  } else {
-    len -= position;
-    ret->len = len;
-    ret->ptr = malloc((len+1)*sizeof(char));
-    memcpy(ret->ptr, RString(rstr)->ptr + position, len);
-  }
-
-  return ret;
-}
-
-void
-test_core_ext_string_at()
-{
-  char *test = "0123456789";
-  assert(!strcmp(core_ext_string_at(test, 0), "0"));
-  assert(!strcmp(core_ext_string_at(test, 1), "1"));
-  assert(!strcmp(core_ext_string_at(test, 9), "9"));
-  assert(!strcmp(core_ext_string_at(test, 10), ""));
-  assert(!strcmp(core_ext_string_at(test, 15), ""));
-  assert(!strcmp(core_ext_string_at(test, -1), "9"));
-  assert(!strcmp(core_ext_string_at(test, -2), "8"));
-  assert(!strcmp(core_ext_string_at(test, -10), "0"));
-  assert(!strcmp(core_ext_string_at(test, -11), ""));
-  assert(!strcmp(core_ext_string_at(test, -15), ""));
-}
-
-VALUE
-core_ext_string_first(VALUE rstr, VALUE rposition)
-{
-  Check_Type(rstr, T_STRING);
-  Check_Type(rposition, T_FIXNUM);
-
-  //int len = strlen(str);
-  return Qnil;
-}
-
-void
-test_core_ext_string_first()
-{
-  char *test = "0123456789";
-  assert(!strcmp(core_ext_string_first(test, 0), "0123456789"));
-  assert(!strcmp(core_ext_string_first(test, 1), "0"));
-  assert(!strcmp(core_ext_string_first(test, 2), "01"));
-  assert(!strcmp(core_ext_string_first(test, 9), "012345678"));
-  assert(!strcmp(core_ext_string_first(test, 10), "0123456789"));
-  assert(!strcmp(core_ext_string_first(test, 15), "0123456789"));
-  assert(!strcmp(core_ext_string_first(test, -1), "012345678"));
-  assert(!strcmp(core_ext_string_first(test, -2), "01234567"));
-  assert(!strcmp(core_ext_string_first(test, -10), ""));
-  assert(!strcmp(core_ext_string_first(test, -11), ""));
-  assert(!strcmp(core_ext_string_first(test, -15), ""));
-}
-
-VALUE
-core_ext_string_from(VALUE rstr, VALUE rposition)
-{
-  Check_Type(rstr, T_STRING);
-  Check_Type(rposition, T_FIXNUM);
-
-  int len = RCORE_EXT_STRING_LEN(rstr)
-
-  if (position < 0) {
-    position += len; // -10 + 10 = 0
-  }
-
-  if (position > len || position < 0) {
-    position = len;
-  }
-  
-  return str + position;
-}
-
-void
-test_core_ext_string_from()
-{
-  char *test = "0123456789";
-  assert(!strcmp(core_ext_string_from(test, 0), "0123456789"));
-  assert(!strcmp(core_ext_string_from(test, 1), "123456789"));
-  assert(!strcmp(core_ext_string_from(test, 9), "9"));
-  assert(!strcmp(core_ext_string_from(test, 10), ""));
-  assert(!strcmp(core_ext_string_from(test, 15), ""));
-  assert(!strcmp(core_ext_string_from(test, -1), "9"));
-  assert(!strcmp(core_ext_string_from(test, -2), "89"));
-  assert(!strcmp(core_ext_string_from(test, -10), "0123456789"));
-  assert(!strcmp(core_ext_string_from(test, -11), ""));
-  assert(!strcmp(core_ext_string_from(test, -15), ""));
-}
-
-VALUE
-core_ext_string_to(VALUE rstr, VALUE rposition)
-{
-  int position = FIX2INT(rposition);
-  
-  int len = RString(rstr)->len;
-  struct RString ret;
-  
-  if (position < 0) { // allow for negative indices
-    position += len;
-  }
-
-  if (position > len) { // past top bound
-    ret->len = len;
-    ret->ptr = malloc((len+1)*sizeof(char));
-    memcpy(ret->ptr, RString(rstr)->ptr, len);
-  } else if (position < 0) { // under bottom bound
-    ret->ptr = calloc(1, sizeof(char));
-    ret->len = 0;
-  } else {
-    ret->len = position + 1;
-    ret->ptr = malloc((position + 2) * sizeof(char));
-
-    memcpy(ret->ptr, RString(rstr)->ptr, position+1);
-    *(ret->ptr + position + 1) = '\0';
-  }
-
-  return ret; 
-}
-
-void
-test_core_ext_string_to()
-{
-  char *test = "0123456789";
-  assert(!strcmp(core_ext_string_to(test, 0), "0"));
-  assert(!strcmp(core_ext_string_to(test, 1), "01"));
-  assert(!strcmp(core_ext_string_to(test, 9), "0123456789"));
-  assert(!strcmp(core_ext_string_to(test, 10), "0123456789"));
-  assert(!strcmp(core_ext_string_to(test, 15), "0123456789"));
-  assert(!strcmp(core_ext_string_to(test, -1), "0123456789"));
-  assert(!strcmp(core_ext_string_to(test, -2), "012345678"));
-  assert(!strcmp(core_ext_string_to(test, -10), "0"));
-  assert(!strcmp(core_ext_string_to(test, -11), ""));
-  assert(!strcmp(core_ext_string_to(test, -15), ""));
-}

data/ext/core_ext/string/access.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "ruby.h"
-
-VALUE core_ext_string_from(VALUE str, VALUE position);
-VALUE core_ext_string_to(VALUE str, VALUE position);

data/ext/core_ext/string/filters.c

@@ -1,52 +0,0 @@
-#include <stdbool.h>
-#include <string.h>
-#include <stdlib.h>
-
-#include "filters.h"
-
-static bool /* Ugly, but fast! */
-_is_space(char chr)
-{
-  if (chr > 13) {
-    return (chr == 32);
-  } else {
-    return (chr == 9 || chr == 10 || chr == 12 || chr == 13);
-  }
-}
-
-VALUE
-string_squish(VALUE rstr)
-{
-  int ilen = RString(rstr)->len;
-  int olen = ilen;
-  char *ip = RString(rstr)->ptr; 
-  bool in_space = true;
-  int i;
-  struct RString ret;
-  ret->ptr = (char *)malloc(len+1)*(sizeof (char));
-  char *op = ret->ptr;
-
-  
-  for (i = 0; i < ilen; i++, ip++) {
-    if (_is_space(*ip)) {
-      if (in_space) {
-        olen--;
-      } else {
-        in_space = true;
-        *op++ = ' ';
-      }
-    } else {
-      in_space = false;
-      *op++ = *ip;
-    }
-  }
-
-  if (*(op-1) == ' ') {
-    *(op-1) = '\0';
-    olen--;
-  }
-
-  ret->len = olen;
-  return ret;
-}
-

data/ext/core_ext/string/filters.h

@@ -1,5 +0,0 @@
-#pragma once
-
-#include "ruby.h"
-
-VALUE string_squish(VALUE rstr);

data/ext/core_ext/string/starts_ends_with.c

@@ -1,68 +0,0 @@
-#include <assert.h>
-#include <stdbool.h>
-#include <string.h>
-#include <ctype.h>
-
-#include "starts_ends_with.h"
-#include "ruby.h"
-
-VALUE
-string_starts_with(VALUE str, VALUE substr)
-{
-  int sublen = RString(substr)->len;
-  char *p1 = RString(str)->ptr;
-  char *p2 = RString(substr)->ptr;
-  
-  while (sublen--) {
-    if (*p1++ != *p2++) {
-      return Qfalse;
-    }
-  }
-
-  return Qtrue;
-}
-
-void
-test_starts_with()
-{
-  assert(string_starts_with("asdf", "") == true);
-  assert(string_starts_with("asdf", "asdfasdf") == false);
-  assert(string_starts_with("", "asdfasdf") == false);
-  assert(string_starts_with("", "") == true);
-}
-
-VALUE
-string_ends_with(VALUE str, VALUE substr)
-{
-  int l_str, l_substr;
-  char *p_str, *p_substr;
-
-  l_str    = RString(str)->len;
-  l_substr = RString(substr)->len;
-
-  if (l_substr > l_str) {
-    return Qfalse;
-  }
-  
-  p_str    = RString(str)->ptr    + l_str;
-  p_substr = RString(substr)->ptr + l_substr;
-  
-  
-  while (p_substr >= RString(substr)->ptr) {
-    if (*p_substr-- != *p_str--) {
-      return Qfale;
-    }
-  }
-  
-  return Qtrue;
-}
-
-void
-test_ends_with()
-{
-  assert(string_ends_with("asdf", "") == true);
-  assert(string_ends_with("asdf", "asdfasdf") == false);
-  assert(string_ends_with("", "asdfasdf") == false);
-  assert(string_ends_with("", "") == true);
-}
-

data/ext/core_ext/string/starts_ends_with.h

@@ -1,6 +0,0 @@
-#pragma once
-
-#include "ruby.h"
-
-VALUE string_starts_with(VALUE str, VALUE substr);
-VALUE string_ends_with(VALUE str, VALUE substr);

data/ext/extconf.rb

@@ -1,4 +0,0 @@
-require 'mkmf'
-extension_name = 'active_support_c'
-dir_config(extension_name)
-create_makefile(extension_name)

data/ext/inflector.h

@@ -1,10 +0,0 @@
-#pragma once
-#include "ruby.h"
-
-VALUE inflector_underscore(VALUE self, VALUE str);
-VALUE inflector_parameterize(VALUE self, VALUE str, VALUE sep);
-VALUE inflector_dasherize(VALUE self, VALUE str);
-VALUE inflector_demodulize(VALUE self, VALUE str);
-VALUE inflector_camelize(VALUE self, VALUE str, VALUE first_letter_uppercase);
-VALUE inflector_foreign_key(VALUE self, VALUE str, VALUE use_underscore);
-VALUE inflector_ordinalize(VALUE self, VALUE n);

data/lib/monkeysupport/inflector.rb

@@ -1,75 +0,0 @@
-module ActiveSupport
-  module Inflector
-
-    extend MonkeySupport::Memoizable
-    extend MonkeySupport::TypeChecks
-    monkey_memoize :pluralize, :singularize, :humanize
-    
-    alias_method :__camelize, :camelize
-    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if is_ascii_string?(lower_case_and_underscored_word)
-        ActiveSupport::ASC.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 is_ascii_string?(camel_cased_word)
-        ActiveSupport::ASC.inflector_underscore(camel_cased_word)
-      else 
-        __underscore(camel_cased_word)
-      end
-    end
-    
-    alias_method :__dasherize, :dasherize
-    def dasherize(underscored_word)
-      if is_ascii_string?(underscored_word)
-        ActiveSupport::ASC.inflector_dasherize(underscored_word)
-      else
-        __dasherize(underscored_word)
-      end
-    end
-    
-    alias_method :__demodulize, :demodulize
-    def demodulize(class_name_in_module)
-      if is_ascii_string?(class_name_in_module)
-        ActiveSupport::ASC.inflector_demodulize(class_name_in_module)
-      else
-        __demodulize(class_name_in_module)
-      end
-    end
-
-    alias_method :__parameterize, :parameterize
-    def parameterize(string, sep = '-')
-      parameterized_string = transliterate(string)
-      if is_ascii_string?(parameterized_string) && is_ascii_string?(sep)
-        ActiveSupport::ASC.inflector_parameterize(parameterized_string.to_s, sep)
-      else
-        __parameterize(string, sep)
-      end
-    end
-    
-    alias_method :__foreign_key, :foreign_key
-    def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-      if is_ascii_string?(class_name)
-        ActiveSupport::ASC.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
-
-    alias_method :__ordinalize, :ordinalize
-    def ordinalize(number)
-      x = number.to_i
-      if is_fixnum?(x)
-        ActiveSupport::ASC.inflector_ordinalize(number.to_i)
-      else 
-        __ordinalize(number)
-      end
-    end
-
-  end
-end
-