mack-markaby 0.8.1 → 0.8.2

data/lib/gems/markaby-0.5/lib/markaby/builder.rb

@@ -0,0 +1,288 @@
+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
+    }
+
+    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
+      @elements = {}
+
+      @@default.each do |k, v|
+        instance_variable_set("@#{k}", @assigns[k] || v)
+      end
+
+      if helpers.nil?
+        @helpers = nil
+      else
+        @helpers = helpers.dup
+        for iv in helpers.instance_variables
+          instance_variable_set(iv, helpers.instance_variable_get(iv))
+        end
+      end
+
+      unless assigns.nil? || assigns.empty?
+        for iv, val in assigns
+          instance_variable_set("@#{iv}", val)
+          unless @helpers.nil?
+            @helpers.instance_variable_set("@#{iv}", val)
+          end
+        end
+      end
+
+      @builder = ::Builder::XmlMarkup.new(:indent => @indent, :target => @streams.last)
+      class << @builder
+          attr_accessor :target, :level
+      end
+
+      if block
+        text(capture(&block))
+      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}"
+      nil
+    end
+    alias_method :<<, :text
+    alias_method :concat, :text
+
+    # Emulate ERB to satisfy helpers like <tt>form_for</tt>.
+    def _erbout; self end
+
+    # 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
+              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 ::Builder::XmlMarkup.instance_methods.include?(sym.to_s) 
+        @builder.__send__(sym, *args, &block)
+      elsif instance_variables.include?("@#{sym}")
+        instance_variable_get("@#{sym}")
+      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"
+      end
+      if args.empty? and block.nil? and not NO_PROXY.include?(sym)
+        return CssProxy.new do |args, block|
+          if @tagset.forms.include?(sym) and args.last.respond_to?(:to_hash) and args.last[:id]
+            args.last[:name] ||= args.last[:id]
+          end
+          tag!(sym, *args, &block)
+        end
+      end
+      if not @tagset.self_closing.include?(sym) and args.first.respond_to?(:to_hash)
+        block ||= proc{}
+      end
+      tag!(sym, *args, &block)
+    end
+
+    XHTMLTransitional.tags.each do |k|
+      class_eval %{
+        def #{k}(*args, &block)
+          html_tag(#{k.inspect}, *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(&block)
+      self.tagset = Markaby::XHTMLTransitional
+      xhtml_html &block
+    end
+
+    # Builds an html tag with XHTML 1.0 Strict doctype instead.
+    def xhtml_strict(&block)
+      self.tagset = Markaby::XHTMLStrict
+      xhtml_html &block
+    end
+
+    private
+
+    def xhtml_html(&block)
+      instruct! if @output_xml_instruction
+      declare!(:DOCTYPE, :html, :PUBLIC, *tagset.doctype)
+      tag!(:html, :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en", &block)
+    end
+
+    def fragment
+      stream = @streams.last
+      f1 = stream.length
+      yield
+      f2 = stream.length - f1
+      Fragment.new(stream, f1, f2)
+    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(s, a, b)
+      @s, @f1, @f2 = s, a, b 
+    end
+    def method_missing(*a)
+      unless @str
+        @str = @s[@f1, @f2].to_s  
+        @s[@f1, @f2] = [nil] * @f2
+        @str
+      end
+      @str.send(*a)
+    end
+  end
+
+end

data/lib/gems/markaby-0.5/lib/markaby/cssproxy.rb

@@ -0,0 +1,53 @@
+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.  The +opts+ and +block+ passed in are
+    # stored until the element is created by Builder.tag!
+    def initialize(opts = {}, &blk)
+      @opts = opts
+      @blk = blk
+    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
+    end
+
+    # 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
+      else
+        if args.last.respond_to? :to_hash
+          @opts.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
+
+  end
+end

data/lib/gems/markaby-0.5/lib/markaby/metaid.rb

@@ -0,0 +1,16 @@
+# metaprogramming assistant -- metaid.rb
+class Object
+  # 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/gems/markaby-0.5/lib/markaby/rails.rb

@@ -0,0 +1,46 @@
+module Markaby
+
+  # 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
+
+  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
+
+  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)")
+    end
+  end
+
+end

data/lib/gems/markaby-0.5/lib/markaby/tags.rb

@@ -0,0 +1,165 @@
+module Markaby
+
+  FORM_TAGS = [ :form, :input, :select, :textarea ]
+  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col ]
+  NO_PROXY = [ :hr, :br ]
+
+  # Common sets of attributes.
+  AttrCore = [:id, :class, :style, :title]
+  AttrI18n = [:lang, 'xml:lang'.intern, :dir]
+  AttrEvents = [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, :onmousemove, 
+      :onmouseout, :onkeypress, :onkeydown, :onkeyup]
+  AttrFocus = [:accesskey, :tabindex, :onfocus, :onblur]
+  AttrHAlign = [:align, :char, :charoff]
+  AttrVAlign = [:valign]
+  Attrs = AttrCore + AttrI18n + AttrEvents
+
+  # All the tags and attributes from XHTML 1.0 Strict
+  class XHTMLStrict
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+    @doctype = ["-//W3C//DTD XHTML 1.0 Strict//EN", "DTD/xhtml1-strict.dtd"]
+    @tagset = {
+      :html => AttrI18n + [:id, :xmlns],
+      :head => AttrI18n + [:id, :profile],
+      :title => AttrI18n + [:id],
+      :base => [:href, :id],
+      :meta => AttrI18n + [:id, :http, :name, :content, :scheme, 'http-equiv'.intern],
+      :link => Attrs + [:charset, :href, :hreflang, :type, :rel, :rev, :media],
+      :style => AttrI18n + [:id, :type, :media, :title, 'xml:space'.intern],
+      :script => [:id, :charset, :type, :src, :defer, 'xml:space'.intern],
+      :noscript => Attrs,
+      :body => Attrs + [:onload, :onunload],
+      :div => Attrs,
+      :p => Attrs,
+      :ul => Attrs,
+      :ol => Attrs,
+      :li => Attrs,
+      :dl => Attrs,
+      :dt => Attrs,
+      :dd => Attrs,
+      :address => Attrs,
+      :hr => Attrs,
+      :pre => Attrs + ['xml:space'.intern],
+      :blockquote => Attrs + [:cite],
+      :ins => Attrs + [:cite, :datetime],
+      :del => Attrs + [:cite, :datetime],
+      :a => Attrs + AttrFocus + [:charset, :type, :name, :href, :hreflang, :rel, :rev, :shape, :coords],
+      :span => Attrs,
+      :bdo => AttrCore + AttrEvents + [:lang, 'xml:lang'.intern, :dir],
+      :br => AttrCore,
+      :em => Attrs,
+      :strong => Attrs,
+      :dfn => Attrs,
+      :code => Attrs,
+      :samp => Attrs,
+      :kbd => Attrs,
+      :var => Attrs,
+      :cite => Attrs,
+      :abbr => Attrs,
+      :acronym => Attrs,
+      :q => Attrs + [:cite],
+      :sub => Attrs,
+      :sup => Attrs,
+      :tt => Attrs,
+      :i => Attrs,
+      :b => Attrs,
+      :big => Attrs,
+      :small => Attrs,
+      :object => Attrs + [:declare, :classid, :codebase, :data, :type, :codetype, :archive, :standby, :height, :width, :usemap, :name, :tabindex],
+      :param => [:id, :name, :value, :valuetype, :type],
+      :img => Attrs + [:src, :alt, :longdesc, :height, :width, :usemap, :ismap],
+      :map => AttrI18n + AttrEvents + [:id, :class, :style, :title, :name],
+      :area => Attrs + AttrFocus + [:shape, :coords, :href, :nohref, :alt],
+      :form => Attrs + [:action, :method, :enctype, :onsubmit, :onreset, :accept, :accept],
+      :label => Attrs + [:for, :accesskey, :onfocus, :onblur],
+      :input => Attrs + AttrFocus + [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength, :src, :alt, :usemap, :onselect, :onchange, :accept],
+      :select => Attrs + [:name, :size, :multiple, :disabled, :tabindex, :onfocus, :onblur, :onchange],
+      :optgroup => Attrs + [:disabled, :label],
+      :option => Attrs + [:selected, :disabled, :label, :value],
+      :textarea => Attrs + AttrFocus + [:name, :rows, :cols, :disabled, :readonly, :onselect, :onchange],
+      :fieldset => Attrs,
+      :legend => Attrs + [:accesskey],
+      :button => Attrs + AttrFocus + [:name, :value, :type, :disabled],
+      :table => Attrs + [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding],
+      :caption => Attrs,
+      :colgroup => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :col => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
+      :thead => Attrs + AttrHAlign + AttrVAlign,
+      :tfoot => Attrs + AttrHAlign + AttrVAlign,
+      :tbody => Attrs + AttrHAlign + AttrVAlign,
+      :tr => Attrs + AttrHAlign + AttrVAlign,
+      :th => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :td => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
+      :h1 => Attrs,
+      :h2 => Attrs,
+      :h3 => Attrs,
+      :h4 => Attrs,
+      :h5 => Attrs,
+      :h6 => Attrs
+    }
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+  # Additional tags found in XHTML 1.0 Transitional
+  class XHTMLTransitional
+    class << self
+      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
+    end
+    @doctype = ["-//W3C//DTD XHTML 1.0 Transitional//EN", "DTD/xhtml1-transitional.dtd"]
+    @tagset = XHTMLStrict.tagset.merge \
+      :strike => Attrs,
+      :center => Attrs,
+      :dir => Attrs + [:compact], 
+      :noframes => Attrs,
+      :basefont => [:id, :size, :color, :face], 
+      :u => Attrs,
+      :menu => Attrs + [:compact], 
+      :iframe => AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :scrolling, :align, :height, :width],
+      :font => AttrCore + AttrI18n + [:size, :color, :face],
+      :s => Attrs,
+      :applet => AttrCore + [:codebase, :archive, :code, :object, :alt, :name, :width, :height, :align, :hspace, :vspace],
+      :isindex => AttrCore + AttrI18n + [:prompt]
+
+    # Additional attributes found in XHTML 1.0 Transitional
+    { :script => [:language],
+      :a => [:target],
+      :td => [:bgcolor, :nowrap, :width, :height],
+      :p => [:align],
+      :h5 => [:align],
+      :h3 => [:align],
+      :li => [:type, :value],
+      :div => [:align],
+      :pre => [:width],
+      :body => [:background, :bgcolor, :text, :link, :vlink, :alink],
+      :ol => [:type, :compact, :start],
+      :h4 => [:align],
+      :h2 => [:align],
+      :object => [:align, :border, :hspace, :vspace],
+      :img => [:name, :align, :border, :hspace, :vspace],
+      :link => [:target],
+      :legend => [:align],
+      :dl => [:compact],
+      :input => [:align],
+      :h6 => [:align],
+      :hr => [:align, :noshade, :size, :width],
+      :base => [:target],
+      :ul => [:type, :compact],
+      :br => [:clear],
+      :form => [:name, :target],
+      :area => [:target],
+      :h1 => [:align]
+    }.each do |k, v|
+        @tagset[k] += v
+    end
+
+    @tags = @tagset.keys
+    @forms = @tags & FORM_TAGS
+    @self_closing = @tags & SELF_CLOSING_TAGS
+  end
+
+end

data/lib/gems/markaby-0.5/lib/markaby/template.rb

@@ -0,0 +1,12 @@
+module Markaby
+  class Template
+    def initialize(template)
+      @template = template      
+    end
+    def render(*args)
+      output = Builder.new(*args)
+      output.instance_eval @template
+      return output.to_s
+    end
+  end
+end

data/lib/gems/markaby-0.5/lib/markaby.rb

@@ -0,0 +1,35 @@
+# = About lib/markaby.rb
+#
+# By requiring <tt>lib/markaby</tt>, you can load Markaby's dependency (the Builder library,)
+# as well as the full set of Markaby classes.
+#
+# For a full list of features and instructions, see the README.
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+# Markaby is a module containing all of the great Markaby classes that
+# do such an excellent job.
+# 
+# * Markaby::Builder: the class for actually calling the Ruby methods
+#   which write the HTML.
+# * Markaby::CSSProxy: a class which adds element classes and IDs to
+#   elements when used within Markaby::Builder.
+# * Markaby::MetAid: metaprogramming helper methods.
+# * Markaby::Tags: lists the roles of various XHTML tags to help Builder
+#   use these tags as they are intended.
+# * Markaby::Template: a class for hooking Markaby into Rails as a
+#   proper templating language.
+module Markaby
+  VERSION = '0.5'
+
+  class InvalidXhtmlError < Exception; end
+end
+
+unless defined?(Builder)
+  require 'rubygems'
+  require 'builder'
+end
+
+require 'markaby/builder'
+require 'markaby/cssproxy'
+require 'markaby/metaid'
+require 'markaby/template'

data/lib/gems.rb

@@ -0,0 +1,13 @@
+path = File.expand_path(File.join(File.dirname(__FILE__), 'gems'))
+Gem.set_paths(path)
+
+Dir.glob(File.join(path, '*')).each do |p|
+  full_gem_name = File.basename(p)
+  version = full_gem_name.match(/([\d\.?]+)/).to_s
+  gem_name = full_gem_name.gsub("-#{version}", '')
+  $:.unshift(File.join(p, 'lib'))
+  begin
+    gem gem_name, "~> #{version}"
+  rescue Gem::LoadError
+  end
+end

data/lib/mack-markaby.rb

@@ -1,2 +1,4 @@
+require File.join(File.dirname(__FILE__), 'gems')
+
 require 'markaby'
 require File.join(File.dirname(__FILE__), "mack-markaby", 'markaby_engine')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mack-markaby
 version: !ruby/object:Gem::Version 
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors: 
 - Darsono Sutedja
@@ -9,19 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-26 00:00:00 -04:00
+date: 2008-11-30 00:00:00 -05:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: markaby
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        version: 0.5.0
-    version: 
+dependencies: []
+
 description: Markaby Rendering Engine for Mack Framework
 email: darsono.sutedja@gmail.com
 executables: []
@@ -31,14 +22,31 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/gems
+- lib/gems/cache
+- lib/gems/doc
+- lib/gems/gems
+- lib/gems/markaby-0.5
+- lib/gems/markaby-0.5/lib
+- lib/gems/markaby-0.5/lib/markaby
+- lib/gems/markaby-0.5/lib/markaby/builder.rb
+- lib/gems/markaby-0.5/lib/markaby/cssproxy.rb
+- lib/gems/markaby-0.5/lib/markaby/metaid.rb
+- lib/gems/markaby-0.5/lib/markaby/rails.rb
+- lib/gems/markaby-0.5/lib/markaby/tags.rb
+- lib/gems/markaby-0.5/lib/markaby/template.rb
+- lib/gems/markaby-0.5/lib/markaby.rb
+- lib/gems/specifications
+- lib/gems.rb
+- lib/mack-markaby
 - lib/mack-markaby/markaby_engine.rb
 - lib/mack-markaby.rb
 - README
 has_rdoc: true
 homepage: http://www.mackframework.com
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --exclude=gems/
 require_paths: 
 - lib
 - lib
@@ -57,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: magrathea
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Rendering Engine