honkster-erector 0.8.1

data/lib/erector/unicode_builder.rb

@@ -0,0 +1,67 @@
+# Note that this class is only used in building erector itself
+# (and even then, only needs to be run when there is a new
+# UnicodeData.txt file from unicode.org).
+class Erector::UnicodeBuilder
+
+  def initialize(input, output)
+    @input = input
+    @output = output
+    @first = true
+  end
+  
+  def generate()
+    @output.puts "Erector::CHARACTERS = {"
+    process_file
+    @output.puts "}"
+  end
+
+  def process_file()
+    while !@input.eof
+      line = @input.gets.strip
+      if (line == "")
+        next;
+      end
+      
+      process_line(line)
+    end
+    if (!@first)
+      @output.puts
+    end
+  end
+  
+  def output_line(line)
+    if (!@first)
+      @output.puts(',')
+    end
+    
+    @output.print(line)
+
+    @first = false
+  end
+  
+  def process_line(line)
+    fields = line.split(';')
+    code_point = fields[0]
+    name = fields[1]
+    alternate_name = fields[10]
+
+    if /^</.match(name)
+      return ""
+    end
+
+    output name, code_point
+    if (!alternate_name.nil? && alternate_name != "")
+      output alternate_name, code_point
+    end
+  end
+  
+  def output(name, code_point)
+    output_line "  :#{namify(name)} => 0x#{code_point.downcase}"
+  end
+  
+  def namify(name)
+    name.downcase.gsub(/[- ]/, '_')
+  end
+
+end
+

data/lib/erector/version.rb

@@ -0,0 +1,12 @@
+require 'yaml'
+
+##
+# Erector view framework
+module Erector
+  if !Erector.const_defined?(:VERSION)
+    dir = File.dirname(__FILE__)
+    version = YAML.load_file(File.expand_path("#{dir}/../../VERSION.yml"))
+    VERSION = "#{version[:major]}.#{version[:minor]}.#{version[:patch]}"
+  end
+end
+

data/lib/erector/widget.rb

@@ -0,0 +1,54 @@
+module Erector
+
+  # A Widget is the center of the Erector universe.
+  #
+  # To create a widget, extend Erector::Widget and implement the +content+
+  # method. Inside this method you may call any of the tag methods like +span+
+  # or +p+ to emit HTML/XML tags.
+  #
+  # You can also define a widget on the fly by passing a block to +new+. This
+  # block will get executed when the widget's +content+ method is called. See
+  # the userguide for important details about the scope of this block when run --
+  # http://erector.rubyforge.org/userguide.html#blocks
+  #
+  # To render a widget from the outside, instantiate it and call its +to_html+
+  # method.
+  #
+  # A widget's +new+ method optionally accepts an options hash. Entries in
+  # this hash are converted to instance variables.
+  #
+  # You can add runtime input checking via the +needs+ macro. See #needs.
+  # This mechanism is meant to ameliorate development-time confusion about
+  # exactly what parameters are supported by a given widget, avoiding
+  # confusing runtime NilClass errors.
+  #
+  # To call one widget from another, inside the parent widget's +content+
+  # method, instantiate the child widget and call the +widget+ method. This
+  # assures that the same output stream is used, which gives better
+  # performance than using +capture+ or +to_html+. It also preserves the
+  # indentation and helpers of the enclosing class.
+  #
+  # In this documentation we've tried to keep the distinction clear between
+  # methods that *emit* text and those that *return* text. "Emit" means that
+  # it writes to the output stream; "return" means that it returns a string
+  # like a normal method and leaves it up to the caller to emit that string if
+  # it wants.
+  #
+  # This class extends AbstractWidget and includes several modules,
+  # so be sure to check all of those places for API documentation for the
+  # various methods of Widget. Also read the API Cheatsheet in the user guide
+  # at http://erector.rubyforge.org/userguide#apicheatsheet
+  #
+  # Now, seriously, after playing around a bit, go read the user guide. It's
+  # fun!
+  class Widget < AbstractWidget
+    include Erector::HTML
+    include Erector::Needs
+#    include Erector::Caching
+    include Erector::Externals
+    include Erector::Convenience
+    include Erector::JQuery
+    include Erector::AfterInitialize
+    include Erector::Sass if Object.const_defined?(:Sass)
+  end
+end

data/lib/erector/widgets.rb

@@ -0,0 +1,6 @@
+require "erector/widgets/environment_badge"
+require "erector/widgets/field_table"
+require "erector/widgets/form"
+require "erector/widgets/external_renderer"
+require "erector/widgets/page"
+require "erector/widgets/table"

data/lib/erector/widgets/environment_badge.rb

@@ -0,0 +1,29 @@
+module Erector
+  module Widgets #:nodoc:
+
+    # Displays a colored badge in the upper-left corner 
+    # signifying the environment the app is running in. 
+    # Inspired by Assaf Arkin
+    #  <http://blog.labnotes.org/2009/10/08/using-a-badge-to-distinguish-development-and-production-environments/>
+    # Erectorized by Alex Chaffee
+    class EnvironmentBadge < Erector::Widget
+      def content
+        style <<-STYLE
+#environment_badge { position: fixed; left: 1em; font-weight: bold; padding: .2em 0.9em; text-transform: uppercase; display: none }
+#environment_badge.staging { color: #000; background: #ffff00; border: 2px solid #cccc20; }
+#environment_badge.development { color: #fff; background: #ff0000; border: 2px solid #cc2020; }
+#environment_badge.staging, #environment_badge.development { border-top: none; display: block; opacity: 0.6 }    
+        STYLE
+        unless environment =~ /production/
+          p environment, :class => environment, :id => "environment_badge"
+        end
+      end
+
+      def environment
+        RAILS_ENV
+      rescue NameError
+        ENV['RAILS_ENV'] || ENV['RACK_ENV']
+      end
+    end
+  end
+end

data/lib/erector/widgets/external_renderer.rb

@@ -0,0 +1,51 @@
+class ExternalRenderer < Erector::Widget
+  needs :classes
+  needs :included_stylesheets => true, :inline_styles => true, :included_scripts => true, :inline_scripts => true
+  
+  def content
+    included_stylesheets if @included_stylesheets
+    inline_styles if @inline_styles
+    included_scripts if @included_scripts
+    inline_scripts if @inline_scripts
+  end
+  
+  def rendered_externals(type)
+    @classes.map do |klass|
+      klass.dependencies(type)
+    end.flatten.uniq
+  end
+  
+  def included_scripts
+    rendered_externals(:js).each do |external|
+      script({:type => "text/javascript", :src => external.text}.merge(external.options))
+    end
+  end
+  
+  def included_stylesheets
+    rendered_externals(:css).each do |external|
+      link({:rel => "stylesheet", :href => external.text, :type => "text/css", :media => "all"}.merge(external.options))
+    end
+  end
+
+  def inline_styles
+    rendered_externals(:style).each do |external|
+      style({:type => "text/css", 'xml:space' => 'preserve'}.merge(external.options)) do
+        rawtext external.text
+      end
+    end
+  end
+  
+  def inline_scripts
+    rendered_externals(:script).each do |external|
+      javascript external.options do
+        rawtext external.text
+      end
+    end
+    # todo: allow :load or :ready per external script
+    rendered_externals(:jquery).each do |external|
+      jquery :load, external.text, external.options
+    end
+  end
+
+end
+

data/lib/erector/widgets/field_table.rb

@@ -0,0 +1,110 @@
+# A simple HTML table with three columns: label, contents, and (optionally) note.
+# Each row is called a field.
+# The last row can optionally contain "buttons" (actually any widget will do)
+# that are all shown in the 2nd column.
+# It's all surrounded with a fieldset element for a title.
+# 
+# In ASCII art, it looks something like this:
+#
+# /-Meals----------------------------------------\
+# | Breakfast | eggs              |              |
+# | Lunch     | sandwich          |              |
+# | Dinner    | lo mein           | with shrimp! | 
+# |           | [Save] [Cancel]   |              |
+# \----------------------------------------------/
+#
+# There are two ways to create a FieldTable.
+# 1. Pass a block in to the constructor.
+# 2. Make a subclass.
+# In both cases you'll want to call the "field" and "button" methods on the table. 
+# This sets up the contents which will be rendered later during FieldTable#content.
+# If you make a subclass (#2) you can do this either in the constructor or in
+# the content method *before* you call super.
+#
+# The FieldTable is surrounded by a fieldset element whose legend is the "title" instance variable.
+# Inside this fieldset is a table element.
+# Each field (row of the table) has a label (th), a content cell (td), and an optional note (td).
+#
+# If you call "button" you can pass in a block that'll get rendered inside the 2nd column of the last row. The idea here is that you might want to make an HTML form that has a bunch of buttons at the bottom (Save, Cancel, Clear) and these all go in the same cell, with no label for the row.
+#
+# TODO: error messages?
+# @author Alex Chaffee
+class FieldTable < Erector::Widget
+
+  include Erector::Inline
+  
+  class Field < Erector::Widget
+    needs :label, :note => nil
+    
+    def content
+      tr :class => "field_table_field" do
+        th do
+          text @label
+          text ":" unless @label.nil?
+        end
+        td do
+          super # calls the block
+        end
+        if @note
+          td do
+            text @note
+          end
+        end
+      end
+    end
+  end
+
+  # Define a field, containing a label, optional note, and block for the contents
+  #
+  # TODO: allow passing in a widget instead of a block
+  def field(label = nil, note = nil, &contents)
+    @fields << Field.new(:label => label, :note => note, &contents)
+  end
+  
+  # If you call "button" you can pass in a block that'll get rendered inside the 2nd column of the
+  # last row. The idea here is that you might want to make an HTML form that has a bunch of buttons at
+  # the bottom (Save, Cancel, Clear) and these all go in the same cell, with no label for the row.
+  #
+  # TODO: allow passing in a widget instead of a block
+  def button(&button_proc)
+    @buttons << button_proc
+  end
+
+  needs :title
+  
+  # Pass in a block and it'll get called with a pointer to this table, so you can call
+  # 'field' and 'button' to configure it
+  def initialize(*args)
+    super
+    @fields = []
+    @buttons = []
+    yield self if block_given? # invoke the configuration block
+  end
+  
+  def content
+    fieldset :class => "field_table" do
+      legend @title
+      table :width => '100%' do
+        @fields.each do |f|
+          widget f
+        end
+        unless @buttons.empty?
+          tr :class => "field_table_buttons" do
+            td :colspan => 2, :align => "right" do          
+              table :class => 'layout' do
+                tr do
+                  @buttons.each do |button|
+                    td :class => "field_table_button" do
+                      button.call
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+end

data/lib/erector/widgets/form.rb

@@ -0,0 +1,30 @@
+# todo: make more like http://github.com/justinfrench/formtastic
+
+class Form < Erector::Widget
+  needs :action, :method => "post"
+  
+  def content
+    form :method => form_method, :action => @action do
+      unless rest_method == form_method
+        input :type => "hidden", :name => "_method", :value => rest_method
+      end
+      super
+    end
+  end
+  
+  def method
+    @method.to_s.downcase
+  end
+  
+  def form_method
+    if method == "get"
+      "get"
+    else
+      "post"
+    end
+  end
+  
+  def rest_method
+    method
+  end
+end

data/lib/erector/widgets/page.rb

@@ -0,0 +1,165 @@
+# Erector Page base class.
+#
+# Allows for accumulation of script and style tags (see example below) with
+# either external or inline content. External references are 'uniq'd, so it's
+# a good idea to declare a js script in all widgets that use it, so you don't
+# accidentally lose the script if you remove the one widget that happened to
+# declare it.
+#
+# The script and style declarations are accumulated at class load time, as
+# 'dependencies'. This technique allows all widgets to add their own requirements
+# to the page header without extra logic for declaring which pages include
+# which nested widgets. Fortunately, Page is now smart enough to figure out
+# which widgets were actually rendered during the body_content run, so it only
+# emits into its HEAD the dependencies that are relevant. If it misses some, or
+# if you want to add some extra dependencies -- for instance, styles that apply
+# to widgets that are rendered later via AJAX -- then return an array of those
+# widget classes in your subclass by overriding the #extra_widgets method.
+#
+# If you want something to show up in the headers for just one page type
+# (subclass), then override #head_content, call super, and then emit it
+# yourself.
+#
+# Body content can be supplied in several ways:
+#
+#   * In a Page subclass, by overriding the #body_content method:
+#
+#      class MyPage < Erector::Widgets::Page
+#        def body_content
+#          text "body content"
+#        end
+#      end
+#
+#   * Or by overriding #content and passing a block to super:
+#
+#      class MyPage < Erector::Widgets::Page
+#        def content
+#          super do
+#            text "body content"
+#          end
+#        end
+#      end
+#
+#   * Or by passing a block to Page.new:
+#
+#      Erector::Widgets::Page.new do
+#        text "body content"
+#      end
+#
+# This last trick (passing a block to Page.new) works because Page is an
+# InlineWidget so its block is evaluated in the context of the newly
+# instantiated widget object, and not in the context of its caller. But this
+# means you can't access instance variables of the caller, e.g.
+#
+#      @name = "fred"
+#      Erector::Widgets::Page.new do
+#        text "my name is #{@name}"
+#      end
+#
+# will emit "my name is " because @name is nil inside the new Page. However,
+# you *can* call methods in the parent class, thanks to some method_missing
+# magic. Confused? You should be. See Erector::Inline#content for more
+# documentation.
+#
+# Author::   Alex Chaffee, alex@stinky.com 
+#
+# = Example Usage: 
+#
+#   class MyPage < Page
+#     external :js, "lib/jquery.js"
+#     external :script, "$(document).ready(function(){...});"
+#     external :css, "stuff.css"
+#     external :style, "li.foo { color: red; }"
+#
+#     def page_title
+#       "my app"
+#     end
+#
+#     def body_content
+#       h1 "My App"
+#       p "welcome to my app"
+#       widget WidgetWithExternalStyle
+#     end
+#   end
+#
+#   class WidgetWithExternalStyle < Erector::Widget
+#     external :style, "div.custom { border: 2px solid green; }"
+#
+#     def content
+#       div :class => "custom" do
+#         text "green is good"
+#       end
+#     end
+#   end
+#
+# = Thoughts:
+#  * It may be desirable to unify #js and #script, and #css and #style, and have the routine be
+#    smart enough to analyze its parameter to decide whether to make it a file or a script.
+#
+class Erector::Widgets::Page < Erector::InlineWidget
+
+  # Emit the Transitional doctype.
+  # TODO: allow selection from among different standard doctypes
+  def doctype
+    '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+  end
+
+  def content
+    extra_head_slot = nil
+    rawtext doctype
+    html(html_attributes) do
+      head do
+        head_content
+        extra_head_slot = output.placeholder
+      end
+      body(body_attributes) do
+        if block_given?
+          yield
+        else
+          body_content
+        end
+      end
+    end
+    # after everything's been rendered, use the placeholder to
+    # insert all the head's dependencies
+    extra_head_slot << included_head_content
+  end
+
+  # override me to provide a page title (default = name of the Page subclass)
+  def page_title
+    self.class.name
+  end
+  
+  # override me to change the attributes of the HTML element
+  def html_attributes
+    {:xmlns => 'http://www.w3.org/1999/xhtml', 'xml:lang' => 'en', :lang => 'en'}
+  end
+  
+  # override me to add attributes (e.g. a css class) to the body
+  def body_attributes
+    {}
+  end
+
+  # override me (or instantiate Page with a block)
+  def body_content
+    call_block
+  end
+
+  # emit the contents of the head element. Override and call super if you want to put more stuff in there.
+  def head_content
+    meta 'http-equiv' => 'content-type', :content => 'text/html;charset=UTF-8'
+    title page_title
+  end
+  
+  def included_head_content
+    # now that we've rendered the whole page, it's the right time
+    # to ask what all widgets were rendered to the output stream
+    included_widgets = [self.class] + output.widgets.to_a + extra_widgets
+    ExternalRenderer.new(:classes => included_widgets).to_html
+  end
+  
+  def extra_widgets
+    []
+  end
+end