domo 0.0.4 → 0.0.5

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

@@ -1,18 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/document.rb

@@ -1,90 +0,0 @@
-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/sax/parser.rb

@@ -1,48 +0,0 @@
-module Nokogiri
-  module HTML
-    ###
-    # Nokogiri lets you write a SAX parser to process HTML but get HTML
-    # correction features.
-    #
-    # See Nokogiri::HTML::SAX::Parser for a basic example of using a
-    # SAX parser with HTML.
-    #
-    # For more information on SAX parsers, see Nokogiri::XML::SAX
-    module SAX
-      ###
-      # This class lets you perform SAX style parsing on HTML with HTML
-      # error correction.
-      #
-      # Here is a basic usage example:
-      #
-      #   class MyDoc < Nokogiri::XML::SAX::Document
-      #     def start_element name, attributes = []
-      #       puts "found a #{name}"
-      #     end
-      #   end
-      #
-      #   parser = Nokogiri::HTML::SAX::Parser.new(MyDoc.new)
-      #   parser.parse(File.read(ARGV[0], 'rb'))
-      #
-      # For more information on SAX parsers, see Nokogiri::XML::SAX
-      class Parser < Nokogiri::XML::SAX::Parser
-        ###
-        # Parse html stored in +data+ using +encoding+
-        def parse_memory data, encoding = 'UTF-8'
-          raise ArgumentError unless data
-          return unless data.length > 0
-          ParserContext.memory(data, encoding).parse_with self
-        end
-
-        ###
-        # Parse a file with +filename+
-        def parse_file filename, encoding = 'UTF-8'
-          raise ArgumentError unless filename
-          raise Errno::ENOENT unless File.exists?(filename)
-          raise Errno::EISDIR if File.directory?(filename)
-          ParserContext.file(filename, encoding).parse_with self
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Nokogiri
-  # The version of Nokogiri you are using
-  VERSION = '1.4.4'
-
-  # More complete version information about libxml
-  VERSION_INFO = {}
-  VERSION_INFO['warnings']              = []
-  VERSION_INFO['nokogiri']              = Nokogiri::VERSION
-  VERSION_INFO['ruby']                  = {}
-  VERSION_INFO['ruby']['version']       = ::RUBY_VERSION
-  VERSION_INFO['ruby']['platform']      = ::RUBY_PLATFORM
-  VERSION_INFO['ruby']['engine']        = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'mri'
-  VERSION_INFO['ruby']['jruby']         = ::JRUBY_VERSION if RUBY_PLATFORM == "java"
-  if defined?(LIBXML_VERSION)
-    VERSION_INFO['libxml']              = {}
-    VERSION_INFO['libxml']['binding']   = 'extension'
-    VERSION_INFO['libxml']['compiled']  = LIBXML_VERSION
-    VERSION_INFO['libxml']['loaded']    = LIBXML_PARSER_VERSION.scan(/^(.*)(..)(..)$/).first.collect{|j|j.to_i}.join(".")
-
-    if VERSION_INFO['libxml']['compiled'] != VERSION_INFO['libxml']['loaded']
-      warning = "Nokogiri was built against LibXML version #{VERSION_INFO['libxml']['compiled']}, but has dynamically loaded #{VERSION_INFO['libxml']['loaded']}"
-      VERSION_INFO['warnings'] << warning
-      warn "WARNING: #{warning}"
-    end
-  end
-
-  def self.uses_libxml? # :nodoc:
-    !Nokogiri::VERSION_INFO['libxml'].nil?
-  end
-
-  def self.ffi? # :nodoc:
-    uses_libxml? && Nokogiri::VERSION_INFO['libxml']['binding'] == 'ffi'
-  end
-
-  def self.is_2_6_16? # :nodoc:
-    Nokogiri::VERSION_INFO['libxml']['loaded'] <= '2.6.16'
-  end
-end