domo 0.0.3 → 0.0.4

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/ffi/xml/text.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    class Text < CharacterData
+
+      def self.new(string, document, *rest) # :nodoc:
+        node_ptr = LibXML.xmlNewText(string)
+        node_cstruct = LibXML::XmlNode.new(node_ptr)
+        node_cstruct[:doc] = document.cstruct[:doc]
+
+        node = Node.wrap(node_cstruct, self)
+        node.send :initialize, string, document, *rest
+        yield node if block_given?
+        node
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/ffi/xml/xpath.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class XPath
+      
+      attr_accessor :cstruct # :nodoc:
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/ffi/xml/xpath_context.rb

@@ -0,0 +1,153 @@
+module Nokogiri
+  module XML
+    class XPathContext
+
+      attr_accessor :cstruct # :nodoc:
+
+      def register_ns(prefix, uri) # :nodoc:
+        LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
+      end
+
+      def register_variable(name, value) # :nodoc:
+        xml_value = LibXML.xmlXPathNewCString(value);
+        LibXML.xmlXPathRegisterVariable(cstruct, name, xml_value);
+      end
+
+      def evaluate(search_path, xpath_handler=nil) # :nodoc:
+        lookup = nil # to keep lambda in scope long enough to avoid a possible GC tragedy
+        query = search_path.to_s
+
+        if xpath_handler
+          lookup = lambda do |ctx, name, uri|
+            return nil unless xpath_handler.respond_to?(name)
+            ruby_funcall name, xpath_handler
+          end
+          LibXML.xmlXPathRegisterFuncLookup(cstruct, lookup, nil);
+        end
+
+        exception_handler = lambda do |ctx, error|
+          raise XPath::SyntaxError.wrap(error)
+        end
+        LibXML.xmlResetLastError()
+        LibXML.xmlSetStructuredErrorFunc(nil, exception_handler)
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xmlSetGenericErrorFunc(nil, generic_exception_handler)
+
+        xpath_ptr = LibXML.xmlXPathEvalExpression(query, cstruct)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlSetGenericErrorFunc(nil, nil)
+
+        if xpath_ptr.null?
+          error = LibXML.xmlGetLastError()
+          raise XPath::SyntaxError.wrap(error)
+        end
+
+        xpath = XML::XPath.new
+        xpath.cstruct = LibXML::XmlXpathObject.new(xpath_ptr)
+        xpath.document = cstruct.document.ruby_doc
+
+        case xpath.cstruct[:type]
+        when LibXML::XmlXpathObject::XPATH_NODESET
+          if xpath.cstruct[:nodesetval].null?
+            NodeSet.new(xpath.document)
+          else
+            NodeSet.wrap(xpath.cstruct[:nodesetval], xpath.document)
+          end
+        when LibXML::XmlXpathObject::XPATH_STRING
+          xpath.cstruct[:stringval]
+        when LibXML::XmlXpathObject::XPATH_NUMBER
+          xpath.cstruct[:floatval]
+        when LibXML::XmlXpathObject::XPATH_BOOLEAN
+          0 != xpath.cstruct[:boolval]
+        else
+          NodeSet.new(xpath.document)
+        end
+      end
+
+      def self.new(node) # :nodoc:
+        LibXML.xmlXPathInit()
+
+        ptr = LibXML.xmlXPathNewContext(node.cstruct[:doc])
+
+        ctx = allocate
+        ctx.cstruct = LibXML::XmlXpathContext.new(ptr)
+        ctx.cstruct[:node] = node.cstruct
+        ctx
+      end
+
+      private
+
+      #
+      #  returns a lambda that will call the handler function with marshalled parameters
+      #
+      def ruby_funcall(name, xpath_handler) # :nodoc:
+        lambda do |ctx, nargs|
+          parser_context = LibXML::XmlXpathParserContext.new(ctx)
+          context_cstruct = parser_context.context
+          document = context_cstruct.document.ruby_doc
+
+          params = []
+
+          nargs.times do |j|
+            obj = LibXML::XmlXpathObject.new(LibXML.valuePop(ctx))
+            case obj[:type]
+            when LibXML::XmlXpathObject::XPATH_STRING
+              params.unshift obj[:stringval]
+            when LibXML::XmlXpathObject::XPATH_BOOLEAN
+              params.unshift obj[:boolval] == 1
+            when LibXML::XmlXpathObject::XPATH_NUMBER
+              params.unshift obj[:floatval]
+            when LibXML::XmlXpathObject::XPATH_NODESET
+              params.unshift NodeSet.wrap(obj[:nodesetval], document)
+            else
+              char_ptr = params.unshift LibXML.xmlXPathCastToString(obj)
+              string = char_ptr.read_string
+              LibXML.xmlFree(char_ptr)
+              string
+            end
+          end
+
+          result = xpath_handler.send(name, *params)
+
+          case result.class.to_s
+          when Fixnum.to_s, Float.to_s, Bignum.to_s
+            LibXML.xmlXPathReturnNumber(ctx, result)
+          when String.to_s
+            LibXML.xmlXPathReturnString(
+              ctx,
+              LibXML.xmlXPathWrapCString(result)
+              )
+          when TrueClass.to_s
+            LibXML.xmlXPathReturnTrue(ctx)
+          when FalseClass.to_s
+            LibXML.xmlXPathReturnFalse(ctx)
+          when NilClass.to_s
+            ;
+          when Array.to_s
+            node_set = XML::NodeSet.new(document, result)
+            LibXML.xmlXPathReturnNodeSet(
+              ctx,
+              LibXML.xmlXPathNodeSetMerge(nil, node_set.cstruct)
+              )
+          else
+            if result.is_a?(XML::NodeSet)
+              LibXML.xmlXPathReturnNodeSet(
+                ctx,
+                LibXML.xmlXPathNodeSetMerge(nil, result.cstruct)
+                )
+            else
+              raise RuntimeError.new("Invalid return type #{result.class.inspect}")
+            end
+          end
+
+          nil
+        end # lambda
+      end # ruby_funcall
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/ffi/xslt/stylesheet.rb

@@ -0,0 +1,73 @@
+module Nokogiri
+  module XSLT
+    @modules = {}
+
+    @method_caller = lambda do |context, nargs|
+      # TODO
+    end
+
+    @init_func = lambda do |context, uri|
+      klass = @modules[uri]
+      klass.instance_methods(false).each do |method_name|
+	LibXML.xsltRegisterExtFunction(context, method_name, uri, @method_caller)
+      end
+      klass.new
+    end
+
+    @shutdown_func = lambda do |context, uri, data|
+    end
+
+    def self.register(uri, klass) # :nodoc:
+      raise NotImplementedError.new("sorry, you should implement me.")
+    end
+
+    class Stylesheet
+
+      attr_accessor :cstruct # :nodoc:
+
+      def self.parse_stylesheet_doc(document) # :nodoc:
+        LibXML.exsltRegisterAll
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xsltSetGenericErrorFunc(nil, generic_exception_handler)
+
+        ss = LibXML.xsltParseStylesheetDoc(LibXML.xmlCopyDoc(document.cstruct, 1)) # 1 => recursive
+
+        LibXML.xsltSetGenericErrorFunc(nil, nil)
+
+        obj = allocate
+        obj.cstruct = LibXML::XsltStylesheet.new(ss)
+        obj
+      end
+
+      def serialize(document) # :nodoc:
+        buf_ptr = FFI::Buffer.new :pointer
+        buf_len = FFI::Buffer.new :int
+        LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
+        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.get_pointer(0))
+        buf.pointer.read_string(buf_len.get_int(0))
+      end
+
+      def transform(document, params=[]) # :nodoc:
+        params = params.to_a.flatten if params.is_a?(Hash)
+        raise(TypeError) unless params.is_a?(Array)
+
+        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1, false)
+
+        # Keep the MemoryPointer instances alive until after the call
+        ptrs = params.map { |param | FFI::MemoryPointer.from_string(param.to_s) }
+        param_arr.put_array_of_pointer(0, ptrs)
+        
+        # Terminate the list with a NULL pointer
+        param_arr.put_pointer(LibXML.pointer_offset(params.length), nil)
+
+        ptr = LibXML.xsltApplyStylesheet(cstruct, document.cstruct, param_arr)
+        raise(RuntimeError, "could not perform xslt transform on document") if ptr.null?
+
+        XML::Document.wrap(ptr)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/html.rb

@@ -0,0 +1,35 @@
+require 'nokogiri/html/entity_lookup'
+require 'nokogiri/html/document'
+require 'nokogiri/html/document_fragment'
+require 'nokogiri/html/sax/parser_context'
+require 'nokogiri/html/sax/parser'
+require 'nokogiri/html/element_description'
+
+module Nokogiri
+  class << self
+    ###
+    # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+      Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
+    end
+  end
+
+  module HTML
+    class << self
+      ###
+      # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+        Document.parse(thing, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string, encoding = nil
+        HTML::DocumentFragment.parse string, encoding
+      end
+    end
+
+    # Instance of Nokogiri::HTML::EntityLookup
+    NamedCharacters = EntityLookup.new
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/html/builder.rb

@@ -0,0 +1,35 @@
+module Nokogiri
+  module HTML
+    ###
+    # Nokogiri HTML builder is used for building HTML documents.  It is very
+    # similar to the Nokogiri::XML::Builder.  In fact, you should go read the
+    # documentation for Nokogiri::XML::Builder before reading this
+    # documentation.
+    #
+    # == Synopsis:
+    #
+    # Create an HTML document with a body that has an onload attribute, and a
+    # span tag with a class of "bold" that has content of "Hello world".
+    #
+    #   builder = Nokogiri::HTML::Builder.new do |doc|
+    #     doc.html {
+    #       doc.body(:onload => 'some_func();') {
+    #         doc.span.bold {
+    #           doc.text "Hello world"
+    #         }
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_html
+    #
+    # The HTML builder inherits from the XML builder, so make sure to read the
+    # Nokogiri::XML::Builder documentation.
+    class Builder < Nokogiri::XML::Builder
+      ###
+      # Convert the builder to HTML
+      def to_html
+        @doc.to_html
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/html/document.rb

@@ -0,0 +1,90 @@
+module Nokogiri
+  module HTML
+    class Document < Nokogiri::XML::Document
+      ###
+      # Get the meta tag encoding for this document.  If there is no meta tag,
+      # then nil is returned
+      def meta_encoding
+        return nil unless meta = css('meta').find { |node|
+          node['http-equiv'] =~ /Content-Type/i
+        }
+
+        /charset\s*=\s*([\w-]+)/i.match(meta['content'])[1]
+      end
+
+      ###
+      # Set the meta tag encoding for this document.  If there is no meta
+      # content tag, nil is returned and the encoding is not set.
+      def meta_encoding= encoding
+        return nil unless meta = css('meta').find { |node|
+          node['http-equiv'] =~ /Content-Type/i
+        }
+
+        meta['content'] = "text/html; charset=%s" % encoding
+        encoding
+      end
+
+      ####
+      # Serialize Node using +options+.  Save options can also be set using a
+      # block. See SaveOptions.
+      #
+      # These two statements are equivalent:
+      #
+      #  node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)
+      #
+      # or
+      #
+      #   node.serialize(:encoding => 'UTF-8') do |config|
+      #     config.format.as_xml
+      #   end
+      #
+      def serialize options = {}
+        options[:save_with] ||= XML::Node::SaveOptions::FORMAT |
+            XML::Node::SaveOptions::AS_HTML |
+            XML::Node::SaveOptions::NO_DECLARATION |
+            XML::Node::SaveOptions::NO_EMPTY_TAGS
+        super
+      end
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      def fragment tags = nil
+        DocumentFragment.new(self, tags, self.root)
+      end
+
+      class << self
+        ###
+        # Parse HTML.  +thing+ may be a String, or any object that
+        # responds to _read_ and _close_ such as an IO, or StringIO.
+        # +url+ is resource where this document is located.  +encoding+ is the
+        # encoding that should be used when processing the document. +options+
+        # is a number that sets options in the parser, such as
+        # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
+        # Nokogiri::XML::ParseOptions.
+        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML
+
+          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?(:encoding)
+            unless string_or_io.encoding.name == "ASCII-8BIT"
+              encoding ||= string_or_io.encoding.name
+            end
+          end
+
+          if string_or_io.respond_to?(:read)
+            url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+            return read_io(string_or_io, url, encoding, options.to_i)
+          end
+
+          # read_memory pukes on empty docs
+          return new if string_or_io.nil? or string_or_io.empty?
+
+          read_memory(string_or_io, url, encoding, options.to_i)
+        end
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/nokogiri-1.4.4/lib/nokogiri/html/document_fragment.rb

@@ -0,0 +1,41 @@
+module Nokogiri
+  module HTML
+    class DocumentFragment < Nokogiri::XML::DocumentFragment
+      attr_accessor :errors
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+, using +encoding+
+      def self.parse tags, encoding = nil
+        doc = HTML::Document.new
+
+        encoding ||= tags.respond_to?(:encoding) ? tags.encoding.name : 'UTF-8'
+        doc.encoding = encoding
+
+        new(doc, tags)
+      end
+
+      def initialize document, tags = nil, ctx = nil
+        return self unless tags
+
+        if ctx
+          preexisting_errors = document.errors.dup
+          node_set = ctx.parse("<div>#{tags}</div>")
+          node_set.first.children.each { |child| child.parent = self } unless node_set.empty?
+          self.errors = document.errors - preexisting_errors
+        else
+          # This is a horrible hack, but I don't care
+          if tags.strip =~ /^<body/i
+            path = "/html/body"
+          else
+            path = "/html/body/node()"
+          end
+
+          temp_doc = HTML::Document.parse "<html><body>#{tags}", nil, document.encoding
+          temp_doc.xpath(path).each { |child| child.parent = self }
+          self.errors = temp_doc.errors
+        end
+        children
+      end
+    end
+  end
+end