refinerycms 0.9.6.34 → 0.9.7

data/vendor/plugins/hpricot/lib/hpricot/inspect.rb

@@ -1,103 +0,0 @@
-require 'pp'
-
-module Hpricot
-  # :stopdoc:
-  class Elements
-    def pretty_print(q)
-      q.object_group(self) { super }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  class Doc
-    def pretty_print(q)
-      q.object_group(self) { children.each {|elt| q.breakable; q.pp elt } if children }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  module Leaf
-    def pretty_print(q)
-      q.group(1, '{', '}') {
-        q.text self.class.name.sub(/.*::/,'').downcase
-        if rs = raw_string
-          rs.scan(/[^\r\n]*(?:\r\n?|\n|[^\r\n]\z)/) {|line|
-            q.breakable
-            q.pp line
-          }
-        elsif self.respond_to? :to_s
-          q.breakable
-          q.text self.to_s
-        end
-      }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  class Elem
-    def pretty_print(q)
-      if empty?
-        q.group(1, '{emptyelem', '}') {
-          q.breakable; pretty_print_stag q
-        }
-      else
-        q.group(1, "{elem", "}") {
-          q.breakable; pretty_print_stag q
-          if children
-            children.each {|elt| q.breakable; q.pp elt }
-          end
-          if etag
-            q.breakable; q.text etag
-          end
-        }
-      end
-    end
-    def pretty_print_stag(q)
-      q.group(1, '<', '>') {
-        q.text name
-
-        if raw_attributes
-          raw_attributes.each {|n, t|
-            q.breakable
-            if t
-              q.text "#{n}=\"#{Hpricot.uxs(t)}\""
-            else
-              q.text n
-            end
-          }
-        end
-      }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  class ETag
-    def pretty_print(q)
-      q.group(1, '</', '>') {
-        q.text name
-      }
-    end
-    alias inspect pretty_print_inspect
-  end
-
-  class Text
-    def pretty_print(q)
-      q.text content.dump
-    end
-  end
-
-  class BogusETag
-    def pretty_print(q)
-      q.group(1, '{', '}') {
-        q.text self.class.name.sub(/.*::/,'').downcase
-        if rs = raw_string
-          q.breakable
-          q.text rs
-        else
-          q.text "</#{name}>"
-        end
-      }
-    end
-  end
-  # :startdoc:
-end

data/vendor/plugins/hpricot/lib/hpricot/modules.rb

@@ -1,40 +0,0 @@
-module Hpricot
-  class Name; include Hpricot end
-  class Context; include Hpricot end
-
-  # :stopdoc:
-  module Tag; include Hpricot end
-    class ETag; include Tag end
-  # :startdoc:
-
-  module Node; include Hpricot end
-    class ETag; include Node end
-    module Container; include Node end
-      class Doc; include Container end
-      class Elem; include Container end
-
-    module Leaf; include Node end
-      class CData; include Leaf end
-      class Text; include Leaf end
-      class XMLDecl; include Leaf end
-      class DocType; include Leaf end
-      class ProcIns; include Leaf end
-      class Comment; include Leaf end
-      class BogusETag; include Leaf end
-
-  module Traverse end
-  module Container::Trav; include Traverse end
-  module Leaf::Trav; include Traverse end
-  class Doc;       module Trav; include Container::Trav end; include Trav end
-  class Elem;      module Trav; include Container::Trav end; include Trav end
-  class CData;     module Trav; include Leaf::Trav      end; include Trav end
-  class Text;      module Trav; include Leaf::Trav      end; include Trav end
-  class XMLDecl;   module Trav; include Leaf::Trav      end; include Trav end
-  class DocType;   module Trav; include Leaf::Trav      end; include Trav end
-  class ProcIns;   module Trav; include Leaf::Trav      end; include Trav end
-  class Comment;   module Trav; include Leaf::Trav      end; include Trav end
-  class BogusETag; module Trav; include Leaf::Trav      end; include Trav end
-
-  class Error < StandardError; end
-end
-

data/vendor/plugins/hpricot/lib/hpricot/parse.rb

@@ -1,38 +0,0 @@
-require 'hpricot/htmlinfo'
-
-def Hpricot(input = nil, opts = {}, &blk)
-  Hpricot.make(input, opts, &blk)
-end
-
-module Hpricot
-  # Exception class used for any errors related to deficiencies in the system when
-  # handling the character encodings of a document.
-  class EncodingError < StandardError; end
-
-  # Hpricot.parse parses <i>input</i> and return a document tree.
-  # represented by Hpricot::Doc.
-  def Hpricot.parse(input = nil, opts = {}, &blk)
-    make(input, opts, &blk)
-  end
-
-  # Hpricot::XML parses <i>input</i>, disregarding all the HTML rules
-  # and returning a document tree.
-  def Hpricot.XML(input = nil, opts = {}, &blk)
-    opts.merge! :xml => true
-    make(input, opts, &blk)
-  end
-
-  # :stopdoc:
-
-  def Hpricot.make(input = nil, opts = {}, &blk)
-    if blk
-      doc = Hpricot.build(&blk)
-      doc.instance_variable_set("@options", opts)
-      doc
-    else
-      Hpricot.scan(input, opts)
-    end
-  end
-
-  # :startdoc:
-end

data/vendor/plugins/hpricot/lib/hpricot/tag.rb

@@ -1,219 +0,0 @@
-module Hpricot
-  # :stopdoc:
-
-  class Doc
-    def output(out, opts = {})
-      children.each do |n|
-        n.output(out, opts)
-      end if children
-      out
-    end
-    def make(input = nil, &blk)
-      Hpricot.make(input, @options, &blk).children
-    end
-    def altered!; end
-    def inspect_tree
-      children.map { |x| x.inspect_tree }.join if children
-    end
-  end
-
-  module Node
-    def html_quote(str)
-      "\"" + str.gsub('"', '\\"') + "\""
-    end
-    def clear_raw; end
-    def if_output(opts)
-      if opts[:preserve] and not raw_string.nil?
-        raw_string
-      else
-        yield opts
-      end
-    end
-    def pathname; self.name end
-    def altered!
-      clear_raw
-    end
-    def inspect_tree(depth = 0)
-      %{#{" " * depth}} + self.class.name.split(/::/).last.downcase + "\n"
-    end
-  end
-
-  class Attributes
-    attr_accessor :element
-    def initialize e
-      @element = e
-    end
-    def [] k
-      Hpricot.uxs((@element.raw_attributes || {})[k])
-    end
-    def []= k, v
-      (@element.raw_attributes ||= {})[k] = v.fast_xs
-    end
-    def to_hash
-      if @element.raw_attributes
-        @element.raw_attributes.inject({}) do |hsh, (k, v)|
-          hsh[k] = Hpricot.uxs(v)
-          hsh
-        end
-      else
-        {}
-      end
-    end
-    def to_s
-      to_hash.to_s
-    end
-    def inspect
-      to_hash.inspect
-    end
-  end
-
-  class Elem
-    def initialize tag, attrs = nil, children = nil, etag = nil
-      self.name, self.raw_attributes, self.children, self.etag =
-        tag, attrs, children, etag
-    end
-    def empty?; children.nil? or children.empty? end
-    def attributes
-      Attributes.new self
-    end
-    def to_plain_text
-      if self.name == 'br'
-        "\n"
-      elsif self.name == 'p'
-        "\n\n" + super + "\n\n"
-      elsif self.name == 'a' and self.has_attribute?('href')
-        "#{super} [#{self['href']}]"
-      elsif self.name == 'img' and self.has_attribute?('src')
-        "[img:#{self['src']}]"
-      else
-        super
-      end
-    end
-    def pathname; self.name end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<#{name}#{attributes_as_html}" +
-            ((empty? and not etag) ? " /" : "") +
-            ">"
-        end
-      if children
-        children.each { |n| n.output(out, opts) }
-      end
-      if opts[:preserve]
-        out << etag if etag
-      elsif etag or !empty?
-        out << "</#{name}>"
-      end
-      out
-    end
-    def attributes_as_html
-      if raw_attributes
-        raw_attributes.map do |aname, aval|
-          " #{aname}" +
-            (aval ? "=#{html_quote aval}" : "")
-        end.join
-      end
-    end
-    def inspect_tree(depth = 0)
-      %{#{" " * depth}} + name + "\n" +
-        (children ? children.map { |x| x.inspect_tree(depth + 1) }.join : "")
-    end
-  end
-
-  class BogusETag
-    def initialize name; self.name = name end
-    def output(out, opts = {})
-      out << if_output(opts) { "" }
-    end
-  end
-
-  class ETag < BogusETag
-    def output(out, opts = {}); out << if_output(opts) { '' }; end
-  end
-
-  class Text
-    def initialize content; self.content = content end
-    def pathname; "text()" end
-    def to_s
-      Hpricot.uxs(content)
-    end
-    alias_method :inner_text, :to_s
-    alias_method :to_plain_text, :to_s
-    def << str; self.content << str end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          content.to_s
-        end
-    end
-  end
-
-  class CData
-    def initialize content; self.content = content end
-    alias_method :to_s, :content
-    alias_method :to_plain_text, :content
-    alias_method :inner_text, :content
-    def raw_string; "<![CDATA[#{content}]]>" end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<![CDATA[#{content}]]>"
-        end
-    end
-  end
-
-  class XMLDecl
-    def pathname; "xmldecl()" end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<?xml version=\"#{version}\"" +
-            (encoding ? " encoding=\"#{encoding}\"" : "") +
-            (standalone != nil ? " standalone=\"#{standalone ? 'yes' : 'no'}\"" : "") +
-            "?>"
-        end
-    end
-  end
-
-  class DocType
-    def initialize target, pub, sys
-      self.target, self.public_id, self.system_id = target, pub, sys
-    end
-    def pathname; "doctype()" end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<!DOCTYPE #{target} " +
-            (public_id ? "PUBLIC \"#{public_id}\"" : "SYSTEM") +
-            (system_id ? " #{html_quote(system_id)}" : "") + ">"
-        end
-    end
-  end
-
-  class ProcIns
-    def pathname; "procins()" end
-    def raw_string; output("") end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<?#{target}" +
-           (content ? " #{content}" : "") +
-           "?>"
-        end
-    end
-  end
-
-  class Comment
-    def pathname; "comment()" end
-    def raw_string; "<!--#{content}-->" end
-    def output(out, opts = {})
-      out <<
-        if_output(opts) do
-          "<!--#{content}-->"
-        end
-    end
-  end
-
-  # :startdoc:
-end

data/vendor/plugins/hpricot/lib/hpricot/tags.rb

@@ -1,164 +0,0 @@
-module Hpricot
-
-  FORM_TAGS = [ :form, :input, :select, :textarea ]
-  SELF_CLOSING_TAGS = [ :base, :meta, :link, :hr, :br, :param, :img, :area, :input, :col ]
-
-  # Common sets of attributes.
-  AttrCore = [:id, :class, :style, :title]
-  AttrI18n = [:lang, 'xml:lang'.intern, :dir]
-  AttrEvents = [:onclick, :ondblclick, :onmousedown, :onmouseup, :onmouseover, :onmousemove,
-      :onmouseout, :onkeypress, :onkeydown, :onkeyup]
-  AttrFocus = [:accesskey, :tabindex, :onfocus, :onblur]
-  AttrHAlign = [:align, :char, :charoff]
-  AttrVAlign = [:valign]
-  Attrs = AttrCore + AttrI18n + AttrEvents
-
-  # All the tags and attributes from XHTML 1.0 Strict
-  class XHTMLStrict
-    class << self
-      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
-    end
-    @doctype = ["-//W3C//DTD XHTML 1.0 Strict//EN", "DTD/xhtml1-strict.dtd"]
-    @tagset = {
-      :html => AttrI18n + [:id, :xmlns],
-      :head => AttrI18n + [:id, :profile],
-      :title => AttrI18n + [:id],
-      :base => [:href, :id],
-      :meta => AttrI18n + [:id, :http, :name, :content, :scheme, 'http-equiv'.intern],
-      :link => Attrs + [:charset, :href, :hreflang, :type, :rel, :rev, :media],
-      :style => AttrI18n + [:id, :type, :media, :title, 'xml:space'.intern],
-      :script => [:id, :charset, :type, :src, :defer, 'xml:space'.intern],
-      :noscript => Attrs,
-      :body => Attrs + [:onload, :onunload],
-      :div => Attrs,
-      :p => Attrs,
-      :ul => Attrs,
-      :ol => Attrs,
-      :li => Attrs,
-      :dl => Attrs,
-      :dt => Attrs,
-      :dd => Attrs,
-      :address => Attrs,
-      :hr => Attrs,
-      :pre => Attrs + ['xml:space'.intern],
-      :blockquote => Attrs + [:cite],
-      :ins => Attrs + [:cite, :datetime],
-      :del => Attrs + [:cite, :datetime],
-      :a => Attrs + AttrFocus + [:charset, :type, :name, :href, :hreflang, :rel, :rev, :shape, :coords],
-      :span => Attrs,
-      :bdo => AttrCore + AttrEvents + [:lang, 'xml:lang'.intern, :dir],
-      :br => AttrCore,
-      :em => Attrs,
-      :strong => Attrs,
-      :dfn => Attrs,
-      :code => Attrs,
-      :samp => Attrs,
-      :kbd => Attrs,
-      :var => Attrs,
-      :cite => Attrs,
-      :abbr => Attrs,
-      :acronym => Attrs,
-      :q => Attrs + [:cite],
-      :sub => Attrs,
-      :sup => Attrs,
-      :tt => Attrs,
-      :i => Attrs,
-      :b => Attrs,
-      :big => Attrs,
-      :small => Attrs,
-      :object => Attrs + [:declare, :classid, :codebase, :data, :type, :codetype, :archive, :standby, :height, :width, :usemap, :name, :tabindex],
-      :param => [:id, :name, :value, :valuetype, :type],
-      :img => Attrs + [:src, :alt, :longdesc, :height, :width, :usemap, :ismap],
-      :map => AttrI18n + AttrEvents + [:id, :class, :style, :title, :name],
-      :area => Attrs + AttrFocus + [:shape, :coords, :href, :nohref, :alt],
-      :form => Attrs + [:action, :method, :enctype, :onsubmit, :onreset, :accept, :accept],
-      :label => Attrs + [:for, :accesskey, :onfocus, :onblur],
-      :input => Attrs + AttrFocus + [:type, :name, :value, :checked, :disabled, :readonly, :size, :maxlength, :src, :alt, :usemap, :onselect, :onchange, :accept],
-      :select => Attrs + [:name, :size, :multiple, :disabled, :tabindex, :onfocus, :onblur, :onchange],
-      :optgroup => Attrs + [:disabled, :label],
-      :option => Attrs + [:selected, :disabled, :label, :value],
-      :textarea => Attrs + AttrFocus + [:name, :rows, :cols, :disabled, :readonly, :onselect, :onchange],
-      :fieldset => Attrs,
-      :legend => Attrs + [:accesskey],
-      :button => Attrs + AttrFocus + [:name, :value, :type, :disabled],
-      :table => Attrs + [:summary, :width, :border, :frame, :rules, :cellspacing, :cellpadding],
-      :caption => Attrs,
-      :colgroup => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
-      :col => Attrs + AttrHAlign + AttrVAlign + [:span, :width],
-      :thead => Attrs + AttrHAlign + AttrVAlign,
-      :tfoot => Attrs + AttrHAlign + AttrVAlign,
-      :tbody => Attrs + AttrHAlign + AttrVAlign,
-      :tr => Attrs + AttrHAlign + AttrVAlign,
-      :th => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
-      :td => Attrs + AttrHAlign + AttrVAlign + [:abbr, :axis, :headers, :scope, :rowspan, :colspan],
-      :h1 => Attrs,
-      :h2 => Attrs,
-      :h3 => Attrs,
-      :h4 => Attrs,
-      :h5 => Attrs,
-      :h6 => Attrs
-    }
-
-    @tags = @tagset.keys
-    @forms = @tags & FORM_TAGS
-    @self_closing = @tags & SELF_CLOSING_TAGS
-  end
-
-  # Additional tags found in XHTML 1.0 Transitional
-  class XHTMLTransitional
-    class << self
-      attr_accessor :tags, :tagset, :forms, :self_closing, :doctype
-    end
-    @doctype = ["-//W3C//DTD XHTML 1.0 Transitional//EN", "DTD/xhtml1-transitional.dtd"]
-    @tagset = XHTMLStrict.tagset.merge \
-      :strike => Attrs,
-      :center => Attrs,
-      :dir => Attrs + [:compact],
-      :noframes => Attrs,
-      :basefont => [:id, :size, :color, :face],
-      :u => Attrs,
-      :menu => Attrs + [:compact],
-      :iframe => AttrCore + [:longdesc, :name, :src, :frameborder, :marginwidth, :marginheight, :scrolling, :align, :height, :width],
-      :font => AttrCore + AttrI18n + [:size, :color, :face],
-      :s => Attrs,
-      :applet => AttrCore + [:codebase, :archive, :code, :object, :alt, :name, :width, :height, :align, :hspace, :vspace],
-      :isindex => AttrCore + AttrI18n + [:prompt]
-
-    # Additional attributes found in XHTML 1.0 Transitional
-    { :script => [:language],
-      :a => [:target],
-      :td => [:bgcolor, :nowrap, :width, :height],
-      :p => [:align],
-      :h5 => [:align],
-      :h3 => [:align],
-      :li => [:type, :value],
-      :div => [:align],
-      :pre => [:width],
-      :body => [:background, :bgcolor, :text, :link, :vlink, :alink],
-      :ol => [:type, :compact, :start],
-      :h4 => [:align],
-      :h2 => [:align],
-      :object => [:align, :border, :hspace, :vspace],
-      :img => [:name, :align, :border, :hspace, :vspace],
-      :link => [:target],
-      :legend => [:align],
-      :dl => [:compact],
-      :input => [:align],
-      :h6 => [:align],
-      :hr => [:align, :noshade, :size, :width],
-      :base => [:target],
-      :ul => [:type, :compact],
-      :br => [:clear],
-      :form => [:name, :target],
-      :area => [:target],
-      :h1 => [:align]
-    }.each do |k, v|
-        @tagset[k] += v
-    end
-
-    @tags = @tagset.keys
-    @forms = @tags & FORM_TAGS
-    @self_closing = @tags & SELF_CLOSING_TAGS
-  end
-
-end