fortitude 0.9.1-java → 0.9.2-java

data/doc/source/why/example_list.rb

@@ -0,0 +1,60 @@
+module Views
+  module Why
+    module ExampleList
+      EXAMPLES = begin
+        out = [
+          { :subpath => 'a_simple_helper', :title => 'A Simple Helper' },
+          { :subpath => 'a_larger_view', :title => 'A Larger View' },
+          { :subpath => 'commonality_and_inheritance', :title => 'Commonality and Inheritance' },
+          { :subpath => 'building_a_rich_modal_dialog', :title => 'Building a Rich Modal Dialog' }
+        ]
+        out.each_with_index do |hash, index|
+          hash[:number] = (index + 1)
+          hash[:path] = "/why/#{hash[:subpath]}.html"
+        end
+        out
+      end
+
+      def first_example
+        EXAMPLES[0]
+      end
+
+      def number_of_examples
+        EXAMPLES.length
+      end
+
+      def this_example_number
+        this_example[:number] if this_example
+      end
+
+      def example_by_number(number)
+        EXAMPLES.detect { |e| e[:number] == number }
+      end
+
+      def this_example
+        @this_example ||= begin
+          request_path = request[:path]
+          request_path = "/#{request_path}" unless request_path.start_with?("/")
+
+          out = EXAMPLES.detect { |e| e[:path] == request_path }
+          out || :none
+        end
+        @this_example unless @this_example == :none
+      end
+
+      def example_title(example)
+        "Example #{example[:number]}. #{example[:title]}"
+      end
+
+      def next_example
+        @next_example ||= begin
+          if this_example_number
+            example_by_number(this_example_number + 1)
+          else
+            first_example
+          end
+        end
+      end
+    end
+  end
+end

data/doc/source/why/example_page.rb

@@ -0,0 +1,116 @@
+require 'source/shared/standard_page'
+require 'source/why/example_list'
+
+module Views
+  module Why
+    class ExamplePage < Views::Shared::StandardPage
+      include Views::Why::ExampleList
+
+      css %{
+        .example_link {
+          font-family: $heading-font;
+
+          .next {
+            font-weight: $heading-font-light-weight;
+            font-size: 18px;
+            margin-right: 10px;
+          }
+
+          a {
+            font-weight: $heading-font-heavy-weight;
+            font-size: 20px;
+          }
+
+          padding: 20px;
+          margin-left: auto;
+          margin-right: 0;
+          margin-top: 40px;
+          margin-bottom: 40px;
+
+          background-color: $bold-translucent;
+
+          text-align: right;
+        }
+
+        h4 { margin-top: 25px; }
+      }
+
+      def page_content
+        big_title "Why use Fortitude?"
+        example_body
+      end
+
+      def example_body
+        standard_text_row {
+          show_example_title
+          example_intro
+
+          section {
+            h4 "What We’re Trying To Do"
+            example_description
+          }
+
+          section {
+            h4 "Using Standard Templating Engines"
+            using_standard_engines
+          }
+
+          section {
+            h4 "Issues with Standard Templating Engines"
+            standard_engine_issues
+          }
+
+          section {
+            h4 "Using Fortitude"
+            using_fortitude
+          }
+
+          section {
+            h4 "The Benefits"
+            fortitude_benefits
+          }
+
+          link_to_next_example if next_example
+        }
+      end
+
+      def show_example_title
+        h3 example_title(this_example)
+      end
+
+      def example_intro
+        raise "Must override in #{self.class.name}"
+      end
+
+      def example_description
+        raise "Must override in #{self.class.name}"
+      end
+
+      def using_standard_engines
+        raise "Must override in #{self.class.name}"
+      end
+
+      def standard_engine_issues
+        raise "Must override in #{self.class.name}"
+      end
+
+      def using_fortitude
+        raise "Must override in #{self.class.name}"
+      end
+
+      def fortitude_benefits
+        raise "Must override in #{self.class.name}"
+      end
+
+      def link_to_next_example
+        e = next_example
+        div(:class => 'example_link') {
+          span "next", :class => 'next'
+          a(:href => e[:path]) {
+            text example_title(e)
+          }
+        }
+      end
+    end
+  end
+end

data/doc/source/why/index.html.rb

@@ -0,0 +1,86 @@
+require 'source/why/example_page'
+
+module Views
+  module Why
+    class Index < Views::Why::ExamplePage
+      def example_body
+        standard_text_row {
+          bang_intro
+          examples_setup
+
+          link_to_next_example
+        }
+      end
+
+      def bang_intro
+        p %{There is exactly one overwhelming reason to use Fortitude:}
+
+        emphatic_pullquote %{It allows you to write vastly better-factored views.}
+
+        p %{With Fortitude, you can turn this:}
+
+        erb <<-EOS
+<div class="container main outermost" id="main-container">
+  <div class="row primary">
+    <div class="col-sm-7">
+      <figure class="source">
+        <figcaption>example_code_1.rb</figcaption>
+        <pre class="ruby">
+[ 1, 2, 3 ].map { |x| x * 2 } # =&gt; [ 2, 4, 6 ]
+</pre>
+      </figure>
+
+      <%= render :partial => '/shared/buttons/icon_button', :locals => {
+        :target => conditional_refresh_url(:user => @user),
+        :icon_name => 'refresh',
+        :tooltip_html => "<p>Refresh this page</p>"
+      } %>
+    </div>
+  </div>
+</div>
+EOS
+
+        p %{Into this:}
+
+        fortitude <<-EOS
+simple_page {
+  ruby "example_code_1.rb", "[ 1, 2, 3 ].map { |x| x * 2 } # => [ 2, 4, 6 ]"
+
+  icon_button(:refresh, conditional_refresh_url(:user => @user)) {
+    p "Refresh this page"
+  }
+}
+EOS
+
+        p {
+          text %{…and that’s just the beginning. With Fortitude, you can }
+          strong "refactor your views into the methods that are right for your application"
+          text ". This means:"
+        }
+
+        ul {
+          li "You’ll be able to enhance, modify, and debug views much faster."
+          li %{You’ll build new views faster — and this pace will accelerate as
+your codebase grows, not decelerate.}
+          li "You’ll have fewer bugs in your views, and spend less time debugging them."
+          li {
+            text "You’ll "
+            em "enjoy"
+            text " building views much more."
+          }
+        }
+      end
+
+      def examples_setup
+        p %{Fortitude expresses your views using a Ruby DSL that models HTML;
+this allows you to bring all the power of Ruby to bear on your views.
+The difference this makes in the long run is enormous.}
+
+        p %{It’s easiest to explain by example.
+Follow the link below, and you’ll see #{number_of_examples.humanize}
+examples of using Fortitude to refactor common view problems into clear, concise,
+powerful code.}
+      end
+    end
+  end
+end

data/doc/source/why/other_benefits.html.rb

@@ -0,0 +1,110 @@
+module Views
+  module Why
+    class OtherBenefits < Views::Shared::Base
+      def content
+        container {
+          jumbotron {
+            h2 "Other Benefits of Fortitude"
+          }
+
+          row {
+            columns(:small => 3) { }
+            columns(:small => 7) {
+              p {
+                text %{Next to }
+                a("the power Fortitude gives you to factor your views", :href => '/why')
+                text %{, its other
+benefits pale by comparison. It’s not that these advantages are even all that small,
+it’s that being able to factor your views well is so important that it’s by far the biggest
+reason to use Fortitude. Even so, it’s worth listing these other benefits of Fortitude:}
+              }
+
+              ul {
+                li {
+                  strong "Speed"
+                  text %{: Fortitude is currently the fastest general-purpose templating engine
+for Ruby — 20-40% faster than ERb, 4-5x faster than HAML, and 30-40x faster than Erector.}
+                }
+                li {
+                  strong "Syntax"
+                  text %{: Fortitude makes it impossible to make an HTML syntax error, like
+forgetting to close a tag or mismatching tags. If your view parses as Ruby, you’re guaranteed
+to produce syntactically-valid HTML.}
+                }
+                li {
+                  strong "Semantics"
+                  text %{: Fortitude can automatically enforce many of the rules
+of HTML, like which elements can nest within which others (}
+                  em "e.g."
+                  text %{, you can’t put a }
+                  code "<div>"
+                  text " inside a "
+                  code "<p>"
+                  text "), which attributes an element can have (for example, "
+                  code "<video>"
+                  text " can have "
+                  code "width"
+                  text " and "
+                  code "height"
+                  text " attributes, but "
+                  code "<audio>"
+                  text " cannot), and — perhaps most usefully — that no two elements on a page can "
+                  text "have the same "
+                  code "id"
+                  text %{. And when you make a mistake, you get an extremely clear error message, even
+referring you to the proper part of the HTML specification to check what went wrong.}
+                }
+                li {
+                  strong "Formatting"
+                  text %{: Fortitude can produce beautifully-formatted, perfectly-indented HTML — even across
+view boundaries. Conversely, in production, it automatically produces highly-compressed HTML
+to minimize page weight.}
+                }
+                li {
+                  strong "Traceability"
+                  text %{: When working with a large codebase, it can be very frustrating trying to track
+down which partial is responsible for generating a particular piece of content. In development,
+Fortitude emits HTML comments above and below every partial, telling you exactly what's
+being rendered and with what variable assignments — making it a piece of cake to figure
+out which file you need to edit to change something.}
+                }
+                li {
+                  strong "Interoperability"
+                  text %{: Fortitude interoperates perfectly with your existing templating engine(s)
+(like ERb or HAML) and views. You can start using it on new views, or convert existing views
+at any pace you like. There’s even a tool, }
+                  a(:href => "https://github.com/ageweke/html2fortitude") {
+                    code "html2fortitude"
+                  }
+                  text ", that automatically converts ERb views to Fortitue."
+                }
+                li {
+                  strong "Compatibility"
+                  text %{: Fortitude is compatible with Ruby 1.8.7–2.2.}
+                  em "x"
+                  text %{, including JRuby, and all versions of Rails from 3.0.}
+                  em "x"
+                  text %{ through 4.2.}
+                  em "x"
+                  text %{. It also is fully compatible with the wonderful }
+                  a("Tilt", :href => "https://github.com/rtomayko/tilt")
+                  text %{ meta-templating framework, so any tool that uses Tilt can use Fortitude.
+(For example, the documentation you’re reading right now was built using }
+                  a("Middleman", :href => "http://middlemanapp.com/")
+                  text ", using Fortitude as the templating engine.)"
+                }
+              }
+
+              p {
+                text %{Still not convinced? }
+                a("Read more about how powerful it can be to factor your views well", :href => '/why')
+                text "."
+              }
+            }
+            columns(:small => 2) { }
+          }
+        }
+      end
+    end
+  end
+end

data/fortitude.gemspec

@@ -39,5 +39,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake-compiler"
   s.add_development_dependency "json"
   s.add_development_dependency "tilt", "~> 2.0"
-  s.add_development_dependency "oop_rails_server", ">= 0.0.3"
+  s.add_development_dependency "oop_rails_server", ">= 0.0.7"
+
+  # This is because i18n >= 0.7 is incompatible with Ruby 1.8.x.
+  if RUBY_VERSION =~ /^1\.8\./
+    s.add_development_dependency "i18n", "~> 0.6.0", "< 0.7.0"
+  end
 end

data/lib/fortitude/doctypes/html4_tags_strict.rb

@@ -107,6 +107,7 @@ module Fortitude
         :spec => 'http://www.w3.org/TR/html401/struct/text.html#h-9.3.2.1'
       tag :pre, :newline_before => true, :valid_attributes => ATTRS_ATTRIBUTES,
         :can_enclose => INLINE_CONTENT - %w{img object big small sub sup},
+        :suppress_formatting_inside => true,
         :spec => 'http://www.w3.org/TR/html401/struct/text.html#h-9.3.4'
       tag :ins, :valid_attributes => ATTRS_ATTRIBUTES + %w{cite datetime}, :can_enclose => FLOW_CONTENT,
         :spec => 'http://www.w3.org/TR/html401/struct/text.html#h-9.4'

data/lib/fortitude/doctypes/html5.rb

@@ -152,6 +152,7 @@ module Fortitude
       html5_tag :hr, :newline_before => true, :content_allowed => false,
         :spec => 'http://www.w3.org/TR/html5/grouping-content.html#the-hr-element'
       html5_tag :pre, :newline_before => true, :can_enclose => PHRASING_CONTENT,
+        :suppress_formatting_inside => true,
         :spec => 'http://www.w3.org/TR/html5/grouping-content.html#the-pre-element'
       html5_tag :blockquote, :newline_before => true, :can_enclose => FLOW_CONTENT, :valid_attributes => %w{cite},
         :spec => 'http://www.w3.org/TR/html5/grouping-content.html#the-blockquote-element'

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

@@ -17,9 +17,12 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
         if block_given?
           _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
           o.#{concat_method}(#{open_const})
-          #{yield_call}
-          o = @_fortitude_output_buffer_holder.output_buffer
-          o.#{concat_method}(#{close_const})
+          begin
+            #{yield_call}
+            o = @_fortitude_output_buffer_holder.output_buffer
+          ensure
+            o.#{concat_method}(#{close_const})
+          end
         else
           o.#{concat_method}(#{alone_const})
         end
@@ -37,9 +40,12 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
       if block_given?
         _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
         o.#{concat_method}(#{partial_open_end_const})
-        #{yield_call}
-        o = @_fortitude_output_buffer_holder.output_buffer
-        o.#{concat_method}(#{close_const})
+        begin
+          #{yield_call}
+        ensure
+          o = @_fortitude_output_buffer_holder.output_buffer
+          o.#{concat_method}(#{close_const})
+        end
       else
         o.#{concat_method}(#{partial_open_alone_end_const})
       end
@@ -49,12 +55,16 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
       rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get('@html_safe') # :if record_emitting_tag
       content_or_attributes.to_s.fortitude_append_escaped_string(o)        # :if escape_direct_content
       o.#{concat_method}(content_or_attributes.to_s)                       # :if ! escape_direct_content
-      if block_given?
-        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
-        #{yield_call}
+
+      begin
+        if block_given?
+          _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+          #{yield_call}
+        end
+      ensure
         o = @_fortitude_output_buffer_holder.output_buffer
+        o.#{concat_method}(#{close_const})
       end
-      o.#{concat_method}(#{close_const})
     else
       _fortitude_raise_no_content_allowed_error(#{tag_object_const})       # :if ! content_allowed
       this_tag.validate_attributes(self, attributes)                       # :if needs_attribute_rules
@@ -66,12 +76,15 @@ def #{method_name}(content_or_attributes = nil, attributes = nil)
       rc.emitting_tag!(self, FORTITUDE_TEXT_PSEUDOTAG, content_or_attributes, nil) { } unless content_or_attributes.instance_variable_get('@html_safe') # :if record_emitting_tag
       content_or_attributes.to_s.fortitude_append_escaped_string(o)        # :if escape_direct_content
       o.#{concat_method}(content_or_attributes.to_s)                       # :if ! escape_direct_content
-      if block_given?
-        _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
-        #{yield_call}
+      begin
+        if block_given?
+          _fortitude_raise_no_content_allowed_error(#{tag_object_const})     # :if ! content_allowed
+          #{yield_call}
+        end
+      ensure
         o = @_fortitude_output_buffer_holder.output_buffer
+        o.#{concat_method}(#{close_const})
       end
-      o.#{concat_method}(#{close_const})
     end
     rc.needs_newline! if format_output                                     # :if needs_formatting && newline_before
   end                                                                      # :if record_emitting_tag