arbre 0.0.1 → 1.0.0.rc1

data/.gitignore

@@ -2,3 +2,6 @@
 .bundle
 Gemfile.lock
 pkg/*
+benchmarks
+/.rvmrc
+/tags

data/Gemfile

@@ -1,4 +1,13 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in arbre.gemspec
 gemspec
+
+group :test do
+  gem "rspec"
+end
+
+group :rails do
+  gem "rspec-rails"
+  gem 'combustion', '0.3.2'
+  gem "capybara"
+end

data/README.rdoc

@@ -1,3 +1,69 @@
-Arbre - Coming Soon. For now, checkout Active Admin:
+= Arbre - Ruby Object Oriented HTML Views
 
-http://github.com/gregbell/active_admin
+Arbre is the DOM implemented in Ruby. This project is primarily used as
+the object oriented view layer in Active Admin.
+
+== Simple Usage
+
+A simple example of setting up an Arbre context and creating some html
+
+    html = Arbre::Context.new do
+      h2 "Why Arbre is awesome?"
+
+      ul do
+        li "The DOM is implemented in ruby"
+        li "You can create object oriented views"
+        li "Templates suck"
+      end
+    end
+
+    puts html.to_s #=> <h2>Why</h2><ul><li></li></ul>
+
+
+== The DOM in Ruby
+
+The purpose of Arbre is to leave the view as ruby objects as long
+as possible. This allows OO Design to be used to implement the view layer.
+
+
+    html = Arbre::Context.new do
+      h2 "Why Arbre is awesome?"
+    end
+
+    html.children.size #=> 1
+    html.children.first #=> #<Arbre::HTML::H2>
+
+== Components
+
+The purpose of Arbre is to be able to create shareable and extendable HTML
+components. To do this, you create a subclass of Arbre::Component.
+
+For example:
+
+    class Panel < Arbre::Component
+      builder_method :panel
+
+      def build(title, attributes = {})
+        super(attributes)
+
+        h3(title, :class => "panel-title")
+      end
+    end
+
+The builder_method defines the method that will be called to build this component
+when using the DSL. The arguments passed into the builder_method will be passed 
+into the #build method for you.
+
+You can now use this panel in any Arbre context:
+
+    html = Arbre::Context.new do
+      panel "Hello World", :id => "my-panel" do
+        span "Inside the panel"
+      end
+    end
+
+    html.to_s #=>
+      # <div class='panel' id="my-panel">
+      #   <h3 class='panel-title'>Hello World</h3>
+      #   <span>Inside the panel</span>
+      # </div>

data/arbre.gemspec

@@ -16,4 +16,6 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  s.add_dependency("activesupport", ">= 3.0.0")
 end

data/lib/arbre.rb

@@ -1,2 +1,20 @@
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/inflector'
+
 module Arbre
 end
+
+require 'arbre/element'
+require 'arbre/context'
+require 'arbre/html/attributes'
+require 'arbre/html/class_list'
+require 'arbre/html/tag'
+require 'arbre/html/text_node'
+require 'arbre/html/document'
+require 'arbre/html/html5_elements'
+require 'arbre/component'
+
+if defined?(Rails)
+  require 'arbre/rails'
+end

data/lib/arbre/component.rb

@@ -0,0 +1,22 @@
+module Arbre
+  class Component < Arbre::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/arbre/context.rb

@@ -0,0 +1,81 @@
+require 'arbre/element'
+
+module Arbre
+  class Context < Element
+
+    def initialize(assigns = {}, helpers = nil, &block)
+      @_assigns = assigns || {}
+      @_assigns.symbolize_keys!
+      @_helpers = helpers
+      @_current_arbre_element_buffer = [self]
+
+      super(self)
+      instance_eval &block if block_given?
+    end
+
+    def arbre_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?(method)
+      super || cached_html.respond_to?(method)
+    end
+
+    # Webservers treat Arbre::Context as a string. We override
+    # method_missing to delegate to the string representation
+    # of the html.
+    def method_missing(method, *args, &block)
+      if cached_html.respond_to? method
+        cached_html.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    def current_arbre_element
+      @_current_arbre_element_buffer.last
+    end
+
+    def with_current_arbre_element(tag)
+      raise ArgumentError, "Can't be in the context of nil. #{@_current_arbre_element_buffer.inspect}" unless tag
+      @_current_arbre_element_buffer.push tag
+      yield
+      @_current_arbre_element_buffer.pop
+    end
+    alias_method :within, :with_current_arbre_element
+
+    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 = to_s
+        @cached_html = html if html.length > 0
+        html
+      end
+    end
+
+  end
+end

data/lib/arbre/element.rb

@@ -0,0 +1,182 @@
+require 'arbre/element/builder_methods'
+require 'arbre/element_collection'
+
+module Arbre
+
+  class Element
+    include BuilderMethods
+
+    attr_accessor :parent
+    attr_reader :children, :arbre_context
+
+    def initialize(arbre_context = Arbre::Context.new)
+      @arbre_context = arbre_context
+      @children = ElementCollection.new
+    end
+
+    def assigns
+      arbre_context.assigns
+    end
+
+    def helpers
+      arbre_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 = Arbre::HTML::TextNode.from_string(child)
+      end
+
+      if child.respond_to?(:parent)
+        # Remove the child
+        child.parent.remove_child(child) if child.parent
+        # 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 =~ /#{class_name}/
+        elements.concat(child.get_elements_by_tag_name(tag_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 to_str
+      to_s
+    end
+
+    def to_s
+      content
+    end
+
+    def +(element)
+      case element
+      when Element, ElementCollection
+      else
+        element = Arbre::HTML::TextNode.from_string(element)
+      end
+      ElementCollection.new([self]) + element
+    end
+
+    def to_ary
+      ElementCollection.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
+    #
+    def method_missing(name, *args, &block)
+      if current_arbre_element.respond_to?(name)
+        current_arbre_element.send name, *args, &block
+      elsif assigns && assigns.has_key?(name)
+        assigns[name]
+      elsif helpers.respond_to?(name)
+        helpers.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/arbre/element/builder_methods.rb

@@ -0,0 +1,92 @@
+module Arbre
+  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(arbre_context)
+        tag.parent = current_arbre_element
+
+        # If you passed in a block and want the object
+        if block_given? && block.arity > 0
+          # Set out context to the tag, and pass responsibility to the tag
+          with_current_arbre_element tag do
+            tag.build(*args, &block)
+          end
+        else
+          # Build the tag
+          tag.build(*args)
+
+          # Render the blocks contents
+          if block_given?
+            with_current_arbre_element tag do
+              append_return_block(yield)
+            end
+          end
+        end
+
+        tag
+      end
+
+      def insert_tag(klass, *args, &block)
+        tag = build_tag(klass, *args, &block)
+        current_arbre_element.add_child(tag)
+        tag
+      end
+
+      def current_arbre_element
+        arbre_context.current_arbre_element
+      end
+
+      def with_current_arbre_element(tag, &block)
+        arbre_context.with_current_arbre_element(tag, &block)
+      end
+      alias_method :within, :with_current_arbre_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_arbre_element.children?
+
+        if appendable_tag?(tag)
+          current_arbre_element << Arbre::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?(Arbre::Element) && tag.respond_to?(:to_s)
+
+        # In ruby 1.9, Arraay.new.to_s prints out an empty array ("[]"). In
+        # Arbre, 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