RubyGems - backbone-deep-rails - Versions diffs - 0.0.1 → 0.0.2 - Mend

backbone-deep-rails 0.0.1 → 0.0.2

Files changed (2168) hide show

data/vendor/bundle/gems/builder-3.0.4/lib/builder/xmlmarkup.rb DELETED

@@ -1,334 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Copyright 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-# Provide a flexible and easy to use Builder for creating XML markup.
-# See XmlBuilder for usage details.
-require 'builder/xmlbase'
-module Builder
-  # Create XML markup easily.  All (well, almost all) methods sent to
-  # an XmlMarkup object will be translated to the equivalent XML
-  # markup.  Any method with a block will be treated as an XML markup
-  # tag with nested markup in the block.
-  #
-  # Examples will demonstrate this easier than words.  In the
-  # following, +xm+ is an +XmlMarkup+ object.
-  #
-  #   xm.em("emphasized")            # => <em>emphasized</em>
-  #   xm.em { xm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
-  #   xm.a("A Link", "href"=>"http://onestepback.org")
-  #                                  # => <a href="http://onestepback.org">A Link</a>
-  #   xm.div { xm.br }               # => <div><br/></div>
-  #   xm.target("name"=>"compile", "option"=>"fast")
-  #                                  # => <target option="fast" name="compile"\>
-  #                                  # NOTE: order of attributes is not specified.
-  #
-  #   xm.instruct!                   # <?xml version="1.0" encoding="UTF-8"?>
-  #   xm.html {                      # <html>
-  #     xm.head {                    #   <head>
-  #       xm.title("History")        #     <title>History</title>
-  #     }                            #   </head>
-  #     xm.body {                    #   <body>
-  #       xm.comment! "HI"           #     <!-- HI -->
-  #       xm.h1("Header")            #     <h1>Header</h1>
-  #       xm.p("paragraph")          #     <p>paragraph</p>
-  #     }                            #   </body>
-  #   }                              # </html>
-  #
-  # == Notes:
-  #
-  # * The order that attributes are inserted in markup tags is
-  #   undefined.
-  #
-  # * Sometimes you wish to insert text without enclosing tags.  Use
-  #   the <tt>text!</tt> method to accomplish this.
-  #
-  #   Example:
-  #
-  #     xm.div {                          # <div>
-  #       xm.text! "line"; xm.br          #   line<br/>
-  #       xm.text! "another line"; xmbr   #    another line<br/>
-  #     }                                 # </div>
-  #
-  # * The special XML characters <, >, and & are converted to &lt;,
-  #   &gt; and &amp; automatically.  Use the <tt><<</tt> operation to
-  #   insert text without modification.
-  #
-  # * Sometimes tags use special characters not allowed in ruby
-  #   identifiers.  Use the <tt>tag!</tt> method to handle these
-  #   cases.
-  #
-  #   Example:
-  #
-  #     xml.tag!("SOAP:Envelope") { ... }
-  #
-  #   will produce ...
-  #
-  #     <SOAP:Envelope> ... </SOAP:Envelope>"
-  #
-  #   <tt>tag!</tt> will also take text and attribute arguments (after
-  #   the tag name) like normal markup methods.  (But see the next
-  #   bullet item for a better way to handle XML namespaces).
-  #
-  # * Direct support for XML namespaces is now available.  If the
-  #   first argument to a tag call is a symbol, it will be joined to
-  #   the tag to produce a namespace:tag combination.  It is easier to
-  #   show this than describe it.
-  #
-  #     xml.SOAP :Envelope do ... end
-  #
-  #   Just put a space before the colon in a namespace to produce the
-  #   right form for builder (e.g. "<tt>SOAP:Envelope</tt>" =>
-  #   "<tt>xml.SOAP :Envelope</tt>")
-  #
-  # * XmlMarkup builds the markup in any object (called a _target_)
-  #   that accepts the <tt><<</tt> method.  If no target is given,
-  #   then XmlMarkup defaults to a string target.
-  #
-  #   Examples:
-  #
-  #     xm = Builder::XmlMarkup.new
-  #     result = xm.title("yada")
-  #     # result is a string containing the markup.
-  #
-  #     buffer = ""
-  #     xm = Builder::XmlMarkup.new(buffer)
-  #     # The markup is appended to buffer (using <<)
-  #
-  #     xm = Builder::XmlMarkup.new(STDOUT)
-  #     # The markup is written to STDOUT (using <<)
-  #
-  #     xm = Builder::XmlMarkup.new
-  #     x2 = Builder::XmlMarkup.new(:target=>xm)
-  #     # Markup written to +x2+ will be send to +xm+.
-  #
-  # * Indentation is enabled by providing the number of spaces to
-  #   indent for each level as a second argument to XmlBuilder.new.
-  #   Initial indentation may be specified using a third parameter.
-  #
-  #   Example:
-  #
-  #     xm = Builder.new(:indent=>2)
-  #     # xm will produce nicely formatted and indented XML.
-  #
-  #     xm = Builder.new(:indent=>2, :margin=>4)
-  #     # xm will produce nicely formatted and indented XML with 2
-  #     # spaces per indent and an over all indentation level of 4.
-  #
-  #     builder = Builder::XmlMarkup.new(:target=>$stdout, :indent=>2)
-  #     builder.name { |b| b.first("Jim"); b.last("Weirich) }
-  #     # prints:
-  #     #     <name>
-  #     #       <first>Jim</first>
-  #     #       <last>Weirich</last>
-  #     #     </name>
-  #
-  # * The instance_eval implementation which forces self to refer to
-  #   the message receiver as self is now obsolete.  We now use normal
-  #   block calls to execute the markup block.  This means that all
-  #   markup methods must now be explicitly send to the xml builder.
-  #   For instance, instead of
-  #
-  #      xml.div { strong("text") }
-  #
-  #   you need to write:
-  #
-  #      xml.div { xml.strong("text") }
-  #
-  #   Although more verbose, the subtle change in semantics within the
-  #   block was found to be prone to error.  To make this change a
-  #   little less cumbersome, the markup block now gets the markup
-  #   object sent as an argument, allowing you to use a shorter alias
-  #   within the block.
-  #
-  #   For example:
-  #
-  #     xml_builder = Builder::XmlMarkup.new
-  #     xml_builder.div { |xml|
-  #       xml.stong("text")
-  #     }
-  #
-  class XmlMarkup < XmlBase
-    # Create an XML markup builder.  Parameters are specified by an
-    # option hash.
-    #
-    # :target=><em>target_object</em>::
-    #    Object receiving the markup.  +target_object+ must respond to
-    #    the <tt><<(<em>a_string</em>)</tt> operator and return
-    #    itself.  The default target is a plain string target.
-    #
-    # :indent=><em>indentation</em>::
-    #    Number of spaces used for indentation.  The default is no
-    #    indentation and no line breaks.
-    #
-    # :margin=><em>initial_indentation_level</em>::
-    #    Amount of initial indentation (specified in levels, not
-    #    spaces).
-    #
-    # :escape_attrs=><em>OBSOLETE</em>::
-    #    The :escape_attrs option is no longer supported by builder
-    #    (and will be quietly ignored).  String attribute values are
-    #    now automatically escaped.  If you need unescaped attribute
-    #    values (perhaps you are using entities in the attribute
-    #    values), then give the value as a Symbol.  This allows much
-    #    finer control over escaping attribute values.
-    #
-    def initialize(options={})
-      indent = options[:indent] || 0
-      margin = options[:margin] || 0
-      super(indent, margin)
-      @target = options[:target] || ""
-    end
-    # Return the target of the builder.
-    def target!
-      @target
-    end
-    def comment!(comment_text)
-      _ensure_no_block ::Kernel::block_given?
-      _special("<!-- ", " -->", comment_text, nil)
-    end
-    # Insert an XML declaration into the XML markup.
-    #
-    # For example:
-    #
-    #   xml.declare! :ELEMENT, :blah, "yada"
-    #       # => <!ELEMENT blah "yada">
-    def declare!(inst, *args, &block)
-      _indent
-      @target << "<!#{inst}"
-      args.each do |arg|
-        case arg
-        when ::String
-          @target << %{ "#{arg}"} # " WART
-        when ::Symbol
-          @target << " #{arg}"
-        end
-      end
-      if ::Kernel::block_given?
-        @target << " ["
-        _newline
-        _nested_structures(block)
-        @target << "]"
-      end
-      @target << ">"
-      _newline
-    end
-    # Insert a processing instruction into the XML markup.  E.g.
-    #
-    # For example:
-    #
-    #    xml.instruct!
-    #        #=> <?xml version="1.0" encoding="UTF-8"?>
-    #    xml.instruct! :aaa, :bbb=>"ccc"
-    #        #=> <?aaa bbb="ccc"?>
-    #
-    # Note: If the encoding is setup to "UTF-8" and the value of
-    # $KCODE is "UTF8", then builder will emit UTF-8 encoded strings
-    # rather than the entity encoding normally used.
-    def instruct!(directive_tag=:xml, attrs={})
-      _ensure_no_block ::Kernel::block_given?
-      if directive_tag == :xml
-        a = { :version=>"1.0", :encoding=>"UTF-8" }
-        attrs = a.merge attrs
-	@encoding = attrs[:encoding].downcase
-      end
-      _special(
-        "<?#{directive_tag}",
-        "?>",
-        nil,
-        attrs,
-        [:version, :encoding, :standalone])
-    end
-    # Insert a CDATA section into the XML markup.
-    #
-    # For example:
-    #
-    #    xml.cdata!("text to be included in cdata")
-    #        #=> <![CDATA[text to be included in cdata]]>
-    #
-    def cdata!(text)
-      _ensure_no_block ::Kernel::block_given?
-      _special("<![CDATA[", "]]>", text.gsub(']]>', ']]]]><![CDATA[>'), nil)
-    end
-    private
-    # NOTE: All private methods of a builder object are prefixed when
-    # a "_" character to avoid possible conflict with XML tag names.
-    # Insert text directly in to the builder's target.
-    def _text(text)
-      @target << text
-    end
-    # Insert special instruction.
-    def _special(open, close, data=nil, attrs=nil, order=[])
-      _indent
-      @target << open
-      @target << data if data
-      _insert_attributes(attrs, order) if attrs
-      @target << close
-      _newline
-    end
-    # Start an XML tag.  If <tt>end_too</tt> is true, then the start
-    # tag is also the end tag (e.g.  <br/>
-    def _start_tag(sym, attrs, end_too=false)
-      @target << "<#{sym}"
-      _insert_attributes(attrs)
-      @target << "/" if end_too
-      @target << ">"
-    end
-    # Insert an ending tag.
-    def _end_tag(sym)
-      @target << "</#{sym}>"
-    end
-    # Insert the attributes (given in the hash).
-    def _insert_attributes(attrs, order=[])
-      return if attrs.nil?
-      order.each do |k|
-        v = attrs[k]
-        @target << %{ #{k}="#{_attr_value(v)}"} if v # " WART
-      end
-      attrs.each do |k, v|
-        @target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k) # " WART
-      end
-    end
-    def _attr_value(value)
-      case value
-      when ::Symbol
-        value.to_s
-      else
-        _escape_attribute(value.to_s)
-      end
-    end
-    def _ensure_no_block(got_block)
-      if got_block
-        ::Kernel::raise IllegalBlockError.new(
-          "Blocks are not allowed on XML instructions"
-        )
-      end
-    end
-  end
-end

data/vendor/bundle/gems/builder-3.0.4/test/performance.rb DELETED

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-require 'builder/xmlmarkup'
-require 'benchmark'
-text = "This is a test of the new xml markup. I�t�rn�ti�n�liz�ti�n\n" * 10000
-include Benchmark          # we need the CAPTION and FMTSTR constants
-include Builder
-n = 50
-Benchmark.benchmark do |bm|
-  tf = bm.report("base")   {
-    n.times do
-      x = XmlMarkup.new
-      x.text(text)
-      x.target!
-    end
-  }
-  def XmlMarkup._escape(text)
-    text.to_xs
-  end
-  tf = bm.report("to_xs")   {
-    n.times do
-      x = XmlMarkup.new
-      x.text(text)
-      x.target!
-    end
-  }
-end

data/vendor/bundle/gems/builder-3.0.4/test/preload.rb DELETED

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-# We are defining method_added in Kernel and Object so that when
-# BlankSlate overrides them later, we can verify that it correctly
-# calls the older hooks.
-module Kernel
-  class << self
-    attr_reader :k_added_names
-    alias_method :preload_method_added, :method_added
-    def method_added(name)
-      preload_method_added(name)
-      @k_added_names ||= []
-      @k_added_names << name
-    end
-  end
-end
-class Object
-  class << self
-    attr_reader :o_added_names
-    alias_method :preload_method_added, :method_added
-    def method_added(name)
-      preload_method_added(name)
-      @o_added_names ||= []
-      @o_added_names << name
-    end
-  end
-end

data/vendor/bundle/gems/builder-3.0.4/test/test_blankslate.rb DELETED

@@ -1,217 +0,0 @@
-#!/usr/bin/env ruby
-#--
-# Portions copyright 2004 by Jim Weirich (jim@weirichhouse.org).
-# Portions copyright 2005 by Sam Ruby (rubys@intertwingly.net).
-# All rights reserved.
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-require 'test/unit'
-require 'test/preload'
-require 'blankslate'
-require 'stringio'
-# Methods to be introduced into the Object class late.
-module LateObject
-  def late_object
-    33
-  end
-  def LateObject.included(mod)
-    # Modules defining an included method should not prevent blank
-    # slate erasure!
-  end
-end
-# Methods to be introduced into the Kernel module late.
-module LateKernel
-  def late_kernel
-    44
-  end
-  def LateKernel.included(mod)
-    # Modules defining an included method should not prevent blank
-    # slate erasure!
-  end
-end
-# Introduce some late methods (both module and direct) into the Kernel
-# module.
-module Kernel
-  include LateKernel
-  def late_addition
-    1234
-  end
-  def double_late_addition
-    11
-  end
-  def double_late_addition
-    22
-  end
-end
-# Introduce some late methods (both module and direct) into the Object
-# class.
-class Object
-  include LateObject
-  def another_late_addition
-    4321
-  end
-end
-# Introduce some late methods by inclusion.
-module GlobalModule
- def global_inclusion
-   42
- end
-end
-include GlobalModule
-def direct_global
-  43
-end
-######################################################################
-# Test case for blank slate.
-#
-class TestBlankSlate < Test::Unit::TestCase
-  def setup
-    @bs = BlankSlate.new
-  end
-  def test_undefined_methods_remain_undefined
-    assert_raise(NoMethodError) { @bs.no_such_method }
-    assert_raise(NoMethodError) { @bs.nil? }
-  end
-  # NOTE: NameError is acceptable because the lack of a '.' means that
-  # Ruby can't tell if it is a method or a local variable.
-  def test_undefined_methods_remain_undefined_during_instance_eval
-    assert_raise(NoMethodError, NameError)  do
-      @bs.instance_eval do nil? end
-    end
-    assert_raise(NoMethodError, NameError)  do
-      @bs.instance_eval do no_such_method end
-    end
-  end
-  def test_private_methods_are_undefined
-    assert_raise(NoMethodError) do
-      @bs.puts "HI"
-    end
-  end
-  def test_targetted_private_methods_are_undefined_during_instance_eval
-    assert_raise(NoMethodError, NameError) do
-      @bs.instance_eval do self.puts "HI" end
-    end
-  end
-  def test_untargetted_private_methods_are_defined_during_instance_eval
-    oldstdout = $stdout
-    $stdout = StringIO.new
-    @bs.instance_eval do
-      puts "HI"
-    end
-  ensure
-    $stdout = oldstdout
-  end
-  def test_methods_added_late_to_kernel_remain_undefined
-    assert_equal 1234, nil.late_addition
-    assert_raise(NoMethodError) { @bs.late_addition }
-  end
-  def test_methods_added_late_to_object_remain_undefined
-    assert_equal 4321, nil.another_late_addition
-    assert_raise(NoMethodError) { @bs.another_late_addition }
-  end
-  def test_methods_added_late_to_global_remain_undefined
-    assert_equal 42, global_inclusion
-    assert_raise(NoMethodError) { @bs.global_inclusion }
-  end
-  def test_preload_method_added
-    assert Kernel.k_added_names.include?(:late_addition)
-    assert Object.o_added_names.include?(:another_late_addition)
-  end
-  def test_method_defined_late_multiple_times_remain_undefined
-    assert_equal 22, nil.double_late_addition
-    assert_raise(NoMethodError) { @bs.double_late_addition }
-  end
-  def test_late_included_module_in_object_is_ok
-    assert_equal 33, 1.late_object
-    assert_raise(NoMethodError) { @bs.late_object }
-  end
-  def test_late_included_module_in_kernel_is_ok
-    assert_raise(NoMethodError) { @bs.late_kernel }
-  end
-  def test_revealing_previously_hidden_methods_are_callable
-    with_to_s = Class.new(BlankSlate) do
-      reveal :to_s
-    end
-    assert_match(/^#<.*>$/, with_to_s.new.to_s)
-  end
-  def test_revealing_previously_hidden_methods_are_callable_with_block
-    Object.class_eval <<-EOS
-      def given_block(&block)
-        block
-      end
-    EOS
-    with_given_block = Class.new(BlankSlate) do
-      reveal :given_block
-    end
-    assert_not_nil with_given_block.new.given_block {}
-  end
-  def test_revealing_a_hidden_method_twice_is_ok
-    with_to_s = Class.new(BlankSlate) do
-      reveal :to_s
-      reveal :to_s
-    end
-    assert_match(/^#<.*>$/, with_to_s.new.to_s)
-  end
-  def test_revealing_unknown_hidden_method_is_an_error
-    assert_raises(RuntimeError) do
-      Class.new(BlankSlate) do
-        reveal :xyz
-      end
-    end
-  end
-  def test_global_includes_still_work
-    assert_nothing_raised do
-      assert_equal 42, global_inclusion
-      assert_equal 42, Object.new.global_inclusion
-      assert_equal 42, "magic number".global_inclusion
-      assert_equal 43, direct_global
-    end
-  end
-  def test_reveal_should_not_bind_to_an_instance
-    with_object_id = Class.new(BlankSlate) do
-      reveal(:object_id)
-    end
-    obj1 = with_object_id.new
-    obj2 = with_object_id.new
-    assert obj1.object_id != obj2.object_id,
-       "Revealed methods should not be bound to a particular instance"
-  end
-end