fortitude 0.0.1

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
+
+// */

data/fortitude.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fortitude/version'
+
+Gem::Specification.new do |s|
+  s.name          = "fortitude"
+  s.version       = Fortitude::VERSION
+  s.authors       = ["Andrew Geweke"]
+  s.email         = ["andrew@geweke.org"]
+  s.summary       = %q{Views Are Code: use all the power of Ruby to build views in your own language.}
+  s.description   = %q{Views Are Code: use all the power of Ruby to build views in your own language.}
+  s.homepage      = "https://github.com/ageweke/fortitude"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.extensions << "ext/fortitude_native_ext/extconf.rb"
+
+  activesupport_spec = if RUBY_VERSION =~ /^1\.8\./
+    [ ">= 3.0", "< 4.0" ]
+  else
+    [ ">= 3.0" ]
+  end
+
+  s.add_dependency "activesupport", *activesupport_spec
+
+  s.add_development_dependency "bundler", "~> 1.5"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.99"
+  s.add_development_dependency "rake-compiler"
+  s.add_development_dependency "json"
+  s.add_development_dependency "tilt", "~> 2.0"
+end

data/lib/fortitude/assign_locals_from_template.rb.smpl

@@ -0,0 +1,22 @@
+def assign_locals_from(assigns)
+  @_fortitude_raw_assigns = assigns
+  @_fortitude_raw_assigns = @_fortitude_raw_assigns.delete_if { |k,v| ! self.class.is_valid_ruby_method_name?(k) } # :if extra_assigns == :use
+  @_fortitude_default_assigns = { }
+  the_needs = needs_as_hash
+  missing = [ ]
+  have_missing = false
+
+  @_fortitude_extra_assigns = assigns.symbolize_keys          # :if [ :error, :use ].include?(extra_assigns)
+
+  #{needs_text}
+
+  if @_fortitude_extra_assigns.size > 0                       # :if extra_assigns == :error
+    raise Fortitude::Errors::ExtraAssigns.new(self, @_fortitude_extra_assigns) # :if extra_assigns == :error
+  end                                                         # :if extra_assigns == :error
+
+  @_fortitude_extra_assigns.each do |key, value|              # :if extra_assigns == :use
+    instance_variable_set(instance_variable_name_for_need(key), value) # :if extra_assigns == :use
+  end                                                         # :if extra_assigns == :use
+
+  raise Fortitude::Errors::MissingNeed.new(self, missing, assigns) if have_missing
+end

data/lib/fortitude/assigns_proxy.rb

@@ -0,0 +1,75 @@
+require 'active_support/core_ext'
+
+module Fortitude
+  class AssignsProxy
+    def initialize(widget, keys)
+      @widget = widget
+      @keys = { }
+      keys.each { |k| @keys[k] = true }
+    end
+
+    def is_default?(x)
+      !! @widget._fortitude_default_assigns[x.to_sym]
+    end
+
+    def keys
+      @keys.keys
+    end
+
+    def has_key?(x)
+      !! @keys[x.to_sym]
+    end
+
+    def [](x)
+      if has_key?(x)
+        ivar_name = @widget.class.instance_variable_name_for_need(x)
+        @widget.instance_variable_get(ivar_name)
+      end
+    end
+
+    def []=(x, y)
+      if has_key?(x)
+        ivar_name = @widget.class.instance_variable_name_for_need(x)
+        @widget.instance_variable_set(ivar_name, y)
+      end
+    end
+
+    def to_hash
+      out = { }
+      keys.each { |k| out[k] = self[k] }
+      out
+    end
+
+    def to_h
+      to_hash
+    end
+
+    def length
+      @keys.length
+    end
+
+    def size
+      @keys.size
+    end
+
+    def to_s
+      "<Assigns for #{@widget}: #{to_hash}>"
+    end
+
+    def inspect
+      "<Assigns for #{@widget}: #{to_hash.inspect}>"
+    end
+
+    def member?(x)
+      has_key?(x)
+    end
+
+    def store(key, value)
+      self[key] = value
+    end
+
+    delegate :==, :assoc, :each, :each_pair, :each_key, :each_value, :empty?, :eql?, :fetch, :flatten,
+      :has_value?, :hash, :include?, :invert, :key, :key?, :merge, :rassoc, :reject, :select,
+      :to_a, :value?, :values, :values_at, :to => :to_hash
+  end
+end

data/lib/fortitude/class_inheritable_attributes.rb

@@ -0,0 +1,96 @@
+require 'active_support'
+require 'active_support/concern'
+
+module Fortitude
+  module ClassInheritableAttributes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+        raise ArgumentError, "Invalid arguments: #{args.inspect}" if args.length > 1
+        instance_variable_name = "@_fortitude_#{attribute_name}"
+        if args.length == 0
+          _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, false)
+        else
+          _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, args[0])
+        end
+      end
+
+      def _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, allow_not_present)
+        return instance_variable_get(instance_variable_name) if instance_variable_defined?(instance_variable_name)
+        return superclass.send(attribute_name) if superclass.respond_to?(attribute_name)
+
+        if allow_not_present
+          :_fortitude_class_inheritable_attribute_not_present
+        else
+          raise "Fortitude class-inheritable attribute error: there should always be a declared value for #{attribute_name} at the top of the inheritance hierarchy somewhere"
+        end
+      end
+
+      def _fortitude_write_class_inheritable_attribute(attribute_name, instance_variable_name, allowable_values, new_value)
+        allowed = if allowable_values.respond_to?(:call)
+          allowable_values.call(new_value)
+        else
+          allowable_values.include?(new_value)
+        end
+
+        if (! allowed)
+          error = "#{attribute_name} cannot be set to #{new_value.inspect}"
+          error << "; valid values are: #{allowable_values.inspect}" unless allowable_values.respond_to?(:call)
+          raise ArgumentError, error
+        end
+
+        old_value = _fortitude_read_class_inheritable_attribute(attribute_name, instance_variable_name, true)
+
+        instance_variable_set(instance_variable_name, new_value)
+
+        if (old_value != :_fortitude_class_inheritable_attribute_not_present) && (new_value != old_value)
+          _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+        end
+
+        new_value
+      end
+
+      def _fortitude_class_inheritable_attribute(attribute_name, default_value, allowable_values)
+        metaclass = (class << self; self; end)
+
+        metaclass.send(:define_method, attribute_name) do |*args|
+          _fortitude_invoke_class_inheritable_attribute(attribute_name, allowable_values, *args)
+        end
+
+        send(attribute_name, default_value)
+      end
+
+      def _fortitude_on_class_inheritable_attribute_change(*attribute_names, &block)
+        if attribute_names.length == 0
+          raise ArgumentError, "You must pass at least one attribute name, not: #{attribute_names.inspect}"
+        end
+
+        @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+        attribute_names.each do |attribute_name|
+          @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] ||= [ ]
+          @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] |= [ block ]
+        end
+      end
+
+      def _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+        out = if superclass.respond_to?(:_fortitude_class_inheritable_attribute_callbacks_for)
+          superclass._fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+        else
+          [ ]
+        end
+
+        @_fortitude_class_inheritable_attribute_change_callbacks ||= { }
+        out += @_fortitude_class_inheritable_attribute_change_callbacks[attribute_name] || [ ]
+
+        out
+      end
+
+      def _fortitude_class_inheritable_attribute_changed!(attribute_name, old_value, new_value)
+        callbacks = _fortitude_class_inheritable_attribute_callbacks_for(attribute_name)
+        # klass = self
+        callbacks.each { |cb| instance_exec(attribute_name, old_value, new_value, &cb) }
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/base.rb

@@ -0,0 +1,38 @@
+require 'fortitude/tag_store'
+
+module Fortitude
+  module Doctypes
+    class Base
+      extend Fortitude::TagStore
+
+      class << self
+        def delegate_tag_stores
+          if superclass.respond_to?(:tags)
+            [ superclass ]
+          else
+            [ ]
+          end
+        end
+      end
+
+      attr_reader :name
+
+      def initialize(name, doctype_line)
+        @name = name
+        @doctype_line = doctype_line
+      end
+
+      def tags
+        self.class.tags
+      end
+
+      def declare!(w)
+        w.doctype(@doctype_line)
+      end
+
+      def to_s
+        "<Doctype #{name.inspect}>"
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/html4.rb

@@ -0,0 +1,20 @@
+require 'fortitude/doctypes/base'
+require 'fortitude/doctypes/html4_tags_strict'
+
+module Fortitude
+  module Doctypes
+    class Html4 < Base
+      def default_javascript_tag_attributes
+        { :type => 'text/javascript'.freeze }.freeze
+      end
+
+      def needs_cdata_in_javascript_tag?
+        false
+      end
+
+      def close_void_tags?
+        false
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/html4_frameset.rb

@@ -0,0 +1,18 @@
+require 'fortitude/doctypes/html4'
+require 'fortitude/doctypes/html4_tags_frameset'
+
+module Fortitude
+  module Doctypes
+    class Html4Frameset < Html4Transitional
+      def initialize
+        super(:html4_frameset, 'HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd"')
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsFrameset ]
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/html4_strict.rb

@@ -0,0 +1,17 @@
+require 'fortitude/doctypes/html4'
+
+module Fortitude
+  module Doctypes
+    class Html4Strict < Html4
+      def initialize
+        super(:html4_strict, 'HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"')
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsStrict ]
+        end
+      end
+    end
+  end
+end