Markaby 0.6.3

data/lib/markaby/builder.rb

@@ -0,0 +1,275 @@
+require 'markaby/tags'
+require 'markaby/builder_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
+    include Markaby::BuilderTags
+    
+    DEFAULT_OPTIONS = {
+      :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'
+      }
+    }
+    
+    @@options = DEFAULT_OPTIONS.dup
+    
+    def self.restore_defaults!
+      @@options = DEFAULT_OPTIONS.dup
+    end
+    
+    def self.set(option, value)
+      @@options[option] = value
+    end
+    
+    def self.get(option)
+      @@options[option]
+    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 +helper+, 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 = {}, helper = nil, &block)
+      @streams = [[]]
+      @assigns = assigns.dup
+      @_helper = helper
+      @used_ids = {}
+
+      @@options.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)
+
+      instance_eval(&block) if block
+    end
+
+    def helper=(helper)
+      @_helper = helper
+    end
+
+    def metaclass(&block)
+      metaclass = class << self; self; end
+      metaclass.class_eval(&block)
+    end
+
+    private :metaclass
+
+    def locals=(locals)
+      locals.each do |key, value|
+        metaclass do
+          define_method key do
+            value
+          end
+        end
+      end
+    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 && @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) && 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 @used_ids.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) }
+      @used_ids[ele_id] = f if ele_id
+      f
+    end
+
+  private
+
+    # 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 @_helper.respond_to?(sym, true) && !self.class.ignored_helpers.include?(sym)
+        r = @_helper.send(sym, *args, &block)
+        if @output_helpers && 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 @_helper && @_helper.instance_variables.include?(ivar)
+        @_helper.instance_variable_get(ivar)
+      elsif ::Builder::XmlMarkup.instance_methods.include?(sym.to_s)
+        @builder.__send__(sym, *args, &block)
+      elsif !@tagset
+        tag!(sym, *args, &block)
+      else
+        super
+      end
+    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
+      @transformed_stream = false
+    end
+    
+  private
+
+    def method_missing(*args, &block)
+      transform_stream unless transformed_stream?
+      @str.__send__(*args, &block)
+    end
+    
+    def transform_stream
+      @transformed_stream = true
+      
+      # 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
+    end
+    
+    def transformed_stream?
+      @transformed_stream
+    end
+  end
+
+  class XmlMarkup < ::Builder::XmlMarkup
+    attr_accessor :target, :level
+
+    private :method_missing
+  end
+end

data/lib/markaby/builder_tags.rb

@@ -0,0 +1,64 @@
+module Markaby
+  module BuilderTags
+    (XHTMLTransitional.tags - [:head]).each do |k|
+      class_eval <<-CODE, __FILE__, __LINE__
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *args, &block)
+        end
+      CODE
+    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 && @tagset.self_closing.include?(sym) && block
+        raise InvalidXhtmlError, "the `#{sym}' element is self-closing, please remove the block"
+      elsif args.empty? && !block
+        CssProxy.new(self, @streams.last, sym)
+      else
+        tag!(sym, *args, &block)
+      end
+    end
+
+    # 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
+  end
+end

data/lib/markaby/cssproxy.rb

@@ -0,0 +1,55 @@
+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
+    def initialize(builder, stream, sym)
+      @builder = builder
+      @stream  = stream
+      @sym     = sym
+      @attrs   = {}
+      
+      @original_stream_length = @stream.length
+      
+      @builder.tag! sym
+    end
+    
+    def respond_to?(sym, include_private = false)
+      include_private || !private_methods.include?(sym.to_s) ? true : false
+    end
+
+  private
+
+    # 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 id_or_class.to_s =~ /(.*)!$/
+        @attrs[:id] = $1
+      else
+        id = id_or_class
+        @attrs[:class] = @attrs[:class] ? "#{@attrs[:class]} #{id}".strip : id
+      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
+      
+      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/rails/current.rb

@@ -0,0 +1,41 @@
+module Markaby
+  module Rails
+    class TemplateHandler < ::ActionView::TemplateHandler
+      def compile(template, local_assigns={})
+        <<-CODE
+          handler = Markaby::Rails::TemplateHandler.new
+          handler.view = self
+          handler.render(lambda { #{template.source} }, local_assigns)
+        CODE
+      end
+
+      def render(template, local_assigns = (template.respond_to?(:locals) ? template.locals : {}))
+        builder = Markaby::Builder.new(instance_variables.merge(local_assigns), @view)
+
+        template.is_a?(Proc) ?
+          builder.instance_eval(&template) :
+          builder.instance_eval(template.source)
+
+        builder.to_s
+      end
+
+      attr_accessor :view
+
+    private
+
+      def instance_variables
+        instance_variable_hash(@view)
+      end
+
+      def instance_variable_hash(object)
+        returning Hash.new do |hash|
+          object.instance_variables.each do |var_name|
+            hash[var_name.gsub("@", "")] = object.instance_variable_get(var_name)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler(:mab, Markaby::Rails::TemplateHandler)

data/lib/markaby/rails/deprecated.rb

@@ -0,0 +1,122 @@
+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
+    class Template
+
+      def self.builder_class=(builder)
+        @@builder_class = builder
+      end
+
+      def self.builder_class
+        @@builder_class ||= Builder
+      end
+
+      attr_accessor :source, :path
+
+      def initialize(source)
+        @source = source.to_s
+      end
+
+      def render(*args)
+        output = self.class.builder_class.new(*args)
+
+        if path
+          output.instance_eval source, path
+        else
+          output.instance_eval source
+        end
+
+        output.to_s
+      end
+    end
+    
+    # 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
+  
+  if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+    ActionView::Template
+  else
+    ActionView::Base
+  end.register_template_handler(:mab, Markaby::Rails::ActionViewTemplateHandler)
+end

data/lib/markaby/rails.rb

@@ -0,0 +1,68 @@
+module Markaby
+  module Rails
+    DEPRECATED_RAILS_VERSIONS = [
+      "1.2.2",
+      "1.2.3",
+      "1.2.4",
+      "1.2.5",
+      "1.2.6",
+    ]
+
+    FULLY_SUPPORTED_RAILS_VERSIONS = [
+      # "2.0.0",
+      # "2.0.1",
+      # "2.0.2",
+      # "2.0.3",
+      # "2.0.4",
+      # "2.0.5",
+      "2.1.0",
+      "2.1.1",
+      "2.1.2",
+      "2.2.0",
+      "2.2.1",
+      "2.2.2",
+      "2.2.3",
+      # "2.3.0",
+      "2.3.1",
+      "2.3.2",
+      "2.3.2.1",
+      "2.3.3",
+      "2.3.3.1",
+      "2.3.4"
+    ]
+
+    SUPPORTED_RAILS_VERSIONS = DEPRECATED_RAILS_VERSIONS + FULLY_SUPPORTED_RAILS_VERSIONS
+  
+    class << self
+      def load
+        check_rails_version
+
+        if deprecated_rails_version?
+          require File.dirname(__FILE__) + "/rails/deprecated"
+        else
+          require File.dirname(__FILE__) + "/rails/current"
+        end
+      end
+      
+      def deprecated_rails_version?
+        DEPRECATED_RAILS_VERSIONS.include?(detected_rails_version)
+      end
+
+      def check_rails_version
+        unless SUPPORTED_RAILS_VERSIONS.include?(detected_rails_version)
+          error_message = "Cannot load markaby under rails version #{detected_rails_version}.  "
+          error_message << "See Markaby::Rails::SUPPORTED_RAILS_VERSIONS for exactly that, or redefine this constant."
+          raise LoadError, error_message
+        end
+      end
+
+    private
+
+      def detected_rails_version
+        if defined?(::Rails)
+          ::Rails::VERSION::STRING
+        end
+      end
+    end
+  end
+end