ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/rss/utils.rb

@@ -0,0 +1,111 @@
+module RSS
+  module Utils
+    module_function
+
+    # Convert a name_with_underscores to CamelCase.
+    def to_class_name(name)
+      name.split(/[_\-]/).collect do |part|
+        "#{part[0, 1].upcase}#{part[1..-1]}"
+      end.join("")
+    end
+    
+    def get_file_and_line_from_caller(i=0)
+      file, line, = caller[i].split(':')
+      line = line.to_i
+      line += 1 if i.zero?
+      [file, line]
+    end
+
+    # escape '&', '"', '<' and '>' for use in HTML.
+    def html_escape(s)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    alias h html_escape
+    
+    # If +value+ is an instance of class +klass+, return it, else
+    # create a new instance of +klass+ with value +value+.
+    def new_with_value_if_need(klass, value)
+      if value.is_a?(klass)
+        value
+      else
+        klass.new(value)
+      end
+    end
+
+    def element_initialize_arguments?(args)
+      [true, false].include?(args[0]) and args[1].is_a?(Hash)
+    end
+
+    module YesCleanOther
+      module_function
+      def parse(value)
+        if [true, false, nil].include?(value)
+          value
+        else
+          case value.to_s
+          when /\Ayes\z/i
+            true
+          when /\Aclean\z/i
+            false
+          else
+            nil
+          end
+        end
+      end
+    end
+
+    module YesOther
+      module_function
+      def parse(value)
+        if [true, false].include?(value)
+          value
+        else
+          /\Ayes\z/i.match(value.to_s) ? true : false
+        end
+      end
+    end
+
+    module CSV
+      module_function
+      def parse(value, &block)
+        if value.is_a?(String)
+          value = value.strip.split(/\s*,\s*/)
+          value = value.collect(&block) if block_given?
+          value
+        else
+          value
+        end
+      end
+    end
+
+    module InheritedReader
+      def inherited_reader(constant_name)
+        base_class = inherited_base
+        result = base_class.const_get(constant_name)
+        found_base_class = false
+        ancestors.reverse_each do |klass|
+          if found_base_class
+            if klass.const_defined?(constant_name)
+              result = yield(result, klass.const_get(constant_name))
+            end
+          else
+            found_base_class = klass == base_class
+          end
+        end
+        result
+      end
+
+      def inherited_array_reader(constant_name)
+        inherited_reader(constant_name) do |result, current|
+          current + result
+        end
+      end
+
+      def inherited_hash_reader(constant_name)
+        inherited_reader(constant_name) do |result, current|
+          result.merge(current)
+        end
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/rss/xml-stylesheet.rb

@@ -0,0 +1,105 @@
+require "rss/utils"
+
+module RSS
+
+  module XMLStyleSheetMixin
+    attr_accessor :xml_stylesheets
+    def initialize(*args)
+      super
+      @xml_stylesheets = []
+    end
+    
+    private
+    def xml_stylesheet_pi
+      xsss = @xml_stylesheets.collect do |xss|
+        pi = xss.to_s
+        pi = nil if /\A\s*\z/ =~ pi
+        pi
+      end.compact
+      xsss.push("") unless xsss.empty?
+      xsss.join("\n")
+    end
+  end
+
+  class XMLStyleSheet
+
+    include Utils
+
+    ATTRIBUTES = %w(href type title media charset alternate)
+
+    GUESS_TABLE = {
+      "xsl" => "text/xsl",
+      "css" => "text/css",
+    }
+
+    attr_accessor(*ATTRIBUTES)
+    attr_accessor(:do_validate)
+    def initialize(*attrs)
+      if attrs.size == 1 and
+          (attrs.first.is_a?(Hash) or attrs.first.is_a?(Array))
+        attrs = attrs.first
+      end
+      @do_validate = true
+      ATTRIBUTES.each do |attr|
+        __send__("#{attr}=", nil)
+      end
+      vars = ATTRIBUTES.dup
+      vars.unshift(:do_validate)
+      attrs.each do |name, value|
+        if vars.include?(name.to_s)
+          __send__("#{name}=", value)
+        end
+      end
+    end
+
+    def to_s
+      rv = ""
+      if @href
+        rv << %Q[<?xml-stylesheet]
+        ATTRIBUTES.each do |name|
+          if __send__(name)
+            rv << %Q[ #{name}="#{h __send__(name)}"]
+          end
+        end
+        rv << %Q[?>]
+      end
+      rv
+    end
+
+    remove_method(:href=)
+    def href=(value)
+      @href = value
+      if @href and @type.nil?
+        @type = guess_type(@href)
+      end
+      @href
+    end
+
+    remove_method(:alternate=)
+    def alternate=(value)
+      if value.nil? or /\A(?:yes|no)\z/ =~ value
+        @alternate = value
+      else
+        if @do_validate
+          args = ["?xml-stylesheet?", %Q[alternate="#{value}"]]
+          raise NotAvailableValueError.new(*args)
+        end
+      end
+      @alternate
+    end
+
+    def setup_maker(maker)
+      xss = maker.xml_stylesheets.new_xml_stylesheet
+      ATTRIBUTES.each do |attr|
+        xss.__send__("#{attr}=", __send__(attr))
+      end
+    end
+    
+    private
+    def guess_type(filename)
+      /\.([^.]+)$/ =~ filename
+      GUESS_TABLE[$1]
+    end
+
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/rss/xml.rb

@@ -0,0 +1,71 @@
+require "rss/utils"
+
+module RSS
+  module XML
+    class Element
+      include Enumerable
+
+      attr_reader :name, :prefix, :uri, :attributes, :children
+      def initialize(name, prefix=nil, uri=nil, attributes={}, children=[])
+        @name = name
+        @prefix = prefix
+        @uri = uri
+        @attributes = attributes
+        if children.is_a?(String) or !children.respond_to?(:each)
+          @children = [children]
+        else
+          @children = children
+        end
+      end
+
+      def [](name)
+        @attributes[name]
+      end
+
+      def []=(name, value)
+        @attributes[name] = value
+      end
+
+      def <<(child)
+        @children << child
+      end
+
+      def each(&block)
+        @children.each(&block)
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) and
+          @name == other.name and
+          @uri == other.uri and
+          @attributes == other.attributes and
+          @children == other.children
+      end
+
+      def to_s
+        rv = "<#{full_name}"
+        attributes.each do |key, value|
+          rv << " #{Utils.html_escape(key)}=\"#{Utils.html_escape(value)}\""
+        end
+        if children.empty?
+          rv << "/>"
+        else
+          rv << ">"
+          children.each do |child|
+            rv << child.to_s
+          end
+          rv << "</#{full_name}>"
+        end
+        rv
+      end
+
+      def full_name
+        if @prefix
+          "#{@prefix}:#{@name}"
+        else
+          @name
+        end
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/rss/xmlparser.rb

@@ -0,0 +1,93 @@
+begin
+  require "xml/parser"
+rescue LoadError
+  require "xmlparser"
+end
+
+begin
+  require "xml/encoding-ja"
+rescue LoadError
+  require "xmlencoding-ja"
+  if defined?(Kconv)
+    module XMLEncoding_ja
+      class SJISHandler
+        include Kconv
+      end
+    end
+  end
+end
+
+module XML
+  class Parser
+    unless defined?(Error)
+      Error = ::XMLParserError
+    end
+  end
+end
+
+module RSS
+  
+  class REXMLLikeXMLParser < ::XML::Parser
+    
+    include ::XML::Encoding_ja
+
+    def listener=(listener)
+      @listener = listener
+    end
+
+    def startElement(name, attrs)
+      @listener.tag_start(name, attrs)
+    end
+    
+    def endElement(name)
+      @listener.tag_end(name)
+    end
+
+    def character(data)
+      @listener.text(data)
+    end
+
+    def xmlDecl(version, encoding, standalone)
+      @listener.xmldecl(version, encoding, standalone == 1)
+    end
+
+    def processingInstruction(target, content)
+      @listener.instruction(target, content)
+    end
+
+  end
+
+  class XMLParserParser < BaseParser
+
+    class << self
+      def listener
+        XMLParserListener
+      end
+    end
+    
+    private
+    def _parse
+      begin
+        parser = REXMLLikeXMLParser.new
+        parser.listener = @listener
+        parser.parse(@rss)
+      rescue ::XML::Parser::Error => e
+        raise NotWellFormedError.new(parser.line){e.message}
+      end
+    end
+    
+  end
+  
+  class XMLParserListener < BaseListener
+
+    include ListenerMixin
+    
+    def xmldecl(version, encoding, standalone)
+      super
+      # Encoding is converted to UTF-8 when XMLParser parses XML.
+      @encoding = 'UTF-8'
+    end
+
+  end
+
+end

data/vendor/javascripts/emscripted-ruby/lib/rss/xmlscanner.rb

@@ -0,0 +1,121 @@
+require 'xmlscan/scanner'
+require 'stringio'
+
+module RSS
+  
+  class XMLScanParser < BaseParser
+    
+    class << self
+      def listener
+        XMLScanListener
+      end
+    end
+    
+    private
+    def _parse
+      begin
+        if @rss.is_a?(String)
+          input = StringIO.new(@rss)
+        else
+          input = @rss
+        end
+        scanner = XMLScan::XMLScanner.new(@listener)
+        scanner.parse(input)
+      rescue XMLScan::Error => e
+        lineno = e.lineno || scanner.lineno || input.lineno
+        raise NotWellFormedError.new(lineno){e.message}
+      end
+    end
+    
+  end
+
+  class XMLScanListener < BaseListener
+    
+    include XMLScan::Visitor
+    include ListenerMixin
+
+    ENTITIES = {
+      'lt' => '<',
+      'gt' => '>',
+      'amp' => '&',
+      'quot' => '"',
+      'apos' => '\''
+    }
+
+    def on_xmldecl_version(str)
+      @version = str
+    end
+
+    def on_xmldecl_encoding(str)
+      @encoding = str
+    end
+
+    def on_xmldecl_standalone(str)
+      @standalone = str
+    end
+
+    def on_xmldecl_end
+      xmldecl(@version, @encoding, @standalone == "yes")
+    end
+
+    alias_method(:on_pi, :instruction)
+    alias_method(:on_chardata, :text)
+    alias_method(:on_cdata, :text)
+
+    def on_etag(name)
+      tag_end(name)
+    end
+
+    def on_entityref(ref)
+      text(entity(ref))
+    end
+
+    def on_charref(code)
+      text([code].pack('U'))
+    end
+
+    alias_method(:on_charref_hex, :on_charref)
+
+    def on_stag(name)
+      @attrs = {}
+    end
+
+    def on_attribute(name)
+      @attrs[name] = @current_attr = ''
+    end
+
+    def on_attr_value(str)
+      @current_attr << str
+    end
+
+    def on_attr_entityref(ref)
+      @current_attr << entity(ref)
+    end
+
+    def on_attr_charref(code)
+      @current_attr << [code].pack('U')
+    end
+
+    alias_method(:on_attr_charref_hex, :on_attr_charref)
+
+    def on_stag_end(name)
+      tag_start(name, @attrs)
+    end
+
+    def on_stag_end_empty(name)
+      tag_start(name, @attrs)
+      tag_end(name)
+    end
+
+    private
+    def entity(ref)
+      ent = ENTITIES[ref]
+      if ent
+        ent
+      else
+        wellformed_error("undefined entity: #{ref}")
+      end
+    end
+  end
+
+end