arbre2 2.1.0

data/lib/arbre/html/html_tags.rb

@@ -0,0 +1,67 @@
+module Arbre
+  module Html
+
+    # This file creates a class for all known HTML 5 tags. You can derive
+    # from these classes to build specialized versions.
+
+    SELF_CLOSING_TAGS = %w[
+      input img col br meta link
+    ]
+    OTHER_TAGS = %w[
+      a abbr address area article aside audio b base
+      bdo blockquote body button canvas caption cite
+      code colgroup command datalist dd del details
+      dfn div dl dt em embed fieldset figcaption figure
+      footer form h1 h2 h3 h4 h5 h6 head header hgroup
+      hr html i iframe ins keygen kbd label
+      legend li map mark menu meter nav noscript
+      object ol optgroup option output pre progress q
+      s samp script section select small source span
+      strong style sub summary sup table tbody td
+      textarea tfoot th thead time title tr ul var video
+    ]
+
+    def self.create_tag_class(tag, builder_method = tag.to_sym, self_closing: false)
+      self_closing_method = self_closing ? 'def self_closing_tag?() true end' : ''
+
+      module_eval <<-RUBY, __FILE__, __LINE__+1
+        class #{tag.camelize} < Tag
+          builder_method #{builder_method.inspect}
+          tag #{tag.inspect}
+
+          #{self_closing_method}
+        end
+      RUBY
+    end
+
+    SELF_CLOSING_TAGS.each do |tag|
+      create_tag_class tag, self_closing: true
+    end
+    OTHER_TAGS.each do |tag|
+      create_tag_class tag
+    end
+
+    create_tag_class 'p', :para
+
+    Input.class_eval do
+      attribute :type
+    end
+
+    Table.class_eval do
+      def initialize(*)
+        super
+        set_table_tag_defaults
+      end
+
+      protected
+
+      # Set some good defaults for tables
+      def set_table_tag_defaults
+        set_attribute :border,      0
+        set_attribute :cellspacing, 0
+        set_attribute :cellpadding, 0
+      end
+    end
+
+  end
+end

data/lib/arbre/html/querying.rb

@@ -0,0 +1,256 @@
+require 'active_support/core_ext/object/blank'
+
+module Arbre
+  module Html
+
+    ######
+    # Querying mixin
+
+      # Adds querying to the Arbre elements.
+      module Querying
+
+        # Finds elements by running a query.
+        def find(query)
+          Query.new(self).execute(query)
+        end
+
+        # Finds the first element from the given query.
+        def find_first(query)
+          find(query).first
+        end
+
+        # Finds all child tags of this element. This operation sees through all elements that
+        # are not a tag.
+        # @return [ElementCollection]
+        def child_tags
+          result = ElementCollection.new
+
+          children.each do |child|
+            if child.is_a?(Tag)
+              result << child
+            else
+              result.concat child.child_tags
+            end
+          end
+
+          result
+        end
+
+        # Finds all descendant tags of this element. This operation sees through all elements that
+        # are not a tag.
+        # @return [ElementCollection]
+        def descendant_tags
+          result = ElementCollection.new
+
+          children.each do |child|
+            result << child if child.is_a?(Tag)
+            result.concat child.descendant_tags
+          end
+
+          result
+        end
+
+        # Finds elements by a combination of tag and / or classes.
+        def find_by_tag_and_classes(tag = nil, classes = nil)
+          tag_matches = ->(el) { tag.nil? || el.tag_name == tag }
+          classes_match = ->(el) { classes.nil? || classes.all? { |cls| el.has_class?(cls) } }
+
+          found = []
+          children.each do |child|
+            if child.is_a?(Tag)
+              found << child if tag_matches[child] && classes_match[child]
+            end
+
+            found += child.find_by_tag_and_classes(tag, classes)
+          end
+
+          ElementCollection.new(found)
+        end
+
+        def find_by_tag(tag)
+          find_by_tag_and_classes tag
+        end
+
+        def find_by_classes(classes)
+          find_by_tag_and_classes nil, classes
+        end
+
+        # Finds an element by an ID. Note that only the first element with the specified ID
+        # is retrieved.
+        def find_by_id(id)
+          children.each do |child|
+            found = if child.is_a?(Tag) && child.id == id
+              child
+            else
+              child.find_by_id(id)
+            end
+            return found if found
+          end
+
+          nil
+        end
+
+      end
+
+    ######
+    # Query class
+
+      # Class to find tags from a given root tag / element based on a CSS-like query.
+      class Query
+
+        ######
+        # Initialization
+
+          def initialize(root)
+            @root = root
+          end
+
+          attr_reader :root
+
+        ######
+        # Constants
+
+          # @api private
+          CSS_IDENTIFIER = /[-_a-z][-_a-z0-9]*/
+
+          # @api private
+          CSS_SCAN = %r[
+
+            # Child node operator
+            (>)?
+
+            \s*
+
+            (?:
+
+              (\*)
+
+              |
+
+              # Tag name
+              (#{CSS_IDENTIFIER})?
+
+              # ID
+              (?:\#(#{CSS_IDENTIFIER}))?
+
+              # Class
+              ((?:\.#{CSS_IDENTIFIER})+)?
+
+              # Pseudo
+              ((?::#{CSS_IDENTIFIER})+)?
+
+              # Attributes
+              ((?:\[.+?\])+)?
+
+            )
+
+          ]x
+
+        ######
+        # Execution
+
+          # Executes the given query.
+          def execute(query)
+            # Sanitize the query for processing.
+            query = query.downcase.squeeze(' ')
+
+            result = []
+
+            selectors = query.split(',').map(&:strip).reject(&:blank?)
+
+            selectors.map do |selector|
+              tags = [ root ]
+
+              # Run through all segments in the selector and process them one by one.
+              selector.scan CSS_SCAN do |operator, all, tag, id, classes, pseudos, attributes|
+                next unless all || tag || id || classes || pseudos || attributes
+
+                classes = classes.split('.').reject(&:blank?) if classes
+                pseudos = pseudos.split(':').reject(&:blank?) if pseudos
+
+                # First process combinations of operator, all and id.
+                tags = case operator
+                when '>' then find_children(tags, tag, id, classes)
+                else find_descendants(tags, tag, id, classes)
+                end
+
+                filter_by_pseudos tags, pseudos if pseudos
+                filter_by_attributes tags, attributes if attributes
+              end
+
+              result.concat tags
+            end
+
+            # Convert to an element collection.
+            ElementCollection.new(result)
+          end
+
+        ######
+        # Internal methods
+
+          private
+
+          def find_children(tags, tag_name, id, classes)
+            children = tags.inject([]) { |result, tag| result += tag.child_tags }
+
+            children.select! { |tag| tag.tag_name == tag_name } if tag_name
+            children.select! { |tag| classes.all? { |cls| tag.has_class?(cls) } } if classes
+            children.select! { |tag| tag.id == id } if id
+
+            children
+          end
+
+          def find_descendants(tags, tag_name, id, classes)
+            if id
+              # Find all children by ID.
+              children = tags.map{ |tag| tag.find_by_id(id) }.compact
+
+              # If a tag or classes are specified as well, filter the children.
+              children.select! { |tag| tag.tag_name == tag_name } if tag_name
+              children.select! { |tag| classes.all? { |cls| tag.has_class?(cls) } } if classes
+
+              children
+            elsif tag_name || classes
+              # All descendants matching tag and/or classes.
+              tags.inject([]) { |result, tag| result += tag.find_by_tag_and_classes(tag_name, classes) }
+            else
+              # All descendants.
+              tags.inject([]) { |result, tag| result += tag.descendant_tags }
+            end
+          end
+
+          def filter_by_pseudos(tags, pseudos)
+            pseudos.each do |pseudo|
+              case pseudo
+              when 'first'
+                tags.slice! 1..-1
+              when 'last'
+                tags.slice! 0..-2
+              when 'first-child'
+                tags.select! do |tag|
+                  tag == tag.parent.children.first
+                end
+              when 'last-child'
+                tags.select! do |tag|
+                  tag == tag.parent.children.last
+                end
+              end
+            end
+          end
+
+          def filter_by_attributes(tags, attributes)
+            attributes.scan(/\[(.+?=".+?")\]|\[(.+?)\]/).each do |quoted, simple|
+              key, value = (quoted||simple).split('=')
+              value = $1 if value =~ /^"(.+?)"$/
+              if value
+                tags.select! { |tag| tag[key] == value }
+              else
+                tags.select! { |tag| tag.has_attribute?(key) }
+              end
+            end
+          end
+
+      end
+
+  end
+end

data/lib/arbre/html/tag.rb

@@ -0,0 +1,317 @@
+require 'erb'
+
+module Arbre
+  module Html
+
+    # HTML tag element. Has attributes and is rendered as a HTML tag.
+    class Tag < Element
+
+      ######
+      # Initialization
+
+        def initialize(*)
+          super
+
+          @attributes = Attributes.new
+        end
+
+      ######
+      # Attributes
+
+        # Override this to provide a proper tag name.
+        # You can also use method {.tag} for the same purpose.
+        def tag_name
+          raise NotImplementedError, "method `tag_name' not implemented for #{self.class.name}"
+        end
+
+        # Override this if you want to give your tag a default ID.
+        # You can also use method {.id} for the same purpose.
+        def tag_id
+        end
+
+        # Override this if you want to give your tag some default classes.
+        # You can also use method {.classes} for the same purpose.
+        def tag_classes
+        end
+
+        attr_reader :attributes
+
+      ######
+      # Building
+
+        # Builds a tag.
+        #
+        # Any remaining keyword arguments that are received by this method are merged
+        # into the attributes array. This means that in your subclass, you can use
+        # keyword arguments, if you always end with +**extra+ which you pass on to this
+        # method.
+        #
+        # @param [String] content
+        #   Any raw content for in the tag.
+        # @param [Hash] attributes
+        #   HTML attributes to render.
+        def build!(*args, **extra)
+          attributes = args.extract_options!
+
+          self.content  = args.first unless args.empty?
+          self.id     ||= tag_id
+
+          attributes.update extra
+
+          # Take out attributes that have a corresponding '<attribute>=' method, so that
+          # they can be processed better.
+          attributes.keys.each do |name|
+            next if name.to_s == 'content'
+            next if helpers && helpers.respond_to?(:"#{name}=")
+
+            send :"#{name}=", attributes.delete(name) if respond_to?(:"#{name}=")
+          end
+
+          # Set all other attributes normally.
+          self.attributes.update attributes
+
+          # Add classes now, so as to not overwrite these with a :class argument.
+          add_class tag_classes.join(' ') if tag_classes.present?
+
+          super()
+        end
+
+      ######
+      # Attributes
+
+        class << self
+
+          # Defines an HTML attribute accessor.
+          #
+          # == Example
+          #
+          #   class CheckBox < Tag
+          #
+          #     def tag_name
+          #       'input'
+          #     end
+          #
+          #     attribute :value
+          #     attribute :checked, boolean: true
+          #
+          #     def build
+          #       self[:type] = 'checkbox'
+          #       self.value = '1'         # equivalent to self[:value] = '1'
+          #       self.checked = true      # equivalent to self[:checked] = 'checked'
+          #       self.checked = false     # equivalent to self[:checked] = nil, i.e. removes the attribute
+          #     end
+          #
+          #   end
+          def attribute(*attributes, boolean: false)
+            attributes.each do |attribute|
+              if boolean
+                class_eval <<-RUBY, __FILE__, __LINE__+1
+                  def #{attribute}
+                    has_attribute? :#{attribute}
+                  end
+                  def #{attribute}=(value)
+                    self[:#{attribute}] = !!value
+                  end
+                RUBY
+              else
+                class_eval <<-RUBY, __FILE__, __LINE__+1
+                  def #{attribute}
+                    self[:#{attribute}]
+                  end
+                  def #{attribute}=(value)
+                    self[:#{attribute}] = value
+                  end
+                RUBY
+              end
+            end
+          end
+
+          # Defines the tag name for this class and derived classes. This is a DSL-alternative to
+          # defining method tag_name.
+          #
+          # == Usage
+          #
+          # The following two are equivalent:
+          #
+          #   tag 'div'
+          #
+          # and
+          #
+          #   def tag_name
+          #     'div'
+          #   end
+          def tag(tag)
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              def tag_name
+                #{tag.to_s.inspect}
+              end
+            RUBY
+          end
+
+          # Defines the tag ID attribute for this class and derived classes.
+          #
+          # == Usage
+          #
+          # The following two are equivalent:
+          #
+          #   id 'my-div'
+          #
+          # and
+          #
+          #   def build!(*)
+          #     super
+          #     self.id = 'my-div'
+          #   end
+          def id(id)
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              def tag_id
+                #{id.to_s.inspect}
+              end
+            RUBY
+          end
+
+          # Defines the tag (CSS) classes for this class and derived classes.
+          #
+          # == Usage
+          #
+          # The following two are equivalent:
+          #
+          #   classes 'dashboard', 'floatright'
+          #
+          # and
+          #
+          #   def build!(*)
+          #     super
+          #     add_class 'dashboard'
+          #     add_class 'floatright'
+          #   end
+          def classes(*classes)
+            classes = classes.flatten.map(&:to_s)
+            class_eval <<-RUBY, __FILE__, __LINE__+1
+              def tag_classes
+                #{classes.inspect}
+              end
+            RUBY
+          end
+
+        end
+
+        def [](attribute)
+          attributes[attribute]
+        end
+        alias_method :get_attribute, :[]
+
+        def []=(attribute, value)
+          attributes[attribute] = value
+        end
+        alias_method :set_attribute, :[]=
+
+        def has_attribute?(name)
+          attributes.has_key? name
+        end
+
+      ######
+      # ID, class, style
+
+        attribute :id
+        def generate_id!
+          self.id = object_id
+        end
+
+        def add_class(classes)
+          self[:class].add classes if classes.present?
+        end
+
+        def remove_class(classes)
+          self[:class].remove classes
+          self[:class] = nil if self[:class].empty?
+        end
+
+        def classes=(classes)
+          self[:class] = classes.present? ? classes : nil
+        end
+
+        def classes
+          self[:class]
+        end
+
+        def has_class?(klass)
+          klass.split(' ').all? { |cls| classes.include?(cls) }
+        end
+
+      ######
+      # Rendering
+
+        def to_s
+          indent opening_tag, content, closing_tag
+        end
+
+        private
+
+        def opening_tag
+          attrs = " #{attributes}" unless attributes.empty?
+          "<#{tag_name}#{attrs}>".html_safe
+        end
+
+        def closing_tag
+          "</#{tag_name}>".html_safe
+        end
+
+        def self_closing_tag
+          attrs = " #{attributes}" unless attributes.empty?
+          "<#{tag_name}#{attrs}/>".html_safe
+        end
+
+        INDENT_SIZE = 2
+
+        def indent(open_tag, child_content, close_tag)
+          spaces = (' ' * indent_level * INDENT_SIZE)
+
+          html = ActiveSupport::SafeBuffer.new
+
+          if empty? && self_closing_tag?
+            html << spaces << self_closing_tag
+          elsif empty? || one_line?
+            html << spaces << open_tag << child_content << close_tag
+          else
+            html << spaces << open_tag << "\n"
+            html << child_content << "\n"
+            html << spaces << close_tag
+          end
+
+          html
+        end
+
+        public
+
+        def empty?
+          children.empty?
+        end
+
+        def one_line?
+          children.length == 1 &&
+          children.first.is_a?(TextNode) &&
+          !children.first.text.include?("\n")
+        end
+
+        def self_closing_tag?
+          false
+        end
+
+      ######
+      # Misc
+
+        def inspect
+          tag_desc = tag_name
+          tag_desc << "(#{self.class.name})" if self.class.name.demodulize != tag_name.camelize
+          tag_desc << "##{id}" if id
+          tag_desc << classes.map{ |cls| ".#{cls}" }.join
+          tag_desc << "[type=#{self[:type]}]" if has_attribute?(:type)
+
+          "<#{tag_desc}>"
+        end
+
+    end
+
+  end
+end