rxhp 0.0.1

data/lib/rxhp/attribute_validator.rb

@@ -0,0 +1,116 @@
+require 'rxhp/error'
+
+module Rxhp
+  module AttributeValidator
+    class ValidationError < Rxhp::ScriptError
+    end
+
+    class UnacceptableAttributeError < ValidationError
+      attr_reader :element, :attribute, :value
+      def initialize element, attribute, value
+        @element, @attribute, @value = element, attribute, value
+        super "Class #{element.class.name} does not support #{attribute}=#{value.inspect}"
+      end
+    end
+
+    class MissingRequiredAttributeError < ValidationError
+      attr_reader :element, :attribute
+      def initialize element, attribute
+        @element, @attribute = element, attribute
+        super "Element #{element.inspect} is missing required attributes: #{attribute.inspect}"
+      end
+    end
+
+    def valid_attributes?
+      begin
+        self.validate_attributes!
+        true
+      rescue ValidationError
+        false
+      end
+    end
+
+    def validate_attributes!
+      # Check for required attributes
+      self.class.required_attributes.each do |matcher|
+        matched = self.attributes.any? do |key, value|
+          key = key.to_s
+          Rxhp::AttributeValidator.match? matcher, key, value
+        end
+        if !matched
+          raise MissingRequiredAttributeError.new(self, matcher)
+        end
+      end
+
+      # Check other attributes are acceptable
+      return true if self.attributes.empty?
+      self.attributes.each do |key, value|
+        key = key.to_s
+        matched = self.class.acceptable_attributes.any? do |matcher|
+          Rxhp::AttributeValidator.match? matcher, key, value
+        end
+
+        if !matched
+          raise UnacceptableAttributeError.new(self, key, value)
+        end
+      end
+      true
+    end
+
+    def self.match? matcher, name, value
+      case matcher
+      when Array
+        matcher.any? { |x| match? x, name, value }
+      when Hash
+        matcher.any? do |name_matcher, value_matcher|
+          name_match = match?(name_matcher, name, nil)
+          value_match = match?(value_matcher, value, nil)
+          name_match && value_match
+        end
+      when Symbol
+        matcher.to_s.gsub('_', '-') == name
+      else
+        matcher === name
+      end
+    end
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      class << klass
+        attr_accessor :acceptable_attributes, :required_attributes
+        def accept_attributes matcher
+          acceptable_attributes.push matcher
+        end
+        alias :accept_attribute :accept_attributes
+
+        def require_attributes matcher
+          accept_attributes matcher
+          required_attributes.push matcher
+        end
+        alias :require_attribute :require_attributes
+
+        def accept_all_attributes
+          attribute_matches.push Object
+        end
+      end
+
+      klass.acceptable_attributes = []
+      klass.required_attributes = []
+    end
+
+    def self.inherited(subklass)
+      subklass.class_eval do
+        include Rxhp::AttributeValidator
+      end
+      subklass.acceptable_attributes = subklass.superclass.acceptable_attributes.dup
+      subklass.required_attributes = subklass.superclass.required_attributes.dup
+    end
+
+    module ClassMethods
+      def inherited(subklass)
+        Rxhp::AttributeValidator.inherited(subklass)
+      end
+
+    end
+  end
+end

data/lib/rxhp/composable_element.rb

@@ -0,0 +1,57 @@
+require 'rxhp/attribute_validator'
+require 'rxhp/element'
+require 'rxhp/fragment'
+
+module Rxhp
+  # This defines an element that is only a handy way to think of a
+  # tree of other elements - it has no real rendering by itself, just those
+  # of its' children.
+  #
+  # Most of the time, those children will either be ComposableElement's in
+  # turn, or subclasses of Rxhp::HtmlElement
+  class ComposableElement < Rxhp::Element
+    include Rxhp::AttributeValidator
+
+    def initialize *args
+      super *args
+      validate_attributes!
+    end
+
+    # You don't want to implement this function in your subclasses -
+    # just reimplement compose instead.
+    #
+    # This calls compose, provides the 'yield' magic, and callls render on
+    # the output.
+    def render options = {}
+      validate_attributes!
+      self.compose do
+        # Allow 'yield' to embed all children
+        self.children.each do |child|
+          fragment child
+        end
+      end.render(options)
+    end
+
+    # Implement this method - return an Rxhp::Element subclass.
+    def compose
+      raise NotImplementedError.new
+    end
+
+    # Automatically add a foo_bar method to Rxhp scopes when a FooBar
+    # subclass of this is created.
+    def self.inherited subclass
+      Rxhp::AttributeValidator.inherited(subclass)
+      full_name = subclass.name
+      parts = full_name.split('::')
+      klass_name = parts.pop
+      namespace = Kernel
+      parts.each do |part|
+        namespace = namespace.const_get(part)
+      end
+      # UpperCamelCase => under_scored
+      tag_name = klass_name.gsub(/(.)([A-Z])/, '\1_\2').downcase
+
+      Rxhp::Scope.define_element tag_name, subclass, namespace
+    end
+  end
+end

data/lib/rxhp/constants.rb

@@ -0,0 +1,19 @@
+module Rxhp
+  # Basic output formats
+  HTML_FORMAT = :html
+  TINY_HTML_FORMAT = :tiny_html
+  XHTML_FORMAT = :xhtml
+
+  # Doctypes
+  HTML_5 = "<!DOCTYPE html>\n"
+  HTML_4_01_TRANSITIONAL = <<EOF
+<!DOCTYPE HTML PUBLIC
+  "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+EOF
+  XHTML_1_0_STRICT = <<EOF
+<!DOCTYPE html PUBLIC
+  "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+EOF
+end

data/lib/rxhp/data/html/attributes.rb

@@ -0,0 +1,154 @@
+require 'uri'
+
+module Rxhp
+  module Html
+    # Given ['foo', 'bar', 'baz'], match:
+    # - 'foo'
+    # - 'bar baz'
+    # - 'foo bar baz'
+    # etc.
+    def self.token_list tokens
+      token = tokens.join('|')
+      /^#{token}( (#{token}) )*$/
+    end
+
+    # All the non-javascript attributes shared by every HTML element.
+    GLOBAL_ATTRIBUTES = {
+      /^data-[^:]+$/ => Object,
+
+      :accesskey => String,
+      :class => String,
+      :contenteditable => %w'true false inherit',
+      :contextmenu => String,
+      :dir => %w'ltr rtl auto',
+      :draggable => %w'true false',
+      :dropzone => String,
+      :hidden => [true, false],
+      :id => /^[^ ]+$/,
+      :lang => String,
+      :spellcheck => %w'true false',
+      :style => String,
+      :tabindex => Integer,
+      :title => String,
+    }
+
+    # Every HTML element has these
+    GLOBAL_EVENT_HANDLERS = {
+      :onabort => String,
+      :onblur => String,
+      :oncanplay => String,
+      :oncanplaythrough => String,
+      :onchange => String,
+      :onclick => String,
+      :oncontextmenu => String,
+      :oncuechange => String,
+      :ondblclick => String,
+      :ondrag => String,
+      :ondragend => String,
+      :ondragenter => String,
+      :ondragleave => String,
+      :ondragover => String,
+      :ondragstart => String,
+      :ondrop => String,
+      :ondurationchange => String,
+      :onemptied => String,
+      :onended => String,
+      :onerror => String,
+      :onfocus => String,
+      :oninput => String,
+      :oninvalid => String,
+      :onkeydown => String,
+      :onkeypress => String,
+      :onkeyup => String,
+      :onload => String,
+      :onloadeddata => String,
+      :onloadedmetadata => String,
+      :onloadstart => String,
+      :onmousedown => String,
+      :onmousemove => String,
+      :onmouseout => String,
+      :onmouseover => String,
+      :onmouseup => String,
+      :onmousewheel => String,
+      :onpause => String,
+      :onplay => String,
+      :onplaying => String,
+      :onprogress => String,
+      :onratechange => String,
+      :onreset => String,
+      :onscroll => String,
+      :onseeked => String,
+      :onseeking => String,
+      :onselect => String,
+      :onshow => String,
+      :onstalled => String,
+      :onsubmit => String,
+      :onsuspend => String,
+      :ontimeupdate => String,
+      :onvolumechange => String,
+      :onwaiting => String,
+    }
+
+    # Specific attributes used by multiple elements
+    HREF_ATTRIBUTE = { :href => [String, URI] }
+    MEDIA_ATTRIBUTE = { :media => String }
+    REL_ATTRIBUTE = {
+      :rel => Rxhp::Html.token_list(%w[
+        alternate
+        author
+        bookmark
+        help
+        icon
+        license
+        next
+        nofollow
+        noreferrer
+        prefetch
+        prev
+        search
+        stylesheet
+        tag
+      ]),
+    }
+    DATETIME_ATTRIBUTE = { :datetime => String }
+    CITE_ATTRIBUTE = { :cite => [String, URI] }
+    SRC_ATTRIBUTE = { :src => [String, URI] }
+    DIMENSION_ATTRIBUTES = {
+      :width => String,
+      :height => String,
+    }
+    CROSSORIGIN_ATTRIBUTE = {
+      :crossorigin => /^(anonymous|use-credentials)$/,
+    }
+    COMMON_MEDIA_ATTRIBUTES = {
+      :preload => /^(none|metadata|auto)/,
+      :autoplay => [true, false],
+      :mediagroup => String,
+      :loop => [true, false],
+      :muted => [true, false],
+      :controls => [true, false],
+    }
+    SPAN_ATTRIBUTE = { :span => Integer }
+    TABLE_CELL_ATTRIBUTES = {
+      :colspan => Integer,
+      :rowspan => Integer,
+      :headers => String,
+    },
+    AUTOCOMPLETE_ATTRIBUTE = { :autocomplete => ['on', 'off'] }
+
+    ENC_TYPES = %w[
+      application/x-www-form-urlencoded
+      multipart/form-data
+      text/plain
+    ]
+    INTEGER_LIST = /^\d+(,\d+)*$/
+    FORM_ATTRIBUTES = {
+      :form => String,
+      :formaction => [String, URI],
+      :formenctype => ENC_TYPES,
+      :formmethod => ['get', 'post'],
+      :formnovalidate => [true, false],
+      :formtarget => String,
+    }
+  end
+end

data/lib/rxhp/data/html/tags.rb

@@ -0,0 +1,533 @@
+require 'rxhp/html_element'
+require 'rxhp/html_self_closing_element'
+require 'rxhp/html_singleton_element'
+
+require 'rxhp/data/html/attributes'
+
+module Rxhp
+  # Definitions of all standard HTML 4.01 and HTML 5 elements.
+  #
+  # All the classes are created when this file is loaded, regardless
+  # of usage.
+  #
+  # There are three common superclasses:
+  # - HtmlElement - standard elements
+  # - HtmlSelfClosingElement - elements where in HTML, the closing tag is
+  #   optional - for example, <p>, <li>, and <body>
+  # - HtmlSingletonElement - not only is the closing tag optional, but
+  #   child elements are forbidden - for example, <br> and <img>
+  #
+  # 'Special' classes are defined in rxhp/tags/ - for example, the HTML
+  # element in Rxhp is defined to add a doctype, depending on the formatter
+  # settings.
+  module Html
+    TAGS = {
+      :a => {
+        :attributes => [
+          HREF_ATTRIBUTE,
+          MEDIA_ATTRIBUTE,
+          REL_ATTRIBUTE,
+          {
+            :target => String,
+            :hreflang => String,
+            :type => String,
+          },
+        ],
+      },
+      :abbr => {},
+      :acronym => {},
+      :address => {},
+      :applet => {},
+      :area => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          HREF_ATTRIBUTE,
+          REL_ATTRIBUTE,
+          MEDIA_ATTRIBUTE,
+          {
+            :alt => String,
+            :coords => INTEGER_LIST,
+            :shape => %w(circle default poly rect),
+            :target => String,
+            :media => String,
+            :hreflang => String,
+            :type => String,
+          },
+        ],
+      },
+      :article => {},
+      :aside => {},
+      :audio => {
+        :attributes => [
+          SRC_ATTRIBUTE,
+          CROSSORIGIN_ATTRIBUTE,
+          COMMON_MEDIA_ATTRIBUTES,
+        ],
+      },
+      :b => {},
+      :base => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          HREF_ATTRIBUTE,
+          { :target => String },
+        ],
+      },
+      :basefont => {},
+      :bdo => {},
+      :bdi => {},
+      :big => {},
+      :blockquote => { :attributes => CITE_ATTRIBUTE },
+      :body => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => %w[
+          onafterprint
+          onbeforeprint
+          onbeforeunload
+          onblur
+          onerror
+          onfocus
+          onhashchange
+          onload
+          onmessage
+          onoffline
+          ononline
+          onpagehide
+          onpageshow
+          onpopstate
+          onresize
+          onscroll
+          onstorage
+          onunload
+        ],
+      },
+      :br => {:is_a => HtmlSingletonElement},
+      :button => {
+        :attributes => [
+          FORM_ATTRIBUTES,
+          {
+            :autofocus => [true, false],
+            :disabled => [true, false],
+            :name => String,
+            :value => Object,
+            :type => %w[submit reset button],
+          },
+        ],
+      },
+      :canvas => {
+        :attributes => DIMENSION_ATTRIBUTES,
+      },
+      :caption => {},
+      :center => {},
+      :cite => {},
+      :code => {},
+      :col => {
+        :is_a => HtmlSingletonElement,
+        :attributes => SPAN_ATTRIBUTE,
+      },
+      :colgroup => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => SPAN_ATTRIBUTE,
+      },
+      :command => {
+        :is_a => HtmlSingletonElement,
+        :attributes => {
+          :type => %w[command checkbox radio],
+          :label => String,
+          :icon => [String, URI],
+          :disabled => [true, false],
+          :radiogroup => String,
+        },
+      },
+      :datalist => {},
+      :dd => {:is_a => HtmlSelfClosingElement},
+      :del => {
+        :attributes => [
+          CITE_ATTRIBUTE,
+          DATETIME_ATTRIBUTE,
+        ],
+      },
+      :details => { :attributes => { :open => [true, false] } },
+      :dfn => {},
+      :dir => {},
+      :div => {},
+      :dl => {},
+      :dt => {:is_a => HtmlSelfClosingElement},
+      :em => {},
+      :embed => {
+        :is_a => HtmlSingletonElement,
+        :attributes => {Object => Object }, # anything :/
+      },
+      :fieldset => {
+        :attributes => {
+          :disabled => [true, false],
+          :form => String,
+          :name => String,
+        },
+      },
+      :figcaption => {},
+      :figure => {},
+      :font => {},
+      :footer => {},
+      :form => {
+        :attributes => [
+          AUTOCOMPLETE_ATTRIBUTE,
+          {
+            'accept-charset' => String,
+            :action => [String, URI],
+            :enctype => ENC_TYPES,
+            :method => ['get', 'post'],
+            :name => String,
+            :novalidate => [true, false],
+            :target => String,
+          },
+        ],
+      },
+      :frame => {},
+      :frameset => {},
+      :h1 => {},
+      :h2 => {},
+      :h3 => {},
+      :h4 => {},
+      :h5 => {},
+      :h6 => {},
+      :head => {:is_a => HtmlSelfClosingElement},
+      :header => {},
+      :hgroup => {},
+      :hr => {:is_a => HtmlSingletonElement},
+      :html => {:require => 'rxhp/tags/html_tag'},
+      :i => {},
+      :iframe => {
+        :attributes => [
+          SRC_ATTRIBUTE,
+          DIMENSION_ATTRIBUTES,
+          {
+            :srcdoc => String,
+            :name => String,
+            :sandbox => ['', token_list(%w[
+              allow-forms
+              allow-same-origin
+              allow-scripts
+              allow-top-navigation
+            ])],
+            :seamless => [true, false],
+          },
+        ],
+      },
+      :img => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          SRC_ATTRIBUTE,
+          DIMENSION_ATTRIBUTES,
+          CROSSORIGIN_ATTRIBUTE,
+          {
+            :alt => String,
+            :usemap => String,
+            :ismap => [true, false],
+          },
+        ],
+      },
+      :input => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          AUTOCOMPLETE_ATTRIBUTE,
+          DIMENSION_ATTRIBUTES,
+          SRC_ATTRIBUTE,
+          FORM_ATTRIBUTES,
+          {
+            :accept => String,
+            :alt => String,
+            :autofocus => [true, false],
+            :checked => [true, false],
+            :dirname => String,
+            :disabled => [true, false],
+            :list => String,
+            :max => [Numeric, String],
+            :maxlength => Integer,
+            :min => [Numeric, String],
+            :multiple => [true, false],
+            :name => String,
+            :pattern => String, # ECMAScript RE != RegExp.to_s
+            :placeholder => String,
+            :required => [true, false],
+            :step => [Numeric, String],
+            :value => Object,
+            :type => %w[
+              hidden
+              text
+              search
+              tel
+              url
+              email
+              password
+              datetime
+              date
+              month
+              week
+              time
+              datetime-local
+              number
+              range
+              color
+              checkbox
+              radio
+              file
+              submit
+              image
+              reset
+              button
+            ],
+          },
+        ],
+      },
+      :ins => {
+        :attributes => [
+          CITE_ATTRIBUTE,
+          DATETIME_ATTRIBUTE,
+        ],
+      },
+      :isindex => {},
+      :kbd => {},
+      :keygen => {
+        :is_a => HtmlSingletonElement,
+        :attributes => {
+          :autofocus => [true, false],
+          :challenge => String,
+          :disabled => [true, false],
+          :form => String,
+          :keytype => 'rsa',
+          :name => String,
+        },
+      },
+      :label => {
+        :attributes => {
+          :form => String,
+          :for => String,
+        },
+      },
+      :legend => {},
+      :li => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => {
+          :value => Integer,
+        },
+      },
+      :link => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          HREF_ATTRIBUTE,
+          REL_ATTRIBUTE,
+          {
+            :href_lang => String,
+            :type => String,
+            :sizes => [
+              'any',
+              /^\d+x\d+( \d+x\d+)*/,
+            ],
+          },
+        ],
+      },
+      :map => { :attributes => { :name => String } },
+      :mark => {},
+      :menu => {
+        :attributes => {
+          :type => ['context', 'toolbar'],
+          :label => String,
+        },
+      },
+      :meta => {
+        :is_a => HtmlSingletonElement,
+        :attributes => {
+          :name => String,
+          :content => String,
+          :charset => String,
+          'http-equiv' => %w(content-language content-type default-style refresh set-cookie),
+        },
+      },
+      :meter => {
+        :attributes => {
+          %w[value min max low high optimum] => [String, Numeric],
+        },
+      },
+      :nav => {},
+      :noframes => {},
+      :noscript => {},
+      :object => {
+        :attributes => [
+          DIMENSION_ATTRIBUTES,
+          {
+            :data => [String, URI],
+            :type => String,
+            :typemustmatch => [true, false],
+            :name => String,
+            :usemap => String,
+            :form => String,
+          },
+        ],
+      },
+      :ol => {
+        :attributes => {
+          :reversed => [true, false],
+          :start => Integer,
+          :type => %w{1 a A i I},
+        },
+      },
+      :optgroup => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => {
+          :disabled => [true, false],
+          :label => String,
+        },
+      },
+      :option => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => {
+          :disabled => [true, false],
+          :label => String,
+          :selected => [true, false],
+          :value => Object,
+        },
+      },
+      :output => {
+        :attributes => {
+          :for => String,
+          :form => String,
+          :name => String,
+        },
+      },
+      :p => {:is_a => HtmlSelfClosingElement},
+      :param => {
+        :is_a => HtmlSingletonElement,
+        :attributes => {
+          :name => String,
+          :value => String,
+        },
+      },
+      :pre => {},
+      :progress => {
+        :attributes => {
+          :value => Object,
+          :max => [Numeric, String],
+        },
+      },
+      :rb => {},
+      :rt => {},
+      :ruby => {},
+      :q => { :attributes => CITE_ATTRIBUTE },
+      :s => {},
+      :samp => {},
+      :script => {
+        :attributes => [
+          SRC_ATTRIBUTE,
+          {
+            :async => [true, false],
+            :defer => [true, false],
+            :type => String,
+            :charset => String,
+          },
+        ],
+      },
+      :section => {},
+      :select => {
+        :attributes => {
+          :autofocus => [true, false],
+          :disabled => [true, false],
+          :form => String,
+          :multiple => [true, false],
+          :name => String,
+          :required => [true, false],
+          :size => Integer,
+        },
+      },
+      :small => {},
+      :source => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          SRC_ATTRIBUTE,
+          MEDIA_ATTRIBUTE,
+          { :type => String },
+        ],
+      },
+      :span => {},
+      :strike => {},
+      :strong => {},
+      :style => {
+        :attributes => [
+          MEDIA_ATTRIBUTE,
+          {
+            :type => String,
+            :scoped => [true, false],
+          },
+        ],
+      },
+      :sub => {},
+      :summary => {},
+      :sup => {},
+      :table => { :attributes => {:border => '1' } },
+      :tbody => {:is_a => HtmlSelfClosingElement},
+      :td => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => TABLE_CELL_ATTRIBUTES,
+      },
+      :textarea => {
+        :attributes => {
+          :autofocus => [true, false],
+          :cols => Integer,
+          :dirname => String,
+          :disabled => [true, false],
+          :form => String,
+          :maxlength => Integer,
+          :name => String,
+          :placeholder => String,
+          :readonly => [true, false],
+          :required => [true, false],
+          :rows => Integer,
+          :wrap => ['soft', 'hard'],
+        },
+      },
+      :tfoot => {:is_a => HtmlSelfClosingElement},
+      :th => {
+        :is_a => HtmlSelfClosingElement,
+        :attributes => [
+          TABLE_CELL_ATTRIBUTES,
+          {
+            :scope => %w(row col rowgroup colgroup),
+          },
+        ],
+      },
+      :thead => {:is_a => HtmlSelfClosingElement},
+      :time => {
+        :attributes => DATETIME_ATTRIBUTE,
+      },
+      :title => {},
+      :tr => {:is_a => HtmlSelfClosingElement},
+      :track => {
+        :is_a => HtmlSingletonElement,
+        :attributes => [
+          SRC_ATTRIBUTE,
+          {
+            :kind => %w(subtitles captions descriptions chapters metadata),
+            :srclang => String,
+            :label => String,
+            :default => [true, false],
+          },
+        ],
+      },
+      :tt => {},
+      :u => {},
+      :ul => {},
+      :var => {},
+      :video => {
+        :attributes => [
+          SRC_ATTRIBUTE,
+          CROSSORIGIN_ATTRIBUTE,
+          DIMENSION_ATTRIBUTES,
+          COMMON_MEDIA_ATTRIBUTES,
+          {
+            :poster => [String, URI],
+          },
+        ],
+      },
+      :wbr => {:is_a => HtmlSingletonElement},
+    }
+  end
+end

data/lib/rxhp/element.rb

@@ -0,0 +1,70 @@
+require 'rxhp/constants'
+require 'rxhp/scope'
+
+module Rxhp
+  # Base class for all element-like things in RXHP.
+  #
+  # Everything in the tree is a subclass of this, a subclass of String,
+  # something that responds nicely to to_s, or something that will cause en
+  # error at render-time :p
+  class Element
+    include ::Rxhp::Scope
+    attr_accessor :attributes, :children
+
+    def initialize attributes = {}
+      @attributes = attributes
+      @children = Array.new
+    end
+
+    def children?
+      !children.empty?
+    end
+
+    # Return a flat HTML string for this element and all its' decendants.
+    #
+    # You probably don't want to implement this yourself - interesting
+    # implementations are in Rxhp::Fragment, Rxhp::HtmlElement, and
+    # Rxhp::ComposableElement
+    def render options = {}
+      raise NotImplementedError.new
+    end
+
+    # Called when something that isn't an element is found in the tree.
+    #
+    # Implemented in Rxhp::HtmlElement.
+    def render_string string, options
+      raise NotImplementedError.new
+    end
+
+
+    # Iterate over all the children, calling render.
+    def render_children options = {}
+      return if children.empty?
+
+      out = String.new
+      children.each do |child|
+        case child
+        when Element
+          out += child.render(options)
+        when String
+          out += self.render_string(child, options)
+        else
+          out += self.render_string(child.to_s, options)
+        end
+      end
+      out
+    end
+
+    # Fill default options
+    def fill_options options
+      {
+        :pretty => true,
+        :format => Rxhp::HTML_FORMAT,
+        :skip_doctype => false,
+        :doctype => Rxhp::HTML_5,
+        :depth => 0,
+        :indent => 2,
+      }.merge(options)
+    end
+  end
+end

data/lib/rxhp/error.rb

@@ -0,0 +1,7 @@
+module Rxhp
+  class Error < ::StandardError
+  end
+
+  class ScriptError < ::ScriptError
+  end
+end

data/lib/rxhp/fragment.rb

@@ -0,0 +1,13 @@
+require 'rxhp/element'
+
+module Rxhp
+  # Fake element that only renders its' children.
+  #
+  # Can be used like an array, or if you just need something that acts like
+  # an element - this is used internally as the root of all render trees.
+  class Fragment < Element
+    def render options = {}
+      self.render_children(options)
+    end
+  end
+end

data/lib/rxhp/html.rb

@@ -0,0 +1,43 @@
+require 'rxhp/data/html/attributes'
+require 'rxhp/data/html/tags'
+
+module Rxhp
+  module Html
+    def fragment x
+      Rxhp::Scope.current.children.push x
+    end
+    alias :frag :fragment
+    alias :text :fragment
+
+    class <<self
+      def fragment x
+        Rxhp::Scope.current.children.push x
+      end
+      alias :frag :fragment
+      alias :text :fragment
+    end
+  end
+end
+
+Rxhp::Html::TAGS.each do |tag, data|
+  if data[:require]
+    require data[:require]
+  else
+    data = {
+      :is_a => Rxhp::HtmlElement,
+    }.merge(data)
+
+    klass_name = tag.to_s.dup
+    klass_name[0] = klass_name[0,1].upcase
+    klass = Class.new(data[:is_a])
+    klass.send(:define_method, :tag_name) { tag.to_s }
+
+    if data[:attributes]
+      klass.accept_attributes data[:attributes]
+    end
+
+    Rxhp::Html.const_set(klass_name, klass)
+
+    Rxhp::Scope.define_element tag, klass, Rxhp::Html
+  end
+end

data/lib/rxhp/html_element.rb

@@ -0,0 +1,143 @@
+require 'rxhp/element'
+require 'rxhp/attribute_validator'
+
+require 'rxhp/data/html/attributes'
+
+module Rxhp
+  # Base class for 'real' elements that actually end up in the markup.
+  #
+  # For example, <span> is a subclass of this.
+  #
+  # To use:
+  # 1. subclass
+  # 2. define tag_name
+  # 3. call Rxhp::Scope.define_element('foo', Foo) to register the class
+  # ... or just add a define_tag line to html.rb.
+  #
+  # There's another two base classes for special types of html elements:
+  # - HtmlSelfClosingElement - elements where in HTML, the closing tag is
+  #   optional - for example, <p>, <li>, and <body>
+  # - HtmlSingletonElement - not only is the closing tag optional, but
+  #   child elements are forbidden - for example, <br> and <img>
+  #
+  # These can also be defined via Rxhp::Html#define_tag
+  #
+  # If you're making a custom element that's purely server-side (i.e. is
+  # just composed of HTML elements), you want to subclass ComposableElement
+  # instead.
+  class HtmlElement < Element
+    include Rxhp::AttributeValidator
+    accept_attributes Rxhp::Html::GLOBAL_ATTRIBUTES
+    accept_attributes Rxhp::Html::GLOBAL_EVENT_HANDLERS
+
+    def initialize *args
+      super *args
+      validate_attributes!
+    end
+
+    def tag_name
+      raise NotImplementedError.new
+    end
+
+    # Render the element.
+    #
+    # Pays attention to the formatter type, doctype, pretty print options,
+    # etc.
+    def render options = {}
+      validate_attributes!
+      options = fill_options(options)
+
+      open = render_open_tag(options)
+      inner = render_children(options)
+      close = render_close_tag(options)
+
+      if options[:pretty]
+        indent = ' ' * (options[:indent] * options[:depth])
+        out = "%s%s\n" % [indent, open]
+        out += inner if inner
+        out += "%s%s\n" % [indent, close] if close && !close.empty?
+        out
+      else
+        out = open
+        out += inner if inner
+        out += close if close
+        out
+      end
+    end
+
+    # Override to increase the depth count for the sake of pretty printing
+    def render_children options = {}
+      child_options = options.dup
+      child_options[:depth] += 1
+      super child_options
+    end
+
+    protected
+
+    # html-escape a string, paying attention to indentation too.
+    def render_string string, options
+      escaped = html_escape(string)
+      if options[:pretty]
+        indent = ' ' * (options[:indent] * options[:depth])
+        indent + escaped + "\n"
+      else
+        escaped
+      end
+    end
+
+    # Render the opening tag.
+    #
+    # Considers:
+    #  - attributes
+    #  - XHTML or HTML?
+    #  - are there any children?
+    #
+    # #render_close_tag assumes that this will not leave a tag open in XHTML
+    # unless there are children.
+    def render_open_tag options
+      out = '<' + tag_name
+      unless attributes.empty?
+        attributes.each do |name,value|
+          case value
+          when false
+            next
+          when true
+            if options[:format] == Rxhp::XHTML_FORMAT
+              out += ' ' + name.to_s + '="' + name.to_s + '"'
+            else
+              out += ' ' + name
+            end
+          else
+            out += ' ' + name.to_s + '="' + html_escape(value.to_s) + '"'
+          end
+        end
+      end
+
+      if options[:format] == Rxhp::XHTML_FORMAT && !children?
+        out + ' />'
+      else
+        out + '>'
+      end
+    end
+
+    # Render the closing tag.
+    #
+    # Assumes that #render_open_tag would have made a self-closing tag if
+    # appropriate.
+    #
+    # This is overriden in:
+    # - HtmlSingletonElement: never any children, so never a closing tag
+    # - HtmlSelfClosingElement: calls this, /unless/ tiny html output is
+    #   selected, in which case the closing tag is skipped.
+    def render_close_tag options
+      if options[:format] != Rxhp::XHTML_FORMAT || children?
+        '</' + tag_name + '>'
+      end
+    end
+
+    # Don't pull in ActiveSupport just for this...
+    def html_escape s
+      s.gsub('&','&amp;').gsub('<','&lt;').gsub('>','&gt;').gsub('"','&quot;')
+    end
+  end
+end

data/lib/rxhp/html_self_closing_element.rb

@@ -0,0 +1,16 @@
+require 'rxhp/html_element'
+
+module Rxhp
+  # Base class for HTML elements where the closing tag is optional, but
+  # there can still be children.
+  #
+  # For example, </p> is optional in HTML, but required in XHTML.
+  # This will change whether they're included or not based on the selected
+  # render format.
+  class HtmlSelfClosingElement < HtmlElement
+    protected
+    def render_close_tag options
+      super if options[:format] != Rxhp::TINY_HTML_FORMAT
+    end
+  end
+end

data/lib/rxhp/html_singleton_element.rb

@@ -0,0 +1,26 @@
+require 'rxhp/html_element'
+require 'rxhp/error'
+
+module Rxhp
+  # Superclass for all HTML elements that should never have children.
+  #
+  # This is enforced. Examples include '<br>', '<img>' etc
+  #
+  # There is never a close tag:
+  # - in HTML it would be optional (and meaningless) anyway
+  # - people don't expect to see them
+  # - in XHTML, the opening tag will have been self closing.
+  class HtmlSingletonElement < HtmlElement
+    def render *args
+      unless children.empty?
+        raise Rxhp::ScriptError.new('Singleton element has children')
+      end
+      super *args
+    end
+
+    protected
+    def render_close_tag options
+      nil
+    end
+  end
+end

data/lib/rxhp/scope.rb

@@ -0,0 +1,114 @@
+module Rxhp
+  autoload :Fragment, 'rxhp/fragment'
+  # A place for factory methods to be defined.
+  #
+  # These are methods like Rxhp::Scope#h1 which creates an Rxhp::Html::H1
+  # instance.
+  #
+  # The actual HTML classes are defined in rxhp/html.rb
+  #
+  module Scope
+    # Helper function to append a child to the current context.
+    # Allows you to do this:
+    #   inner = body { 'hi' }
+    #   html do
+    #     fragment inner
+    #   end
+    def fragment x
+      Rxhp::Scope.current.children.push x
+    end
+    alias :frag :fragment
+    alias :text :fragment
+
+    def self.current
+      self.stack.last || Rxhp::Fragment.new
+    end
+
+    def self.with_parent parent
+      result = nil
+      begin
+        self.stack.push parent
+        result = yield
+      ensure
+        self.stack.pop
+      end
+      result
+    end
+
+    # Define the factory method.
+    #
+    # can be called like:
+    #   tag 'content'
+    #   tag { content }
+    #   tag 'content', :attribute => 'value'
+    #   tag(:attribute=>'value') do
+    #     content
+    #   end
+    #   tag
+    #   tag (:attribute => value)
+    def self.define_element name, klass, namespace
+      impl = Proc.new do |*args, &block|
+        # Yay for faking named parameters as a hash :p
+        children = nil
+        attributes = {}
+        args.each do |arg|
+          if arg.is_a?(Hash)
+            attributes = arg
+          else
+            children ||= []
+            children.push arg
+          end
+        end
+
+        # Create the actual element
+        element = klass.new(attributes)
+        Rxhp::Scope.current.children.push element
+
+        # Append non-block children
+        if children
+          if children.is_a? Array
+            children.each do |child|
+              element.children.push child
+            end
+          else
+            element.children.push children # well, child
+          end
+        end
+
+        if block
+          Rxhp::Scope.with_parent(element) do
+            if block.call.is_a? String
+              raise Rxhp::ScriptError.new(
+                "In a block, use the 'text' method to include Strings"
+              )
+            end
+            nil
+          end
+        end
+        element
+      end
+
+      # Instance method if mixed in.
+      #
+      # Usage:
+      #  include Rxhp::Html
+      #  html do
+      #    ...
+      #  end
+      namespace.send(:define_method, name, impl)
+      # Class method for fully-qualified.
+      #
+      # Usage:
+      #  Rxhp::Html.html do
+      #    ...
+      #  end
+      (class <<namespace; self; end).send(:define_method, name, impl)
+    end
+
+    private
+
+    def self.stack
+      Thread.current[:rxhp_scope_stack] ||= []
+    end
+  end
+end

data/lib/rxhp/tags/html_tag.rb

@@ -0,0 +1,21 @@
+require 'rxhp/html_self_closing_element'
+require 'rxhp/scope'
+
+module Rxhp
+  module Html
+    class Html < HtmlSelfClosingElement
+      def tag_name; 'html'; end
+
+      protected
+      def render_open_tag options
+        if options[:skip_doctype]
+          super
+        else
+          options[:doctype] + super
+        end
+      end
+    end
+  end
+end
+
+Rxhp::Scope.define_element('html', Rxhp::Html::Html, Rxhp::Html)

data/lib/rxhp.rb

@@ -0,0 +1,4 @@
+require 'rxhp/constants'
+require 'rxhp/error'
+require 'rxhp/composable_element'
+require 'rxhp/html'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: rxhp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Fred Emmott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-21 00:00:00.000000000Z
+dependencies: []
+description: An object-oriented validating HTML template system
+email:
+- rxhp-gem@fredemmott.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rxhp/attribute_validator.rb
+- lib/rxhp/composable_element.rb
+- lib/rxhp/constants.rb
+- lib/rxhp/data/html/attributes.rb
+- lib/rxhp/data/html/tags.rb
+- lib/rxhp/element.rb
+- lib/rxhp/error.rb
+- lib/rxhp/fragment.rb
+- lib/rxhp/html.rb
+- lib/rxhp/html_element.rb
+- lib/rxhp/html_self_closing_element.rb
+- lib/rxhp/html_singleton_element.rb
+- lib/rxhp/scope.rb
+- lib/rxhp/tags/html_tag.rb
+- lib/rxhp.rb
+homepage: https://github.com/fredemmott/rxhp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: An object-oriented validating HTML template system
+test_files: []