arbo 1.2.0

data/lib/arbo/component.rb

@@ -0,0 +1,22 @@
+module Arbo
+  class Component < Arbo::HTML::Div
+
+    # By default components render a div
+    def tag_name
+      'div'
+    end
+
+    def initialize(*)
+      super
+      add_class default_class_name
+    end
+
+    protected
+
+    # By default, add a css class named after the ruby class
+    def default_class_name
+      self.class.name.demodulize.underscore
+    end
+
+  end
+end

data/lib/arbo/context.rb

@@ -0,0 +1,118 @@
+require 'arbo/element'
+require 'ruby2_keywords'
+
+module Arbo
+
+  # The Arbo::Context class is the frontend for using Arbo.
+  #
+  # The simplest example possible:
+  #
+  #     html = Arbo::Context.new do
+  #       h1 "Hello World"
+  #     end
+  #
+  #     html.to_s #=> "<h1>Hello World</h1>"
+  #
+  # The contents of the block are instance eval'd within the Context
+  # object. This means that you lose context to the outside world from
+  # within the block. To pass local variables into the Context, use the
+  # assigns param.
+  #
+  #     html = Arbo::Context.new({one: 1}) do
+  #       h1 "Your number #{one}"
+  #     end
+  #
+  #     html.to_s #=> "Your number 1"
+  #
+  class Context < Element
+
+    # Initialize a new Arbo::Context
+    #
+    # @param [Hash] assigns A hash of objecs that you would like to be
+    #                       availble as local variables within the Context
+    #
+    # @param [Object] helpers An object that has methods on it which will become
+    #                         instance methods within the context.
+    #
+    # @yield [] The block that will get instance eval'd in the context
+    def initialize(assigns = {}, helpers = nil, &block)
+      assigns = assigns || {}
+      @_assigns = assigns.symbolize_keys
+
+      @_helpers = helpers
+      @_current_arbo_element_buffer = [self]
+
+      super(self)
+      instance_eval(&block) if block_given?
+    end
+
+    def arbo_context
+      self
+    end
+
+    def assigns
+      @_assigns
+    end
+
+    def helpers
+      @_helpers
+    end
+
+    def indent_level
+      # A context does not increment the indent_level
+      super - 1
+    end
+
+    def bytesize
+      cached_html.bytesize
+    end
+    alias :length :bytesize
+
+    def respond_to_missing?(method, include_all)
+      super || cached_html.respond_to?(method, include_all)
+    end
+
+    # Webservers treat Arbo::Context as a string. We override
+    # method_missing to delegate to the string representation
+    # of the html.
+    ruby2_keywords def method_missing(method, *args, &block)
+      if cached_html.respond_to? method
+        cached_html.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    def current_arbo_element
+      @_current_arbo_element_buffer.last
+    end
+
+    def with_current_arbo_element(tag)
+      raise ArgumentError, "Can't be in the context of nil. #{@_current_arbo_element_buffer.inspect}" unless tag
+      @_current_arbo_element_buffer.push tag
+      yield
+      @_current_arbo_element_buffer.pop
+    end
+    alias_method :within, :with_current_arbo_element
+
+    def output_buffer
+      @output_buffer ||= ActiveSupport::SafeBuffer.new
+    end
+
+    private
+
+
+    # Caches the rendered HTML so that we don't re-render just to
+    # get the content lenght or to delegate a method to the HTML
+    def cached_html
+      if defined?(@cached_html)
+        @cached_html
+      else
+        html = render_in(self)
+        @cached_html = html if html.length > 0
+        html
+      end
+    end
+
+  end
+end

data/lib/arbo/element/builder_methods.rb

@@ -0,0 +1,83 @@
+module Arbo
+  class Element
+
+    module BuilderMethods
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def builder_method(method_name)
+          BuilderMethods.class_eval <<-EOF, __FILE__, __LINE__
+            def #{method_name}(*args, &block)
+              insert_tag ::#{self.name}, *args, &block
+            end
+          EOF
+        end
+
+      end
+
+      def build_tag(klass, *args, &block)
+        tag = klass.new(arbo_context)
+        tag.parent = current_arbo_element
+
+        with_current_arbo_element tag do
+          if block_given? && block.arity > 0
+            tag.build(*args, &block)
+          else
+            tag.build(*args)
+            append_return_block(yield) if block_given?
+          end
+        end
+
+        tag
+      end
+
+      def insert_tag(klass, *args, &block)
+        tag = build_tag(klass, *args, &block)
+        current_arbo_element.add_child(tag)
+        tag
+      end
+
+      def current_arbo_element
+        arbo_context.current_arbo_element
+      end
+
+      def with_current_arbo_element(tag, &block)
+        arbo_context.with_current_arbo_element(tag, &block)
+      end
+      alias_method :within, :with_current_arbo_element
+
+      private
+
+      # Appends the value to the current DOM element if there are no
+      # existing DOM Children and it responds to #to_s
+      def append_return_block(tag)
+        return nil if current_arbo_element.children?
+
+        if appendable_tag?(tag)
+          current_arbo_element << Arbo::HTML::TextNode.from_string(tag.to_s)
+        end
+      end
+
+      # Returns true if the object should be converted into a text node
+      # and appended into the DOM.
+      def appendable_tag?(tag)
+        is_appendable = !tag.is_a?(Arbo::Element) && tag.respond_to?(:to_s)
+
+        # In ruby 1.9, Arraay.new.to_s prints out an empty array ("[]"). In
+        # Arbo, we append the return value of blocks to the output, which
+        # can cause empty arrays to show up within the output. To get
+        # around this, we check if the object responds to #empty?
+        if tag.respond_to?(:empty?) && tag.empty?
+          is_appendable = false
+        end
+
+        is_appendable
+      end
+    end
+
+  end
+end

data/lib/arbo/element/proxy.rb

@@ -0,0 +1,28 @@
+module Arbo
+  class Element
+    class Proxy < BasicObject
+      undef_method :==
+      undef_method :equal?
+
+      def initialize(element)
+        @element = element
+      end
+
+      def respond_to?(method, include_all = false)
+        if method.to_s == 'to_ary'
+          false
+        else
+          super || @element.respond_to?(method, include_all)
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if method.to_s == 'to_ary'
+          super
+        else
+          @element.__send__ method, *args, &block
+        end
+      end
+    end
+  end
+end

data/lib/arbo/element.rb

@@ -0,0 +1,225 @@
+require 'arbo/element/builder_methods'
+require 'arbo/element/proxy'
+require 'arbo/element_collection'
+require 'ruby2_keywords'
+
+module Arbo
+
+  class Element
+    include BuilderMethods
+
+    attr_reader :parent
+    attr_reader :children, :arbo_context
+
+    def initialize(arbo_context = Arbo::Context.new)
+      @arbo_context = arbo_context
+      @children = ElementCollection.new
+      @parent = nil
+    end
+
+    def assigns
+      arbo_context.assigns
+    end
+
+    def helpers
+      arbo_context.helpers
+    end
+
+    def tag_name
+      @tag_name ||= self.class.name.demodulize.downcase
+    end
+
+    def build(*args, &block)
+      # Render the block passing ourselves in
+      append_return_block(block.call(self)) if block
+    end
+
+    def add_child(child)
+      return unless child
+
+      if child.is_a?(Array)
+        child.each{|item| add_child(item) }
+        return @children
+      end
+
+      # If its not an element, wrap it in a TextNode
+      unless child.is_a?(Element)
+        child = Arbo::HTML::TextNode.from_string(child)
+      end
+
+      if child.respond_to?(:parent)
+        # Remove the child
+        child.parent.remove_child(child) if child.parent && child.parent != self
+        # Set ourselves as the parent
+        child.parent = self
+      end
+
+      @children << child
+    end
+
+    def remove_child(child)
+      child.parent = nil if child.respond_to?(:parent=)
+      @children.delete(child)
+    end
+
+    def <<(child)
+      add_child(child)
+    end
+
+    def children?
+      @children.any?
+    end
+
+    def parent=(parent)
+      @parent = parent
+    end
+
+    def parent?
+      !@parent.nil?
+    end
+
+    def ancestors
+      if parent?
+        [parent] + parent.ancestors
+      else
+        []
+      end
+    end
+
+    # TODO: Shouldn't grab whole tree
+    def find_first_ancestor(type)
+      ancestors.find{|a| a.is_a?(type) }
+    end
+
+    def content=(contents)
+      clear_children!
+      add_child(contents)
+    end
+
+    def get_elements_by_tag_name(tag_name)
+      elements = ElementCollection.new
+      children.each do |child|
+        elements << child if child.tag_name == tag_name
+        elements.concat(child.get_elements_by_tag_name(tag_name))
+      end
+      elements
+    end
+    alias_method :find_by_tag, :get_elements_by_tag_name
+
+    def get_elements_by_class_name(class_name)
+      elements = ElementCollection.new
+      children.each do |child|
+        elements << child if child.class_list.include?(class_name)
+        elements.concat(child.get_elements_by_class_name(class_name))
+      end
+      elements
+    end
+    alias_method :find_by_class, :get_elements_by_class_name
+
+    def content
+      children.to_s
+    end
+
+    def html_safe
+      to_s
+    end
+
+    def indent_level
+      parent? ? parent.indent_level + 1 : 0
+    end
+
+    def each(&block)
+      [to_s].each(&block)
+    end
+
+    def inspect
+      content
+    end
+
+    def to_str
+      ActiveSupport::Deprecation.warn("don't rely on implicit conversion of Element to String")
+      content
+    end
+
+    def to_s
+      ActiveSupport::Deprecation.warn("#render_in should be defined for rendering #{method_owner(:to_s)} instead of #to_s")
+      content
+    end
+
+    # Rendering strategy that visits all elements and appends output to a buffer.
+    def render_in(context = arbo_context)
+      children.collect do |element|
+        element.render_in_or_to_s(context)
+      end.join('')
+    end
+
+    # Use render_in to render element unless closer ancestor overrides :to_s only.
+    def render_in_or_to_s(context)
+      if method_distance(:render_in) <= method_distance(:to_s)
+        render_in(context)
+      else
+        ActiveSupport::Deprecation.warn("#render_in should be defined for rendering #{method_owner(:to_s)} instead of #to_s")
+        to_s.tap { |s| context.output_buffer << s }
+      end
+    end
+
+    def +(element)
+      case element
+      when Element, ElementCollection
+      else
+        element = Arbo::HTML::TextNode.from_string(element)
+      end
+      to_ary + element
+    end
+
+    def to_ary
+      ElementCollection.new [Proxy.new(self)]
+    end
+    alias_method :to_a, :to_ary
+
+    private
+
+    # Resets the Elements children
+    def clear_children!
+      @children.clear
+    end
+
+    # Implements the method lookup chain. When you call a method that
+    # doesn't exist, we:
+    #
+    #  1. Try to call the method on the current DOM context
+    #  2. Return an assigned variable of the same name
+    #  3. Call the method on the helper object
+    #  4. Call super
+    #
+    ruby2_keywords def method_missing(name, *args, &block)
+      if current_arbo_element.respond_to?(name)
+        current_arbo_element.send name, *args, &block
+      elsif assigns && assigns.has_key?(name)
+        assigns[name]
+      elsif helpers.respond_to?(name)
+        helper_capture(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    # The helper might have a block that builds Arbo elements
+    # which will be rendered (#to_s) inside ActionView::Base#capture.
+    # We do not want such elements added to self, so we push a dummy
+    # current_arbo_element.
+    ruby2_keywords def helper_capture(name, *args, &block)
+      s = ""
+      within(Element.new) { s = helpers.send(name, *args, &block) }
+      s.is_a?(Element) ? s.to_s : s
+    end
+
+    def method_distance(name)
+      self.class.ancestors.index method_owner(name)
+    end
+
+    def method_owner(name)
+      self.class.instance_method(name).owner
+    end
+  end
+end

data/lib/arbo/element_collection.rb

@@ -0,0 +1,31 @@
+module Arbo
+
+  # Stores a collection of Element objects
+  class ElementCollection < Array
+
+    def +(other)
+      self.class.new(super)
+    end
+
+    def -(other)
+      self.class.new(super)
+    end
+
+    def &(other)
+      self.class.new(super)
+    end
+
+    def to_s
+      self.collect do |element|
+        element.to_s
+      end.join('').html_safe
+    end
+
+    def render_in(context)
+      self.collect do |element|
+        element.render_in(context)
+      end.join('').html_safe
+    end
+  end
+
+end

data/lib/arbo/html/attributes.rb

@@ -0,0 +1,41 @@
+module Arbo
+  module HTML
+
+    class Attributes < Hash
+
+      def to_s
+        flatten_hash.map do |name, value|
+          next if value_empty?(value)
+          "#{html_escape(name)}=\"#{html_escape(value)}\""
+        end.compact.join ' '
+      end
+
+      def any?
+        super{ |k,v| !value_empty?(v) }
+      end
+
+      protected
+
+      def flatten_hash(hash = self, old_path = [], accumulator = {})
+        hash.each do |key, value|
+          path = old_path + [key]
+          if value.is_a? Hash
+            flatten_hash(value, path, accumulator)
+          else
+            accumulator[path.join('-')] = value
+          end
+        end
+        accumulator
+      end
+
+      def value_empty?(value)
+        value.respond_to?(:empty?) ? value.empty? : !value
+      end
+
+      def html_escape(s)
+        ERB::Util.html_escape(s)
+      end
+    end
+
+  end
+end

data/lib/arbo/html/class_list.rb

@@ -0,0 +1,28 @@
+require 'set'
+
+module Arbo
+  module HTML
+
+    # Holds a set of classes
+    class ClassList < Set
+
+      def self.build_from_string(class_names)
+        new.add(class_names)
+      end
+
+      def add(class_names)
+        class_names.to_s.split(" ").each do |class_name|
+          super(class_name)
+        end
+        self
+      end
+      alias :<< :add
+
+      def to_s
+        to_a.join(" ")
+      end
+
+    end
+
+  end
+end

data/lib/arbo/html/document.rb

@@ -0,0 +1,31 @@
+module Arbo
+  module HTML
+
+    class Document < Tag
+
+      def document
+        self
+      end
+
+      def tag_name
+        'html'
+      end
+
+      def doctype
+        '<!DOCTYPE html>'.html_safe
+      end
+
+      def to_s
+        doctype + super
+      end
+
+      def render_in(context = arbo_context)
+        context.output_buffer << doctype
+        super
+        context.output_buffer
+      end
+
+    end
+
+  end
+end

data/lib/arbo/html/html5_elements.rb

@@ -0,0 +1,47 @@
+module Arbo
+  module HTML
+
+    AUTO_BUILD_ELEMENTS = [ :a, :abbr, :address, :area, :article, :aside, :audio, :b, :base,
+                       :bdo, :blockquote, :body, :br, :button, :canvas, :caption, :cite,
+                       :code, :col, :colgroup, :command, :datalist, :dd, :del, :details,
+                       :dfn, :div, :dl, :dt, :em, :embed, :fieldset, :figcaption, :figure,
+                       :footer, :form, :h1, :h2, :h3, :h4, :h5, :h6, :head, :header, :hgroup, 
+                       :hr, :html, :i, :iframe, :img, :input, :ins, :keygen, :kbd, :label, 
+                       :legend, :li, :link, :map, :mark, :menu, :menuitem, :meta, :meter, :nav, :noscript, 
+                       :object, :ol, :optgroup, :option, :output, :param, :pre, :progress, :q,
+                       :s, :samp, :script, :section, :select, :small, :source, :span,
+                       :strong, :style, :sub, :summary, :sup, :svg, :table, :tbody, :td,
+                       :textarea, :tfoot, :th, :thead, :time, :title, :tr, :track, :ul, :var, :video, :wbr ]
+
+    HTML5_ELEMENTS = [ :p ] + AUTO_BUILD_ELEMENTS
+
+    AUTO_BUILD_ELEMENTS.each do |name|
+      class_eval <<-EOF
+        class #{name.to_s.capitalize} < Tag
+          builder_method :#{name}
+        end
+      EOF
+    end
+
+    class P < Tag
+      builder_method :para
+    end
+
+    class Table < Tag
+      def initialize(*)
+        super
+        set_table_tag_defaults
+      end
+
+      protected
+
+      # Set some good defaults for tables
+      def set_table_tag_defaults
+        set_attribute :border,      0
+        set_attribute :cellspacing, 0
+        set_attribute :cellpadding, 0
+      end
+    end
+
+  end
+end