active_component 0.1.2

data/lib/active_component/components/block.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class Block < ActiveComponent::Base
+
+  attr_accessor :tag_type
+
+  def initialize(*args, &content_block)
+    init_component(args, [:content, :title, :tag_type, :attributes], &content_block)
+
+    # Defaults
+    @tag_type ||= :div
+  end
+
+  def to_html
+    wrap_contents(@tag_type, content, nil, @attributes)
+  end
+
+  def_html_sub_components ActiveComponent::BLOCK_ELEMENTS, self
+end
+

data/lib/active_component/components/empty_tag.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+class EmptyTag < ActiveComponent::Base
+
+  attr_accessor :tag_type
+
+  # Content can be passed as a block
+  def initialize(*args)
+    init_component(args, [:title, :tag_type, :attributes])
+
+    # Defaults
+    @tag_type     ||= :br
+  end
+
+  def to_html
+    if ActiveComponent::Config.component_options[:validate_html]
+      raise InvalidHtmlError, "Empty HTML elements must not have content." if content.present?
+    end
+
+    name, attrs = merge_name_and_attributes(@tag_type.to_s, @attributes)
+    attrs = Haml::Precompiler.build_attributes(@haml_buffer.html?, @haml_buffer.options[:attr_wrapper], attrs)
+    "<#{name}#{attrs} />"
+  end
+
+  def_html_sub_components ActiveComponent::EMPTY_ELEMENTS, self
+end

data/lib/active_component/components/heading.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+class Heading < ActiveComponent::Base
+
+  attr_reader :level
+   
+  def level=(level)
+    unless level.nil?
+      raise ArgumentError, "heading_level must be numeric (given #{level.inspect} in heading #{@content})" unless level.is_a? Numeric
+      puts "warning: heading_level should be an integer and between 1 and 6 (given #{level} in heading #{@content})" unless level.between?(1,6)
+      @level = [[level.to_i, 6].min, 1].max
+    end
+  end
+  
+  def initialize(*args, &content_block)
+    init_component(args, [:content, :title, :level, :attributes], &content_block)
+  end
+  
+  def to_html
+    @level ||= determine_level
+
+    wrap_contents("h" + @level.to_s, content, nil, @attributes)
+  end
+  
+  # Determines the heading level by adopting the siblings' one
+  # or by determining the parent's one recursively
+  def determine_level
+    return 1     if is_root?
+    return level if level.present?
+    
+    siblings_level or (
+      if Heading.has_parent_heading?(self)
+        Heading.parent_heading(self).determine_level + 1
+      else
+        1
+      end
+    )
+  end
+  
+  # Collects the level of sibling headings
+  def siblings_level
+    siblings.collect {|sib| sib.level if sib.is_a?(Heading)}.compact.min
+  end
+  
+  # Retrieves the next Heading of the node hierarchy above a given node
+  def Heading.parent_heading(node)
+    raise ArgumentException, "Node has no heading parent." unless Heading.has_parent_heading?(node)
+    node.parent.siblings.find_a(Heading) or Heading.parent_heading(node.parent)
+  end
+  
+  # Checks whether a Heading exists in the node hierarchy above a given node
+  def Heading.has_parent_heading?(node)
+    !node.is_root? && (
+      node.parent.siblings.includes_a?(Heading) || 
+      Heading.has_parent_heading?(node.parent)
+    )
+  end
+
+  def_html_sub_components ActiveComponent::HEADING_ELEMENTS, self
+end

data/lib/active_component/components/inline_tag.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+class InlineTag < ActiveComponent::Base
+
+  attr_accessor :tag_type
+
+  # Content can be passed as a block
+  def initialize(*args, &content_block)
+    init_component(args, [:content, :title, :tag_type, :attributes], &content_block)
+
+    # Defaults
+    @tag_type     ||= :span
+  end
+
+  def to_html
+    if ActiveComponent::Config.component_options[:validate_html]
+      raise InvalidHtmlError, "Inline tags must not have blocks as inner content." if content.includes_a? Block
+    end
+
+    wrap_contents(@tag_type, content, nil, @attributes)
+  end
+
+  def_html_sub_components ActiveComponent::PHRASING_ELEMENTS, self
+end

data/lib/active_component/components/section.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+class Section < ActiveComponent::Base
+
+  attr_accessor :tag_type, :heading, :heading_level, :heading_attrs
+
+  def initialize(*args, &content_block)
+    init_component(args, [:content, :title, :tag_type, :heading, :heading_level, :heading_attrs, :attributes], &content_block)
+
+    # Defaults
+    @tag_type     ||= :section
+
+    # Validations
+    raise ArgumentError, "attributes must be a hash (given #{@attributes.inspect} in section #{@title})" unless @attributes.is_a? Hash
+    # TODO: Heading rank
+  end
+
+  def to_html
+    if @heading.present? && !@heading.is_a?(ActiveComponent)
+      @heading = Heading.new @heading, @heading_level, @heading_attrs
+      children.nil? ? (self << @heading) : self.prepend(@heading)
+    end
+
+    # TODO: Is this clean? Is there a better way that hides buffer operations?
+    # wrap_contents(@tag_type, :attributes => @attributes, :content => [@heading, content]
+
+    print_buffer do
+      tag_to_buffer @tag_type, @attributes do
+        write_to_buffer print_object(@heading)
+        content.transmogrify do |content|
+          write_to_buffer print_object(content)
+        end
+      end
+    end
+  end
+
+  def_html_sub_components ActiveComponent::SECTION_ELEMENTS, self
+end
+

data/lib/active_component/components/table.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+class Table < ActiveComponent::Base
+
+  attr_accessor :cols, :headers, :row_attrs, :header_attrs, :field_attrs
+  
+  def initialize(*args) 
+    init_component(args, [:content, :title, :cols, :headers, :attributes, :row_attrs, :header_attrs, :field_attrs])
+
+    # Defaults
+    if @title.nil?
+      @title                    = content.first.class.to_s.hyphenize.pluralize
+      @attributes[:class].to_a.unshift @title
+    end
+    if @cols.nil? && content.first.respond_to?(:attributes)
+      @cols                     = content.first.attributes.keys
+      @headers                ||= @cols.collect {|col| col.to_s.humanize}
+    end
+    @attributes[:cellspacing] ||= 0
+    @row_attrs                ||= {}
+    @header_attrs             ||= {}
+    @field_attrs              ||= {}
+  end
+  
+  def to_html
+    print_buffer do
+      tag_to_buffer :table, @attributes do
+        row_count = 0
+        unless @headers.blank?
+          tag_to_buffer :tr, get_row_attrs(row_count) do
+            @headers.each_with_index do |header, i|
+              tag_to_buffer :th, header, get_header_attrs(i)
+            end
+            row_count = 1
+          end
+        end
+        content.each_with_index do |row, i|
+          unless row.blank?
+            tag_to_buffer :tr, get_row_attrs(row_count + i) do
+              print_contents(:td, row, @cols, @field_attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  private
+    def get_attrs(attrs_collection, index = nil)
+      attrs = attrs_collection[index] || attrs_collection
+      attrs.is_a?(Hash) ? attrs : {}
+    end
+    
+    def get_row_attrs(index = nil)
+      get_attrs(@row_attrs, index)
+    end
+    
+    def get_header_attrs(index = nil)
+      get_attrs(@header_attrs, index)
+    end
+end

data/lib/active_component/config.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module ActiveComponent
+  # The module for all global ActiveComponent configurations
+  module Config
+    extend self
+
+    @component_options = {}
+    # The options hash for Haml when used within Rails.
+    # See {file:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+    #
+    # @return [{Symbol => Object}]
+    attr_accessor :component_options
+    
+    def template_engine_options
+      Haml::Template.options
+    end  
+    
+    def template_engine_options=(options)
+      Haml::Template.options = options
+    end
+
+    template_engine_options[:format]    ||= :html5
+    
+    if Haml::Util.rails_env == "development"
+      component_options[:validate_html] ||= true
+      template_engine_options[:ugly]    ||= false
+    else
+      component_options[:validate_html] ||= false
+    end
+    
+  end
+end

data/lib/active_component/core_extensions.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+class Object
+  
+  # Transmogrify yields self to the given block by default
+  def transmogrify(*ignored_args)
+    yield self
+  end
+  
+  # Wrapper for enumerable transmogrify
+  def transmogrify_with_index(&block)
+    transmogrify(:yield_index, &block)
+  end
+  
+  alias :includes_a? :is_a?
+  
+end
+
+class String
+  
+  # Performs same transformation as underscore, but with hyphens
+  def hyphenize
+    gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("_", "-").
+    tr(" ", "-").
+    downcase
+  end
+  
+end
+
+class Symbol
+  
+  def to_class_constant
+    to_s.camelize.constantize
+  end
+  
+end
+
+module Enumerable
+  
+  # Transmogrify yields each element to the given block
+  def transmogrify(*options)    
+    if options.include? :yield_index
+      each_with_index do |element, index|
+        yield element, index
+      end
+    else
+      each do |element| 
+        yield element
+      end
+    end
+  end
+  
+  # Determines if enumerable contains an object of the specified class
+  def includes_a?(klass)
+    each do |e|
+      return true if e.is_a? klass      
+    end
+    false
+  end
+  
+  # Returns the first object of the specified class contained in enumerable
+  def find_a(klass)
+    each do |e|
+      return e if e.is_a? klass
+    end
+    nil
+  end
+  
+end
+
+# FIXME: There should be a better way to provide the module to ActionView.
+class ActionView::Base
+  include ActiveComponent
+end
+
+if defined? ActiveSupport::CoreExtensions::Hash::ReverseMerge
+  # Rails 2
+  module ActiveSupport::CoreExtensions::Hash::ReverseMerge
+    alias :set_defaults :reverse_merge 
+    alias :set_defaults! :reverse_merge! 
+  end
+else
+  # Rails 3
+  class Hash
+    alias :set_defaults :reverse_merge 
+    alias :set_defaults! :reverse_merge! 
+  end
+end
+
+module Haml::Helpers
+  alias :init_buffer :init_haml_helpers
+  alias :print_buffer :capture_haml
+  alias :tag_to_buffer :haml_tag
+  alias :write_to_buffer :haml_concat
+  alias :string_to_buffer :haml_concat
+end

data/lib/active_component/template_handler.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module ActiveComponent
+  class TemplateHandler
+    include ActionView::TemplateHandlers::Compilable
+    
+    def compile(template)
+      # For Rails < 2.1.0, template is a string
+      # For Rails >= 2.1.0, template is a Template object
+      if template.respond_to? :source
+        # # For Rails >=3.0.0, there is a generic identifier
+        # options[:filename] = template.respond_to?(:identifier) ? template.identifier : template.filename
+        template.source
+      else
+        template
+      end
+    end
+    
+  end
+end

data/spec/active_component_spec.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+
+require 'active_component_spec_helper'
+
+describe ActiveComponent do
+
+  before(:each) { @comp = Block.new }
+  after(:each) { @comp = nil }
+
+  describe "print_contents" do
+    it "should print content and wrap it with a tag" do
+      content = "content"
+      @comp.print_contents(:span, content).should == "<span>content</span>\n"
+    end
+
+    it "should print multiple contents and wrap each item with a tag" do
+      content = [:a, "b", 3]
+      Factory.sequence(:content) {|n| content[n]}
+      @comp.print_contents(:span, content).should == "<span>a</span>\n<span>b</span>\n<span>3</span>\n"
+    end
+
+    it "should print content using a method and wrap the output with a tag" do
+      deep_thought = mock :content
+      deep_thought.should_receive(:question).once.and_return(42)
+      @comp.print_contents("div.the-answer", deep_thought, :question).should == "<div class='the-answer'>42</div>\n"
+    end
+
+    it "should print multiple contents using a method and wrap each one with a tag" do
+      names = %w(Aron Noel Trebor)
+      transformation = Proc.new {|x| x.downcase.reverse.humanize}
+      @comp.print_contents(:li, names, transformation).should == "<li>Nora</li>\n<li>Leon</li>\n<li>Robert</li>\n"
+    end
+
+    it "should print multiple contents using a set of methods and wrap each of the method outputs with a tag" do
+      things = []
+      things << Factory.build(:thing, :name => "thingamabob", :color => :yellow)
+      things << Factory.build(:thing, :name => "whatchamacallit", :color => :red)
+      things << Factory.build(:thing, :name => "gizmo", :color => :blue)
+      @comp.print_contents(:p, things, things.first.attributes.keys).should == "<p>thingamabob</p>\n<p>yellow</p>\n<p>whatchamacallit</p>\n<p>red</p>\n<p>gizmo</p>\n<p>blue</p>\n"
+    end
+
+    it "should print multiple contents, each item being paired with its own method and wrap each of the method outputs with a tag" do
+      accomodations = []
+      accomodations << mock(:hostel)
+      accomodations << mock(:campground)
+      accomodations[0].should_receive(:rooms).and_return(15)
+      accomodations[1].should_receive(:campsites).and_return(25)
+      capacity_information = [
+        Proc.new {|h| "There are #{h.rooms} hostel rooms available."},
+        Proc.new {|c| "The campground can take #{c.campsites} tents."}
+      ]
+      @comp.print_contents(:p, accomodations, capacity_information, :couple_methods_with_contents).should == "<p>There are 15 hostel rooms available.</p>\n<p>The campground can take 25 tents.</p>\n"
+    end
+
+    it "should merge attributes"
+
+  end
+
+  describe "wrap_contents" do
+    it "should wrap text content with a tag" do
+      content = "content"
+      @comp.print_contents(:span, content, nil, :wrap_whole_content).should == "<span>\n  content\n</span>\n"
+    end
+
+    it "should wrap HTML content with a tag" do
+      content = "<span>\n  content\n</span>\n"
+      @comp.wrap_contents(:p, content).should == "<p>\n  <span>\n    content\n  </span>\n</p>\n"
+    end
+
+    it "should wrap multiple contents with a tag" do
+      names_list = ["<li>Nora</li>", "<li>Leon</li>", "<li>Robert</li>"]
+      @comp.wrap_contents(:ul, names_list).should == "<ul>\n  <li>Nora</li>\n  <li>Leon</li>\n  <li>Robert</li>\n</ul>\n"
+    end
+
+    it "should print content using a method and wrap the output with a tag" do
+      deep_thought = mock :content
+      deep_thought.should_receive(:question).once.and_return(42)
+      @comp.wrap_contents("div.the-answer", deep_thought, :question).should == "<div class='the-answer'>\n  42\n</div>\n"
+    end
+
+    it "should print multiple contents using a method and wrap the whole output into a tag" do
+      names = %w(Aron Noel Trebor)
+      transformation = Proc.new {|x| x.downcase.reverse.humanize}
+      @comp.wrap_contents(:p, names, transformation).should == "<p>\n  Nora\n  Leon\n  Robert\n</p>\n"
+    end
+
+    it "should wrap multiple contents with a tag, each item being printed using its own method" do
+      accomodations = []
+      accomodations << mock(:hostel)
+      accomodations << mock(:campground)
+      accomodations[0].should_receive(:rooms).and_return(15)
+      accomodations[1].should_receive(:campsites).and_return(25)
+      capacity_information = [
+        Proc.new {|h| "There are #{h.rooms} hostel rooms available."},
+        Proc.new {|c| "The campground can take #{c.campsites} tents."}
+      ]
+      @comp.wrap_contents(:p, accomodations, capacity_information, :couple_methods_with_contents).should == "<p>\n  There are 15 hostel rooms available.\n  The campground can take 25 tents.\n</p>\n"
+    end
+  end
+
+  describe "print_object" do
+    it "should print primitive data" do
+      for primitive in ["test", 1.0, 7, true, '']
+        @comp.print_object(primitive).should == primitive.to_s
+      end
+    end
+
+    it "should call callable objects" do
+      callable = mock :method
+      callable.should_receive(:call).at_least(:once).and_return(42)
+      @comp.print_object(callable).should == callable.call.to_s
+    end
+
+    it "should render components" do
+      renderable = mock :component
+      html = "<div>\n Component content\n</div"
+      renderable.should_receive(:to_html).any_number_of_times.and_return(html)
+      renderable.should_receive(:to_s).any_number_of_times.and_return(html)
+      @comp.print_object(renderable).should == html
+    end
+
+    it "should capture Haml buffers" do
+      p = lambda { @comp.haml_tag(:span, "haml") }
+      @comp.print_object(p).should == "<span>haml</span>\n"
+      p = lambda { @comp.haml_concat("written-to-buffer-and-captured") }
+      @comp.print_object(p).should == "written-to-buffer-and-captured\n"
+    end
+
+    it "should utilize receiver capabilities of object if applicable" do
+      receiver = mock :object
+      receiver.should_receive(:message).at_least(:once).and_return(42)
+      @comp.print_object(receiver, :message).should == receiver.message.to_s
+    end
+
+    it "should yield non-receiver objects if a suitable method is given" do
+      callable = mock :method
+      object = 42
+      callable.should_receive(:arity).at_least(:once).and_return(1, -1, -2)
+      callable.should_receive(:call).with(object).at_least(:once).and_return(42)
+      3.times do
+        @comp.print_object(object, callable).should == callable.call(object).to_s
+      end
+    end
+
+    it "should not try to print non-receiver objects if an unsuitable method is given" do
+      callable = mock :method
+      object = 42
+      callable.should_receive(:arity).at_least(:once).and_return(0, 2, -3)
+      callable.should_not_receive(:call)
+      3.times do
+        lambda {@comp.print_object(object, callable)}.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+end