hexp 0.0.1 → 0.2.0

data/lib/hexp/node/attributes.rb

@@ -0,0 +1,176 @@
+module Hexp
+  class Node
+    # Node API methods that deal with attributes
+    #
+    module Attributes
+      # Attribute getter/setter
+      #
+      # When called with one argument : return the attribute value with that name.
+      # When called with two arguments : return a new Node with the attribute set.
+      # When the second argument is nil : return a new Node with the attribute unset.
+      #
+      # @example
+      #    H[:p, class: 'hello'].attr('class')       # => "hello"
+      #    H[:p, class: 'hello'].attr('id', 'para1') # => H[:p, {"class"=>"hello", "id"=>"para1"}]
+      #    H[:p, class: 'hello'].attr('class', nil)  # => H[:p]
+      #
+      # @return [String|Hexp::Node]
+      # @api private
+      #
+      def attr(*args)
+        arity     = args.count
+        attr_name = args[0].to_s
+
+        case arity
+        when 1
+          attributes[attr_name]
+        when 2
+          set_attr(*args)
+        else
+          raise ArgumentError, "wrong number of arguments(#{arity} for 1..2)"
+        end
+      end
+
+      # Is an attribute present
+      #
+      # This will also return true if the attribute is present but empty.
+      #
+      # @example
+      #   H[:option].has_attr?('selected') #=> false
+      #
+      # @param name [String|Symbol] the name of the attribute
+      # @return [Boolean]
+      # @api public
+      #
+      def has_attr?(name)
+        attributes.has_key? name.to_s
+      end
+
+      # Check for the presence of a class
+      #
+      # @example
+      #   H[:span, class: "banner strong"].class?("strong") #=> true
+      #
+      # @param klass [String] the name of the class to check for
+      # @return [Boolean] true if the class is present, false otherwise
+      # @api public
+      #
+      def class?(klass)
+        attr('class') && attr('class').split(' ').include?(klass.to_s)
+      end
+
+      # Add a CSS class to the element
+      #
+      # @example
+      #   H[:div].add_class('foo') #=> H[:div, class: 'foo']
+      #
+      # @param klass [#to_s] The class to add
+      # @return [Hexp::Node]
+      # @api public
+      #
+      def add_class(klass)
+        attr('class', [attr('class'), klass].compact.join(' '))
+      end
+
+      # The CSS classes of this element as an array
+      #
+      # Convenience method so you don't have to split the class list yourself.
+      #
+      # @return [Array<String>]
+      # @api public
+      #
+      def class_list
+        @class_list ||= (attr('class') || '').split(' ').freeze
+      end
+
+      # Remove a CSS class from this element
+      #
+      # If the resulting class list is empty, the class attribute will be
+      # removed. If the class is present several times all instances will
+      # be removed. If it's not present at all, the class list will be
+      # unmodified.
+      #
+      # Calling this on a node with a class attribute that is equal to an
+      # empty string will result in the class attribute being removed.
+      #
+      # @param klass [#to_s] The class to be removed
+      # @return [Hexp::Node] A node that is identical to this one, but with
+      #                      the given class removed
+      # @api public
+      #
+      def remove_class(klass)
+        return self unless has_attr?('class')
+        new_list = class_list - [klass.to_s]
+        return remove_attr('class') if new_list.empty?
+        attr('class', new_list.join(' '))
+      end
+
+      # Set or override multiple attributes using a hash syntax
+      #
+      # @param attrs[Hash]
+      # @return [Hexp::Node]
+      # @api public
+      #
+      def set_attrs(attrs)
+        H[
+          self.tag,
+          self.attributes.merge(Hash[*attrs.flat_map{|k,v| [k.to_s, v]}]),
+          self.children
+        ]
+      end
+      alias :% :set_attrs
+      alias :add_attributes :set_attrs
+
+      # Remove an attribute by name
+      #
+      # @param name [#to_s] The attribute to be removed
+      # @return [Hexp::Node] a new node with the attribute removed
+      # @api public
+      #
+      def remove_attr(name)
+        H[
+          self.tag,
+          self.attributes.reject {|key,_| key == name.to_s},
+          self.children
+        ]
+      end
+
+      # Attribute accessor
+      #
+      # @param attribute_name [#to_s] The name of the attribute
+      # @return [String] The value of the attribute
+      # @api public
+      #
+      def [](attr_name)
+        self.attributes[attr_name.to_s]
+      end
+
+      # Merge attributes into this Hexp
+      #
+      # Class attributes are treated special : the class lists are merged, rather
+      # than being overwritten. See {set_attrs} for a more basic version.
+      #
+      # This method is analoguous with {Hash#merge}. As argument it can take a
+      # Hash, or another Hexp element, in which case that element's attributes
+      # are used.
+      #
+      # @param node_or_hash [#to_hexp|Hash]
+      # @return [Hexp::Node]
+      # @api public
+      #
+      def merge_attrs(node_or_hash)
+        hash = node_or_hash.respond_to?(:to_hexp) ?
+                 node_or_hash.to_hexp.attributes : node_or_hash
+        result = self
+        hash.each do |key,value|
+          result = if key.to_s == 'class'
+                     result.add_class(value)
+                   else
+                     result.attr(key, value)
+                   end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/hexp/node/children.rb

@@ -0,0 +1,44 @@
+module Hexp
+  class Node
+    # Node API methods that deal with child_nodes
+    #
+    module Children
+      # Is this node an empty node
+      #
+      # H[:p, class: 'foo'].empty? #=> true
+      # H[:p, [H[:span]].empty?    #=> false
+      #
+      # @return [Boolean] true if this node has no children
+      # @api public
+      #
+      def empty?
+        children.empty?
+      end
+
+      def add_child(child)
+        H[
+          self.tag,
+          self.attributes,
+          self.children + [child]
+        ]
+      end
+      alias :add :add_child
+      alias :<< :add_child
+
+      def text
+        children.map do |node|
+          node.text? ? node : node.text
+        end.join
+      end
+
+      def set_children(new_children)
+        H[tag, attributes, new_children]
+      end
+
+      def map_children(&blk)
+        return to_enum(:map_children) unless block_given?
+        H[tag, attributes, children.map(&blk)]
+      end
+    end
+  end
+end

data/lib/hexp/node/css_selection.rb

@@ -0,0 +1,73 @@
+module Hexp
+  class Node
+    # Select nodes using CSS selectors
+    #
+    class CssSelection < Selector
+      def initialize(node, css_selector)
+        @node, @css_selector = node, css_selector
+      end
+
+      def inspect
+        "#<#{self.class} @node=#{@node.inspect} @css_selector=#{@css_selector.inspect} matches=#{node_matches?}>"
+      end
+
+      def each(&block)
+        return to_enum(:each) unless block_given?
+
+        @node.children.each do |child|
+          next_selection_for(child).each(&block)
+        end
+        yield @node if node_matches?
+      end
+
+      def rewrite(&block)
+        return @node if @node.text?
+
+        new_node = H[
+          @node.tag,
+          @node.attributes,
+          @node.children.flat_map do |child|
+            next_selection_for(child).rewrite(&block)
+          end
+        ]
+        node_matches? ? block.call(new_node) : new_node
+      end
+
+      private
+
+      def comma_sequence
+        @comma_sequence ||= coerce_to_comma_sequence(@css_selector)
+      end
+
+      def coerce_to_comma_sequence(css_selector)
+        return css_selector if css_selector.is_a? CssSelector::CommaSequence
+        CssSelector::Parser.call(@css_selector)
+      end
+
+      def node_matches?
+        comma_sequence.matches?(@node)
+      end
+
+      # returns a new commasequence with the parts removed that have been consumed by matching
+      # against this node. If no part matches, return nil
+      def next_comma_sequence
+        @next_comma_sequence ||= CssSelector::CommaSequence.new(consume_matching_heads)
+      end
+
+      def next_selection_for(child)
+        self.class.new(child, next_comma_sequence)
+      end
+
+      def consume_matching_heads
+        comma_sequence.members.flat_map do |sequence|
+          if sequence.head_matches? @node
+            [sequence, sequence.drop_head]
+          else
+            [sequence]
+          end
+        end.reject(&:empty?)
+      end
+
+    end
+  end
+end

data/lib/hexp/node/domize.rb

@@ -2,22 +2,54 @@ module Hexp
   class Node
     # Turn nodes into DOM objects
     class Domize
+      DEFAULT_OPTIONS = {
+        :include_doctype => true
+      }.freeze
+
+      # The resulting DOM Document
+      #
+      # @return [Nokogiri::HTML::Document]
+      # @api private
+      #
       attr_reader :dom
 
-      def initialize(hexp, dom = Hexp::DOM)
-        @raw = hexp
-        @dom = dom
+      # Instanitiate a Domizer
+      #
+      # @param hexp [Hexp::Node]
+      # @param options [Hash] :include_doctype defaults to true
+      # @api private
+      #
+      def initialize(hexp, options = {})
+        @dom     = Hexp::DOM
+        @raw     = hexp
+        @options = DEFAULT_OPTIONS.merge(options).freeze
       end
 
+      # Turn the hexp into a DOM
+      #
+      # @return [Nokogiri::HTML::Document]
+      # @api private
+      #
       def call
-        dom::Document.new.tap do |doc|
-          @doc = doc
-          doc << domize(@raw)
+        @doc  = dom::Document.new
+        @root = domize(@raw)
+        @doc << @root
+
+        if @options[:include_doctype]
+          @doc
+        else
+          @root
         end
       end
 
       private
 
+      # Turn a Hexp::Node into a Document
+      #
+      # @param hexp [Hexp::Node]
+      # @return [Nokogiri::HTML::Document]
+      # @api private
+      #
       def domize(hexp)
         dom::Node.new(hexp.tag.to_s, @doc).tap do |node|
           set_attributes(node, hexp.attributes)
@@ -25,12 +57,26 @@ module Hexp
         end
       end
 
+      # Set attributes on a DOM node
+      #
+      # @param node [Nokogiri::XML::Element]
+      # @param attributes [Hash]
+      # @return [void]
+      # @api private
+      #
       def set_attributes(node, attributes)
         attributes.each do |key,value|
           node[key] = value
         end
       end
 
+      # Set children on the DOM node
+      #
+      # @param node [Nokogiri::XML::Element]
+      # @param children [Hexp::List]
+      # @return [void]
+      # @api private
+      #
       def set_children(node, children)
         children.each do |child|
           if child.instance_of?(TextNode)

data/lib/hexp/node/normalize.rb

@@ -40,6 +40,12 @@ module Hexp
         {}
       end
 
+      # Returns the attributes hash with key and value converted to strings
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
       def normalized_attributes
         Hash[*
           attributes.flat_map do |key, value|
@@ -55,10 +61,14 @@ module Hexp
       # @api private
       #
       def children
-        @raw[1..2].each do |arg|
-          return Array(arg) unless [Symbol, Hash].any?{|klz| arg.instance_of?(klz)}
+        last = @raw.last
+        if last.respond_to? :to_ary
+          last.to_ary
+        elsif @raw.count < 2 || last.instance_of?(Hash)
+          []
+        else
+          [last]
         end
-        []
       end
 
       # Normalize the third element of a hexp node, the list of children
@@ -75,14 +85,14 @@ module Hexp
               child
             when String, TextNode
               Hexp::TextNode.new(child)
+            when ->(ch) { ch.respond_to? :to_hexp }
+              response = child.to_hexp
+              raise FormatError, "to_hexp must return a Hexp::Node, got #{response.inspect}" unless response.instance_of?(Hexp::Node)
+              response
             when Array
-              Hexp::Node[*child]
+              Hexp::Node[*child.map(&:freeze)]
             else
-              if child.respond_to? :to_hexp
-                response = child.to_hexp
-                raise FormatError, "to_hexp must return a Hexp::Node, got #{response.inspect}" unless response.instance_of?(Hexp::Node)
-                response
-              end
+              raise FormatError, "Invalid value in Hexp literal : #{child.inspect} (#{child.class}) does not implement #to_hexp ; #{children.inspect}"
             end
           end
         ]

data/lib/hexp/node/pp.rb

@@ -2,10 +2,20 @@ module Hexp
   class Node
     # Pretty-print a node and its contents
     class PP
+      # Create a new pretty-printer
+      #
+      # @param node [Hexp::Node] The node to represent
+      # @api private
+      #
       def initialize(node)
         @node = node
       end
 
+      # Perform the pretty-printing
+      #
+      # @return [String] The pp output
+      # @api private
+      #
       def call
         [
           @node.class.inspect_name,
@@ -14,22 +24,44 @@ module Hexp
         ].join
       end
 
+      # Format the node tag
+      #
+      # @return [String]
+      # @api private
+      #
       def pp_tag
         "[#{@node.tag.inspect}"
       end
 
+      # Format the node attributes
+      #
+      # @return [String]
+      # @api private
+      #
       def pp_attributes
         attrs = @node.attributes
         return '' if attrs.empty?
         ', ' + attrs.inspect
       end
 
+      # Format the node children
+      #
+      # @return [String]
+      # @api private
+      #
       def pp_children
         children = @node.children
         return ']' if children.empty?
         ", [\n#{ children.map(&:pp).join(",\n") }]]"
       end
 
+      # Indent a multiline string with a number of spaces
+      #
+      # @param string [String] The string to indent
+      # @param indent [Integer] The number of spaces to use for indentation
+      # @return [String]
+      # @api private
+      #
       def self.indent(string, indent = 2)
         string.lines.map {|line|  " "*indent + line}.join
       end