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/node_set.rb

@@ -0,0 +1,355 @@
+module Nokogiri
+  module XML
+    ####
+    # A NodeSet contains a list of Nokogiri::XML::Node objects.  Typically
+    # a NodeSet is return as a result of searching a Document via
+    # Nokogiri::XML::Node#css or Nokogiri::XML::Node#xpath
+    class NodeSet
+      include Enumerable
+
+      # The Document this NodeSet is associated with
+      attr_accessor :document
+
+      # Create a NodeSet with +document+ defaulting to +list+
+      def initialize document, list = []
+        @document = document
+        document.decorate(self)
+        list.each { |x| self << x }
+        yield self if block_given?
+      end
+
+      ###
+      # Get the first element of the NodeSet.
+      def first n = nil
+        return self[0] unless n
+        list = []
+        n.times { |i| list << self[i] }
+        list
+      end
+
+      ###
+      # Get the last element of the NodeSet.
+      def last
+        self[-1]
+      end
+
+      ###
+      # Is this NodeSet empty?
+      def empty?
+        length == 0
+      end
+
+      ###
+      # Returns the index of the first node in self that is == to +node+. Returns nil if no match is found.
+      def index(node)
+        each_with_index { |member, j| return j if member == node }
+        nil
+      end
+
+      ###
+      # Insert +datum+ before the first Node in this NodeSet
+      def before datum
+        first.before datum
+      end
+
+      ###
+      # Insert +datum+ after the last Node in this NodeSet
+      def after datum
+        last.after datum
+      end
+
+      alias :<< :push
+      alias :remove :unlink
+
+      ###
+      # Search this document for +paths+
+      #
+      # For more information see Nokogiri::XML::Node#css and
+      # Nokogiri::XML::Node#xpath
+      def search *paths
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
+
+        sub_set = NodeSet.new(document)
+
+        paths.each do |path|
+          sub_set += send(
+            path =~ /^(\.\/|\/|\.\.|\.$)/ ? :xpath : :css,
+            *(paths + [ns, handler]).compact
+          )
+        end
+
+        document.decorate(sub_set)
+        sub_set
+      end
+      alias :/ :search
+
+      ###
+      # Search this NodeSet for css +paths+
+      #
+      # For more information see Nokogiri::XML::Node#css
+      def css *paths
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
+
+        sub_set = NodeSet.new(document)
+
+        each do |node|
+          doc = node.document
+          search_ns = ns || (doc.root ? doc.root.namespaces : {})
+
+          xpaths = paths.map { |rule|
+            [
+              CSS.xpath_for(rule.to_s, :prefix => ".//", :ns => search_ns),
+              CSS.xpath_for(rule.to_s, :prefix => "self::", :ns => search_ns)
+            ].join(' | ')
+          }
+
+          sub_set += node.xpath(*(xpaths + [search_ns, handler].compact))
+        end
+        document.decorate(sub_set)
+        sub_set
+      end
+
+      ###
+      # Search this NodeSet for XPath +paths+
+      #
+      # For more information see Nokogiri::XML::Node#xpath
+      def xpath *paths
+        handler = ![
+          Hash, String, Symbol
+        ].include?(paths.last.class) ? paths.pop : nil
+
+        ns = paths.last.is_a?(Hash) ? paths.pop : nil
+
+        sub_set = NodeSet.new(document)
+        each do |node|
+          sub_set += node.xpath(*(paths + [ns, handler].compact))
+        end
+        document.decorate(sub_set)
+        sub_set
+      end
+
+      ###
+      # Search this NodeSet's nodes' immediate children using CSS selector +selector+
+      def > selector
+        ns = document.root.namespaces
+        xpath CSS.xpath_for(selector, :prefix => "./", :ns => ns).first
+      end
+
+      ###
+      # If path is a string, search this document for +path+ returning the
+      # first Node.  Otherwise, index in to the array with +path+.
+      def at path, ns = document.root ? document.root.namespaces : {}
+        return self[path] if path.is_a?(Numeric)
+        search(path, ns).first
+      end
+      alias :% :at
+
+      ##
+      # Search this NodeSet for the first occurrence of XPath +paths+.
+      # Equivalent to <tt>xpath(paths).first</tt>
+      # See NodeSet#xpath for more information.
+      #
+      def at_xpath *paths
+        xpath(*paths).first
+      end
+
+      ##
+      # Search this NodeSet for the first occurrence of CSS +rules+.
+      # Equivalent to <tt>css(rules).first</tt>
+      # See NodeSet#css for more information.
+      #
+      def at_css *rules
+        css(*rules).first
+      end
+
+      ###
+      # Filter this list for nodes that match +expr+
+      def filter expr
+        find_all { |node| node.matches?(expr) }
+      end
+
+      ###
+      # Append the class attribute +name+ to all Node objects in the NodeSet.
+      def add_class name
+        each do |el|
+          classes = el['class'].to_s.split(/\s+/)
+          el['class'] = classes.push(name).uniq.join " "
+        end
+        self
+      end
+
+      ###
+      # Remove the class attribute +name+ from all Node objects in the NodeSet.
+      # If +name+ is nil, remove the class attribute from all Nodes in the
+      # NodeSet.
+      def remove_class name = nil
+        each do |el|
+          if name
+            classes = el['class'].to_s.split(/\s+/)
+            if classes.empty?
+              el.delete 'class'
+            else
+              el['class'] = (classes - [name]).uniq.join " "
+            end
+          else
+            el.delete "class"
+          end
+        end
+        self
+      end
+
+      ###
+      # Set the attribute +key+ to +value+ or the return value of +blk+
+      # on all Node objects in the NodeSet.
+      def attr key, value = nil, &blk
+        unless Hash === key || key && (value || blk)
+          return first.attribute(key)
+        end
+
+        hash = key.is_a?(Hash) ? key : { key => value }
+
+        hash.each { |k,v| each { |el| el[k] = v || blk[el] } }
+
+        self
+      end
+      alias :set :attr
+      alias :attribute :attr
+
+      ###
+      # Remove the attributed named +name+ from all Node objects in the NodeSet
+      def remove_attr name
+        each { |el| el.delete name }
+        self
+      end
+
+      ###
+      # Iterate over each node, yielding  to +block+
+      def each(&block)
+        0.upto(length - 1) do |x|
+          yield self[x]
+        end
+      end
+
+      ###
+      # Get the inner text of all contained Node objects
+      def inner_text
+        collect{|j| j.inner_text}.join('')
+      end
+      alias :text :inner_text
+
+      ###
+      # Get the inner html of all contained Node objects
+      def inner_html *args
+        collect{|j| j.inner_html(*args) }.join('')
+      end
+
+      ###
+      # Wrap this NodeSet with +html+ or the results of the builder in +blk+
+      def wrap(html, &blk)
+        each do |j|
+          new_parent = document.parse(html).first
+          j.add_next_sibling(new_parent)
+          new_parent.add_child(j)
+        end
+        self
+      end
+
+      ###
+      # Convert this NodeSet to a string.
+      def to_s
+        map { |x| x.to_s }.join
+      end
+
+      ###
+      # Convert this NodeSet to HTML
+      def to_html *args
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
+          end
+          args.insert(0, options)
+        end
+        map { |x| x.to_html(*args) }.join
+      end
+
+      ###
+      # Convert this NodeSet to XHTML
+      def to_xhtml *args
+        map { |x| x.to_xhtml(*args) }.join
+      end
+
+      ###
+      # Convert this NodeSet to XML
+      def to_xml *args
+        map { |x| x.to_xml(*args) }.join
+      end
+
+      alias :size :length
+      alias :to_ary :to_a
+
+      ###
+      # Removes the last element from set and returns it, or +nil+ if
+      # the set is empty
+      def pop
+        return nil if length == 0
+        delete last
+      end
+
+      ###
+      # Returns the first element of the NodeSet and removes it.  Returns
+      # +nil+ if the set is empty.
+      def shift
+        return nil if length == 0
+        delete first
+      end
+
+      ###
+      # Equality -- Two NodeSets are equal if the contain the same number
+      # of elements and if each element is equal to the corresponding
+      # element in the other NodeSet
+      def == other
+        return false unless other.is_a?(Nokogiri::XML::NodeSet)
+        return false unless length == other.length
+        each_with_index do |node, i|
+          return false unless node == other[i]
+        end
+        true
+      end
+
+      ###
+      # Returns a new NodeSet containing all the children of all the nodes in
+      # the NodeSet
+      def children
+        inject(NodeSet.new(document)) { |set, node| set += node.children }
+      end
+
+      ###
+      # Returns a new NodeSet containing all the nodes in the NodeSet
+      # in reverse order
+      def reverse
+        node_set = NodeSet.new(document)
+        (length - 1).downto(0) do |x|
+          node_set.push self[x]
+        end
+        node_set
+      end
+
+      ###
+      # Return a nicely formated string representation
+      def inspect
+        "[#{map { |c| c.inspect }.join ', '}]"
+      end
+
+      alias :+ :|
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Nokogiri
+  module XML
+    class Notation < Struct.new(:name, :public_id, :system_id)
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Nokogiri
+  module XML
+    ###
+    # Parse options for passing to Nokogiri.XML or Nokogiri.HTML
+    class ParseOptions
+      # Strict parsing
+      STRICT      = 0
+      # Recover from errors
+      RECOVER     = 1 << 0
+      # Substitute entities
+      NOENT       = 1 << 1
+      # Load external subsets
+      DTDLOAD     = 1 << 2
+      # Default DTD attributes
+      DTDATTR     = 1 << 3
+      # validate with the DTD
+      DTDVALID    = 1 << 4
+      # suppress error reports
+      NOERROR     = 1 << 5
+      # suppress warning reports
+      NOWARNING   = 1 << 6
+      # pedantic error reporting
+      PEDANTIC    = 1 << 7
+      # remove blank nodes
+      NOBLANKS    = 1 << 8
+      # use the SAX1 interface internally
+      SAX1        = 1 << 9
+      # Implement XInclude substitution
+      XINCLUDE    = 1 << 10
+      # Forbid network access. Recommended for dealing with untrusted documents.
+      NONET       = 1 << 11
+      # Do not reuse the context dictionary
+      NODICT      = 1 << 12
+      # remove redundant namespaces declarations
+      NSCLEAN     = 1 << 13
+      # merge CDATA as text nodes
+      NOCDATA     = 1 << 14
+      # do not generate XINCLUDE START/END nodes
+      NOXINCNODE  = 1 << 15
+      # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
+      COMPACT     = 1 << 16
+      # parse using XML-1.0 before update 5
+      OLD10       = 1 << 17
+      # do not fixup XINCLUDE xml:base uris
+      NOBASEFIX   = 1 << 18
+      # relax any hardcoded limit from the parser
+      HUGE        = 1 << 19
+
+      # the default options used for parsing XML documents
+      DEFAULT_XML  = RECOVER | NONET
+      # the default options used for parsing HTML documents
+      DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET
+
+      attr_accessor :options
+      def initialize options = STRICT
+        @options = options
+      end
+
+      constants.each do |constant|
+        next if constant.to_sym == :STRICT
+        class_eval %{
+          def #{constant.downcase}
+            @options |= #{constant}
+            self
+          end
+
+          def no#{constant.downcase}
+            @options &= ~#{constant}
+            self
+          end
+
+          def #{constant.downcase}?
+            #{constant} & @options == #{constant}
+          end
+        }
+      end
+
+      def strict
+        @options &= ~RECOVER
+        self
+      end
+
+      def strict?
+        @options & RECOVER == STRICT
+      end
+
+      alias :to_i :options
+
+      def inspect
+        options = []
+        self.class.constants.each do |k|
+          options << k.downcase if send(:"#{k.downcase}?")
+        end
+        super.sub(/>$/, " " + options.join(', ') + ">")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    module PP
+      module CharacterData
+        def pretty_print pp # :nodoc:
+          nice_name = self.class.name.split('::').last
+          pp.group(2, "#(#{nice_name} ", ')') do
+            pp.pp text
+          end
+        end
+
+        def inspect # :nodoc:
+          "#<#{self.class.name}:#{sprintf("0x%x",object_id)} #{text.inspect}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Nokogiri
+  module XML
+    module PP
+      module Node
+        def inspect # :nodoc:
+          attributes = inspect_attributes.reject { |x|
+            begin
+              attribute = send x
+              !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
+            rescue NoMethodError
+              true
+            end
+          }.map { |attribute|
+            "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
+          }.join ' '
+          "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
+        end
+
+        def pretty_print pp # :nodoc:
+          nice_name = self.class.name.split('::').last
+          pp.group(2, "#(#{nice_name}:#{sprintf("0x%x", object_id)} {", '})') do
+
+            pp.breakable
+            attrs = inspect_attributes.map { |t|
+              [t, send(t)] if respond_to?(t)
+            }.compact.find_all { |x|
+              if x.last
+                if [:attribute_nodes, :children].include? x.first
+                  !x.last.empty?
+                else
+                  true
+                end
+              end
+            }
+
+            pp.seplist(attrs) do |v|
+              if [:attribute_nodes, :children].include? v.first
+                pp.group(2, "#{v.first.to_s.sub(/_\w+$/, 's')} = [", "]") do
+                  pp.breakable
+                  pp.seplist(v.last) do |item|
+                    pp.pp item
+                  end
+                end
+              else
+                pp.text "#{v.first} = "
+                pp.pp v.last
+              end
+            end
+            pp.breakable
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+require 'nokogiri/xml/pp/node'
+require 'nokogiri/xml/pp/character_data'

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

@@ -0,0 +1,8 @@
+module Nokogiri
+  module XML
+    class ProcessingInstruction < Node
+      def initialize document, name, content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Nokogiri
+  module XML
+    ###
+    # Nokogiri::XML::Reader parses an XML document similar to the way a cursor
+    # would move.  The Reader is given an XML document, and yields nodes
+    # to an each block.
+    #
+    # Here is an example of usage:
+    #
+    #   reader = Nokogiri::XML::Reader(<<-eoxml)
+    #     <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+    #       <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    #     </x>
+    #   eoxml
+    #
+    #   reader.each do |node|
+    #
+    #     # node is an instance of Nokogiri::XML::Reader
+    #     puts node.name
+    #
+    #   end
+    #
+    # Note that Nokogiri::XML::Reader#each can only be called once!!  Once
+    # the cursor moves through the entire document, you must parse the
+    # document again.  So make sure that you capture any information you
+    # need during the first iteration.
+    #
+    # The Reader parser is good for when you need the speed of a SAX parser,
+    # but do not want to write a Document handler.
+    class Reader
+      include Enumerable
+
+      TYPE_NONE = 0
+      # Element node type
+      TYPE_ELEMENT = 1
+      # Attribute node type
+      TYPE_ATTRIBUTE = 2
+      # Text node type
+      TYPE_TEXT = 3
+      # CDATA node type
+      TYPE_CDATA = 4
+      # Entity Reference node type
+      TYPE_ENTITY_REFERENCE = 5
+      # Entity node type
+      TYPE_ENTITY = 6
+      # PI node type
+      TYPE_PROCESSING_INSTRUCTION = 7
+      # Comment node type
+      TYPE_COMMENT = 8
+      # Document node type
+      TYPE_DOCUMENT = 9
+      # Document Type node type
+      TYPE_DOCUMENT_TYPE = 10
+      # Document Fragment node type
+      TYPE_DOCUMENT_FRAGMENT = 11
+      # Notation node type
+      TYPE_NOTATION = 12
+      # Whitespace node type
+      TYPE_WHITESPACE = 13
+      # Significant Whitespace node type
+      TYPE_SIGNIFICANT_WHITESPACE = 14
+      # Element end node type
+      TYPE_END_ELEMENT = 15
+      # Entity end node type
+      TYPE_END_ENTITY = 16
+      # XML Declaration node type
+      TYPE_XML_DECLARATION = 17
+
+      # A list of errors encountered while parsing
+      attr_accessor :errors
+
+      # The encoding for the document
+      attr_reader :encoding
+
+      # The XML source
+      attr_reader :source
+
+      alias :self_closing? :empty_element?
+
+      def initialize source, url = nil, encoding = nil # :nodoc:
+        @source   = source
+        @errors   = []
+        @encoding = encoding
+      end
+      private :initialize
+
+      ###
+      # Get a list of attributes for the current node.
+      def attributes
+        Hash[attribute_nodes.map { |node|
+          [node.name, node.to_s]
+        }].merge(namespaces || {})
+      end
+
+      ###
+      # Get a list of attributes for the current node
+      def attribute_nodes
+        nodes = attr_nodes
+        nodes.each { |v| v.instance_variable_set(:@_r, self) }
+        nodes
+      end
+
+      ###
+      # Move the cursor through the document yielding the cursor to the block
+      def each
+        while cursor = self.read
+          yield cursor
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Nokogiri
+  module XML
+    class << self
+      ###
+      # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
+      # See Nokogiri::XML::RelaxNG for an example.
+      def RelaxNG string_or_io
+        RelaxNG.new(string_or_io)
+      end
+    end
+
+    ###
+    # Nokogiri::XML::RelaxNG is used for validating XML against a
+    # RelaxNG schema.
+    #
+    # == Synopsis
+    #
+    # Validate an XML document against a RelaxNG schema.  Loop over the errors
+    # that are returned and print them out:
+    #
+    #   schema  = Nokogiri::XML::RelaxNG(File.open(ADDRESS_SCHEMA_FILE))
+    #   doc     = Nokogiri::XML(File.open(ADDRESS_XML_FILE))
+    #
+    #   schema.validate(doc).each do |error|
+    #     puts error.message
+    #   end
+    #
+    # The list of errors are Nokogiri::XML::SyntaxError objects.
+    class RelaxNG < Nokogiri::XML::Schema
+    end
+  end
+end