fortitude 0.0.4-java

data/lib/fortitude/doctypes/unknown_doctype.rb

@@ -0,0 +1,20 @@
+require 'fortitude/doctypes'
+require 'fortitude/doctypes/base'
+
+module Fortitude
+  module Doctypes
+    class UnknownDoctype < Base
+      def initialize(declaration = nil)
+        super(:unknown, declaration)
+      end
+
+      def default_javascript_tag_attributes
+        { }
+      end
+
+      def needs_cdata_in_javascript_tag?
+        false
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/xhtml10.rb

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

data/lib/fortitude/doctypes/xhtml10_frameset.rb

@@ -0,0 +1,18 @@
+require 'fortitude/doctypes'
+require 'fortitude/doctypes/xhtml10'
+
+module Fortitude
+  module Doctypes
+    class Xhtml10Frameset < Xhtml10
+      def initialize
+        super(:xhtml10_frameset, 'html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd"')
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsFrameset ]
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/xhtml10_strict.rb

@@ -0,0 +1,18 @@
+require 'fortitude/doctypes'
+require 'fortitude/doctypes/xhtml10'
+
+module Fortitude
+  module Doctypes
+    class Xhtml10Strict < Xhtml10
+      def initialize
+        super(:xhtml10_strict, 'html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"')
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsStrict ]
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/xhtml10_transitional.rb

@@ -0,0 +1,18 @@
+require 'fortitude/doctypes'
+require 'fortitude/doctypes/xhtml10'
+
+module Fortitude
+  module Doctypes
+    class Xhtml10Transitional < Xhtml10
+      def initialize
+        super(:xhtml10_transitional, 'html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"')
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsTransitional ]
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/doctypes/xhtml11.rb

@@ -0,0 +1,30 @@
+require 'fortitude/doctypes'
+require 'fortitude/doctypes/base'
+
+module Fortitude
+  module Doctypes
+    class Xhtml11 < Base
+      def initialize
+        super(:xhtml11, 'html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"')
+      end
+
+      def default_javascript_tag_attributes
+        { :type => 'text/javascript'.freeze }.freeze
+      end
+
+      def needs_cdata_in_javascript_tag?
+        true
+      end
+
+      def close_void_tags_must_be
+        true
+      end
+
+      class << self
+        def delegate_tag_stores
+          [ Fortitude::Doctypes::Html4TagsStrict ]
+        end
+      end
+    end
+  end
+end

data/lib/fortitude/errors.rb

@@ -0,0 +1,153 @@
+module Fortitude
+  module Errors
+    class Base < StandardError; end
+
+    class MissingNeed < Base
+      attr_reader :widget, :missing_needs, :assigns
+
+      def initialize(widget, missing_needs, assigns)
+        super(%{The widget #{widget} requires the following parameters to render, but they were not supplied: #{missing_needs.sort_by(&:to_s).join(", ")}})
+        @widget = widget
+        @missing_needs = missing_needs
+        @assigns = assigns
+      end
+    end
+
+    class BlockPassedToNeedMethod < Base
+      attr_reader :widget, :method_name
+
+      def initialize(widget, method_name)
+        super(%{You passed a block to a method that's a 'needs' method of a Fortitude widget, #{widget}. } +
+          %{This can mean you've declared a 'need' with the same name as a Fortitude tag method (e.g., "needs :#{method_name}"), } +
+          %{and think you're calling the method that will generate that tag, when you're actually calling a method } +
+          %{that will ignore the block you passed and just return the value of that 'need'. If that is the case, try } +
+          %{calling the tag with 'tag_' prefixed to it (e.g., 'tag_#{method_name}'), which does the same thing; if not, remove } +
+          %{the block and try again.})
+        @widget = widget
+        @method_name = method_name
+      end
+    end
+
+    class ExtraAssigns < Base
+      attr_reader :widget, :extra_assigns
+
+      def initialize(widget, extra_assigns)
+        super(%{The widget #{widget} does not accept the following parameters: #{extra_assigns.keys.sort_by(&:to_s).join(", ")}})
+        @widget = widget
+        @extra_assigns = extra_assigns
+      end
+    end
+
+    class InvalidElementNesting < Base
+      attr_reader :widget, :enclosing_element_name, :enclosed_element_name
+
+      def initialize(widget, enclosing_tag, enclosed_tag)
+        message = %{The widget #{widget} tried to render an element that is not allowed by element nesting rules: you can't put a <#{enclosed_tag.name}> inside a <#{enclosing_tag.name}>.}
+        if enclosing_tag.spec
+          message << " (See '#{enclosing_tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @enclosing_tag = enclosing_tag
+        @enclosed_tag = enclosed_tag
+      end
+
+      def enclosing_tag_name
+        @enclosing_tag.name
+      end
+
+      def enclosed_tag_name
+        @enclosed_tag.name
+      end
+    end
+
+    class InvalidElementAttributes < Base
+      attr_reader :widget, :invalid_attributes_hash, :allowed_attribute_names
+
+      def initialize(widget, tag, invalid_attributes_hash, allowed_attribute_names)
+        message = %{The widget #{widget} tried to render an element, <#{tag.name}>, with attributes that are not allowed: #{invalid_attributes_hash.inspect}. Only these attributes are allowed: #{allowed_attribute_names.sort_by(&:to_s).inspect}}
+        if tag.spec
+          message << " (See '#{tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @tag = tag
+        @invalid_attributes_hash = invalid_attributes_hash
+        @allowed_attribute_names = allowed_attribute_names
+      end
+
+      def tag_name
+        @tag.name
+      end
+    end
+
+    class DuplicateId < Base
+      attr_reader :widget, :id, :already_used_widget, :already_used_tag_name, :tag_name
+
+      def initialize(widget, id, already_used_widget, already_used_tag_name, tag_name)
+        super(%{The widget #{widget} tried to use a DOM ID, '#{id}', that has already been used. It was originally used on a <#{already_used_tag_name}> tag within widget #{already_used_widget}, and is now trying to be used on a <#{tag_name}> tag.})
+        @widget = widget
+        @id = id
+        @already_used_widget = already_used_widget
+        @already_used_tag_name = already_used_tag_name
+        @tag_name = tag_name
+      end
+    end
+
+    class DynamicAccessFromStaticMethod < Base
+      attr_reader :widget, :static_method_name, :method_called
+
+      def initialize(widget, static_method_name, method_called)
+        super(%{The widget class #{widget.class.name} declared method #{static_method_name.inspect} to be static, but, when we went to make it static, we found that it called #{method_called.inspect}, and that accesses dynamic data; this therefore can't possibly be made static safely.})
+        @widget = widget
+        @static_method_name = static_method_name
+        @method_called = method_called
+      end
+    end
+
+    class NoContentAllowed < Base
+      attr_reader :widget
+
+      def initialize(widget, tag)
+        message = %{The widget #{widget} tried to render an element, <#{tag.name}>, with content inside it, but that element doesn't accept content.}
+        if tag.spec
+          message << " (See '#{tag.spec}' for more details.)"
+        end
+
+        super(message)
+        @widget = widget
+        @tag = tag
+      end
+
+      def tag_name
+        @tag
+      end
+    end
+
+    class NoReturnValueFromTag < Base
+      attr_reader :method_name
+
+      def initialize(method_name)
+        super(%{You're trying to call a method, #{method_name.inspect}, on the return value of a Fortitude
+tag; tags don't return anything usable. (If you're migrating from Erector, this may
+be a place where you used Erector syntax for classes or IDs -- e.g., p.some_class,
+div.some_id!. Fortitude doesn't support these for important performance reasons;
+you simply need to convert these to "p :class => :some_class" or
+"div :id => :some_id".)})
+        @method_name = method_name
+      end
+    end
+
+    class TagNotFound < Base
+      attr_reader :tag_store, :tag_name
+
+      def initialize(tag_store, tag_name)
+        super(%{The tag store #{tag_store} has no tag named #{tag_name.inspect}.})
+        @tag_store = tag_store
+        @tag_name = tag_name
+      end
+    end
+  end
+end

data/lib/fortitude/extensions/fortitude_ruby_ext.rb

@@ -0,0 +1,76 @@
+require 'erb'
+
+::String.class_eval do
+  def fortitude_append_escaped_string(output)
+    raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
+
+    if html_safe?
+      output.original_concat(self)
+    else
+      output.original_concat(ERB::Util.html_escape(self))
+    end
+  end
+end
+
+::Hash.class_eval do
+  {
+    'FORTITUDE_HYPHEN' => '-',
+    'FORTITUDE_EQUALS_QUOTE' => '="',
+    'FORTITUDE_QUOTE' => '"',
+    'FORTITUDE_SPACE' => ' ',
+    'TARGET_BASE' => ""
+  }.each do |constant_name, value|
+    value = value.html_safe if value.respond_to?(:html_safe)
+    value = value.freeze
+    const_set(constant_name, value)
+  end
+
+  def fortitude_append_as_attributes(output, prefix)
+    raise ArgumentError, "You can only append to a String" unless output.kind_of?(String)
+
+    target = ::Hash::TARGET_BASE.dup
+
+    each do |key, value|
+      if value.kind_of?(Hash)
+        new_prefix = case prefix
+        when String then fortitude_append_to(key, prefix.dup)
+        when nil then fortitude_append_to(key, "".html_safe)
+        else raise ArgumentError, "You can only use a String as a prefix"
+        end
+
+        new_prefix.original_concat(::Hash::FORTITUDE_HYPHEN)
+        value.fortitude_append_as_attributes(target, new_prefix)
+      else
+        target.original_concat(::Hash::FORTITUDE_SPACE)
+
+        case prefix
+        when String then target.original_concat(prefix)
+        when nil then nil
+        else raise ArgumentError, "You can only use a String as a prefix"
+        end
+
+        fortitude_append_to(key, target)
+        target.original_concat(::Hash::FORTITUDE_EQUALS_QUOTE)
+        fortitude_append_to(value, target)
+        target.original_concat(::Hash::FORTITUDE_QUOTE)
+      end
+    end
+
+    output.original_concat(target)
+  end
+
+  private
+  def fortitude_append_to(object, output)
+    case object
+    when String then object.fortitude_append_escaped_string(output)
+    when Symbol then object.to_s.fortitude_append_escaped_string(output)
+    when Array then object.each_with_index do |o,i|
+      output.original_concat(" ") if i > 0
+      fortitude_append_to(o, output)
+    end
+    when nil then nil
+    when Integer then output.original_concat(object.to_s)
+    else object.to_s.fortitude_append_escaped_string(output)
+    end
+  end
+end

data/lib/fortitude/extensions/native_extensions.rb

@@ -0,0 +1,33 @@
+native_loaded = false
+
+if %w{false off 0}.include?((ENV['FORTITUDE_NATIVE_EXTENSIONS'] || '').strip.downcase)
+  $stderr.puts <<-EOM
+WARNING: Fortitude native extensions disabled via environment variable FORTITUDE_NATIVE_EXTENSIONS.
+         Performance may be reduced by a factor of 3-5x!
+EOM
+else
+  begin
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+      require 'fortitude_jruby_native_ext.jar'
+    else
+      require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'fortitude_native_ext'))
+    end
+
+    native_loaded = true
+  rescue LoadError => le
+    $stderr.puts <<-EOM
+WARNING: The Fortitude gem cannot load its native extensions. Performance may be reduced by a factor of 3-5x!
+         Load path: #{$:.inspect}
+         Error: #{le.message} (#{le.class})
+EOM
+    native_loaded = false
+  end
+end
+
+unless native_loaded
+  require 'fortitude/extensions/fortitude_ruby_ext'
+end
+
+require 'active_support'
+
+::ActiveSupport::SafeBuffer.class_eval { public :original_concat } if defined?(::ActiveSupport::SafeBuffer)

data/lib/fortitude/method_templates/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/method_templates/need_assignment_template.rb.smpl

@@ -0,0 +1,16 @@
+# Need '#{need}' -------------------------------------------------
+@_fortitude_extra_assigns.delete(:#{need})           # :if [ :error, :use ].include?(extra_assigns)
+
+value = assigns.fetch(:#{need}, NOT_PRESENT_NEED)
+if value == NOT_PRESENT_NEED
+  value = assigns.fetch('#{need}', NOT_PRESENT_NEED)
+  if value == NOT_PRESENT_NEED
+    value = nil                                      # :if ! has_default
+    missing << :#{need}                              # :if ! has_default
+    have_missing = true                              # :if ! has_default
+    value = the_needs[:#{need}]                      # :if has_default
+    @_fortitude_default_assigns[:#{need}] = true     # :if has_default
+  end
+end
+
+#{ivar_name} = value

data/lib/fortitude/method_templates/need_method_template.rb.smpl

@@ -0,0 +1,4 @@
+def #{need}
+  raise Fortitude::Errors::BlockPassedToNeedMethod.new(self, :#{need}) if block_given? # :if debug
+  #{ivar_name}
+end

data/lib/fortitude/method_templates/simple_template.rb

@@ -0,0 +1,50 @@
+require 'active_support'
+require 'active_support/core_ext/hash'
+
+module Fortitude
+  module MethodTemplates
+    class SimpleTemplate
+      class << self
+        def template(name)
+          @templates ||= { }
+          @templates[name] ||= new(File.join(File.dirname(__FILE__), "#{name}.rb.smpl"))
+        end
+      end
+
+      def initialize(source_file)
+        @lines = File.read(source_file).split(/\r\n|\r|\n/)
+      end
+
+      def result(bindings)
+        bindings = bindings.stringify_keys
+        bindings_target = Object.new
+        bindings.each do |key, value|
+          (class << bindings_target; self; end).send(:define_method, key) { value }
+        end
+
+        result_lines = [ ]
+        @lines.each do |l|
+          if l =~ /^(.*)\#\s*\:if\s*(.*?)\s*$/i
+            l, condition = $1, $2
+            next unless bindings_target.instance_eval(condition)
+          end
+
+          while l =~ /[^\\]\#\{([^}]+)\}/ || l =~ /^\#\{([^}]+)\}/
+            name = $1
+            begin
+              value = bindings_target.send($1)
+            rescue => e
+              raise "Failed when processing #{l.inspect}: #{e.inspect}"
+            end
+            l = l.gsub("\#\{#{$1}\}", value.to_s)
+          end
+          l = l.gsub(/\\\#\{/, "\#\{")
+
+          result_lines << l
+        end
+
+        result_lines.join("\n")
+      end
+    end
+  end
+end