mab 0.0.2 → 0.0.3

data/markaby/lib/markaby/builder_tags.rb

@@ -1,64 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,7 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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