oga 1.2.3-java → 1.3.0-java

data/lib/oga/entity_decoder.rb

@@ -1,17 +1,13 @@
 module Oga
   module EntityDecoder
-    ##
     # @see [decode]
-    #
     def self.try_decode(input, html = false)
       input ? decode(input, html) : nil
     end
 
-    ##
     # @param [String] input
     # @param [TrueClass|FalseClass] html
     # @return [String]
-    #
     def self.decode(input, html = false)
       decoder = html ? HTML::Entities : XML::Entities
 

data/lib/oga/html/entities.rb

@@ -1,14 +1,12 @@
 module Oga
   module HTML
     module Entities
-      ##
       # Hash mapping HTML entities to their Unicode character replacements.
       #
       # Based on the JSON output as listed at
       # http://www.w3.org/TR/html5/syntax.html#named-character-references
       #
       # @return [Hash]
-      #
       DECODE_MAPPING = {
         'Á'                          => [193].pack('U*'),
         'á'                          => [225].pack('U*'),
@@ -2137,11 +2135,9 @@ module Oga
         '‌'                            => [8204].pack('U*'),
       }
 
-      ##
       # Decodes HTML entities.
       #
       # @see [decode]
-      #
       def self.decode(input)
         XML::Entities.decode(input, DECODE_MAPPING)
       end

data/lib/oga/html/parser.rb

@@ -1,6 +1,5 @@
 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.
@@ -8,13 +7,10 @@ module Oga
     # 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)
 

data/lib/oga/html/sax_parser.rb

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

data/lib/oga/lru.rb

@@ -1,5 +1,4 @@
 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).
@@ -22,11 +21,8 @@ module Oga
   #     cache.keys # => [:b, :c, :d]
   #
   # @api private
-  #
   class LRU
-    ##
     # @param [Fixnum] maximum
-    #
     def initialize(maximum = 1024)
       @maximum = maximum
       @cache   = {}
@@ -35,9 +31,7 @@ module Oga
       @owner   = Thread.current
     end
 
-    ##
     # @param [Fixnum] value
-    #
     def maximum=(value)
       synchronize do
         @maximum = value
@@ -46,30 +40,24 @@ module Oga
       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
@@ -82,35 +70,27 @@ module Oga
       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
@@ -118,9 +98,7 @@ module Oga
       end
     end
 
-    ##
     # @return [Fixnum]
-    #
     def size
       synchronize { @cache.size }
     end
@@ -129,10 +107,8 @@ module Oga
 
     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
@@ -147,10 +123,8 @@ module Oga
       end
     end
 
-    ##
     # Removes old keys until the size of the hash no longer exceeds the maximum
     # size.
-    #
     def resize
       return unless size > @maximum
 

data/lib/oga/oga.rb

@@ -1,5 +1,4 @@
 module Oga
-  ##
   # Parses the given XML document.
   #
   # @example
@@ -8,12 +7,10 @@ module Oga
   # @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
@@ -22,12 +19,10 @@ module Oga
   # @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
@@ -36,12 +31,10 @@ module Oga
   #  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
@@ -50,7 +43,6 @@ module Oga
   #  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

data/lib/oga/ruby/generator.rb

@@ -0,0 +1,225 @@
+module Oga
+  module Ruby
+    # Class for converting a Ruby AST to a String.
+    #
+    # This class takes a {Oga::Ruby::Node} instance and converts it (and its
+    # child nodes) to a String that in turn can be passed to `eval` and the
+    # likes.
+    class Generator
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def process(ast)
+        send(:"on_#{ast.type}", ast)
+      end
+
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_followed_by(ast)
+        ast.to_a.map { |child| process(child) }.join("\n\n")
+      end
+
+      # Processes an assignment node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_assign(ast)
+        var, val = *ast
+
+        var_str = process(var)
+        val_str = process(val)
+
+        "#{var_str} = #{val_str}"
+      end
+
+      # Processes a mass assignment node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_massign(ast)
+        vars, val = *ast
+
+        var_names = vars.map { |var| process(var) }
+        val_str   = process(val)
+
+        "#{var_names.join(', ')} = #{val_str}"
+      end
+
+      # Processes a `begin` node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_begin(ast)
+        body = process(ast.to_a[0])
+
+        <<-EOF
+begin
+  #{body}
+end
+        EOF
+      end
+
+      # Processes an equality node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_eq(ast)
+        left, right = *ast
+
+        left_str  = process(left)
+        right_str = process(right)
+
+        "#{left_str} == #{right_str}"
+      end
+
+      # Processes a boolean "and" node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_and(ast)
+        left, right = *ast
+
+        left_str  = process(left)
+        right_str = process(right)
+
+        "#{left_str} && #{right_str}"
+      end
+
+      # Processes a boolean "or" node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_or(ast)
+        left, right = *ast
+
+        left_str  = process(left)
+        right_str = process(right)
+
+        "(#{left_str} || #{right_str})"
+      end
+
+      # Processes an if statement node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_if(ast)
+        cond, body, else_body = *ast
+
+        cond_str = process(cond)
+        body_str = process(body)
+
+        if else_body
+          else_str = process(else_body)
+
+          <<-EOF
+if #{cond_str}
+  #{body_str}
+else
+  #{else_str}
+end
+          EOF
+        else
+          <<-EOF
+if #{cond_str}
+  #{body_str}
+end
+          EOF
+        end
+      end
+
+      # Processes a while statement node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_while(ast)
+        cond, body = *ast
+
+        cond_str = process(cond)
+        body_str = process(body)
+
+        <<-EOF
+while #{cond_str}
+  #{body_str}
+end
+        EOF
+      end
+
+      # Processes a method call node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_send(ast)
+        receiver, name, *args = *ast
+
+        call     = name
+        brackets = name == '[]'
+
+        unless args.empty?
+          arg_str = args.map { |arg| process(arg) }.join(', ')
+          call    = brackets ? "[#{arg_str}]" : "#{call}(#{arg_str})"
+        end
+
+        if receiver
+          rec_str = process(receiver)
+          call    = brackets ? "#{rec_str}#{call}" : "#{rec_str}.#{call}"
+        end
+
+        call
+      end
+
+      # Processes a block node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_block(ast)
+        receiver, args, body = *ast
+
+        receiver_str = process(receiver)
+        body_str     = body ? process(body) : nil
+        arg_strs     = args.map { |arg| process(arg) }
+
+        <<-EOF
+#{receiver_str} do |#{arg_strs.join(', ')}|
+  #{body_str}
+end
+        EOF
+      end
+
+      # Processes a Range node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_range(ast)
+        start, stop = *ast
+
+        start_str = process(start)
+        stop_str  = process(stop)
+
+        "(#{start_str}..#{stop_str})"
+      end
+
+      # Processes a string node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_string(ast)
+        ast.to_a[0].inspect
+      end
+
+      # Processes a Symbol node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_symbol(ast)
+        ast.to_a[0].to_sym.inspect
+      end
+
+      # Processes a literal node.
+      #
+      # @param [Oga::Ruby::Node] ast
+      # @return [String]
+      def on_lit(ast)
+        ast.to_a[0]
+      end
+    end # Generator
+  end # Ruby
+end # Oga