RubyGems - opal-builder - Versions diffs - 3.2.2.1 - Mend

opal-builder 3.2.2.1

Files changed (26) hide show

checksums.yaml +7 -0
data/.gitignore +2 -0
data/.gitmodules +6 -0
data/.travis.yml +10 -0
data/Gemfile +13 -0
data/README.md +57 -0
data/Rakefile +7 -0
data/builder/lib/blankslate.rb +137 -0
data/builder/lib/builder/blankslate.rb +23 -0
data/builder/lib/builder/version.rb +8 -0
data/builder/lib/builder/xchar.rb +197 -0
data/builder/lib/builder/xmlbase.rb +199 -0
data/builder/lib/builder/xmlevents.rb +63 -0
data/builder/lib/builder/xmlmarkup.rb +339 -0
data/builder/lib/builder.rb +13 -0
data/config.ru +10 -0
data/lib/opal-builder.rb +8 -0
data/opal/builder.rb +4 -0
data/opal/opal/builder/builder_mutable_string.rb +43 -0
data/opal/opal/builder/builder_symbol.rb +14 -0
data/opal/opal/builder/version.rb +8 -0
data/opal/opal/builder/xmlbase.rb +68 -0
data/opal/opal/builder/xmlmarkup.rb +28 -0
data/opal-builder.gemspec +19 -0
data/spec/builder_spec.rb +164 -0
metadata +100 -0

data/builder/lib/builder/xmlevents.rb ADDED Viewed

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 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.
+#++
+require 'builder/xmlmarkup'
+module Builder
+  # Create a series of SAX-like XML events (e.g. start_tag, end_tag)
+  # from the markup code.  XmlEvent objects are used in a way similar
+  # to XmlMarkup objects, except that a series of events are generated
+  # and passed to a handler rather than generating character-based
+  # markup.
+  #
+  # Usage:
+  #   xe = Builder::XmlEvents.new(hander)
+  #   xe.title("HI")    # Sends start_tag/end_tag/text messages to the handler.
+  #
+  # Indentation may also be selected by providing value for the
+  # indentation size and initial indentation level.
+  #
+  #   xe = Builder::XmlEvents.new(handler, indent_size, initial_indent_level)
+  #
+  # == XML Event Handler
+  #
+  # The handler object must expect the following events.
+  #
+  # [<tt>start_tag(tag, attrs)</tt>]
+  #     Announces that a new tag has been found.  +tag+ is the name of
+  #     the tag and +attrs+ is a hash of attributes for the tag.
+  #
+  # [<tt>end_tag(tag)</tt>]
+  #     Announces that an end tag for +tag+ has been found.
+  #
+  # [<tt>text(text)</tt>]
+  #     Announces that a string of characters (+text+) has been found.
+  #     A series of characters may be broken up into more than one
+  #     +text+ call, so the client cannot assume that a single
+  #     callback contains all the text data.
+  #
+  class XmlEvents < XmlMarkup
+    def text!(text)
+      @target.text(text)
+    end
+    def _start_tag(sym, attrs, end_too=false)
+      @target.start_tag(sym, attrs)
+      _end_tag(sym) if end_too
+    end
+    def _end_tag(sym)
+      @target.end_tag(sym)
+    end
+  end
+end

data/builder/lib/builder/xmlmarkup.rb ADDED Viewed

@@ -0,0 +1,339 @@
+#!/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).
+    #
+    # :quote => <em>:single</em>::
+    #    Use single quotes for attributes rather than double quotes.
+    #
+    # :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
+      @quote = (options[:quote] == :single) ? "'" : '"'
+      @explicit_nil_handling = options[:explicit_nil_handling]
+      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}=#{@quote}#{_attr_value(v)}#{@quote}} if v
+      end
+      attrs.each do |k, v|
+        @target << %{ #{k}=#{@quote}#{_attr_value(v)}#{@quote}} 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/builder/lib/builder.rb ADDED Viewed

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004 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.
+#++
+require 'builder/xmlmarkup'
+require 'builder/xmlevents'

data/config.ru ADDED Viewed

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler.require
+Opal::Processor.source_map_enabled = false
+run Opal::Server.new { |s|
+  s.main = 'opal/rspec/sprockets_runner'
+  s.append_path 'spec'
+  s.debug = false
+}

data/lib/opal-builder.rb ADDED Viewed

@@ -0,0 +1,8 @@
+require 'opal'
+# Our fixes, need to go first so that require 'builder' is caught by us first
+Opal.append_path File.expand_path('../../opal', __FILE__).untaint
+# builder source itself
+Opal.append_path File.expand_path('../../builder/lib', __FILE__).untaint
+# Contains encoding that's not compatible
+Opal::Processor.stub_file 'builder/xchar'

data/opal/builder.rb ADDED Viewed

@@ -0,0 +1,4 @@
+require 'builder/xmlmarkup'
+require 'builder/xmlevents'
+require 'opal/builder/xmlbase'
+require 'opal/builder/xmlmarkup'

data/opal/opal/builder/builder_mutable_string.rb ADDED Viewed

@@ -0,0 +1,43 @@
+class BuilderMutableString
+  def initialize(str)
+    @state = str
+  end
+  def <<(text)
+    @state += text
+    self
+  end
+  def to_s
+    @state
+  end
+  def to_str
+    @state
+  end
+  def nil?
+    @state.nil?
+  end
+  # Unpack doesn't exist in Opal
+  def to_xs
+    gsub(/&(?!\w+;)/, '&amp;')
+    .gsub(/</, '&lt;')
+    .gsub(/>/, '&gt;')
+    .gsub(/'/, '&apos;')
+  end
+  def gsub(regex, replace)
+    @state = @state.gsub regex,replace
+    self
+  end
+  def ==(other_str)
+    @state == other_str
+  end
+  def size
+    @state.size
+  end
+end

data/opal/opal/builder/builder_symbol.rb ADDED Viewed

@@ -0,0 +1,14 @@
+# In Opal, symbols and strings are the same, builder differentiates
+class BuilderSymbol
+  def initialize(str)
+    @symbol = str
+  end
+  def to_s
+    @symbol
+  end
+  def to_str
+    @symbol
+  end
+end

data/opal/opal/builder/version.rb ADDED Viewed

@@ -0,0 +1,8 @@
+require 'builder/version'
+module Opal
+  module OpalBuilder
+    # Add a minor version to the end in case there are opal-builder specific issues to fix
+    VERSION = "#{::Builder::VERSION}.1"
+  end
+end

data/opal/opal/builder/xmlbase.rb ADDED Viewed

@@ -0,0 +1,68 @@
+require 'opal/builder/builder_mutable_string'
+require 'opal/builder/builder_symbol'
+class Builder::XmlBase
+  def method_missing(sym, *args, &block)
+    # Omitting cache_method_calls because it causes problems
+    # Code in tag cares whether things are actually symbols and method names should be, so "create" them
+    tag!(BuilderSymbol.new(sym), *args, &block)
+  end
+  def tag!(sym, *args, &block)
+    text = nil
+    attrs = nil
+    sym = "#{sym}:#{args.shift}" if args.first.kind_of?(::BuilderSymbol)
+    unless sym.class == ::BuilderSymbol
+      riase "not sure how to convert sym, which is class #{sym.class} and value #{sym} to a symbol"
+    end
+    sym = sym.to_sym unless sym.class == ::BuilderSymbol
+    args.each do |arg|
+      case arg
+      when ::Hash
+        attrs ||= {}
+        attrs.merge!(arg)
+      when nil
+        attrs ||= {}
+        attrs.merge!({:nil => true}) if explicit_nil_handling?
+      else
+        # Changed this from text ||= ''
+        text ||= BuilderMutableString.new ''
+        text << arg.to_s
+      end
+    end
+    if block
+      unless text.nil?
+        ::Kernel::raise ::ArgumentError,
+          "XmlMarkup cannot mix a text argument with a block"
+      end
+      _indent
+      _start_tag(sym, attrs)
+      _newline
+      begin
+        _nested_structures(block)
+      ensure
+        _indent
+        _end_tag(sym)
+        _newline
+      end
+    elsif text.nil?
+      _indent
+      _start_tag(sym, attrs, true)
+      _newline
+    else
+      _indent
+      _start_tag(sym, attrs)
+      text! text
+      _end_tag(sym)
+      _newline
+    end
+    @target
+  end
+  # Not supporting escaping, but do need to ensure we're using mutable strings
+  def _escape(text)
+    ensure_mutable = text.is_a?(BuilderMutableString) ? text : BuilderMutableString.new(text)
+    ensure_mutable.to_xs
+  end
+end

data/opal/opal/builder/xmlmarkup.rb ADDED Viewed

@@ -0,0 +1,28 @@
+require 'opal/builder/builder_mutable_string'
+require 'opal/builder/builder_symbol'
+class Builder::XmlMarkup
+  # Try and avoid a bunch of string mutation changes
+  def initialize(options={})
+    indent = options[:indent] || 0
+    margin = options[:margin] || 0
+    @quote = (options[:quote] == :single) ? "'" : '"'
+    @explicit_nil_handling = options[:explicit_nil_handling]
+    super(indent, margin)
+    @target = options[:target] || BuilderMutableString.new("")
+  end
+  # all strings will be symbols, so we have to change the case statement
+  def _attr_value(value)
+    case value
+    when ::BuilderSymbol
+      value.to_s
+    else
+      _escape_attribute(value.to_s)
+    end
+  end
+  def declare!(inst, *args, &block)
+    ::Kernel.raise 'declare! is not currently supported on Opal because symbols cannot be detected easily.'
+  end
+end

data/opal-builder.gemspec ADDED Viewed

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$: << File.expand_path('../builder/lib', __FILE__)
+require File.expand_path('../opal/opal/builder/version', __FILE__)
+Gem::Specification.new do |s|
+  s.name         = 'opal-builder'
+  s.version      =  Opal::OpalBuilder::VERSION
+  s.author       = 'Brady Wied'
+  s.email        = 'brady@bswtechconsulting.com'
+  s.summary      = 'Builder for Opal'
+  s.description  = 'Opal compatible builder library'
+  s.files = `git ls-files`.split("\n") + Dir.glob('builder/lib/**/*.rb')
+  s.require_paths  = ['lib']
+  s.add_dependency 'opal', ['>= 0.7.0', '< 0.9']
+  s.add_development_dependency 'rake'
+end