markaby 0.5 → 0.6.6

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

@@ -4,50 +4,52 @@ module Markaby
   #
   # See the README for examples.
   class CssProxy
+    def initialize(builder, stream, sym)
+      @builder = builder
+      @stream  = stream
+      @sym     = sym
+      @attrs   = {}
 
-    # Creates a CssProxy object.  The +opts+ and +block+ passed in are
-    # stored until the element is created by Builder.tag!
-    def initialize(opts = {}, &blk)
-      @opts = opts
-      @blk = blk
+      @original_stream_length = @stream.length
+
+      @builder.tag! sym
     end
-  
-    # Adds attributes to an element, for internal use only.  For example, if you
-    # want to write a wrapper which sets a bunch of default attributes for a certain
-    # tag.  Like the default `img' method included with Markaby automatically sets an
-    # empty alt attribute.
-    def merge!(opts)
-      @opts.merge! opts
-      self
+
+    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.  If a block is supplied,
-    # it is executed with a merged hash (@opts + args).
-    def method_missing(id_or_class, *args, &blk)
-      idc = id_or_class.to_s
-      case idc
-      when "pass"
-      when /!$/
-        @opts[:id] = $`
-      else 
-        @opts[:class] = "#{@opts[:class]} #{idc}".strip
-      end
-      if args.empty? and blk.nil?
-        self
+    # 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
-          @opts.merge!(args.pop.to_hash)
+          @attrs.merge! args.pop.to_hash
         end
-        args.push @opts
-        @blk.call(args, blk)
       end
-    end
 
-    def to_str
-      @blk.call([[@opts]]).to_s
-    end
-    alias_method :to_s, :to_str
+      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.rb

@@ -1,46 +1,71 @@
 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"
+    ]
 
-  # 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({}, self, &block).to_s })
-    end
-  end
+    DEPRECATED_RAILS_VERSIONS = [
+      "1.2.2",
+      "1.2.3",
+      "1.2.4",
+      "1.2.5",
+      "1.2.6"
+    ]
 
-  class ActionViewTemplateHandler
-    def initialize(action_view)
-      @action_view = action_view
-    end
-    def render(template, local_assigns = {})
-      Template.new(template).render(@action_view.assigns.merge(local_assigns), @action_view)
-    end
-  end
+    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"
+    ]
+
+    SUPPORTED_RAILS_VERSIONS = DEPRECATED_RAILS_VERSIONS + FULLY_SUPPORTED_RAILS_VERSIONS
 
-  class Builder
-    # Emulate ERB to satisfy helpers like <tt>form_for</tt>.
-    def _erbout; 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)")
+    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/lib/markaby/rails/current.rb

@@ -0,0 +1,46 @@
+require 'markaby/rails/rails_builder'
+
+module Markaby
+  module Rails
+    class TemplateHandler < ::ActionView::TemplateHandler
+      include ActionView::TemplateHandlers::Compilable
+
+      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 = 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
+  end
+end
+
+ActionView::Template.register_template_handler(:mab, Markaby::Rails::TemplateHandler)

data/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/lib/markaby/rails/rails_builder.rb

@@ -0,0 +1,50 @@
+module Markaby
+  module Rails
+    class RailsBuilder < Markaby::Builder
+      def form_for(*args, &block)
+        @template.form_for(*args) do |__form_for_variable|
+          yield(FormHelperProxy.new(self, __form_for_variable))
+        end
+      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(builder, proxied_object)
+          @builder = builder
+          @proxied_object = proxied_object
+        end
+
+        def respond_to?(sym, include_private = false)
+          @proxied_object.respond_to?(sym, include_private) || super
+        end
+
+      private
+
+        def method_missing(sym, *args, &block)
+          result = @proxied_object.__send__(sym, *args, &block)
+          @builder.text(result) if result.is_a?(String)
+          result
+        end
+      end
+    end
+  end
+end