rubyjobbuilderdsl 0.0.0 → 0.0.1

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/sax/document.rb

@@ -0,0 +1,171 @@
+module Nokogiri
+  module XML
+    ###
+    # SAX Parsers are event driven parsers.  Nokogiri provides two different
+    # event based parsers when dealing with XML.  If you want to do SAX style
+    # parsing using HTML, check out Nokogiri::HTML::SAX.
+    #
+    # The basic way a SAX style parser works is by creating a parser,
+    # telling the parser about the events we're interested in, then giving
+    # the parser some XML to process.  The parser will notify you when
+    # it encounters events you said you would like to know about.
+    #
+    # To register for events, you simply subclass Nokogiri::XML::SAX::Document,
+    # and implement the methods for which you would like notification.
+    #
+    # For example, if I want to be notified when a document ends, and when an
+    # element starts, I would write a class like this:
+    #
+    #   class MyDocument < Nokogiri::XML::SAX::Document
+    #     def end_document
+    #       puts "the document has ended"
+    #     end
+    #
+    #     def start_element name, attributes = []
+    #       puts "#{name} started"
+    #     end
+    #   end
+    #
+    # Then I would instantiate a SAX parser with this document, and feed the
+    # parser some XML
+    #
+    #   # Create a new parser
+    #   parser = Nokogiri::XML::SAX::Parser.new(MyDocument.new)
+    #
+    #   # Feed the parser some XML
+    #   parser.parse(File.open(ARGV[0]))
+    #
+    # Now my document handler will be called when each node starts, and when
+    # then document ends.  To see what kinds of events are available, take
+    # a look at Nokogiri::XML::SAX::Document.
+    #
+    # Two SAX parsers for XML are available, a parser that reads from a string
+    # or IO object as it feels necessary, and a parser that lets you spoon
+    # feed it XML.  If you want to let Nokogiri deal with reading your XML,
+    # use the Nokogiri::XML::SAX::Parser.  If you want to have fine grain
+    # control over the XML input, use the Nokogiri::XML::SAX::PushParser.
+    module SAX
+      ###
+      # This class is used for registering types of events you are interested
+      # in handling.  All of the methods on this class are available as
+      # possible events while parsing an XML document.  To register for any
+      # particular event, just subclass this class and implement the methods
+      # you are interested in knowing about.
+      #
+      # To only be notified about start and end element events, write a class
+      # like this:
+      #
+      #   class MyDocument < Nokogiri::XML::SAX::Document
+      #     def start_element name, attrs = []
+      #       puts "#{name} started!"
+      #     end
+      #
+      #     def end_element name
+      #       puts "#{name} ended"
+      #     end
+      #   end
+      #
+      # You can use this event handler for any SAX style parser included with
+      # Nokogiri.  See Nokogiri::XML::SAX, and Nokogiri::HTML::SAX.
+      class Document
+        ###
+        # Called when an XML declaration is parsed
+        def xmldecl version, encoding, standalone
+        end
+
+        ###
+        # Called when document starts parsing
+        def start_document
+        end
+
+        ###
+        # Called when document ends parsing
+        def end_document
+        end
+
+        ###
+        # Called at the beginning of an element
+        # * +name+ is the name of the tag
+        # * +attrs+ are an assoc list of namespaces and attributes, e.g.:
+        #     [ ["xmlns:foo", "http://sample.net"], ["size", "large"] ]
+        def start_element name, attrs = []
+        end
+
+        ###
+        # Called at the end of an element
+        # +name+ is the tag name
+        def end_element name
+        end
+
+        ###
+        # Called at the beginning of an element
+        # +name+ is the element name
+        # +attrs+ is a list of attributes
+        # +prefix+ is the namespace prefix for the element
+        # +uri+ is the associated namespace URI
+        # +ns+ is a hash of namespace prefix:urls associated with the element
+        def start_element_namespace name, attrs = [], prefix = nil, uri = nil, ns = []
+          ###
+          # Deal with SAX v1 interface
+          name = [prefix, name].compact.join(':')
+          attributes = ns.map { |ns_prefix,ns_uri|
+            [['xmlns', ns_prefix].compact.join(':'), ns_uri]
+          } + attrs.map { |attr|
+            [[attr.prefix, attr.localname].compact.join(':'), attr.value]
+          }
+          start_element name, attributes
+        end
+
+        ###
+        # Called at the end of an element
+        # +name+ is the element's name
+        # +prefix+ is the namespace prefix associated with the element
+        # +uri+ is the associated namespace URI
+        def end_element_namespace name, prefix = nil, uri = nil
+          ###
+          # Deal with SAX v1 interface
+          end_element [prefix, name].compact.join(':')
+        end
+
+        ###
+        # Characters read between a tag.  This method might be called multiple
+        # times given one contiguous string of characters.
+        #
+        # +string+ contains the character data
+        def characters string
+        end
+
+        ###
+        # Called when comments are encountered
+        # +string+ contains the comment data
+        def comment string
+        end
+
+        ###
+        # Called on document warnings
+        # +string+ contains the warning
+        def warning string
+        end
+
+        ###
+        # Called on document errors
+        # +string+ contains the error
+        def error string
+        end
+
+        ###
+        # Called when cdata blocks are found
+        # +string+ contains the cdata content
+        def cdata_block string
+        end
+
+        ###
+        # Called when processing instructions are found
+        # +name+ is the target of the instruction
+        # +content+ is the value of the instruction
+        def processing_instruction name, content
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/sax/parser.rb

@@ -0,0 +1,123 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # This parser is a SAX style parser that reads it's input as it
+      # deems necessary.  The parser takes a Nokogiri::XML::SAX::Document,
+      # an optional encoding, then given an XML input, sends messages to
+      # the Nokogiri::XML::SAX::Document.
+      #
+      # Here is an example of using this parser:
+      #
+      #   # Create a subclass of Nokogiri::XML::SAX::Document and implement
+      #   # the events we care about:
+      #   class MyDoc < Nokogiri::XML::SAX::Document
+      #     def start_element name, attrs = []
+      #       puts "starting: #{name}"
+      #     end
+      #
+      #     def end_element name
+      #       puts "ending: #{name}"
+      #     end
+      #   end
+      #
+      #   # Create our parser
+      #   parser = Nokogiri::XML::SAX::Parser.new(MyDoc.new)
+      #
+      #   # Send some XML to the parser
+      #   parser.parse(File.open(ARGV[0]))
+      #
+      # For more information about SAX parsers, see Nokogiri::XML::SAX.  Also
+      # see Nokogiri::XML::SAX::Document for the available events.
+      class Parser
+        class Attribute < Struct.new(:localname, :prefix, :uri, :value)
+        end
+
+        # Encodinds this parser supports
+        ENCODINGS = {
+          'NONE'        => 0, # No char encoding detected
+          'UTF-8'       => 1, # UTF-8
+          'UTF16LE'     => 2, # UTF-16 little endian
+          'UTF16BE'     => 3, # UTF-16 big endian
+          'UCS4LE'      => 4, # UCS-4 little endian
+          'UCS4BE'      => 5, # UCS-4 big endian
+          'EBCDIC'      => 6, # EBCDIC uh!
+          'UCS4-2143'   => 7, # UCS-4 unusual ordering
+          'UCS4-3412'   => 8, # UCS-4 unusual ordering
+          'UCS2'        => 9, # UCS-2
+          'ISO-8859-1'  => 10, # ISO-8859-1 ISO Latin 1
+          'ISO-8859-2'  => 11, # ISO-8859-2 ISO Latin 2
+          'ISO-8859-3'  => 12, # ISO-8859-3
+          'ISO-8859-4'  => 13, # ISO-8859-4
+          'ISO-8859-5'  => 14, # ISO-8859-5
+          'ISO-8859-6'  => 15, # ISO-8859-6
+          'ISO-8859-7'  => 16, # ISO-8859-7
+          'ISO-8859-8'  => 17, # ISO-8859-8
+          'ISO-8859-9'  => 18, # ISO-8859-9
+          'ISO-2022-JP' => 19, # ISO-2022-JP
+          'SHIFT-JIS'   => 20, # Shift_JIS
+          'EUC-JP'      => 21, # EUC-JP
+          'ASCII'       => 22, # pure ASCII
+        }
+
+        # The Nokogiri::XML::SAX::Document where events will be sent.
+        attr_accessor :document
+
+        # The encoding beings used for this document.
+        attr_accessor :encoding
+
+        # Create a new Parser with +doc+ and +encoding+
+        def initialize doc = Nokogiri::XML::SAX::Document.new, encoding = 'UTF-8'
+          check_encoding(encoding)
+          @encoding = encoding
+          @document = doc
+          @warned   = false
+        end
+
+        ###
+        # Parse given +thing+ which may be a string containing xml, or an
+        # IO object.
+        def parse thing, &block
+          if thing.respond_to?(:read) && thing.respond_to?(:close)
+            parse_io(thing, &block)
+          else
+            parse_memory(thing, &block)
+          end
+        end
+
+        ###
+        # Parse given +io+
+        def parse_io io, encoding = 'ASCII'
+          check_encoding(encoding)
+          @encoding = encoding
+          ctx = ParserContext.io(io, ENCODINGS[encoding])
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        ###
+        # Parse a file with +filename+
+        def parse_file filename
+          raise ArgumentError unless filename
+          raise Errno::ENOENT unless File.exist?(filename)
+          raise Errno::EISDIR if File.directory?(filename)
+          ctx = ParserContext.file filename
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        def parse_memory data
+          ctx = ParserContext.memory data
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        private
+        def check_encoding(encoding)
+          encoding.upcase!
+          raise ArgumentError.new("'#{encoding}' is not a valid encoding") unless ENCODINGS[encoding]
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/sax/parser_context.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # Context for XML SAX parsers.  This class is usually not instantiated
+      # by the user.  Instead, you should be looking at
+      # Nokogiri::XML::SAX::Parser
+      class ParserContext
+        def self.new thing, encoding = 'UTF-8'
+          [:read, :close].all? { |x| thing.respond_to?(x) } ?
+            io(thing, Parser::ENCODINGS[encoding]) : memory(thing)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/sax/push_parser.rb

@@ -0,0 +1,60 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # PushParser can parse a document that is fed to it manually.  It
+      # must be given a SAX::Document object which will be called with
+      # SAX events as the document is being parsed.
+      #
+      # Calling PushParser#<< writes XML to the parser, calling any SAX
+      # callbacks it can.
+      #
+      # PushParser#finish tells the parser that the document is finished
+      # and calls the end_document SAX method.
+      #
+      # Example:
+      #
+      #   parser = PushParser.new(Class.new(XML::SAX::Document) {
+      #     def start_document
+      #       puts "start document called"
+      #     end
+      #   }.new)
+      #   parser << "<div>hello<"
+      #   parser << "/div>"
+      #   parser.finish
+      class PushParser
+
+        # The Nokogiri::XML::SAX::Document on which the PushParser will be
+        # operating
+        attr_accessor :document
+
+        ###
+        # Create a new PushParser with +doc+ as the SAX Document, providing
+        # an optional +file_name+ and +encoding+
+        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+          @document = doc
+          @encoding = encoding
+          @sax_parser = XML::SAX::Parser.new(doc)
+
+          ## Create our push parser context
+          initialize_native(@sax_parser, file_name)
+        end
+
+        ###
+        # Write a +chunk+ of XML to the PushParser.  Any callback methods
+        # that can be called will be called immediately.
+        def write chunk, last_chunk = false
+          native_write(chunk, last_chunk)
+        end
+        alias :<< :write
+
+        ###
+        # Finish the parsing.  This method is only necessary for
+        # Nokogiri::XML::SAX::Document#end_document to be called.
+        def finish
+          write '', true
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/sax.rb

@@ -0,0 +1,4 @@
+require 'nokogiri/xml/sax/document'
+require 'nokogiri/xml/sax/parser_context'
+require 'nokogiri/xml/sax/parser'
+require 'nokogiri/xml/sax/push_parser'

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/schema.rb

@@ -0,0 +1,63 @@
+module Nokogiri
+  module XML
+    class << self
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def Schema string_or_io
+        Schema.new(string_or_io)
+      end
+    end
+
+    ###
+    # Nokogiri::XML::Schema is used for validating XML against a schema
+    # (usually from an xsd file).
+    #
+    # == Synopsis
+    #
+    # Validate an XML document against a Schema.  Loop over the errors that
+    # are returned and print them out:
+    #
+    #   xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
+    #   doc = Nokogiri::XML(File.read(PO_XML_FILE))
+    #
+    #   xsd.validate(doc).each do |error|
+    #     puts error.message
+    #   end
+    #
+    # The list of errors are Nokogiri::XML::SyntaxError objects.
+    class Schema
+      # Errors while parsing the schema file
+      attr_accessor :errors
+
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def self.new string_or_io
+        from_document Nokogiri::XML(string_or_io)
+      end
+
+      ###
+      # Validate +thing+ against this schema.  +thing+ can be a
+      # Nokogiri::XML::Document object, or a filename.  An Array of
+      # Nokogiri::XML::SyntaxError objects found while validating the
+      # +thing+ is returned.
+      def validate thing
+        if thing.is_a?(Nokogiri::XML::Document) 
+          validate_document(thing) 
+        elsif File.file?(thing)
+          validate_file(thing)
+        else
+          raise ArgumentError, "Must provide Nokogiri::Xml::Document or the name of an existing file"
+        end
+      end
+
+      ###
+      # Returns true if +thing+ is a valid Nokogiri::XML::Document or
+      # file.
+      def valid? thing
+        validate(thing).length == 0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/syntax_error.rb

@@ -0,0 +1,47 @@
+module Nokogiri
+  module XML
+    ###
+    # This class provides information about XML SyntaxErrors.  These
+    # exceptions are typically stored on Nokogiri::XML::Document#errors.
+    class SyntaxError < ::Nokogiri::SyntaxError
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+
+      ###
+      # return true if this is a non error
+      def none?
+        level == 0
+      end
+
+      ###
+      # return true if this is a warning
+      def warning?
+        level == 1
+      end
+
+      ###
+      # return true if this is an error
+      def error?
+        level == 2
+      end
+
+      ###
+      # return true if this error is fatal
+      def fatal?
+        level == 3
+      end
+
+      def to_s
+        super.chomp
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/text.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class Text < Nokogiri::XML::CharacterData
+      def content=(string)
+        self.native_content = string.to_s
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/xpath/syntax_error.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class XPath
+      class SyntaxError < XML::SyntaxError
+        def to_s
+          [super.chomp, str1].compact.join(': ')
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/xpath.rb

@@ -0,0 +1,10 @@
+require 'nokogiri/xml/xpath/syntax_error'
+
+module Nokogiri
+  module XML
+    class XPath
+      # The Nokogiri::XML::Document tied to this XPath instance
+      attr_accessor :document
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml/xpath_context.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module XML
+    class XPathContext
+
+      ###
+      # Register namespaces in +namespaces+
+      def register_namespaces(namespaces)
+        namespaces.each do |k, v|
+          k = k.to_s.gsub(/.*:/,'') # strip off 'xmlns:' or 'xml:'
+          register_ns(k, v)
+        end
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xml.rb

@@ -0,0 +1,73 @@
+require 'nokogiri/xml/pp'
+require 'nokogiri/xml/parse_options'
+require 'nokogiri/xml/sax'
+require 'nokogiri/xml/node'
+require 'nokogiri/xml/attribute_decl'
+require 'nokogiri/xml/element_decl'
+require 'nokogiri/xml/element_content'
+require 'nokogiri/xml/character_data'
+require 'nokogiri/xml/namespace'
+require 'nokogiri/xml/attr'
+require 'nokogiri/xml/dtd'
+require 'nokogiri/xml/cdata'
+require 'nokogiri/xml/text'
+require 'nokogiri/xml/document'
+require 'nokogiri/xml/document_fragment'
+require 'nokogiri/xml/processing_instruction'
+require 'nokogiri/xml/node_set'
+require 'nokogiri/xml/syntax_error'
+require 'nokogiri/xml/xpath'
+require 'nokogiri/xml/xpath_context'
+require 'nokogiri/xml/builder'
+require 'nokogiri/xml/reader'
+require 'nokogiri/xml/notation'
+require 'nokogiri/xml/entity_decl'
+require 'nokogiri/xml/schema'
+require 'nokogiri/xml/relax_ng'
+
+module Nokogiri
+  class << self
+    ###
+    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    def XML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block
+      Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
+    end
+  end
+
+  module XML
+    # Original C14N 1.0 spec canonicalization
+    XML_C14N_1_0 =       0
+    # Exclusive C14N 1.0 spec canonicalization
+    XML_C14N_EXCLUSIVE_1_0 =     1
+    # C14N 1.1 spec canonicalization
+    XML_C14N_1_1 = 2
+    class << self
+      ###
+      # Parse an XML document using the Nokogiri::XML::Reader API.  See
+      # Nokogiri::XML::Reader for mor information
+      def Reader string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT
+
+        options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
+        # Give the options to the user
+        yield options if block_given?
+
+        if string_or_io.respond_to? :read
+          return Reader.from_io(string_or_io, url, encoding, options.to_i)
+        end
+        Reader.from_memory(string_or_io, url, encoding, options.to_i)
+      end
+
+      ###
+      # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
+        Document.parse(thing, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string
+        XML::DocumentFragment.parse(string)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.1.0/gems/nokogiri-1.6.3.1-x64-mingw32/lib/nokogiri/xslt/stylesheet.rb

@@ -0,0 +1,25 @@
+module Nokogiri
+  module XSLT
+    ###
+    # A Stylesheet represents an XSLT Stylesheet object.  Stylesheet creation
+    # is done through Nokogiri.XSLT.  Here is an example of transforming
+    # an XML::Document with a Stylesheet:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #
+    #   puts xslt.transform(doc)
+    #
+    # See Nokogiri::XSLT::Stylesheet#transform for more transformation
+    # information.
+    class Stylesheet
+      ###
+      # Apply an XSLT stylesheet to an XML::Document.
+      # +params+ is an array of strings used as XSLT parameters.
+      # returns serialized document
+      def apply_to document, params = []
+        serialize(transform(document, params))
+      end
+    end
+  end
+end