fortitude 0.0.4-java

data/Rakefile

@@ -0,0 +1,67 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "fileutils"
+
+RSpec::Core::RakeTask.new(:spec)
+
+default_prerequisites = [ :spec ]
+if defined?(RUBY_ENGINE) && RUBY_ENGINE.to_s.strip.downcase == 'jruby'
+  default_prerequisites = [ 'jruby:clean', 'jruby:compile' ] + default_prerequisites
+else
+  default_prerequisites = [ :clobber, :compile ] + default_prerequisites
+end
+
+task :default => default_prerequisites
+
+require 'rake/extensiontask'
+spec = Gem::Specification.load('fortitude.gemspec')
+Rake::ExtensionTask.new('fortitude_native_ext', spec)
+
+namespace :jruby do
+  base_directory = File.expand_path(File.dirname(__FILE__))
+  jar_path = File.join(base_directory, 'lib', 'fortitude_jruby_native_ext.jar')
+  source_path = File.join(base_directory, 'ext')
+  classes_output_path = File.join(base_directory, 'tmp', 'classes')
+  jruby_jar_path = File.join(RbConfig::CONFIG['libdir'], 'jruby.jar')
+
+  def safe_system(cmd)
+    output = `#{cmd} 2>&1`
+    unless $?.success?
+      raise "Command failed:\n  #{cmd}\nreturned #{$?.inspect}, and produced output:\n#{output}"
+    end
+  end
+
+  task :ensure_jruby do
+    unless RUBY_ENGINE == 'jruby'
+      raise "You must run this task using JRuby, not #{RUBY_ENGINE}"
+    end
+  end
+
+  desc "Cleans all temporary files and the JAR from the JRuby extension"
+  task :clean => [ :ensure_jruby ] do
+    to_remove = [ classes_output_path, jar_path ]
+    to_remove.each { |r| FileUtils.rm_rf(r) }
+    puts "Cleaned: #{to_remove.join(", ")}"
+  end
+
+  desc "Compiles the JRuby extension"
+  task :compile => [ :ensure_jruby ] do
+    require 'find'
+
+    files = [ ]
+    Find.find(source_path) do |f|
+      files << "'#{f}'" if f =~ /\.java$/i
+    end
+
+    FileUtils.mkdir_p(classes_output_path)
+    FileUtils.mkdir_p(File.dirname(jruby_jar_path))
+
+    puts "Compiling #{files.length} Java source files."
+    safe_system("javac -cp '#{jruby_jar_path}' -g -sourcepath '#{source_path}' -d '#{classes_output_path}' #{files.join(" ")}")
+    FileUtils.rm_rf(jar_path)
+    puts "Building JAR."
+    Dir.chdir(classes_output_path) do
+      safe_system("jar cf '#{jar_path}' .")
+    end
+  end
+end

data/ext/FortitudeJrubyNativeExtService.java

@@ -0,0 +1,11 @@
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class FortitudeJrubyNativeExtService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        new com.fortituderuby.ext.fortitude.FortitudeNativeLibrary().load(runtime, false);
+        return true;
+    }
+}

data/ext/com/fortituderuby/ext/fortitude/FortitudeNativeLibrary.java

@@ -0,0 +1,223 @@
+package com.fortituderuby.ext.fortitude;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyBasicObject;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyHash;
+import org.jruby.RubyNil;
+import org.jruby.RubyString;
+import org.jruby.RubySymbol;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+public class FortitudeNativeLibrary implements Library {
+    public static final int BUFFER_SIZE = 256;
+
+    static Ruby runtime;
+
+    public void load(Ruby theRuntime, boolean wrap) throws IOException {
+        runtime = theRuntime;
+
+        RubyClass stringClass = runtime.getClass("String");
+        stringClass.defineAnnotatedMethod(FortitudeStringExtensions.class, "fortitude_append_escaped_string");
+
+        RubyClass hashClass = runtime.getClass("Hash");
+        hashClass.defineAnnotatedMethod(FortitudeHashExtensions.class, "fortitude_append_as_attributes");
+    }
+
+    public static class FortitudeStringExtensions {
+        public static final int MAX_SUBSTITUTION_LENGTH = 6;
+
+        public static final byte AMPERSAND_BYTE = (byte) '&';
+        public static final byte LESS_THAN_BYTE = (byte) '<';
+        public static final byte GREATER_THAN_BYTE = (byte) '>';
+        public static final byte SINGLE_QUOTE_BYTE = (byte) '\'';
+        public static final byte DOUBLE_QUOTE_BYTE = (byte) '\"';
+
+        @JRubyMethod(name = "fortitude_append_escaped_string")
+        public static IRubyObject fortitude_append_escaped_string(ThreadContext context, IRubyObject self, IRubyObject output) {
+            if (! (output instanceof RubyString)) {
+                RaiseException exception = runtime.newArgumentError("You can only append to a String (this is a native (Java) method)");
+                throw exception;
+            }
+
+            RubyString selfString = (RubyString) self;
+            RubyString outputString = (RubyString) output;
+
+            IRubyObject htmlSafe = selfString.getInstanceVariable("@html_safe");
+            if (htmlSafe != null && htmlSafe.isTrue()) {
+                outputString.cat(selfString);
+            } else {
+                byte[] selfBytes = selfString.getBytes();
+                fortitude_escaped_strcpy(outputString, selfBytes);
+            }
+
+            return runtime.getNil();
+        }
+
+        public static void fortitude_escaped_strcpy(RubyString output, byte[] source) {
+            byte[] buffer = new byte[BUFFER_SIZE];
+            int bufferPos = 0;
+
+            for (int i = 0; i < source.length; ++i) {
+                if (bufferPos > (BUFFER_SIZE - MAX_SUBSTITUTION_LENGTH)) {
+                    output.cat(buffer, 0, bufferPos);
+                    bufferPos = 0;
+                }
+
+                byte sourceByte = source[i];
+
+                switch(sourceByte) {
+                case AMPERSAND_BYTE:
+                    buffer[bufferPos++] = '&';
+                    buffer[bufferPos++] = 'a';
+                    buffer[bufferPos++] = 'm';
+                    buffer[bufferPos++] = 'p';
+                    buffer[bufferPos++] = ';';
+                    break;
+
+                case LESS_THAN_BYTE:
+                    buffer[bufferPos++] = '&';
+                    buffer[bufferPos++] = 'l';
+                    buffer[bufferPos++] = 't';
+                    buffer[bufferPos++] = ';';
+                    break;
+
+                case GREATER_THAN_BYTE:
+                    buffer[bufferPos++] = '&';
+                    buffer[bufferPos++] = 'g';
+                    buffer[bufferPos++] = 't';
+                    buffer[bufferPos++] = ';';
+                    break;
+
+                case SINGLE_QUOTE_BYTE:
+                    buffer[bufferPos++] = '&';
+                    buffer[bufferPos++] = '#';
+                    buffer[bufferPos++] = '3';
+                    buffer[bufferPos++] = '9';
+                    buffer[bufferPos++] = ';';
+                    break;
+
+                case DOUBLE_QUOTE_BYTE:
+                    buffer[bufferPos++] = '&';
+                    buffer[bufferPos++] = 'q';
+                    buffer[bufferPos++] = 'u';
+                    buffer[bufferPos++] = 'o';
+                    buffer[bufferPos++] = 't';
+                    buffer[bufferPos++] = ';';
+                    break;
+
+                default:
+                    buffer[bufferPos++] = sourceByte;
+                    break;
+                }
+            }
+
+            if (bufferPos > 0) {
+                output.cat(buffer, 0, bufferPos);
+            }
+        }
+    }
+
+    public static class FortitudeHashExtensions {
+        public static final byte SPACE = (byte) ' ';
+
+        public static void fortitude_append_to(IRubyObject object, RubyString rbOutput) {
+            if (object instanceof RubyString) {
+                FortitudeStringExtensions.fortitude_escaped_strcpy(rbOutput, ((RubyString) object).getBytes());
+            } else if (object instanceof RubySymbol) {
+                FortitudeStringExtensions.fortitude_escaped_strcpy(rbOutput, ((RubyString) ((RubySymbol) object).to_s()).getBytes());
+            } else if (object instanceof RubyArray) {
+                RubyArray array = (RubyArray) object;
+
+                for (int i = 0; i < array.getLength(); ++i) {
+                    IRubyObject element = (IRubyObject) array.entry(i);
+                    if (i > 0) {
+                        rbOutput.cat(SPACE);
+                    }
+                    fortitude_append_to(element, rbOutput);
+                }
+            } else if (object instanceof RubyNil) {
+                // nothing here
+            } else if (object instanceof RubyFixnum) {
+                RubyString asString = ((RubyFixnum) object).to_s();
+                FortitudeStringExtensions.fortitude_escaped_strcpy(rbOutput, asString.getBytes());
+            } else {
+                RubyString asString = (RubyString) ((RubyBasicObject) object).callMethod("to_s");
+                FortitudeStringExtensions.fortitude_escaped_strcpy(rbOutput, asString.getBytes());
+            }
+        }
+
+        public static class AppendKeyAndValueVisitor extends RubyHash.Visitor {
+            public final ThreadContext threadContext;
+            public final RubyString prefix;
+            public final RubyString output;
+
+            public static final byte[] EQUALS_QUOTE = new byte[] { (byte) '=', (byte) '"' };
+
+            public AppendKeyAndValueVisitor(ThreadContext threadContext, RubyString prefix, RubyString output) {
+                this.threadContext = threadContext;
+                this.prefix = prefix;
+                this.output = output;
+            }
+
+            public void visit(IRubyObject key, IRubyObject value) {
+                if (value instanceof RubyHash) {
+                    RubyString newPrefix;
+
+                    if (prefix != null) {
+                        newPrefix = (RubyString) prefix.dup();
+                        fortitude_append_to(key, newPrefix);
+                    } else {
+                        newPrefix = RubyString.newEmptyString(runtime);
+                        fortitude_append_to(key, newPrefix);
+                    }
+
+                    newPrefix.cat('-');
+                    fortitude_append_as_attributes(threadContext, value, output, newPrefix);
+                } else {
+                    output.cat(' ');
+
+                    if (prefix != null) {
+                        output.cat(prefix);
+                    } else {
+                        // nothing here
+                    }
+
+                    fortitude_append_to(key, output);
+                    output.cat(EQUALS_QUOTE);
+                    fortitude_append_to(value, output);
+                    output.cat('"');
+                }
+            }
+        }
+
+        @JRubyMethod(name = "fortitude_append_as_attributes")
+        public static IRubyObject fortitude_append_as_attributes(ThreadContext context, IRubyObject self, IRubyObject output, IRubyObject prefix) {
+            if (! (output instanceof RubyString)) {
+                RaiseException exception = runtime.newArgumentError("You can only append to a String (this is a native (Java) method)");
+                throw exception;
+            }
+            if (prefix instanceof RubyNil) {
+                prefix = null;
+            }
+            if (prefix != null && (! (prefix instanceof RubyString))) {
+                RaiseException exception = runtime.newArgumentError("You can only use a prefix that is a String (this is a native (Java) method)");
+                throw exception;
+            }
+
+            AppendKeyAndValueVisitor visitor = new AppendKeyAndValueVisitor(context, (RubyString) prefix, (RubyString) output);
+
+            ((RubyHash) self).visitAll(visitor);
+
+            return runtime.getNil();
+        }
+    }
+}

data/ext/fortitude_native_ext/extconf.rb

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

data/ext/fortitude_native_ext/fortitude_native_ext.c

@@ -0,0 +1,333 @@
+#include "ruby.h"
+
+void Init_fortitude_native_ext();
+
+VALUE method_append_escaped_string(VALUE self, VALUE rb_output);
+VALUE method_append_as_attributes(VALUE self, VALUE rb_output, VALUE prefix);
+
+void Init_fortitude_native_ext() {
+    VALUE string_class, hash_class;
+
+    string_class = rb_const_get(rb_cObject, rb_intern("String"));
+    rb_define_method(string_class, "fortitude_append_escaped_string", method_append_escaped_string, 1);
+
+    hash_class = rb_const_get(rb_cObject, rb_intern("Hash"));
+    rb_define_method(hash_class, "fortitude_append_as_attributes", method_append_as_attributes, 2);
+}
+
+#define BUF_SIZE 256
+#define MAX_SUBSTITUTION_LENGTH 6
+
+void fortitude_escaped_strcpy(VALUE rb_output, const char * src) {
+    char buf[BUF_SIZE + 1];
+    char* buf_pos = buf;
+    char* max_buf_pos = buf + (BUF_SIZE - MAX_SUBSTITUTION_LENGTH);
+    char ch;
+
+    while (1) {
+        if (buf_pos >= max_buf_pos) {
+            *buf_pos = '\0';
+            rb_str_cat2(rb_output, buf);
+            buf_pos = buf;
+        }
+
+        ch = *src;
+
+        if (ch == '&') {
+            *buf_pos++ = '&';
+            *buf_pos++ = 'a';
+            *buf_pos++ = 'm';
+            *buf_pos++ = 'p';
+            *buf_pos++ = ';';
+        } else if (ch == '<') {
+            *buf_pos++ = '&';
+            *buf_pos++ = 'l';
+            *buf_pos++ = 't';
+            *buf_pos++ = ';';
+        } else if (ch == '>') {
+            *buf_pos++ = '&';
+            *buf_pos++ = 'g';
+            *buf_pos++ = 't';
+            *buf_pos++ = ';';
+        } else if (ch == '\'') {
+            *buf_pos++ = '&';
+            *buf_pos++ = '#';
+            *buf_pos++ = '3';
+            *buf_pos++ = '9';
+            *buf_pos++ = ';';
+        } else if (ch == '"') {
+            *buf_pos++ = '&';
+            *buf_pos++ = 'q';
+            *buf_pos++ = 'u';
+            *buf_pos++ = 'o';
+            *buf_pos++ = 't';
+            *buf_pos++ = ';';
+        } else {
+            if (ch == '\0') {
+                break;
+            }
+
+            *buf_pos++ = ch;
+        }
+
+        src++;
+    }
+
+    if (buf_pos > buf) {
+        *buf_pos = '\0';
+        rb_str_cat2(rb_output, buf);
+    }
+}
+
+VALUE method_append_escaped_string(VALUE self, VALUE rb_output) {
+    const char* c_self = RSTRING_PTR(self);
+    VALUE html_safe = rb_iv_get(self, "@html_safe");
+
+    if (TYPE(rb_output) != T_STRING) {
+        rb_raise(rb_eArgError, "You can only append to a String (this is a native (C) method)");
+    }
+
+    if (RTEST(html_safe)) {
+        rb_str_cat2(rb_output, c_self);
+        return Qnil;
+    }
+
+    fortitude_escaped_strcpy(rb_output, c_self);
+    return Qnil;
+}
+
+void fortitude_append_to(VALUE object, VALUE rb_output) {
+    ID to_s;
+    char buf[25];
+    long value;
+    int i;
+    VALUE new_string, array_element;
+
+#ifdef CONST_ID
+    CONST_ID(to_s, "to_s");
+#else
+    to_s = rb_intern("to_s");
+#endif
+
+    switch (TYPE(object)) {
+        case T_STRING:
+            fortitude_escaped_strcpy(rb_output, RSTRING_PTR(object));
+            break;
+
+        case T_SYMBOL:
+            fortitude_escaped_strcpy(rb_output, rb_id2name(SYM2ID(object)));
+            break;
+
+        case T_ARRAY:
+            value = RARRAY_LEN(object);
+            for (i = 0; i < value; ++i) {
+                array_element = rb_ary_entry(object, i);
+                if (i > 0) {
+                    rb_str_cat2(rb_output, " ");
+                }
+                fortitude_append_to(array_element, rb_output);
+            }
+
+        case T_NONE:
+        case T_NIL:
+            break;
+
+        case T_FIXNUM:
+            value = NUM2LONG(object);
+            sprintf(buf, "%ld", value);
+            rb_str_cat2(rb_output, buf);
+            break;
+
+        default:
+            new_string = rb_funcall(object, to_s, 0);
+            fortitude_escaped_strcpy(rb_output, RSTRING_PTR(new_string));
+            break;
+    }
+}
+
+struct fortitude_prefix_and_output {
+    VALUE prefix;
+    VALUE rb_output;
+};
+
+int fortitude_append_key_and_value(VALUE key, VALUE value, VALUE prefix_and_output_value) {
+    struct fortitude_prefix_and_output * prefix_and_output = (struct fortitude_prefix_and_output *)prefix_and_output_value;
+
+    VALUE prefix = prefix_and_output->prefix;
+    VALUE rb_output = prefix_and_output->rb_output;
+
+    if (TYPE(value) == T_HASH) {
+        VALUE new_prefix_as_string;
+        ID dup;
+        ID to_s;
+
+#ifdef CONST_ID
+        CONST_ID(dup, "dup");
+        CONST_ID(to_s, "to_s");
+#else
+        dup = rb_intern("dup");
+        to_s = rb_intern("to_s");
+#endif
+
+        switch (TYPE(prefix)) {
+            case T_STRING:
+                new_prefix_as_string = rb_funcall(prefix, dup, 0);
+                fortitude_append_to(key, new_prefix_as_string);
+                break;
+
+            case T_NIL:
+                new_prefix_as_string = rb_str_new("", 0);
+                fortitude_append_to(key, new_prefix_as_string);
+                break;
+
+            default:
+                rb_raise(rb_eArgError, "You can only use a String as a prefix (this is a native (C) method)");
+                break;
+        }
+
+        rb_str_cat2(new_prefix_as_string, "-");
+        method_append_as_attributes(value, rb_output, new_prefix_as_string);
+    } else {
+        rb_str_cat2(rb_output, " ");
+
+        switch (TYPE(prefix)) {
+            case T_STRING:
+                rb_str_append(rb_output, prefix);
+                break;
+
+            case T_NIL:
+                break;
+
+            default:
+                rb_raise(rb_eArgError, "You can only use a String as a prefix (this is a native (C) method)");
+                break;
+        }
+
+        fortitude_append_to(key, rb_output);
+        rb_str_cat2(rb_output, "=\"");
+        fortitude_append_to(value, rb_output);
+        rb_str_cat2(rb_output, "\"");
+    }
+
+    return 0;
+}
+
+
+VALUE method_append_as_attributes(VALUE self, VALUE rb_output, VALUE prefix) {
+    struct fortitude_prefix_and_output prefix_and_output;
+
+    if (TYPE(rb_output) != T_STRING) {
+        rb_raise(rb_eArgError, "You can only append to a String (this is a native (C) method)");
+    }
+
+    prefix_and_output.prefix = prefix;
+    prefix_and_output.rb_output = rb_output;
+
+    rb_hash_foreach(self, fortitude_append_key_and_value, (VALUE) &prefix_and_output);
+    return Qnil;
+}
+
+// int append_hash_attributes(VALUE key, VALUE val, VALUE current_output) {
+//     static char buf[100];
+
+//     char *c_key, *c_value;
+
+//     sprintf(buf, " %s=\"%s\"", RSTRING_PTR(key), RSTRING_PTR(val));
+//     rb_str_cat2(current_output, buf);
+
+//     return ST_CONTINUE;
+// }
+
+// VALUE method_insert_element(VALUE self, VALUE rb_output, VALUE rb_name, VALUE rb_attributes) {
+//     char* c_name = RSTRING_PTR(rb_name);
+
+//     static char buf[100];
+
+//     switch(TYPE(rb_attributes)) {
+//         case T_STRING:
+//             sprintf(buf, "<%s>", c_name);
+//             rb_str_cat2(rb_output, buf);
+
+//             rb_str_append(rb_output, rb_attributes);
+
+//             sprintf(buf, "</%s>", c_name);
+//             rb_str_cat2(rb_output, buf);
+//         break;
+
+//         case T_HASH:
+//             sprintf(buf, "<%s ", c_name);
+//             rb_str_cat2(rb_output, buf);
+
+//             // fprintf(stderr, "About to append attributes...");
+
+//             // rb_hash_foreach(rb_attributes, append_hash_attributes, rb_output);
+
+//             // fprintf(stderr, "...appended attributes.");
+
+//             if (rb_block_given_p()) {
+//                 rb_str_cat2(rb_output, ">");
+
+//                 rb_yield(Qnil);
+
+//                 sprintf(buf, "</%s>", c_name);
+//                 rb_str_cat2(rb_output, buf);
+//             } else {
+//                 rb_str_cat2(rb_output, "/>");
+//                 sprintf(buf, ">");
+//             }
+//         break;
+
+//         case T_NIL:
+//             if (rb_block_given_p()) {
+//                 sprintf(buf, "<%s>", c_name);
+//                 rb_str_cat2(rb_output, buf);
+
+//                 rb_yield(Qnil);
+
+//                 sprintf(buf, "</%s>", c_name);
+//                 rb_str_cat2(rb_output, buf);
+//             } else {
+//                 sprintf(buf, "<%s/>", c_name);
+//                 rb_str_cat2(rb_output, buf);
+//             }
+//         break;
+
+//         default:
+//             /* raise */
+//         break;
+//     }
+
+//     return Qnil;
+// }
+
+// /*
+//       def #{element_name}(attributes = nil)
+//         o = @_fortitude_output
+
+//         if (! attributes)
+//           if block_given?
+//             o << FAST_ELEMENT_#{element_name.upcase}_OPEN
+//             yield
+//             o << FAST_ELEMENT_#{element_name.upcase}_CLOSE
+//           else
+//             o << FAST_ELEMENT_#{element_name.upcase}_ALONE
+//           end
+//         elsif attributes.kind_of?(String)
+//           o << FAST_ELEMENT_#{element_name.upcase}_OPEN
+//           o << attributes
+//           o << FAST_ELEMENT_#{element_name.upcase}_CLOSE
+//         else
+//           o << FAST_ELEMENT_#{element_name.upcase}_PARTIAL_OPEN
+//           _attributes(attributes)
+
+//           if block_given?
+//             o << FAST_ELEMENT_PARTIAL_OPEN_END
+//             yield
+//             o << FAST_ELEMENT_#{element_name.upcase}_CLOSE
+//           else
+//             o << FAST_ELEMENT_PARTIAL_OPEN_ALONE_END
+//           end
+//         end
+//       end
+
+// */