joho-Markaby 0.6.0

data/lib/markaby/builder.rb

@@ -0,0 +1,289 @@
+require 'markaby/tags'
+
+module Markaby
+  # The Markaby::Builder class is the central gear in the system.  When using
+  # from Ruby code, this is the only class you need to instantiate directly.
+  #
+  #   mab = Markaby::Builder.new
+  #   mab.html do
+  #     head { title "Boats.com" }
+  #     body do
+  #       h1 "Boats.com has great deals"
+  #       ul do
+  #         li "$49 for a canoe"
+  #         li "$39 for a raft"
+  #         li "$29 for a huge boot that floats and can fit 5 people"
+  #       end
+  #     end
+  #   end
+  #   puts mab.to_s
+  #
+  class Builder
+
+    @@default = {
+      :indent => 0,
+      :output_helpers => true,
+      :output_xml_instruction => true,
+      :output_meta_tag => true,
+      :auto_validation => true,
+      :tagset => Markaby::XHTMLTransitional,
+      :root_attributes => {
+        :xmlns => 'http://www.w3.org/1999/xhtml', :'xml:lang' => 'en', :lang => 'en'
+      }
+    }
+
+    def self.set(option, value)
+      @@default[option] = value
+    end
+
+    def self.ignored_helpers 
+      @@ignored_helpers ||= [] 
+    end 
+ 
+    def self.ignore_helpers(*helpers) 
+      ignored_helpers.concat helpers 
+    end 
+
+    attr_accessor :output_helpers, :tagset
+
+    # Create a Markaby builder object.  Pass in a hash of variable assignments to
+    # +assigns+ which will be available as instance variables inside tag construction
+    # blocks.  If an object is passed in to +helpers+, its methods will be available
+    # from those same blocks.
+    #
+    # Pass in a +block+ to new and the block will be evaluated.
+    #
+    #   mab = Markaby::Builder.new {
+    #     html do
+    #       body do
+    #         h1 "Matching Mole"
+    #       end
+    #     end
+    #   }
+    #
+    def initialize(assigns = {}, helpers = nil, &block)
+      @streams = [[]]
+      @assigns = assigns.dup
+      @helpers = helpers
+      @elements = {}
+
+      @@default.each do |k, v|
+        instance_variable_set("@#{k}", @assigns.delete(k) || v)
+      end
+      
+      @assigns.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+
+      @builder = XmlMarkup.new(:indent => @indent, :target => @streams.last)
+
+      text(capture(&block)) if block
+    end
+
+    # Returns a string containing the HTML stream.  Internally, the stream is stored as an Array.
+    def to_s
+      @streams.last.to_s
+    end
+
+    # Write a +string+ to the HTML stream without escaping it.
+    def text(string)
+      @builder << string.to_s
+      nil
+    end
+    alias_method :<<, :text
+    alias_method :concat, :text
+
+    # Captures the HTML code built inside the +block+.  This is done by creating a new
+    # stream for the builder object, running the block and passing back its stream as a string.
+    #
+    #   >> Markaby::Builder.new.capture { h1 "TEST"; h2 "CAPTURE ME" }
+    #   => "<h1>TITLE</h1>\n<h2>CAPTURE ME</h2>\n"
+    #
+    def capture(&block)
+      @streams.push(@builder.target = [])
+      @builder.level += 1
+      str = instance_eval(&block)
+      str = @streams.last.join if @streams.last.any?
+      @streams.pop
+      @builder.level -= 1
+      @builder.target = @streams.last
+      str
+    end
+
+    # Create a tag named +tag+. Other than the first argument which is the tag name,
+    # the arguments are the same as the tags implemented via method_missing.
+    def tag!(tag, *args, &block)
+      ele_id = nil
+      if @auto_validation and @tagset
+          if !@tagset.tagset.has_key?(tag)
+              raise InvalidXhtmlError, "no element `#{tag}' for #{tagset.doctype}"
+          elsif args.last.respond_to?(:to_hash)
+              attrs = args.last.to_hash
+              
+              if @tagset.forms.include?(tag) and attrs[:id]
+                attrs[:name] ||= attrs[:id]
+              end
+              
+              attrs.each do |k, v|
+                  atname = k.to_s.downcase.intern
+                  unless k =~ /:/ or @tagset.tagset[tag].include? atname
+                      raise InvalidXhtmlError, "no attribute `#{k}' on #{tag} elements"
+                  end
+                  if atname == :id
+                      ele_id = v.to_s
+                      if @elements.has_key? ele_id
+                          raise InvalidXhtmlError, "id `#{ele_id}' already used (id's must be unique)."
+                      end
+                  end
+              end
+          end
+      end
+      if block
+        str = capture(&block)
+        block = proc { text(str) }
+      end
+
+      f = fragment { @builder.method_missing(tag, *args, &block) }
+      @elements[ele_id] = f if ele_id
+      f
+    end
+
+    # This method is used to intercept calls to helper methods and instance
+    # variables.  Here is the order of interception:
+    #
+    # * If +sym+ is a helper method, the helper method is called
+    #   and output to the stream.
+    # * If +sym+ is a Builder::XmlMarkup method, it is passed on to the builder object.
+    # * If +sym+ is also the name of an instance variable, the
+    #   value of the instance variable is returned.
+    # * If +sym+ has come this far and no +tagset+ is found, +sym+ and its arguments are passed to tag!
+    # * If a tagset is found, though, +NoMethodError+ is raised.
+    #
+    # method_missing used to be the lynchpin in Markaby, but it's no longer used to handle
+    # HTML tags.  See html_tag for that.
+    def method_missing(sym, *args, &block)
+      if @helpers.respond_to?(sym, true) && !self.class.ignored_helpers.include?(sym)
+        r = @helpers.send(sym, *args, &block)
+        if @output_helpers and r.respond_to? :to_str
+          fragment { @builder << r }
+        else
+          r
+        end
+      elsif @assigns.has_key?(sym)
+        @assigns[sym]
+      elsif @assigns.has_key?(stringy_key = sym.to_s)
+        # Rails' ActionView assigns hash has string keys for
+        # instance variables that are defined in the controller.
+        @assigns[stringy_key]
+      elsif instance_variables.include?(ivar = "@#{sym}")
+        instance_variable_get(ivar)
+      elsif !@helpers.nil? && @helpers.instance_variables.include?(ivar)
+        @helpers.instance_variable_get(ivar)
+      elsif ::Builder::XmlMarkup.instance_methods.include?(sym.to_s) 
+        @builder.__send__(sym, *args, &block)
+      elsif @tagset.nil?
+        tag!(sym, *args, &block)
+      else
+        raise NoMethodError, "no such method `#{sym}'"
+      end
+    end
+
+    # Every HTML tag method goes through an html_tag call.  So, calling <tt>div</tt> is equivalent
+    # to calling <tt>html_tag(:div)</tt>.  All HTML tags in Markaby's list are given generated wrappers
+    # for this method.
+    #
+    # If the @auto_validation setting is on, this method will check for many common mistakes which
+    # could lead to invalid XHTML.
+    def html_tag(sym, *args, &block)
+      if @auto_validation and @tagset.self_closing.include?(sym) and block
+        raise InvalidXhtmlError, "the `#{sym}' element is self-closing, please remove the block"
+      elsif args.empty? and block.nil?
+        CssProxy.new(self, @streams.last, sym)
+      else
+        tag!(sym, *args, &block)
+      end
+    end
+
+    XHTMLTransitional.tags.each do |k|
+      class_eval %{
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *args, &block)
+        end
+      }
+    end
+
+    remove_method :head
+    
+    # Builds a head tag.  Adds a <tt>meta</tt> tag inside with Content-Type
+    # set to <tt>text/html; charset=utf-8</tt>.
+    def head(*args, &block)
+      tag!(:head, *args) do
+        tag!(:meta, "http-equiv" => "Content-Type", "content" => "text/html; charset=utf-8") if @output_meta_tag
+        instance_eval(&block)
+      end
+    end
+
+    # Builds an html tag.  An XML 1.0 instruction and an XHTML 1.0 Transitional doctype
+    # are prepended.  Also assumes <tt>:xmlns => "http://www.w3.org/1999/xhtml",
+    # :lang => "en"</tt>.
+    def xhtml_transitional(attrs = {}, &block)
+      self.tagset = Markaby::XHTMLTransitional
+      xhtml_html(attrs, &block)
+    end
+
+    # Builds an html tag with XHTML 1.0 Strict doctype instead.
+    def xhtml_strict(attrs = {}, &block)
+      self.tagset = Markaby::XHTMLStrict
+      xhtml_html(attrs, &block)
+    end
+
+    # Builds an html tag with XHTML 1.0 Frameset doctype instead.
+    def xhtml_frameset(attrs = {}, &block)
+      self.tagset = Markaby::XHTMLFrameset
+      xhtml_html(attrs, &block)
+    end
+
+    private
+
+    def xhtml_html(attrs = {}, &block)
+      instruct! if @output_xml_instruction
+      declare!(:DOCTYPE, :html, :PUBLIC, *tagset.doctype)
+      tag!(:html, @root_attributes.merge(attrs), &block)
+    end
+
+    def fragment
+      stream = @streams.last
+      start = stream.length
+      yield
+      length = stream.length - start
+      Fragment.new(stream, start, length)
+    end
+
+  end
+
+  # Every tag method in Markaby returns a Fragment.  If any method gets called on the Fragment,
+  # the tag is removed from the Markaby stream and given back as a string.  Usually the fragment
+  # is never used, though, and the stream stays intact.
+  #
+  # For a more practical explanation, check out the README.
+  class Fragment < ::Builder::BlankSlate
+    def initialize(*args)
+      @stream, @start, @length = args
+    end
+    def method_missing(*args, &block)
+      # We can't do @stream.slice!(@start, @length),
+      # as it would invalidate the @starts and @lengths of other Fragment instances.
+      @str = @stream[@start, @length].to_s
+      @stream[@start, @length] = [nil] * @length
+      def self.method_missing(*args, &block)
+        @str.send(*args, &block)
+      end
+      @str.send(*args, &block)
+    end
+  end
+
+  class XmlMarkup < ::Builder::XmlMarkup
+    attr_accessor :target, :level
+  end
+  
+end

data/lib/markaby/cssproxy.rb

@@ -0,0 +1,48 @@
+module Markaby
+  # Class used by Markaby::Builder to store element options.  Methods called
+  # against the CssProxy object are added as element classes or IDs.
+  #
+  # See the README for examples.
+  class CssProxy
+
+    # Creates a CssProxy object.
+    def initialize(builder, stream, sym)
+      @builder, @stream, @sym, @attrs = builder, stream, sym, {}
+      
+      @original_stream_length = @stream.length
+      
+      @builder.tag! @sym
+    end
+    
+    # Adds attributes to an element.  Bang methods set the :id attribute.
+    # Other methods add to the :class attribute.
+    def method_missing(id_or_class, *args, &block)
+      if (idc = id_or_class.to_s) =~ /!$/
+        @attrs[:id] = $`
+      else
+        @attrs[:class] = @attrs[:class].nil? ? idc : "#{@attrs[:class]} #{idc}".strip
+      end
+
+      unless args.empty?
+        if args.last.respond_to? :to_hash
+          @attrs.merge! args.pop.to_hash
+        end
+      end
+      
+      args.push(@attrs)
+      
+      while @stream.length > @original_stream_length
+        @stream.pop
+      end
+      
+      if block
+        @builder.tag! @sym, *args, &block
+      else
+        @builder.tag! @sym, *args
+      end
+      
+      return self
+    end
+
+  end
+end

data/lib/markaby/kernel_method.rb

@@ -0,0 +1,7 @@
+# You'll need to <tt>require 'markaby/kernel_method'</tt> for this.
+module Kernel
+  # Shortcut for creating a quick block of Markaby.
+  def mab(*args, &block)
+    Markaby::Builder.new(*args, &block).to_s
+  end
+end

data/lib/markaby/metaid.rb

@@ -0,0 +1,16 @@
+# metaprogramming assistant -- metaid.rb
+class Object # :nodoc:
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval(&blk); metaclass.instance_eval(&blk); end
+  
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+  
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+end

data/lib/markaby/rails.rb

@@ -0,0 +1,90 @@
+module ActionView # :nodoc:
+  class Base # :nodoc:
+    def render_template(template_extension, template, file_path = nil, local_assigns = {})
+      if handler = @@template_handlers[template_extension]
+        template ||= read_template_file(file_path, template_extension)
+        handler.new(self).render(template, local_assigns, file_path)
+      else
+        compile_and_render_template(template_extension, template, file_path, local_assigns)
+      end
+    end
+  end
+end
+
+module Markaby
+  module Rails
+    # Markaby helpers for Rails.
+    module ActionControllerHelpers
+      # Returns a string of HTML built from the attached +block+.  Any +options+ are
+      # passed into the render method.
+      #
+      # Use this method in your controllers to output Markaby directly from inside.
+      def render_markaby(options = {}, &block)
+        render options.merge({ :text => Builder.new(options[:locals], self, &block).to_s })
+      end
+    end
+
+    class ActionViewTemplateHandler # :nodoc:
+      def initialize(action_view)
+        @action_view = action_view
+      end
+      def render(template, local_assigns, file_path)
+        template = Template.new(template)
+        template.path = file_path
+        template.render(@action_view.assigns.merge(local_assigns), @action_view)
+      end
+    end
+      
+    class Builder < Markaby::Builder # :nodoc:
+      def initialize(*args, &block)
+        super *args, &block
+        
+        @assigns.each { |k, v| @helpers.instance_variable_set("@#{k}", v) }
+      end
+      
+      def flash(*args)
+        @helpers.controller.send(:flash, *args)
+      end
+    
+      # Emulate ERB to satisfy helpers like <tt>form_for</tt>.
+      def _erbout
+        @_erbout ||= FauxErbout.new(self)
+      end
+
+      # Content_for will store the given block in an instance variable for later use 
+      # in another template or in the layout.
+      #
+      # The name of the instance variable is content_for_<name> to stay consistent 
+      # with @content_for_layout which is used by ActionView's layouts.
+      #
+      # Example:
+      #
+      #   content_for("header") do
+      #     h1 "Half Shark and Half Lion"
+      #   end
+      #
+      # If used several times, the variable will contain all the parts concatenated.
+      def content_for(name, &block)
+        @helpers.assigns["content_for_#{name}"] =
+          eval("@content_for_#{name} = (@content_for_#{name} || '') + capture(&block)")
+      end
+    end
+
+
+    
+    Template.builder_class = Builder
+    
+    class FauxErbout < ::Builder::BlankSlate # :nodoc:
+      def initialize(builder)
+        @builder = builder
+      end
+      def nil? # see ActionView::Helpers::CaptureHelper#capture
+        true
+      end
+      def method_missing(*args, &block)
+        @builder.send *args, &block
+      end
+    end
+
+  end
+end