rubyjedi-oga 1.0.3

data/lib/oga/html/parser.rb

@@ -0,0 +1,25 @@
+module Oga
+  module HTML
+    ##
+    # Parser for processing HTML input. This parser is a small wrapper around
+    # {Oga::XML::Parser} and takes care of setting the various options required
+    # for parsing HTML documents.
+    #
+    # A basic example:
+    #
+    #     Oga::HTML::Parser.new('<meta charset="utf-8">').parse
+    #
+    class Parser < XML::Parser
+      ##
+      # @param [String|IO] data
+      # @param [Hash] options
+      # @see [Oga::XML::Parser#initialize]
+      #
+      def initialize(data, options = {})
+        options = options.merge(:html => true)
+
+        super(data, options)
+      end
+    end # Parser
+  end # HTML
+end # Oga

data/lib/oga/html/sax_parser.rb

@@ -0,0 +1,18 @@
+module Oga
+  module HTML
+    ##
+    # SAX parser for HTML documents. See the documentation of
+    # {Oga::XML::SaxParser} for more information.
+    #
+    class SaxParser < XML::SaxParser
+      ##
+      # @see [Oga::XML::SaxParser#initialize]
+      #
+      def initialize(handler, data, options = {})
+        options = options.merge(:html => true)
+
+        super(handler, data, options)
+      end
+    end # SaxParser
+  end # HTML
+end # Oga

data/lib/oga/lru.rb

@@ -0,0 +1,160 @@
+module Oga
+  ##
+  # Thread-safe LRU cache using a Hash as the underlying storage engine.
+  # Whenever the size of the cache exceeds the given limit the oldest keys are
+  # removed (base on insert order).
+  #
+  # This class uses its own list of keys (as returned by {LRU#keys}) instead of
+  # relying on `Hash#keys` as the latter allocates a new Array upon every call.
+  #
+  # This class doesn't use MonitorMixin due to the extra overhead it adds
+  # compared to using a Mutex directly.
+  #
+  # Example usage:
+  #
+  #     cache = LRU.new(3)
+  #
+  #     cache[:a] = 10
+  #     cache[:b] = 20
+  #     cache[:c] = 30
+  #     cache[:d] = 40
+  #
+  #     cache.keys # => [:b, :c, :d]
+  #
+  # @api private
+  #
+  class LRU
+    ##
+    # @param [Fixnum] maximum
+    #
+    def initialize(maximum = 1024)
+      @maximum = maximum
+      @cache   = {}
+      @keys    = []
+      @mutex   = Mutex.new
+      @owner   = Thread.current
+    end
+
+    ##
+    # @param [Fixnum] value
+    #
+    def maximum=(value)
+      synchronize do
+        @maximum = value
+
+        resize
+      end
+    end
+
+    ##
+    # @return [Fixnum]
+    #
+    def maximum
+      synchronize { @maximum }
+    end
+
+    ##
+    # Returns the value of the key.
+    #
+    # @param [Mixed] key
+    # @return [Mixed]
+    #
+    def [](key)
+      synchronize { @cache[key] }
+    end
+
+    ##
+    # Sets the key and its value. Old keys are discarded if the LRU size exceeds
+    # the limit.
+    #
+    # @param [Mixed] key
+    # @param [Mixed] value
+    #
+    def []=(key, value)
+      synchronize do
+        @cache[key] = value
+
+        @keys.delete(key) if @keys.include?(key)
+
+        @keys << key
+
+        resize
+      end
+    end
+
+    ##
+    # Returns a key if it exists, otherwise yields the supplied block and uses
+    # its return value as the key value.
+    #
+    # @param [Mixed] key
+    # @return [Mixed]
+    #
+    def get_or_set(key)
+      synchronize { self[key] ||= yield }
+    end
+
+    ##
+    # @return [Array]
+    #
+    def keys
+      synchronize { @keys }
+    end
+
+    ##
+    # @param [Mixed] key
+    # @return [TrueClass|FalseClass]
+    #
+    def key?(key)
+      synchronize { @cache.key?(key) }
+    end
+
+    ##
+    # Removes all keys from the cache.
+    #
+    def clear
+      synchronize do
+        @keys.clear
+        @cache.clear
+      end
+    end
+
+    ##
+    # @return [Fixnum]
+    #
+    def size
+      synchronize { @cache.size }
+    end
+
+    alias_method :length, :size
+
+    private
+
+    ##
+    # Yields the supplied block in a synchronized manner (if needed). This
+    # method is heavily based on `MonitorMixin#mon_enter`.
+    #
+    def synchronize
+      if @owner != Thread.current
+        @mutex.synchronize do
+          @owner = Thread.current
+
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    ##
+    # Removes old keys until the size of the hash no longer exceeds the maximum
+    # size.
+    #
+    def resize
+      return unless size > @maximum
+
+      to_remove = @keys.shift(size - @maximum)
+
+      to_remove.each { |key| @cache.delete(key) }
+    end
+  end # LRU
+end # Oga

data/lib/oga/oga.rb

@@ -0,0 +1,57 @@
+module Oga
+  ##
+  # Parses the given XML document.
+  #
+  # @example
+  #  document = Oga.parse_xml('<root>Hello</root>')
+  #
+  # @see [Oga::XML::Lexer#initialize]
+  #
+  # @return [Oga::XML::Document]
+  #
+  def self.parse_xml(xml, options = {})
+    XML::Parser.new(xml, options).parse
+  end
+
+  ##
+  # Parses the given HTML document.
+  #
+  # @example
+  #  document = Oga.parse_html('<html>...</html>')
+  #
+  # @see [Oga::XML::Lexer#initialize]
+  #
+  # @return [Oga::XML::Document]
+  #
+  def self.parse_html(html, options = {})
+    HTML::Parser.new(html, options).parse
+  end
+
+  ##
+  # Parses the given XML document using the SAX parser.
+  #
+  # @example
+  #  handler = SomeSaxHandler.new
+  #
+  #  Oga.sax_parse_html(handler, '<root>Hello</root>')
+  #
+  # @see [Oga::XML::SaxParser#initialize]
+  #
+  def self.sax_parse_xml(handler, xml, options = {})
+    XML::SaxParser.new(handler, xml, options).parse
+  end
+
+  ##
+  # Parses the given HTML document using the SAX parser.
+  #
+  # @example
+  #  handler = SomeSaxHandler.new
+  #
+  #  Oga.sax_parse_html(handler, '<script>foo()</script>')
+  #
+  # @see [Oga::XML::SaxParser#initialize]
+  #
+  def self.sax_parse_html(handler, html, options = {})
+    HTML::SaxParser.new(handler, html, options).parse
+  end
+end # Oga

data/lib/oga/version.rb

@@ -0,0 +1,3 @@
+module Oga
+  VERSION = '1.0.3'
+end # Oga

data/lib/oga/whitelist.rb

@@ -0,0 +1,20 @@
+module Oga
+  ##
+  # @api private
+  #
+  class Whitelist < Blacklist
+    ##
+    # @return [TrueClass|FalseClass]
+    #
+    def allow?(name)
+      names.include?(name)
+    end
+
+    ##
+    # @return [Oga::Blacklist]
+    #
+    def to_blacklist
+      Blacklist.new(names)
+    end
+  end # Whitelist
+end # Oga

data/lib/oga/xml/attribute.rb

@@ -0,0 +1,136 @@
+module Oga
+  module XML
+    ##
+    # Class for storing information about a single XML attribute.
+    #
+    class Attribute
+      # The name of the attribute.
+      # @return [String]
+      attr_accessor :name
+
+      # @return [String]
+      attr_accessor :namespace_name
+
+      # The element this attribute belongs to.
+      # @return [Oga::XML::Element]
+      attr_accessor :element
+
+      ##
+      # The default namespace available to all attributes. This namespace can
+      # not be modified.
+      #
+      # @return [Oga::XML::Namespace]
+      #
+      DEFAULT_NAMESPACE = Namespace.new(
+        :name => 'xml',
+        :uri  => XML::DEFAULT_NAMESPACE.uri
+      ).freeze
+
+      ##
+      # @param [Hash] options
+      #
+      # @option options [String] :name
+      # @option options [String] :namespace_name
+      # @option options [String] :value
+      # @option options [Oga::XML::Element] :element
+      #
+      def initialize(options = {})
+        @name    = options[:name]
+        @value   = options[:value]
+        @element = options[:element]
+
+        @namespace_name = options[:namespace_name]
+      end
+
+      ##
+      # Returns the {Oga::XML::Namespace} instance for the current namespace
+      # name.
+      #
+      # @return [Oga::XML::Namespace]
+      #
+      def namespace
+        unless @namespace
+          if namespace_name == DEFAULT_NAMESPACE.name
+            @namespace = DEFAULT_NAMESPACE
+          else
+            @namespace = element.available_namespaces[namespace_name]
+          end
+        end
+
+        @namespace
+      end
+
+      ##
+      # @param [String] value
+      #
+      def value=(value)
+        @value   = value
+        @decoded = false
+      end
+
+      ##
+      # Returns the value of the attribute or nil if no explicit value was set.
+      #
+      # @return [String|NilClass]
+      #
+      def value
+        if !@decoded and @value
+          @value   = EntityDecoder.try_decode(@value, html?)
+          @decoded = true
+        end
+
+        @value
+      end
+
+      ##
+      # @return [String]
+      #
+      def text
+        value.to_s
+      end
+
+      alias_method :to_s, :text
+
+      ##
+      # @return [String]
+      #
+      def to_xml
+        if namespace_name
+          full_name = "#{namespace_name}:#{name}"
+        else
+          full_name = name
+        end
+
+        enc_value = value ? Entities.encode_attribute(value) : nil
+
+        %Q(#{full_name}="#{enc_value}")
+      end
+
+      ##
+      # @return [String]
+      #
+      def inspect
+        segments = []
+
+        [:name, :namespace, :value].each do |attr|
+          value = send(attr)
+
+          if value
+            segments << "#{attr}: #{value.inspect}"
+          end
+        end
+
+        "Attribute(#{segments.join(' ')})"
+      end
+
+      private
+
+      ##
+      # @return [TrueClass|FalseClass]
+      #
+      def html?
+        !!@element && @element.html?
+      end
+    end # Attribute
+  end # XML
+end # Oga

data/lib/oga/xml/cdata.rb

@@ -0,0 +1,17 @@
+module Oga
+  module XML
+    ##
+    # Class used for storing information about CDATA tags.
+    #
+    class Cdata < CharacterNode
+      ##
+      # Converts the node back to XML.
+      #
+      # @return [String]
+      #
+      def to_xml
+        "<![CDATA[#{text}]]>"
+      end
+    end # Cdata
+  end # XML
+end # Oga

data/lib/oga/xml/character_node.rb

@@ -0,0 +1,37 @@
+module Oga
+  module XML
+    ##
+    # Base class for nodes that represent a text-like value such as Text and
+    # Comment nodes.
+    #
+    class CharacterNode < Node
+      # @return [String]
+      attr_accessor :text
+
+      ##
+      # @param [Hash] options
+      #
+      # @option options [String] :text The text of the node.
+      #
+      def initialize(options = {})
+        super
+
+        @text = options[:text]
+      end
+
+      ##
+      # @return [String]
+      #
+      def to_xml
+        text.to_s
+      end
+
+      ##
+      # @return [String]
+      #
+      def inspect
+        "#{self.class.to_s.split('::').last}(#{text.inspect})"
+      end
+    end # CharacterNode
+  end # XML
+end # Oga