mab 0.0.1 → 0.0.2

data/markaby/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/markaby/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.map { |m| m.to_sym }.include?(sym.to_sym) ? 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/markaby/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/markaby/lib/markaby/rails.rb

@@ -0,0 +1,75 @@
+module Markaby
+  module Rails
+    UNSUPPORTED_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.3.0"
+    ]
+
+    DEPRECATED_RAILS_VERSIONS = [
+      "1.2.2",
+      "1.2.3",
+      "1.2.4",
+      "1.2.5",
+      "1.2.6"
+    ]
+
+    FULLY_SUPPORTED_RAILS_VERSIONS = [
+      "2.2.0",
+      "2.2.1",
+      "2.2.2",
+      "2.2.3",
+      "2.3.1",
+      "2.3.2",
+      "2.3.2.1",
+      "2.3.3",
+      "2.3.3.1",
+      "2.3.4",
+      "2.3.5",
+      "2.3.6",
+      "2.3.7",
+      "2.3.8"
+    ]
+
+    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
+        if UNSUPPORTED_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

data/markaby/lib/markaby/rails/current.rb

@@ -0,0 +1,85 @@
+require 'markaby/rails/rails_builder'
+
+module Markaby
+  module Rails
+    class TemplateHandler < ::ActionView::TemplateHandler
+      include ActionView::TemplateHandlers::Compilable
+
+      def compile(template, local_assigns={})
+        <<-CODE
+          __template_handler = Markaby::Rails::TemplateHandler.new
+          __template_handler.view = self
+          __template_handler.render(lambda {
+            #{template.source}
+          }, local_assigns)
+        CODE
+      end
+
+      def render(template, local_assigns = (template.respond_to?(:locals) ? template.locals : {}))
+        builder = RailsBuilder.new(instance_variables.merge(local_assigns), @view)
+        @view.output_buffer = builder
+
+        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
+
+    module Helpers
+      # allow fragments to act as strings.  url_for has a
+      # case statment in it:
+      #
+      # case options
+      # when String
+      #   ...
+      #
+      # which essential is doing the following:
+      #
+      # String === options
+      #
+      # That assertion fails with Markaby::Fragments, which are essential
+      # builder/string fragments.
+      #
+      def url_for(options={})
+        case options
+        when Markaby::Fragment
+          super(options.to_s)
+        else
+          super
+        end
+      end
+
+      def capture(*args, &block)
+        if output_buffer.kind_of?(Markaby::Builder)
+          output_buffer.capture(&block)
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval do
+  include Markaby::Rails::Helpers
+end
+
+ActionView::Template.register_template_handler(:mab, Markaby::Rails::TemplateHandler)

data/markaby/lib/markaby/rails/deprecated.rb

@@ -0,0 +1,124 @@
+require 'markaby/rails/rails_builder'
+
+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 < RailsBuilder # :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/markaby/lib/markaby/rails/rails_builder.rb

@@ -0,0 +1,91 @@
+module Markaby
+  module Rails
+    class RailsBuilder < Markaby::Builder
+      def form_for(*args, &block)
+        @_helper.output_buffer = OutputBuffer.new
+
+        @template.form_for(*args) do |__form_for_variable|
+          # flush <form tags> + switch back to markaby
+          text(@_helper.output_buffer)
+          @_helper.output_buffer = self
+
+          yield FormHelperProxy.new(@_helper, __form_for_variable)
+
+          # switch back to output string output buffer and flush
+          # final </form> tag
+          @_helper.output_buffer = OutputBuffer.new
+        end
+        text(@_helper.output_buffer)
+
+        # finally, switch back to our regular buffer
+        @_helper.output_buffer = self
+      end
+
+      alias_method :safe_concat, :concat
+
+      # Rails 2.3.6 calls safe_concat on the output buffer.
+      # Future versions of rails alias safe_concat to concat on the core
+      # class String.
+      #
+      # Obviously, that's a bad idea.  Thanks a ton, Rails.
+      class OutputBuffer < String
+        alias_method :safe_concat, :concat
+      end
+
+      # This is used for the block variable given to form_for.  Typically, an erb template looks as so:
+      #
+      #   <% form_for :foo do |f|
+      #     <%= f.text_field :bar %>
+      #   <% end %>
+      #
+      # form_for adds the form tag to the input stream, and assumes that later the user will append
+      # the <input> tag to the input stream himself (in erb, this is done with the <%= %> tags).
+      #
+      # We could do the following in Markaby:
+      #
+      #   form_for :foo do |f|
+      #     text f.text_field(:bar)
+      #   end
+      #
+      # But this is ugly.  This is prettier:
+      #
+      #   form_for :foo do |f|
+      #     f.text_field :bar
+      #   end
+      class FormHelperProxy
+        def initialize(view, proxied_object)
+          @view           = view
+          @proxied_object = proxied_object
+        end
+
+        def respond_to?(sym, include_private = false)
+          @proxied_object.respond_to?(sym, include_private) || super
+        end
+
+      private
+
+        if ::Rails::VERSION::STRING == "2.2.0"
+          def __template__
+            @view.instance_variable_get("@_last_render")
+          end
+        else
+          def __template__
+            @view.template
+          end
+        end
+
+        def method_missing(sym, *args, &block)
+          result = @proxied_object.__send__(sym, *args, &block)
+
+          # a markaby template may call render :partial with the form proxy helper.
+          # we only want to manually concat _if_ we are in a markaby template (not, say, erb)
+          if __template__.extension == "mab"
+            @view.concat(result)
+          end
+
+          result
+        end
+      end
+    end
+  end
+end