Class: Amrita::Element

Class Amrita::Element |
In: | lib/amrita/node_expand.rb lib/amrita/node.rb lib/amrita/format.rb lib/amrita/compiler.rb
Parent: | Object

represents HTML element

Methods

<< == [] []= apply_to_children clone delete_attr! each_element_with_id hid hide_hid! include_attr? new put_attr set_tag set_text tagclass tagname tagname_symbol to_ruby

Attributes

:attrs | [R] | return attributes as AttrArray CAUTION! never edit result of this method. use []= instead. because it may be shared by other Elements.
:attrs_hash | [R] | CAUTION! internal use only
:body | [R] | return body
:hide_hid | [R] | CAUTION! internal use only

Included modules

Node

Public Class methods

new(tagname_or_element, *a, &block)

Don't use Element.new. Use Amrita#e instead.

    # File lib/amrita/node.rb, line 340
        def initialize(tagname_or_element, *a, &block)
          case tagname_or_element
          when Element
            @tagname = tagname_or_element.tagname_symbol
            @attrs = tagname_or_element.attrs
            @attrs.shared = true
            @attrs_hash = tagname_or_element.attrs_hash
            @hide_hid = tagname_or_element.hide_hid
            if block_given?
              init_body(&block)
            else
              @body = tagname_or_element.body.clone
            end
          when Symbol, String
            set_tag(tagname_or_element)
            @attrs = AttrArray.new
            @attrs_hash = {}
            @hide_hid = false
            if a.size() == 1 and a.kind_of?(AttrArray)
              @attrs = a
              @attrs.shared = true
              @attrs.each do |a|
                @attrs_hash[a.key_symbol] = a
              end
            else
              a.each { |aa| put_attr(aa) }
            end
            if block_given?
              init_body(&block)
            else
              @body = Null
            end
          end
        end

Public Instance methods

apply_to_children(&block) {|body| ...}

    # File lib/amrita/node_expand.rb, line 336
        def apply_to_children(&block)
          clone { yield(body) }
        end

==(x)

test if tagname and attributes and body are equal to self. doesn't concern the order of attributes

    # File lib/amrita/node.rb, line 377
        def ==(x)
          return false unless x.kind_of?(Element)
          return true if x.id == id
          return false unless x.tagname_symbol == @tagname
          return false unless x.attrs.size == @attrs.size
          @attrs.each do |a|
            return false unless x[a.key] == a.value
          end
          return false unless x.body == @body
          true
        end

set_tag(tagname)

    # File lib/amrita/node.rb, line 389
        def set_tag(tagname)
          if tagname
            @tagname = tagname.intern
          else
            @tagname = nil
          end
        end

clone(&block)

    # File lib/amrita/node.rb, line 397
        def clone(&block)
          Element.new(self, &block)
        end

tagname()

return Tag as String

    # File lib/amrita/node.rb, line 402
        def tagname
          @tagname.id2name
        end

tagname_symbol()

return Tag as Symbol

    # File lib/amrita/node.rb, line 407
        def tagname_symbol
          @tagname
        end

hid()

return id=... attribule value. It can be hide by +hide_hid!

    # File lib/amrita/node.rb, line 412
        def hid
          if @hide_hid
            nil
          else
            self[:id] or self[:ID]
          end
        end

hide_hid!()

hide hid for internal use (expand).

    # File lib/amrita/node.rb, line 421
        def hide_hid!
          @hide_hid = true
        end

tagclass()

    # File lib/amrita/node.rb, line 425
        def tagclass
          self[:class]
        end

put_attr(a)

set attribule.

    # File lib/amrita/node.rb, line 430
        def put_attr(a)
          copy_on_write if @attrs.shared
          case a
          when Attr
            if @attrs_hash[a.key_symbol]
              self[a.key_symbol] = a.value
            else
              a = a.clone
              @attrs << a
              @attrs_hash[a.key_symbol] = a
            end
          when AttrArray
            a.each do |aa|
              put_attr(aa)
            end
          when Hash
            a.each do |k, v|
              put_attr(Attr.new(k, v))
            end
          else
            raise " << not a Attr but a #{a.class}" unless a.kind_of?(Attr)
          end
        end

<<(a, &block)

    # File lib/amrita/node.rb, line 454
        def <<(a, &block)
          put_attr(a)
          init_body(&block) if block_given?
          self
        end

include_attr?(key)

test if it has attribule for `key`

    # File lib/amrita/node.rb, line 461
        def include_attr?(key)
          @attrs_hash.include?(key.intern)
        end

[](key)

return attribule value for `key`

    # File lib/amrita/node.rb, line 466
        def [](key)
          a = @attrs_hash[key.intern]
          if a
            a.value
          else
            nil
          end
        end

[]=(key, value)

set attribule. delete it if `value` is `nil`

    # File lib/amrita/node.rb, line 476
        def []=(key, value)
          copy_on_write if @attrs.shared
          key = key.intern
          a = @attrs_hash[key]
          if a
            if value
              a.value = value
            else
              delete_attr!(key)
            end
          else
            put_attr(Attr.new(key,value)) if value
          end
          value
        end

delete_attr!(key)

delete attribute of `key`

    # File lib/amrita/node.rb, line 493
        def delete_attr!(key)
          copy_on_write if @attrs.shared
          key = key.intern
          old_attrs = @attrs
          @attrs = AttrArray.new
          @attrs_hash = {}
          old_attrs.each do |a|
            put_attr(a) if a.key_symbol != key
          end
        end

to_ruby()

    # File lib/amrita/node.rb, line 504
        def to_ruby
          ret = "e(:#{tagname}"
          if attrs.size > 0
            ret << ","
            ret << attrs.collect { |a| a.to_ruby}.join(",")
          end
          ret << ") "
          ret << "{ #{body.to_ruby} }" if body and not body.kind_of?(NullNode)
          ret
        end

each_element_with_id(recursive=false, &block) {|self| ...}

    # File lib/amrita/node.rb, line 515
        def each_element_with_id(recursive=false, &block)
          if hid
            yield(self)
            super if recursive
          else
            super
          end
        end

set_text(text)

set the `text` to body of this Element.

    # File lib/amrita/node.rb, line 525
        def set_text(text)
          @body = TextElement.new(text)
        end