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

opal-builder 3.2.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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