diff options
Diffstat (limited to 'test/scanners/ruby/example.in.rb')
| -rw-r--r-- | test/scanners/ruby/example.in.rb | 3789 |
1 files changed, 3789 insertions, 0 deletions
diff --git a/test/scanners/ruby/example.in.rb b/test/scanners/ruby/example.in.rb new file mode 100644 index 0000000..8e6d20e --- /dev/null +++ b/test/scanners/ruby/example.in.rb @@ -0,0 +1,3789 @@ +module CodeRay
+ module Scanners
+
+class Ruby < Scanner
+
+ RESERVED_WORDS = [
+ 'and', 'def', 'end', 'in', 'or', 'unless', 'begin',
+ 'defined?', 'ensure', 'module', 'redo', 'super', 'until',
+ 'BEGIN', 'break', 'do', 'next', 'rescue', 'then',
+ 'when', 'END', 'case', 'else', 'for', 'retry',
+ 'while', 'alias', 'class', 'elsif', 'if', 'not', 'return',
+ 'undef', 'yield',
+ ]
+
+ DEF_KEYWORDS = ['def']
+ MODULE_KEYWORDS = ['class', 'module']
+ DEF_NEW_STATE = WordList.new(:initial).
+ add(DEF_KEYWORDS, :def_expected).
+ add(MODULE_KEYWORDS, :module_expected)
+
+ WORDS_ALLOWING_REGEXP = [
+ 'and', 'or', 'not', 'while', 'until', 'unless', 'if', 'elsif', 'when'
+ ]
+ REGEXP_ALLOWED = WordList.new(false).
+ add(WORDS_ALLOWING_REGEXP, :set)
+
+ PREDEFINED_CONSTANTS = [
+ 'nil', 'true', 'false', 'self',
+ 'DATA', 'ARGV', 'ARGF', '__FILE__', '__LINE__',
+ ]
+
+ IDENT_KIND = WordList.new(:ident).
+ add(RESERVED_WORDS, :reserved).
+ add(PREDEFINED_CONSTANTS, :pre_constant)
+
+ METHOD_NAME = / #{IDENT} [?!]? /xo
+ METHOD_NAME_EX = /
+ #{METHOD_NAME} # common methods: split, foo=, empty?, gsub!
+ | \*\*? # multiplication and power
+ | [-+~]@? # plus, minus
+ | [\/%&|^`] # division, modulo or format strings, &and, |or, ^xor, `system`
+ | \[\]=? # array getter and setter
+ | <=?>? | >=? # comparison, rocket operator
+ | << | >> # append or shift left, shift right
+ | ===? # simple equality and case equality
+ /ox
+ GLOBAL_VARIABLE = / \$ (?: #{IDENT} | \d+ | [~&+`'=\/,;_.<>!@0$?*":F\\] | -[a-zA-Z_0-9] ) /ox
+
+ DOUBLEQ = / " [^"\#\\]* (?: (?: \#\{.*?\} | \#(?:$")? | \\. ) [^"\#\\]* )* "? /ox
+ SINGLEQ = / ' [^'\\]* (?: \\. [^'\\]* )* '? /ox
+ STRING = / #{SINGLEQ} | #{DOUBLEQ} /ox
+ SHELL = / ` [^`\#\\]* (?: (?: \#\{.*?\} | \#(?:$`)? | \\. ) [^`\#\\]* )* `? /ox
+ REGEXP = / \/ [^\/\#\\]* (?: (?: \#\{.*?\} | \#(?:$\/)? | \\. ) [^\/\#\\]* )* \/? /ox
+
+ DECIMAL = /\d+(?:_\d+)*/ # doesn't recognize 09 as octal error
+ OCTAL = /0_?[0-7]+(?:_[0-7]+)*/
+ HEXADECIMAL = /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/
+ BINARY = /0b[01]+(?:_[01]+)*/
+
+ EXPONENT = / [eE] [+-]? #{DECIMAL} /ox
+ FLOAT = / #{DECIMAL} (?: #{EXPONENT} | \. #{DECIMAL} #{EXPONENT}? ) /
+ INTEGER = /#{OCTAL}|#{HEXADECIMAL}|#{BINARY}|#{DECIMAL}/
+
+ def reset
+ super
+ @regexp_allowed = false
+ end
+
+ def next_token
+ return if @scanner.eos?
+
+ kind = :error
+ if @scanner.scan(/\s+/) # in every state
+ kind = :space
+ @regexp_allowed = :set if @regexp_allowed or @scanner.matched.index(?\n) # delayed flag setting
+
+ elsif @state == :def_expected
+ if @scanner.scan(/ (?: (?:#{IDENT}(?:\.|::))* | (?:@@?|$)? #{IDENT}(?:\.|::) ) #{METHOD_NAME_EX} /ox)
+ kind = :method
+ @state = :initial
+ else
+ @scanner.getch
+ end
+ @state = :initial
+
+ elsif @state == :module_expected
+ if @scanner.scan(/<</)
+ kind = :operator
+ else
+ if @scanner.scan(/ (?: #{IDENT} (?:\.|::))* #{IDENT} /ox)
+ kind = :method
+ else
+ @scanner.getch
+ end
+ @state = :initial
+ end
+
+ elsif # state == :initial
+ # IDENTIFIERS, KEYWORDS
+ if @scanner.scan(GLOBAL_VARIABLE)
+ kind = :global_variable
+ elsif @scanner.scan(/ @@ #{IDENT} /ox)
+ kind = :class_variable
+ elsif @scanner.scan(/ @ #{IDENT} /ox)
+ kind = :instance_variable
+ elsif @scanner.scan(/ __END__\n ( (?!\#CODE\#) .* )? | \#[^\n]* | =begin(?=\s).*? \n=end(?=\s|\z)(?:[^\n]*)? /mx)
+ kind = :comment
+ elsif @scanner.scan(METHOD_NAME)
+ if @last_token_dot
+ kind = :ident
+ else
+ matched = @scanner.matched
+ kind = IDENT_KIND[matched]
+ if kind == :ident and matched =~ /^[A-Z]/
+ kind = :constant
+ elsif kind == :reserved
+ @state = DEF_NEW_STATE[matched]
+ @regexp_allowed = REGEXP_ALLOWED[matched]
+ end
+ end
+
+ elsif @scanner.scan(STRING)
+ kind = :string
+ elsif @scanner.scan(SHELL)
+ kind = :shell
+ elsif @scanner.scan(/<<
+ (?:
+ ([a-zA-Z_0-9]+)
+ (?: .*? ^\1$ | .* )
+ |
+ -([a-zA-Z_0-9]+)
+ (?: .*? ^\s*\2$ | .* )
+ |
+ (["\'`]) (.+?) \3
+ (?: .*? ^\4$ | .* )
+ |
+ - (["\'`]) (.+?) \5
+ (?: .*? ^\s*\6$ | .* )
+ )
+ /mxo)
+ kind = :string
+ elsif @scanner.scan(/\//) and @regexp_allowed
+ @scanner.unscan
+ @scanner.scan(REGEXP)
+ kind = :regexp
+/%(?:[Qqxrw](?:\([^)#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^)#\\\\]*)*\)?|\[[^\]#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^\]#\\\\]*)*\]?|\{[^}#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^}#\\\\]*)*\}?|<[^>#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^>#\\\\]*)*>?|([^a-zA-Z\\\\])(?:(?!\1)[^#\\\\])*(?:(?:#\{.*?\}|#|\\\\.)(?:(?!\1)[^#\\\\])*)*\1?)|\([^)#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^)#\\\\]*)*\)?|\[[^\]#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^\]#\\\\]*)*\]?|\{[^}#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^}#\\\\]*)*\}?|<[^>#\\\\]*(?:(?:#\{.*?\}|#|\\\\.)[^>#\\\\]*)*>?|([^a-zA-Z\s\\\\])(?:(?!\2)[^#\\\\])*(?:(?:#\{.*?\}|#|\\\\.)(?:(?!\2)[^#\\\\])*)*\2?|\\\\[^#\\\\]*(?:(?:#\{.*?\}|#)[^#\\\\]*)*\\\\?)/
+ elsif @scanner.scan(/:(?:#{GLOBAL_VARIABLE}|#{METHOD_NAME_EX}|#{STRING})/ox)
+ kind = :symbol
+ elsif @scanner.scan(/
+ \? (?:
+ [^\s\\]
+ |
+ \\ (?:M-\\C-|C-\\M-|M-\\c|c\\M-|c|C-|M-))? (?: \\ (?: . | [0-7]{3} | x[0-9A-Fa-f][0-9A-Fa-f] )
+ )
+ /mox)
+ kind = :integer
+
+ elsif @scanner.scan(/ [-+*\/%=<>;,|&!()\[\]{}~?] | \.\.?\.? | ::? /x)
+ kind = :operator
+ @regexp_allowed = :set if @scanner.matched[-1,1] =~ /[~=!<>|&^,\(\[+\-\/\*%]\z/
+ elsif @scanner.scan(FLOAT)
+ kind = :float
+ elsif @scanner.scan(INTEGER)
+ kind = :integer
+ else
+ @scanner.getch
+ end
+ end
+
+ token = Token.new @scanner.matched, kind
+
+ if kind == :regexp
+ token.text << @scanner.scan(/[eimnosux]*/)
+ end
+
+ @regexp_allowed = (@regexp_allowed == :set) # delayed flag setting
+
+ token
+ end
+end
+
+register Ruby, 'ruby', 'rb'
+
+ end
+end
+class Set
+ include Enumerable
+
+ # Creates a new set containing the given objects.
+ def self.[](*ary)
+ new(ary)
+ end
+
+ # Creates a new set containing the elements of the given enumerable
+ # object.
+ #
+ # If a block is given, the elements of enum are preprocessed by the
+ # given block.
+ def initialize(enum = nil, &block) # :yields: o
+ @hash ||= Hash.new
+
+ enum.nil? and return
+
+ if block
+ enum.each { |o| add(block[o]) }
+ else
+ merge(enum)
+ end
+ end
+
+ # Copy internal hash.
+ def initialize_copy(orig)
+ @hash = orig.instance_eval{@hash}.dup
+ end
+
+ # Returns the number of elements.
+ def size
+ @hash.size
+ end
+ alias length size
+
+ # Returns true if the set contains no elements.
+ def empty?
+ @hash.empty?
+ end
+
+ # Removes all elements and returns self.
+ def clear
+ @hash.clear
+ self
+ end
+
+ # Replaces the contents of the set with the contents of the given
+ # enumerable object and returns self.
+ def replace(enum)
+ if enum.class == self.class
+ @hash.replace(enum.instance_eval { @hash })
+ else
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ clear
+ enum.each { |o| add(o) }
+ end
+
+ self
+ end
+
+ # Converts the set to an array. The order of elements is uncertain.
+ def to_a
+ @hash.keys
+ end
+
+ def flatten_merge(set, seen = Set.new)
+ set.each { |e|
+ if e.is_a?(Set)
+ if seen.include?(e_id = e.object_id)
+ raise ArgumentError, "tried to flatten recursive Set"
+ end
+
+ seen.add(e_id)
+ flatten_merge(e, seen)
+ seen.delete(e_id)
+ else
+ add(e)
+ end
+ }
+
+ self
+ end
+ protected :flatten_merge
+
+ # Returns a new set that is a copy of the set, flattening each
+ # containing set recursively.
+ def flatten
+ self.class.new.flatten_merge(self)
+ end
+
+ # Equivalent to Set#flatten, but replaces the receiver with the
+ # result in place. Returns nil if no modifications were made.
+ def flatten!
+ if detect { |e| e.is_a?(Set) }
+ replace(flatten())
+ else
+ nil
+ end
+ end
+
+ # Returns true if the set contains the given object.
+ def include?(o)
+ @hash.include?(o)
+ end
+ alias member? include?
+
+ # Returns true if the set is a superset of the given set.
+ def superset?(set)
+ set.is_a?(Set) or raise ArgumentError, "value must be a set"
+ return false if size < set.size
+ set.all? { |o| include?(o) }
+ end
+
+ # Returns true if the set is a proper superset of the given set.
+ def proper_superset?(set)
+ set.is_a?(Set) or raise ArgumentError, "value must be a set"
+ return false if size <= set.size
+ set.all? { |o| include?(o) }
+ end
+
+ # Returns true if the set is a subset of the given set.
+ def subset?(set)
+ set.is_a?(Set) or raise ArgumentError, "value must be a set"
+ return false if set.size < size
+ all? { |o| set.include?(o) }
+ end
+
+ # Returns true if the set is a proper subset of the given set.
+ def proper_subset?(set)
+ set.is_a?(Set) or raise ArgumentError, "value must be a set"
+ return false if set.size <= size
+ all? { |o| set.include?(o) }
+ end
+
+ # Calls the given block once for each element in the set, passing
+ # the element as parameter.
+ def each
+ @hash.each_key { |o| yield(o) }
+ self
+ end
+
+ # Adds the given object to the set and returns self. Use +merge+ to
+ # add several elements at once.
+ def add(o)
+ @hash[o] = true
+ self
+ end
+ alias << add
+
+ # Adds the given object to the set and returns self. If the
+ # object is already in the set, returns nil.
+ def add?(o)
+ if include?(o)
+ nil
+ else
+ add(o)
+ end
+ end
+
+ # Deletes the given object from the set and returns self. Use +subtract+ to
+ # delete several items at once.
+ def delete(o)
+ @hash.delete(o)
+ self
+ end
+
+ # Deletes the given object from the set and returns self. If the
+ # object is not in the set, returns nil.
+ def delete?(o)
+ if include?(o)
+ delete(o)
+ else
+ nil
+ end
+ end
+
+ # Deletes every element of the set for which block evaluates to
+ # true, and returns self.
+ def delete_if
+ @hash.delete_if { |o,| yield(o) }
+ self
+ end
+
+ # Do collect() destructively.
+ def collect!
+ set = self.class.new
+ each { |o| set << yield(o) }
+ replace(set)
+ end
+ alias map! collect!
+
+ # Equivalent to Set#delete_if, but returns nil if no changes were
+ # made.
+ def reject!
+ n = size
+ delete_if { |o| yield(o) }
+ size == n ? nil : self
+ end
+
+ # Merges the elements of the given enumerable object to the set and
+ # returns self.
+ def merge(enum)
+ if enum.is_a?(Set)
+ @hash.update(enum.instance_eval { @hash })
+ else
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ enum.each { |o| add(o) }
+ end
+
+ self
+ end
+
+ # Deletes every element that appears in the given enumerable object
+ # and returns self.
+ def subtract(enum)
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ enum.each { |o| delete(o) }
+ self
+ end
+
+ # Returns a new set built by merging the set and the elements of the
+ # given enumerable object.
+ def |(enum)
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ dup.merge(enum)
+ end
+ alias + | ##
+ alias union | ##
+
+ # Returns a new set built by duplicating the set, removing every
+ # element that appears in the given enumerable object.
+ def -(enum)
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ dup.subtract(enum)
+ end
+ alias difference - ##
+
+ # Returns a new array containing elements common to the set and the
+ # given enumerable object.
+ def &(enum)
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ n = self.class.new
+ enum.each { |o| n.add(o) if include?(o) }
+ n
+ end
+ alias intersection & ##
+
+ # Returns a new array containing elements exclusive between the set
+ # and the given enumerable object. (set ^ enum) is equivalent to
+ # ((set | enum) - (set & enum)).
+ def ^(enum)
+ enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+ n = dup
+ enum.each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
+ n
+ end
+
+ # Returns true if two sets are equal. The equality of each couple
+ # of elements is defined according to Object#eql?.
+ def ==(set)
+ equal?(set) and return true
+
+ set.is_a?(Set) && size == set.size or return false
+
+ hash = @hash.dup
+ set.all? { |o| hash.include?(o) }
+ end
+
+ def hash # :nodoc:
+ @hash.hash
+ end
+
+ def eql?(o) # :nodoc:
+ return false unless o.is_a?(Set)
+ @hash.eql?(o.instance_eval{@hash})
+ end
+
+ # Classifies the set by the return value of the given block and
+ # returns a hash of {value => set of elements} pairs. The block is
+ # called once for each element of the set, passing the element as
+ # parameter.
+ #
+ # e.g.:
+ #
+ # require 'set'
+ # files = Set.new(Dir.glob("*.rb"))
+ # hash = files.classify { |f| File.mtime(f).year }
+ # p hash # => {2000=>#<Set: {"a.rb", "b.rb"}>,
+ # # 2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
+ # # 2002=>#<Set: {"f.rb"}>}
+ def classify # :yields: o
+ h = {}
+
+ each { |i|
+ x = yield(i)
+ (h[x] ||= self.class.new).add(i)
+ }
+
+ h
+ end
+
+ # Divides the set into a set of subsets according to the commonality
+ # defined by the given block.
+ #
+ # If the arity of the block is 2, elements o1 and o2 are in common
+ # if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are
+ # in common if block.call(o1) == block.call(o2).
+ #
+ # e.g.:
+ #
+ # require 'set'
+ # numbers = Set[1, 3, 4, 6, 9, 10, 11]
+ # set = numbers.divide { |i,j| (i - j).abs == 1 }
+ # p set # => #<Set: {#<Set: {1}>,
+ # # #<Set: {11, 9, 10}>,
+ # # #<Set: {3, 4}>,
+ # # #<Set: {6}>}>
+ def divide(&func)
+ if func.arity == 2
+ require 'tsort'
+
+ class << dig = {} # :nodoc:
+ include TSort
+
+ alias tsort_each_node each_key
+ def tsort_each_child(node, &block)
+ fetch(node).each(&block)
+ end
+ end
+
+ each { |u|
+ dig[u] = a = []
+ each{ |v| func.call(u, v) and a << v }
+ }
+
+ set = Set.new()
+ dig.each_strongly_connected_component { |css|
+ set.add(self.class.new(css))
+ }
+ set
+ else
+ Set.new(classify(&func).values)
+ end
+ end
+
+ InspectKey = :__inspect_key__ # :nodoc:
+
+ # Returns a string containing a human-readable representation of the
+ # set. ("#<Set: {element1, element2, ...}>")
+ def inspect
+ ids = (Thread.current[InspectKey] ||= [])
+
+ if ids.include?(object_id)
+ return sprintf('#<%s: {...}>', self.class.name)
+ end
+
+ begin
+ ids << object_id
+ return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
+ ensure
+ ids.pop
+ end
+ end
+
+ def pretty_print(pp) # :nodoc:
+ pp.text sprintf('#<%s: {', self.class.name)
+ pp.nest(1) {
+ pp.seplist(self) { |o|
+ pp.pp o
+ }
+ }
+ pp.text "}>"
+ end
+
+ def pretty_print_cycle(pp) # :nodoc:
+ pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
+ end
+end
+
+# SortedSet implements a set which elements are sorted in order. See Set.
+class SortedSet < Set
+ @@setup = false
+
+ class << self
+ def [](*ary) # :nodoc:
+ new(ary)
+ end
+
+ def setup # :nodoc:
+ @@setup and return
+
+ begin
+ require 'rbtree'
+
+ module_eval %{
+ def initialize(*args, &block)
+ @hash = RBTree.new
+ super
+ end
+ }
+ rescue LoadError
+ module_eval %{
+ def initialize(*args, &block)
+ @keys = nil
+ super
+ end
+
+ def clear
+ @keys = nil
+ super
+ end
+
+ def replace(enum)
+ @keys = nil
+ super
+ end
+
+ def add(o)
+ @keys = nil
+ @hash[o] = true
+ self
+ end
+ alias << add
+
+ def delete(o)
+ @keys = nil
+ @hash.delete(o)
+ self
+ end
+
+ def delete_if
+ n = @hash.size
+ @hash.delete_if { |o,| yield(o) }
+ @keys = nil if @hash.size != n
+ self
+ end
+
+ def merge(enum)
+ @keys = nil
+ super
+ end
+
+ def each
+ to_a.each { |o| yield(o) }
+ end
+
+ def to_a
+ (@keys = @hash.keys).sort! unless @keys
+ @keys
+ end
+ }
+ end
+
+ @@setup = true
+ end
+ end
+
+ def initialize(*args, &block) # :nodoc:
+ SortedSet.setup
+ initialize(*args, &block)
+ end
+end
+
+module Enumerable
+ # Makes a set from the enumerable object with given arguments.
+ def to_set(klass = Set, *args, &block)
+ klass.new(self, *args, &block)
+ end
+end
+
+# =begin
+# == RestricedSet class
+# RestricedSet implements a set with restrictions defined by a given
+# block.
+#
+# === Super class
+# Set
+#
+# === Class Methods
+# --- RestricedSet::new(enum = nil) { |o| ... }
+# --- RestricedSet::new(enum = nil) { |rset, o| ... }
+# Creates a new restricted set containing the elements of the given
+# enumerable object. Restrictions are defined by the given block.
+#
+# If the block's arity is 2, it is called with the RestrictedSet
+# itself and an object to see if the object is allowed to be put in
+# the set.
+#
+# Otherwise, the block is called with an object to see if the object
+# is allowed to be put in the set.
+#
+# === Instance Methods
+# --- restriction_proc
+# Returns the restriction procedure of the set.
+#
+# =end
+#
+# class RestricedSet < Set
+# def initialize(*args, &block)
+# @proc = block or raise ArgumentError, "missing a block"
+#
+# if @proc.arity == 2
+# instance_eval %{
+# def add(o)
+# @hash[o] = true if @proc.call(self, o)
+# self
+# end
+# alias << add
+#
+# def add?(o)
+# if include?(o) || !@proc.call(self, o)
+# nil
+# else
+# @hash[o] = true
+# self
+# end
+# end
+#
+# def replace(enum)
+# enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+# clear
+# enum.each { |o| add(o) }
+#
+# self
+# end
+#
+# def merge(enum)
+# enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
+# enum.each { |o| add(o) }
+#
+# self
+# end
+# }
+# else
+# instance_eval %{
+# def add(o)
+# if @proc.call(o)
+# @hash[o] = true
+# end
+# self
+# end
+# alias << add
+#
+# def add?(o)
+# if include?(o) || !@proc.call(o)
+# nil
+# else
+# @hash[o] = true
+# self
+# end
+# end
+# }
+# end
+#
+# super(*args)
+# end
+#
+# def restriction_proc
+# @proc
+# end
+# end
+
+if $0 == __FILE__
+ eval DATA.read, nil, $0, __LINE__+4
+end
+
+# = rweb - CGI Support Library
+#
+# Author:: Johannes Barre (mailto:rweb@igels.net)
+# Copyright:: Copyright (c) 2003, 04 by Johannes Barre
+# License:: GNU Lesser General Public License (COPYING, http://www.gnu.org/copyleft/lesser.html)
+# Version:: 0.1.0
+# CVS-ID:: $Id: rweb.rb 6 2004-06-16 15:56:26Z igel $
+#
+# == What is Rweb?
+# Rweb is a replacement for the cgi class included in the ruby distribution.
+#
+# == How to use
+#
+# === Basics
+#
+# This class is made to be as easy as possible to use. An example:
+#
+# require "rweb"
+#
+# web = Rweb.new
+# web.out do
+# web.puts "Hello world!"
+# end
+#
+# The visitor will get a simple "Hello World!" in his browser. Please notice,
+# that won't set html-tags for you, so you should better do something like this:
+#
+# require "rweb"
+#
+# web = Rweb.new
+# web.out do
+# web.puts "<html><body>Hello world!</body></html>"
+# end
+#
+# === Set headers
+# Of course, it's also possible to tell the browser, that the content of this
+# page is plain text instead of html code:
+#
+# require "rweb"
+#
+# web = Rweb.new
+# web.out do
+# web.header("content-type: text/plain")
+# web.puts "Hello plain world!"
+# end
+#
+# Please remember, headers can't be set after the page content has been send.
+# You have to set all nessessary headers before the first puts oder print. It's
+# possible to cache the content until everything is complete. Doing it this
+# way, you can set headers everywhere.
+#
+# If you set a header twice, the second header will replace the first one. The
+# header name is not casesensitive, it will allways converted in to the
+# capitalised form suggested by the w3c (http://w3.org)
+#
+# === Set cookies
+# Setting cookies is quite easy:
+# include 'rweb'
+#
+# web = Rweb.new
+# Cookie.new("Visits", web.cookies['visits'].to_i +1)
+# web.out do
+# web.puts "Welcome back! You visited this page #{web.cookies['visits'].to_i +1} times"
+# end
+#
+# See the class Cookie for more details.
+#
+# === Get form and cookie values
+# There are four ways to submit data from the browser to the server and your
+# ruby script: via GET, POST, cookies and file upload. Rweb doesn't support
+# file upload by now.
+#
+# include 'rweb'
+#
+# web = Rweb.new
+# web.out do
+# web.print "action: #{web.get['action']} "
+# web.puts "The value of the cookie 'visits' is #{web.cookies['visits']}"
+# web.puts "The post parameter 'test['x']' is #{web.post['test']['x']}"
+# end
+
+RWEB_VERSION = "0.1.0"
+RWEB = "rweb/#{RWEB_VERSION}"
+
+#require 'rwebcookie' -> edit by bunny :-)
+
+class Rweb
+ # All parameter submitted via the GET method are available in attribute
+ # get. This is Hash, where every parameter is available as a key-value
+ # pair.
+ #
+ # If your input tag has a name like this one, it's value will be available
+ # as web.get["fieldname"]
+ # <input name="fieldname">
+ # You can submit values as a Hash
+ # <input name="text['index']">
+ # <input name="text['index2']">
+ # will be available as
+ # web.get["text"]["index"]
+ # web.get["text"]["index2"]
+ # Integers are also possible
+ # <input name="int[2]">
+ # <input name="int[3]['hi']>
+ # will be available as
+ # web.get["int"][2]
+ # web.get["int"][3]["hi"]
+ # If you specify no index, the lowest unused index will be used:
+ # <input name="int[]"><!-- First Field -->
+ # <input name="int[]"><!-- Second one -->
+ # will be available as
+ # web.get["int"][0] # First Field
+ # web.get["int"][1] # Second one
+ # Please notice, this doesn'd work like you might expect:
+ # <input name="text[index]">
+ # It will not be available as web.get["text"]["index"] but
+ # web.get["text[index]"]
+ attr_reader :get
+
+ # All parameters submitted via POST are available in the attribute post. It
+ # works like the get attribute.
+ # <input name="text[0]">
+ # will be available as
+ # web.post["text"][0]
+ attr_reader :post
+
+ # All cookies submitted by the browser are available in cookies. This is a
+ # Hash, where every cookie is a key-value pair.
+ attr_reader :cookies
+
+ # The name of the browser identification is submitted as USER_AGENT and
+ # available in this attribute.
+ attr_reader :user_agent
+
+ # The IP address of the client.
+ attr_reader :remote_addr
+
+ # Creates a new Rweb object. This should only done once. You can set various
+ # options via the settings hash.
+ #
+ # "cache" => true: Everything you script send to the client will be cached
+ # until the end of the out block or until flush is called. This way, you
+ # can modify headers and cookies even after printing something to the client.
+ #
+ # "safe" => level: Changes the $SAFE attribute. By default, $SAFE will be set
+ # to 1. If $SAFE is already higher than this value, it won't be changed.
+ #
+ # "silend" => true: Normaly, Rweb adds automaticly a header like this
+ # "X-Powered-By: Rweb/x.x.x (Ruby/y.y.y)". With the silend option you can
+ # suppress this.
+ def initialize (settings = {})
+ # {{{
+ @header = {}
+ @cookies = {}
+ @get = {}
+ @post = {}
+
+ # Internal attributes
+ @status = nil
+ @reasonPhrase = nil
+ @setcookies = []
+ @output_started = false;
+ @output_allowed = false;
+
+ @mod_ruby = false
+ @env = ENV.to_hash
+
+ if defined?(MOD_RUBY)
+ @output_method = "mod_ruby"
+ @mod_ruby = true
+ elsif @env['SERVER_SOFTWARE'] =~ /^Microsoft-IIS/i
+ @output_method = "nph"
+ else
+ @output_method = "ph"
+ end
+
+ unless settings.is_a?(Hash)
+ raise TypeError, "settings must be a Hash"
+ end
+ @settings = settings
+
+ unless @settings.has_key?("safe")
+ @settings["safe"] = 1
+ end
+
+ if $SAFE < @settings["safe"]
+ $SAFE = @settings["safe"]
+ end
+
+ unless @settings.has_key?("cache")
+ @settings["cache"] = false
+ end
+
+ # mod_ruby sets no QUERY_STRING variable, if no GET-Parameters are given
+ unless @env.has_key?("QUERY_STRING")
+ @env["QUERY_STRING"] = ""
+ end
+
+ # Now we split the QUERY_STRING by the seperators & and ; or, if
+ # specified, settings['get seperator']
+ unless @settings.has_key?("get seperator")
+ get_args = @env['QUERY_STRING'].split(/[&;]/)
+ else
+ get_args = @env['QUERY_STRING'].split(@settings['get seperator'])
+ end
+
+ get_args.each do | arg |
+ arg_key, arg_val = arg.split(/=/, 2)
+ arg_key = Rweb::unescape(arg_key)
+ arg_val = Rweb::unescape(arg_val)
+
+ # Parse names like name[0], name['text'] or name[]
+ pattern = /^(.+)\[("[^\]]*"|'[^\]]*'|[0-9]*)\]$/
+ keys = []
+ while match = pattern.match(arg_key)
+ arg_key = match[1]
+ keys = [match[2]] + keys
+ end
+ keys = [arg_key] + keys
+
+ akt = @get
+ last = nil
+ lastkey = nil
+ keys.each do |key|
+ if key == ""
+ # No key specified (like in "test[]"), so we use the
+ # lowerst unused Integer as key
+ key = 0
+ while akt.has_key?(key)
+ key += 1
+ end
+ elsif /^[0-9]*$/ =~ key
+ # If the index is numerical convert it to an Integer
+ key = key.to_i
+ elsif key[0].chr == "'" || key[0].chr == '"'
+ key = key[1, key.length() -2]
+ end
+ if !akt.has_key?(key) || !akt[key].class == Hash
+ # create an empty Hash if there isn't already one
+ akt[key] = {}
+ end
+ last = akt
+ lastkey = key
+ akt = akt[key]
+ end
+ last[lastkey] = arg_val
+ end
+
+ if @env['REQUEST_METHOD'] == "POST"
+ if @env.has_key?("CONTENT_TYPE") && @env['CONTENT_TYPE'] == "application/x-www-form-urlencoded" && @env.has_key?('CONTENT_LENGTH')
+ unless @settings.has_key?("post seperator")
+ post_args = $stdin.read(@env['CONTENT_LENGTH'].to_i).split(/[&;]/)
+ else
+ post_args = $stdin.read(@env['CONTENT_LENGTH'].to_i).split(@settings['post seperator'])
+ end
+ post_args.each do | arg |
+ arg_key, arg_val = arg.split(/=/, 2)
+ arg_key = Rweb::unescape(arg_key)
+ arg_val = Rweb::unescape(arg_val)
+
+ # Parse names like name[0], name['text'] or name[]
+ pattern = /^(.+)\[("[^\]]*"|'[^\]]*'|[0-9]*)\]$/
+ keys = []
+ while match = pattern.match(arg_key)
+ arg_key = match[1]
+ keys = [match[2]] + keys
+ end
+ keys = [arg_key] + keys
+
+ akt = @post
+ last = nil
+ lastkey = nil
+ keys.each do |key|
+ if key == ""
+ # No key specified (like in "test[]"), so we use
+ # the lowerst unused Integer as key
+ key = 0
+ while akt.has_key?(key)
+ key += 1
+ end
+ elsif /^[0-9]*$/ =~ key
+ # If the index is numerical convert it to an Integer
+ key = key.to_i
+ elsif key[0].chr == "'" || key[0].chr == '"'
+ key = key[1, key.length() -2]
+ end
+ if !akt.has_key?(key) || !akt[key].class == Hash
+ # create an empty Hash if there isn't already one
+ akt[key] = {}
+ end
+ last = akt
+ lastkey = key
+ akt = akt[key]
+ end
+ last[lastkey] = arg_val
+ end
+ else
+ # Maybe we should print a warning here?
+ $stderr.print("Unidentified form data recived and discarded.")
+ end
+ end
+
+ if @env.has_key?("HTTP_COOKIE")
+ cookie = @env['HTTP_COOKIE'].split(/; ?/)
+ cookie.each do | c |
+ cookie_key, cookie_val = c.split(/=/, 2)
+
+ @cookies [Rweb::unescape(cookie_key)] = Rweb::unescape(cookie_val)
+ end
+ end
+
+ if defined?(@env['HTTP_USER_AGENT'])
+ @user_agent = @env['HTTP_USER_AGENT']
+ else
+ @user_agent = nil;
+ end
+
+ if defined?(@env['REMOTE_ADDR'])
+ @remote_addr = @env['REMOTE_ADDR']
+ else
+ @remote_addr = nil
+ end
+ # }}}
+ end
+
+ # Prints a String to the client. If caching is enabled, the String will
+ # buffered until the end of the out block ends.
+ def print(str = "")
+ # {{{
+ unless @output_allowed
+ raise "You just can write to output inside of a Rweb::out-block"
+ end
+
+ if @settings["cache"]
+ @buffer += [str.to_s]
+ else
+ unless @output_started
+ sendHeaders
+ end
+ $stdout.print(str)
+ end
+ nil
+ # }}}
+ end
+
+ # Prints a String to the client and adds a line break at the end. Please
+ # remember, that a line break is not visible in HTML, use the <br> HTML-Tag
+ # for this. If caching is enabled, the String will buffered until the end
+ # of the out block ends.
+ def puts(str = "")
+ # {{{
+ self.print(str + "\n")
+ # }}}
+ end
+
+ # Alias to print.
+ def write(str = "")
+ # {{{
+ self.print(str)
+ # }}}
+ end
+
+ # If caching is enabled, all cached data are send to the cliend and the
+ # cache emptied.
+ def flush
+ # {{{
+ unless @output_allowed
+ raise "You can't use flush outside of a Rweb::out-block"
+ end
+ buffer = @buffer.join
+
+ unless @output_started
+ sendHeaders
+ end
+ $stdout.print(buffer)
+
+ @buffer = []
+ # }}}
+ end
+
+ # Sends one or more header to the client. All headers are cached just
+ # before body data are send to the client. If the same header are set
+ # twice, only the last value is send.
+ #
+ # Example:
+ # web.header("Last-Modified: Mon, 16 Feb 2004 20:15:41 GMT")
+ # web.header("Location: http://www.ruby-lang.org")
+ #
+ # You can specify more than one header at the time by doing something like
+ # this:
+ # web.header("Content-Type: text/plain\nContent-Length: 383")
+ # or
+ # web.header(["Content-Type: text/plain", "Content-Length: 383"])
+ def header(str)
+ # {{{
+ if @output_started
+ raise "HTTP-Headers are already send. You can't change them after output has started!"
+ end
+ unless @output_allowed
+ raise "You just can set headers inside of a Rweb::out-block"
+ end
+ if str.is_a?Array
+ str.each do | value |
+ self.header(value)
+ end
+
+ elsif str.split(/\n/).length > 1
+ str.split(/\n/).each do | value |
+ self.header(value)
+ end
+
+ elsif str.is_a? String
+ str.gsub!(/\r/, "")
+
+ if (str =~ /^HTTP\/1\.[01] [0-9]{3} ?.*$/) == 0
+ pattern = /^HTTP\/1.[01] ([0-9]{3}) ?(.*)$/
+
+ result = pattern.match(str)
+ self.setstatus(result[0], result[1])
+ elsif (str =~ /^status: [0-9]{3} ?.*$/i) == 0
+ pattern = /^status: ([0-9]{3}) ?(.*)$/i
+
+ result = pattern.match(str)
+ self.setstatus(result[0], result[1])
+ else
+ a = str.split(/: ?/, 2)
+
+ @header[a[0].downcase] = a[1]
+ end
+ end
+ # }}}
+ end
+
+ # Changes the status of this page. There are several codes like "200 OK",
+ # "302 Found", "404 Not Found" or "500 Internal Server Error". A list of
+ # all codes is available at
+ # http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10
+ #
+ # You can just send the code number, the reason phrase will be added
+ # automaticly with the recommendations from the w3c if not specified. If
+ # you set the status twice or more, only the last status will be send.
+ # Examples:
+ # web.status("401 Unauthorized")
+ # web.status("410 Sad but true, this lonely page is gone :(")
+ # web.status(206)
+ # web.status("400")
+ #
+ # The default status is "200 OK". If a "Location" header is set, the
+ # default status is "302 Found".
+ def status(str)
+ # {{{
+ if @output_started
+ raise "HTTP-Headers are already send. You can't change them after output has started!"
+ end
+ unless @output_allowed
+ raise "You just can set headers inside of a Rweb::out-block"
+ end
+ if str.is_a?Integer
+ @status = str
+ elsif str.is_a?String
+ p1 = /^([0-9]{3}) ?(.*)$/
+ p2 = /^HTTP\/1\.[01] ([0-9]{3}) ?(.*)$/
+ p3 = /^status: ([0-9]{3}) ?(.*)$/i
+
+ if (a = p1.match(str)) == nil
+ if (a = p2.match(str)) == nil
+ if (a = p3.match(str)) == nil
+ raise ArgumentError, "Invalid argument", caller
+ end
+ end
+ end
+ @status = a[1].to_i
+ if a[2] != ""
+ @reasonPhrase = a[2]
+ else
+ @reasonPhrase = getReasonPhrase(@status)
+ end
+ else
+ raise ArgumentError, "Argument of setstatus must be integer or string", caller
+ end
+ # }}}
+ end
+
+ # Handles the output of your content and rescues all exceptions. Send all
+ # data in the block to this method. For example:
+ # web.out do
+ # web.header("Content-Type: text/plain")
+ # web.puts("Hello, plain world!")
+ # end
+ def out
+ # {{{
+ @output_allowed = true
+ @buffer = []; # We use an array as buffer, because it's more performant :)
+
+ begin
+ yield
+ rescue Exception => exception
+ $stderr.puts "Ruby exception rescued (#{exception.class}): #{exception.message}"
+ $stderr.puts exception.backtrace.join("\n")
+
+ unless @output_started
+ self.setstatus(500)
+ @header = {}
+ end
+
+ unless (@settings.has_key?("hide errors") and @settings["hide errors"] == true)
+ unless @output_started
+ self.header("Content-Type: text/html")
+ self.puts "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Strict//EN\" \"http://www.w3.org/TR/html4/strict.dtd\">"
+ self.puts "<html>"
+ self.puts "<head>"
+ self.puts "<title>500 Internal Server Error</title>"
+ self.puts "</head>"
+ self.puts "<body>"
+ end
+ if @header.has_key?("content-type") and (@header["content-type"] =~ /^text\/html/i) == 0
+ self.puts "<h1>Internal Server Error</h1>"
+ self.puts "<p>The server encountered an exception and was unable to complete your request.</p>"
+ self.puts "<p>The exception has provided the following information:</p>"
+ self.puts "<pre style=\"background: #FFCCCC; border: black solid 2px; margin-left: 2cm; margin-right: 2cm; padding: 2mm;\"><b>#{exception.class}</b>: #{exception.message} <b>on</b>"
+ self.puts
+ self.puts "#{exception.backtrace.join("\n")}</pre>"
+ self.puts "</body>"
+ self.puts "</html>"
+ else
+ self.puts "The server encountered an exception and was unable to complete your request"
+ self.puts "The exception has provided the following information:"
+ self.puts "#{exception.class}: #{exception.message}"
+ self.puts
+ self.puts exception.backtrace.join("\n")
+ end
+ end
+ end
+
+ if @settings["cache"]
+ buffer = @buffer.join
+
+ unless @output_started
+ unless @header.has_key?("content-length")
+ self.header("content-length: #{buffer.length}")
+ end
+
+ sendHeaders
+ end
+ $stdout.print(buffer)
+ elsif !@output_started
+ sendHeaders
+ end
+ @output_allowed = false;
+ # }}}
+ end
+
+ # Decodes URL encoded data, %20 for example stands for a space.
+ def Rweb.unescape(str)
+ # {{{
+ if defined? str and str.is_a? String
+ str.gsub!(/\+/, " ")
+ str.gsub(/%.{2}/) do | s |
+ s[1,2].hex.chr
+ end
+ end
+ # }}}
+ end
+
+ protected
+ def sendHeaders
+ # {{{
+
+ Cookie.disallow # no more cookies can be set or modified
+ if !(@settings.has_key?("silent") and @settings["silent"] == true) and !@header.has_key?("x-powered-by")
+ if @mod_ruby
+ header("x-powered-by: #{RWEB} (Ruby/#{RUBY_VERSION}, #{MOD_RUBY})");
+ else
+ header("x-powered-by: #{RWEB} (Ruby/#{RUBY_VERSION})");
+ end
+ end
+
+ if @output_method == "ph"
+ if ((@status == nil or @status == 200) and !@header.has_key?("content-type") and !@header.has_key?("location"))
+ header("content-type: text/html")
+ end
+
+ if @status != nil
+ $stdout.print "Status: #{@status} #{@reasonPhrase}\r\n"
+ end
+
+ @header.each do |key, value|
+ key = key *1 # "unfreeze" key :)
+ key[0] = key[0,1].upcase![0]
+
+ key = key.gsub(/-[a-z]/) do |char|
+ "-" + char[1,1].upcase
+ end
+
+ $stdout.print "#{key}: #{value}\r\n"
+ end
+ cookies = Cookie.getHttpHeader # Get all cookies as an HTTP Header
+ if cookies
+ $stdout.print cookies
+ end
+
+ $stdout.print "\r\n"
+
+ elsif @output_method == "nph"
+ elsif @output_method == "mod_ruby"
+ r = Apache.request
+
+ if ((@status == nil or @status == 200) and !@header.has_key?("content-type") and !@header.has_key?("location"))
+ header("text/html")
+ end
+
+ if @status != nil
+ r.status_line = "#{@status} #{@reasonPhrase}"
+ end
+
+ r.send_http_header
+ @header.each do |key, value|
+ key = key *1 # "unfreeze" key :)
+
+ key[0] = key[0,1].upcase![0]
+ key = key.gsub(/-[a-z]/) do |char|
+ "-" + char[1,1].upcase
+ end
+ puts "#{key}: #{value.class}"
+ #r.headers_out[key] = value
+ end
+ end
+ @output_started = true
+ # }}}
+ end
+
+ def getReasonPhrase (status)
+ # {{{
+ if status == 100
+ "Continue"
+ elsif status == 101
+ "Switching Protocols"
+ elsif status == 200
+ "OK"
+ elsif status == 201
+ "Created"
+ elsif status == 202
+ "Accepted"
+ elsif status == 203
+ "Non-Authoritative Information"
+ elsif status == 204
+ "No Content"
+ elsif status == 205
+ "Reset Content"
+ elsif status == 206
+ "Partial Content"
+ elsif status == 300
+ "Multiple Choices"
+ elsif status == 301
+ "Moved Permanently"
+ elsif status == 302
+ "Found"
+ elsif status == 303
+ "See Other"
+ elsif status == 304
+ "Not Modified"
+ elsif status == 305
+ "Use Proxy"
+ elsif status == 307
+ "Temporary Redirect"
+ elsif status == 400
+ "Bad Request"
+ elsif status == 401
+ "Unauthorized"
+ elsif status == 402
+ "Payment Required"
+ elsif status == 403
+ "Forbidden"
+ elsif status == 404
+ "Not Found"
+ elsif status == 405
+ "Method Not Allowed"
+ elsif status == 406
+ "Not Acceptable"
+ elsif status == 407
+ "Proxy Authentication Required"
+ elsif status == 408
+ "Request Time-out"
+ elsif status == 409
+ "Conflict"
+ elsif status == 410
+ "Gone"
+ elsif status == 411
+ "Length Required"
+ elsif status == 412
+ "Precondition Failed"
+ elsif status == 413
+ "Request Entity Too Large"
+ elsif status == 414
+ "Request-URI Too Large"
+ elsif status == 415
+ "Unsupported Media Type"
+ elsif status == 416
+ "Requested range not satisfiable"
+ elsif status == 417
+ "Expectation Failed"
+ elsif status == 500
+ "Internal Server Error"
+ elsif status == 501
+ "Not Implemented"
+ elsif status == 502
+ "Bad Gateway"
+ elsif status == 503
+ "Service Unavailable"
+ elsif status == 504
+ "Gateway Time-out"
+ elsif status == 505
+ "HTTP Version not supported"
+ else
+ raise "Unknown Statuscode. See http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1 for more information."
+ end
+ # }}}
+ end
+end
+
+class Cookie
+ attr_reader :name, :value, :maxage, :path, :domain, :secure, :comment
+
+ # Sets a cookie. Please see below for details of the attributes.
+ def initialize (name, value = nil, maxage = nil, path = nil, domain = nil, secure = false)
+ # {{{
+ # HTTP headers (Cookies are a HTTP header) can only set, while no content
+ # is send. So an exception will be raised, when @@allowed is set to false
+ # and a new cookie has set.
+ unless defined?(@@allowed)
+ @@allowed = true
+ end
+ unless @@allowed
+ raise "You can't set cookies after the HTTP headers are send."
+ end
+
+ unless defined?(@@list)
+ @@list = []
+ end
+ @@list += [self]
+
+ unless defined?(@@type)
+ @@type = "netscape"
+ end
+
+ unless name.class == String
+ raise TypeError, "The name of a cookie must be a string", caller
+ end
+ if value.class.superclass == Integer || value.class == Float
+ value = value.to_s
+ elsif value.class != String && value != nil
+ raise TypeError, "The value of a cookie must be a string, integer, float or nil", caller
+ end
+ if maxage.class == Time
+ maxage = maxage - Time.now
+ elsif !maxage.class.superclass == Integer || !maxage == nil
+ raise TypeError, "The maxage date of a cookie must be an Integer or Time object or nil.", caller
+ end
+ unless path.class == String || path == nil
+ raise TypeError, "The path of a cookie must be nil or a string", caller
+ end
+ unless domain.class == String || domain == nil
+ raise TypeError, "The value of a cookie must be nil or a string", caller
+ end
+ unless secure == true || secure == false
+ raise TypeError, "The secure field of a cookie must be true or false", caller
+ end
+
+ @name, @value, @maxage, @path, @domain, @secure = name, value, maxage, path, domain, secure
+ @comment = nil
+ # }}}
+ end
+
+ # Modifies the value of this cookie. The information you want to store. If the
+ # value is nil, the cookie will be deleted by the client.
+ #
+ # This attribute can be a String, Integer or Float object or nil.
+ def value=(value)
+ # {{{
+ if value.class.superclass == Integer || value.class == Float
+ value = value.to_s
+ elsif value.class != String && value != nil
+ raise TypeError, "The value of a cookie must be a string, integer, float or nil", caller
+ end
+ @value = value
+ # }}}
+ end
+
+ # Modifies the maxage of this cookie. This attribute defines the lifetime of
+ # the cookie, in seconds. A value of 0 means the cookie should be discarded
+ # imediatly. If it set to nil, the cookie will be deleted when the browser
+ # will be closed.
+ #
+ # Attention: This is different from other implementations like PHP, where you
+ # gives the seconds since 1/1/1970 0:00:00 GMT.
+ #
+ # This attribute must be an Integer or Time object or nil.
+ def maxage=(maxage)
+ # {{{
+ if maxage.class == Time
+ maxage = maxage - Time.now
+ elsif maxage.class.superclass == Integer || !maxage == nil
+ raise TypeError, "The maxage of a cookie must be an Interger or Time object or nil.", caller
+ end
+ @maxage = maxage
+ # }}}
+ end
+
+ # Modifies the path value of this cookie. The client will send this cookie
+ # only, if the requested document is this directory or a subdirectory of it.
+ #
+ # The value of the attribute must be a String object or nil.
+ def path=(path)
+ # {{{
+ unless path.class == String || path == nil
+ raise TypeError, "The path of a cookie must be nil or a string", caller
+ end
+ @path = path
+ # }}}
+ end
+
+ # Modifies the domain value of this cookie. The client will send this cookie
+ # only if it's connected with this domain (or a subdomain, if the first
+ # character is a dot like in ".ruby-lang.org")
+ #
+ # The value of this attribute must be a String or nil.
+ def domain=(domain)
+ # {{{
+ unless domain.class == String || domain == nil
+ raise TypeError, "The domain of a cookie must be a String or nil.", caller
+ end
+ @domain = domain
+ # }}}
+ end
+
+ # Modifies the secure flag of this cookie. If it's true, the client will only
+ # send this cookie if it is secured connected with us.
+ #
+ # The value od this attribute has to be true or false.
+ def secure=(secure)
+ # {{{
+ unless secure == true || secure == false
+ raise TypeError, "The secure field of a cookie must be true or false", caller
+ end
+ @secure = secure
+ # }}}
+ end
+
+ # Modifies the comment value of this cookie. The comment won't be send, if
+ # type is "netscape".
+ def comment=(comment)
+ # {{{
+ unless comment.class == String || comment == nil
+ raise TypeError, "The comment of a cookie must be a string or nil", caller
+ end
+ @comment = comment
+ # }}}
+ end
+
+ # Changes the type of all cookies.
+ # Allowed values are RFC2109 and netscape (default).
+ def Cookie.type=(type)
+ # {{{
+ unless @@allowed
+ raise "The cookies are allready send, so you can't change the type anymore."
+ end
+ unless type.downcase == "rfc2109" && type.downcase == "netscape"
+ raise "The type of the cookies must be \"RFC2109\" or \"netscape\"."
+ end
+ @@type = type;
+ # }}}
+ end
+
+ # After sending this message, no cookies can be set or modified. Use it, when
+ # HTTP-Headers are send. Rweb does this for you.
+ def Cookie.disallow
+ # {{{
+ @@allowed = false
+ true
+ # }}}
+ end
+
+ # Returns a HTTP header (type String) with all cookies. Rweb does this for
+ # you.
+ def Cookie.getHttpHeader
+ # {{{
+ if defined?(@@list)
+ if @@type == "netscape"
+ str = ""
+ @@list.each do |cookie|
+ if cookie.value == nil
+ cookie.maxage = 0
+ cookie.value = ""
+ end
+ # TODO: Name and value should be escaped!
+ str += "Set-Cookie: #{cookie.name}=#{cookie.value}"
+ unless cookie.maxage == nil
+ expire = Time.now + cookie.maxage
+ expire.gmtime
+ str += "; Expire=#{expire.strftime("%a, %d-%b-%Y %H:%M:%S %Z")}"
+ end
+ unless cookie.domain == nil
+ str += "; Domain=#{cookie.domain}"
+ end
+ unless cookie.path == nil
+ str += "; Path=#{cookie.path}"
+ end
+ if cookie.secure
+ str += "; Secure"
+ end
+ str += "\r\n"
+ end
+ return str
+ else # type == "RFC2109"
+ str = "Set-Cookie: "
+ comma = false;
+
+ @@list.each do |cookie|
+ if cookie.value == nil
+ cookie.maxage = 0
+ cookie.value = ""
+ end
+ if comma
+ str += ","
+ end
+ comma = true
+
+ str += "#{cookie.name}=\"#{cookie.value}\""
+ unless cookie.maxage == nil
+ str += "; Max-Age=\"#{cookie.maxage}\""
+ end
+ unless cookie.domain == nil
+ str += "; Domain=\"#{cookie.domain}\""
+ end
+ unless cookie.path == nil
+ str += "; Path=\"#{cookie.path}\""
+ end
+ if cookie.secure
+ str += "; Secure"
+ end
+ unless cookie.comment == nil
+ str += "; Comment=\"#{cookie.comment}\""
+ end
+ str += "; Version=\"1\""
+ end
+ str
+ end
+ else
+ false
+ end
+ # }}}
+ end
+end
+
+require 'strscan'
+
+module BBCode
+ DEBUG = true
+
+ use 'encoder', 'tags', 'tagstack', 'smileys'
+
+=begin
+ The Parser class takes care of the encoding.
+ It scans the given BBCode (as plain text), finds tags
+ and smilies and also makes links of urls in text.
+
+ Normal text is send directly to the encoder.
+
+ If a tag was found, an instance of a Tag subclass is created
+ to handle the case.
+
+ The @tagstack manages tag nesting and ensures valid HTML.
+=end
+
+ class Parser
+ class Attribute
+ # flatten and use only one empty_arg
+ def self.create attr
+ attr = flatten attr
+ return @@empty_attr if attr.empty?
+ new attr
+ end
+
+ private_class_method :new
+
+ # remove leading and trailing whitespace; concat lines
+ def self.flatten attr
+ attr.strip.gsub(/\n/, ' ')
+ # -> ^ and $ can only match at begin and end now
+ end
+
+ ATTRIBUTE_SCAN = /
+ (?!$) # don't match at end
+ \s*
+ ( # $1 = key
+ [^=\s\]"\\]*
+ (?:
+ (?: \\. | "[^"\\]*(?:\\.[^"\\]*)*"? )
+ [^=\s\]"\\]*
+ )*
+ )
+ (?:
+ =
+ ( # $2 = value
+ [^\s\]"\\]*
+ (?:
+ (?: \\. | "[^"\\]*(?:\\.[^"\\]*)*"? )
+ [^\s\]"\\]*
+ )*
+ )?
+ )?
+ \s*
+ /x
+
+ def self.parse source
+ source = source.dup
+ # empty_tag: the tag looks like [... /]
+ # slice!: this deletes the \s*/] at the end
+ # \s+ because [url=http://rubybb.org/forum/] is NOT an empty tag.
+ # In RubyBBCode, you can use [url=http://rubybb.org/forum/ /], and this has to be
+ # interpreted correctly.
+ empty_tag = source.sub!(/^:/, '=') or source.slice!(/\/$/)
+ debug 'PARSE: ' + source.inspect + ' => ' + empty_tag.inspect
+ #-> we have now an attr that's EITHER empty OR begins and ends with non-whitespace.
+
+ attr = Hash.new
+ attr[:flags] = []
+ source.scan(ATTRIBUTE_SCAN) { |key, value|
+ if not value
+ attr[:flags] << unescape(key)
+ else
+ next if value.empty? and key.empty?
+ attr[unescape(key)] = unescape(value)
+ end
+ }
+ debug attr.inspect
+
+ return empty_tag, attr
+ end
+
+ def self.unescape_char esc
+ esc[1]
+ end
+
+ def self.unquote qt
+ qt[1..-1].chomp('"').gsub(/\\./) { |esc| unescape_char esc }
+ end
+
+ def self.unescape str
+ str.gsub(/ (\\.) | (" [^"\\]* (?:\\.[^"\\]*)* "?) /x) {
+ if $1
+ unescape_char $1
+ else
+ unquote $2
+ end
+ }
+ end
+
+ include Enumerable
+ def each &block
+ @args.each(&block)
+ end
+
+ attr_reader :source, :args, :value
+
+ def initialize source
+ @source = source
+ debug 'Attribute#new(%p)' % source
+ @empty_tag, @attr = Attribute.parse source
+ @value = @attr[''].to_s
+ end
+
+ def empty?
+ self == @@empty_attr
+ end
+
+ def empty_tag?
+ @empty_tag
+ end
+
+ def [] *keys
+ res = @attr[*keys]
+ end
+
+ def flags
+ attr[:flags]
+ end
+
+ def to_s
+ @attr
+ end
+
+ def inspect
+ 'ATTR[' + @attr.inspect + (@empty_tag ? ' | empty tag' : '') + ']'
+ end
+ end
+ class Attribute
+ @@empty_attr = new ''
+ end
+ end
+
+ class Parser
+ def Parser.flatten str
+ # replace mac & dos newlines with unix style
+ str.gsub(/\r\n?/, "\n")
+ end
+
+ def initialize input = ''
+ # input manager
+ @scanner = StringScanner.new ''
+ # output manager
+ @encoder = Encoder.new
+ @output = ''
+ # tag manager
+ @tagstack = TagStack.new(@encoder)
+
+ @do_magic = true
+ # set the input
+ feed input
+ end
+
+ # if you want, you can feed a parser instance after creating,
+ # or even feed it repeatedly.
+ def feed food
+ @scanner.string = Parser.flatten food
+ end
+
+ # parse through the string using parse_token
+ def parse
+ parse_token until @scanner.eos?
+ @tagstack.close_all
+ @output = parse_magic @encoder.output
+ end
+
+ def output
+ @output
+ end
+
+ # ok, internals start here
+ private
+ # the default output functions. everything should use them or the tags.
+ def add_text text = @scanner.matched
+ @encoder.add_text text
+ end
+
+ # use this carefully
+ def add_html html
+ @encoder.add_html html
+ end
+
+ # highlights the text as error
+ def add_garbage garbage
+ add_html '<span class="error">' if DEBUG
+ add_text garbage
+ add_html '</span>' if DEBUG
+ end
+
+ # unknown and incorrectly nested tags are ignored and
+ # sent as plaintext (garbage in - garbage out).
+ # in debug mode, garbage is marked with lime background.
+ def garbage_out start
+ @scanner.pos = start
+ garbage = @scanner.scan(/./m)
+ debug 'GARBAGE: ' + garbage
+ add_garbage garbage
+ end
+
+ # simple text; everything but [, \[ allowed
+ SIMPLE_TEXT_SCAN_ = /
+ [^\[\\]* # normal*
+ (?: # (
+ \\.? # special
+ [^\[\\]* # normal*
+ )* # )*
+ /mx
+ SIMPLE_TEXT_SCAN = /[^\[]+/
+
+=begin
+
+ WHAT IS A TAG?
+ ==============
+
+ Tags in BBCode can be much more than just a simple [b].
+ I use many terms here to differ the parts of each tag.
+
+ Basic scheme:
+ [ code ]
+ TAG START TAG INFO TAG END
+
+ Most tags need a second tag to close the range it opened.
+ This is done with CLOSING TAGS:
+ [/code]
+ or by using empty tags that have no content and close themselfes:
+ [url=winamp.com /]
+ You surely know this from HTML.
+ These slashes define the TAG KIND = normal|closing|empty and
+ cannot be used together.
+
+ Everything between [ and ] and expluding the slashes is called the
+ TAG INFO. This info may contain:
+ - TAG ID
+ - TAG NAME including the tag id
+ - attributes
+
+ The TAG ID is the first char of the info:
+
+ TAG | ID
+ ----------+----
+ [quote] | q
+ [±] | &
+ ["[b]"] | "
+ [/url] | u
+ [---] | -
+
+ As you can see, the tag id shows the TAG TYPE, it can be a
+ normal tag, a formatting tag or an entity.
+ Therefor, the parser first scans the id to decide how to go
+ on with parsing.
+=end
+ # tag
+ # TODO more complex expression allowing
+ # [quote="[ladico]"] and [quote=\[ladico\]] to be correct tags
+ TAG_BEGIN_SCAN = /
+ \[ # tag start
+ ( \/ )? # $1 = closing tag?
+ ( [^\]] ) # $2 = tag id
+ /x
+ TAG_END_SCAN = /
+ [^\]]* # rest that was not handled
+ \]? # tag end
+ /x
+ CLOSE_TAG_SCAN = /
+ ( [^\]]* ) # $1 = the rest of the tag info
+ ( \/ )? # $2 = empty tag?
+ \]? # tag end
+ /x
+ UNCLOSED_TAG_SCAN = / \[ /x
+
+ CLASSIC_TAG_SCAN = / [a-z]* /ix
+
+ SEPARATOR_TAG_SCAN = / \** /x
+
+ FORMAT_TAG_SCAN = / -- -* /x
+
+ QUOTED_SCAN = /
+ ( # $1 = quoted text
+ [^"\\]* # normal*
+ (?: # (
+ \\. # special
+ [^"\\]* # normal*
+ )* # )*
+ )
+ "? # end quote "
+ /mx
+
+ ENTITY_SCAN = /
+ ( [^;\]]+ ) # $1 = entity code
+ ;? # optional ending semicolon
+ /ix
+
+ SMILEY_SCAN = Smileys::SMILEY_PATTERN
+
+ # this is the main parser loop that separates
+ # text - everything until "["
+ # from
+ # tags - starting with "[", ending with "]"
+ def parse_token
+ if @scanner.scan(SIMPLE_TEXT_SCAN)
+ add_text
+ else
+ handle_tag
+ end
+ end
+
+ def handle_tag
+ tag_start = @scanner.pos
+
+ unless @scanner.scan TAG_BEGIN_SCAN
+ garbage_out tag_start
+ return
+ end
+
+ closing, id = @scanner[1], @scanner[2]
+ #debug 'handle_tag(%p)' % @scanner.matched
+
+ handled =
+ case id
+
+ when /[a-z]/i
+ if @scanner.scan(CLASSIC_TAG_SCAN)
+ if handle_classic_tag(id + @scanner.matched, closing)
+ already_closed = true
+ end
+ end
+
+ when '*'
+ if @scanner.scan(SEPARATOR_TAG_SCAN)
+ handle_asterisk tag_start, id + @scanner.matched
+ true
+ end
+
+ when '-'
+ if @scanner.scan(FORMAT_TAG_SCAN)
+ #format = id + @scanner.matched
+ @encoder.add_html "\n<hr>\n"
+ true
+ end
+
+ when '"'
+ if @scanner.scan(QUOTED_SCAN)
+ @encoder.add_text unescape(@scanner[1])
+ true
+ end
+
+ when '&'
+ if @scanner.scan(ENTITY_SCAN)
+ @encoder.add_entity @scanner[1]
+ true
+ end
+
+ when Smileys::SMILEY_START_CHARSET
+ @scanner.pos = @scanner.pos - 1 # (ungetch)
+ if @scanner.scan(SMILEY_SCAN)
+ @encoder.add_html Smileys.smiley_to_image(@scanner.matched)
+ true
+ end
+
+ end # case
+
+ return garbage_out(tag_start) unless handled
+
+ @scanner.scan(TAG_END_SCAN) unless already_closed
+ end
+
+ ATTRIBUTES_SCAN = /
+ (
+ [^\]"\\]*
+ (?:
+ (?:
+ \\.
+ |
+ "
+ [^"\\]*
+ (?:
+ \\.
+ [^"\\]*
+ )*
+ "?
+ )
+ [^\]"\\]*
+ )*
+ )
+ \]?
+ /x
+
+ def handle_classic_tag name, closing
+ debug 'TAG: ' + (closing ? '/' : '') + name
+ # flatten
+ name.downcase!
+ tag_class = TAG_LIST[name]
+ return unless tag_class
+
+ #debug((opening ? 'OPEN ' : 'CLOSE ') + tag_class.name)
+
+ # create an attribute object to handle it
+ @scanner.scan(ATTRIBUTES_SCAN)
+ #debug name + ':' + @scanner[1]
+ attr = Attribute.create @scanner[1]
+ #debug 'ATTRIBUTES %p ' % attr #unless attr.empty?
+
+ #debug 'closing: %p; name=%s, attr=%p' % [closing, name, attr]
+
+ # OPEN
+ if not closing and tag = @tagstack.try_open_class(tag_class, attr)
+ #debug 'opening'
+ tag.do_open @scanner
+ # this should be done by the tag itself.
+ if attr.empty_tag?
+ tag.handle_empty
+ @tagstack.close_tag
+ elsif tag.special_content?
+ handle_special_content(tag)
+ @tagstack.close_tag
+ # # ignore asterisks directly after the opening; these are phpBBCode
+ # elsif tag.respond_to? :asterisk
+ # debug 'SKIP ASTERISKS: ' if @scanner.skip(ASTERISK_TAGS_SCAN)
+ end
+
+ # CLOSE
+ elsif @tagstack.try_close_class(tag_class)
+ #debug 'closing'
+ # GARBAGE
+ else
+ return
+ end
+
+ true
+ end
+
+ def handle_asterisk tag_start, stars
+ #debug 'ASTERISK: ' + stars.to_s
+ # rule for asterisk tags: they belong to the last tag
+ # that handles them. tags opened after this tag are closed.
+ # if no open tag uses them, all are closed.
+ tag = @tagstack.close_all_until { |tag| tag.respond_to? :asterisk }
+ unless tag and tag.asterisk stars, @scanner
+ garbage_out tag_start
+ end
+ end
+
+ def handle_special_content tag
+ scanned = @scanner.scan_until(tag.closing_tag)
+ if scanned
+ scanned.slice!(-(@scanner.matched.size)..-1)
+ else
+ scanned = @scanner.scan(/.*/m).to_s
+ end
+ #debug 'SPECIAL CONTENT: ' + scanned
+ tag.handle_content(scanned)
+ end
+
+ def unescape text
+ # input: correctly formatted quoted string (without the quotes)
+ text.gsub(/\\(?:(["\\])|.)/) { $1 or $& }
+ end
+
+
+ # MAGIC FEAUTURES
+
+ URL_PATTERN = /(?:(?:www|ftp)\.|(?>\w{3,}):\/\/)\S+/
+ EMAIL_PATTERN = /(?>[\w\-_.]+)@[\w\-\.]+\.\w+/
+
+ HAS_MAGIC = /[&@#{Smileys::SMILEY_START_CHARS}]|(?i:www|ftp)/
+
+ MAGIC_PATTERN = Regexp.new('(\W|^)(%s)' %
+ [Smileys::MAGIC_SMILEY_PATTERN, URL_PATTERN, EMAIL_PATTERN].map { |pattern|
+ pattern.to_s
+ }.join('|') )
+
+ IS_SMILEY_PATTERN = Regexp.new('^%s' % Smileys::SMILEY_START_CHARSET.to_s )
+ IS_URL_PATTERN = /^(?:(?i:www|ftp)\.|(?>\w+):\/\/)/
+ URL_STARTS_WITH_PROTOCOL = /^\w+:\/\//
+ IS_EMAIL_PATTERN = /^[\w\-_.]+@/
+
+ def to_magic text
+ # debug MAGIC_PATTERN.to_s
+ text.gsub!(MAGIC_PATTERN) {
+ magic = $2
+ $1 + case magic
+ when IS_SMILEY_PATTERN
+ Smileys.smiley_to_img magic
+ when IS_URL_PATTERN
+ last = magic.slice_punctation! # no punctation in my URL
+ href = magic
+ href.insert(0, 'http://') unless magic =~ URL_STARTS_WITH_PROTOCOL
+ '<a href="' + href + '">' + magic + '</a>' + last
+ when IS_EMAIL_PATTERN
+ last = magic.slice_punctation!
+ '<a href="mailto:' + magic + '">' + magic + '</a>' + last
+ else
+ raise '{{{' + magic + '}}}'
+ end
+ }
+ text
+ end
+
+ # handles smileys and urls
+ def parse_magic html
+ return html unless @do_magic
+ scanner = StringScanner.new html
+ out = ''
+ while scanner.rest?
+ if scanner.scan(/ < (?: a\s .*? <\/a> | pre\W .*? <\/pre> | [^>]* > ) /mx)
+ out << scanner.matched
+ elsif scanner.scan(/ [^<]+ /x)
+ out << to_magic(scanner.matched)
+
+ # this should never happen
+ elsif scanner.scan(/./m)
+ raise 'ERROR: else case reached'
+ end
+ end
+ out
+ end
+ end # Parser
+end
+
+class String
+ def slice_punctation!
+ slice!(/[.:,!\?]+$/).to_s # return '' instead of nil
+ end
+end
+
+#
+# = Grammar
+#
+# An implementation of common algorithms on grammars.
+#
+# This is used by Shinobu, a visualization tool for educating compiler-building.
+#
+# Thanks to Andreas Kunert for his wonderful LR(k) Pamphlet (German, see http://www.informatik.hu-berlin.de/~kunert/papers/lr-analyse), and Aho/Sethi/Ullman for their Dragon Book.
+#
+# Homepage:: http://shinobu.cYcnus.de (not existing yet)
+# Author:: murphy (Kornelius Kalnbach)
+# Copyright:: (cc) 2005 cYcnus
+# License:: GPL
+# Version:: 0.2.0 (2005-03-27)
+
+require 'set_hash'
+require 'ctype'
+require 'tools'
+require 'rules'
+require 'trace'
+
+require 'first'
+require 'follow'
+
+# = Grammar
+#
+# == Syntax
+#
+# === Rules
+#
+# Each line is a rule.
+# The syntax is
+#
+# left - right
+#
+# where +left+ and +right+ can be uppercase and lowercase letters,
+# and <code>-</code> can be any combination of <, >, - or whitespace.
+#
+# === Symbols
+#
+# Uppercase letters stand for meta symbols, lowercase for terminals.
+#
+# You can make epsilon-derivations by leaving <code><right></code> empty.
+#
+# === Example
+# S - Ac
+# A - Sc
+# A - b
+# A -
+class Grammar
+
+ attr_reader :tracer
+ # Creates a new Grammar.
+ # If $trace is true, the algorithms explain (textual) what they do to $stdout.
+ def initialize data, tracer = Tracer.new
+ @tracer = tracer
+ @rules = Rules.new
+ @terminals, @meta_symbols = SortedSet.new, Array.new
+ @start_symbol = nil
+ add_rules data
+ end
+
+ attr_reader :meta_symbols, :terminals, :rules, :start_symbol
+
+ alias_method :sigma, :terminals
+ alias_method :alphabet, :terminals
+ alias_method :variables, :meta_symbols
+ alias_method :nonterminals, :meta_symbols
+
+ # A string representation of the grammar for debugging.
+ def inspect productions_too = false
+ 'Grammar(meta symbols: %s; alphabet: %s; productions: [%s]; start symbol: %s)' %
+ [
+ meta_symbols.join(', '),
+ terminals.join(', '),
+ if productions_too
+ @rules.inspect
+ else
+ @rules.size
+ end,
+ start_symbol
+ ]
+ end
+
+ # Add rules to the grammar. +rules+ should be a String or respond to +scan+ in a similar way.
+ #
+ # Syntax: see Grammar.
+ def add_rules grammar
+ @rules = Rules.parse grammar do |rule|
+ @start_symbol ||= rule.left
+ @meta_symbols << rule.left
+ @terminals.merge rule.right.split('').select { |s| terminal? s }
+ end
+ @meta_symbols.uniq!
+ update
+ end
+
+ # Returns a hash acting as FIRST operator, so that
+ # <code>first["ABC"]</code> is FIRST(ABC).
+ # See http://en.wikipedia.org/wiki/LL_parser "Constructing an LL(1) parsing table" for details.
+ def first
+ first_operator
+ end
+
+ # Returns a hash acting as FOLLOW operator, so that
+ # <code>first["A"]</code> is FOLLOW(A).
+ # See http://en.wikipedia.org/wiki/LL_parser "Constructing an LL(1) parsing table" for details.
+ def follow
+ follow_operator
+ end
+
+ LLError = Class.new(Exception)
+ LLErrorType1 = Class.new(LLError)
+ LLErrorType2 = Class.new(LLError)
+
+ # Tests if the grammar is LL(1).
+ def ll1?
+ begin
+ for meta in @meta_symbols
+ first_sets = @rules[meta].map { |alpha| first[alpha] }
+ first_sets.inject(Set[]) do |already_used, another_first_set|
+ unless already_used.disjoint? another_first_set
+ raise LLErrorType1
+ end
+ already_used.merge another_first_set
+ end
+
+ if first[meta].include? EPSILON and not first[meta].disjoint? follow[meta]
+ raise LLErrorType2
+ end
+ end
+ rescue LLError
+ false
+ else
+ true
+ end
+ end
+
+private
+
+ def first_operator
+ @first ||= FirstOperator.new self
+ end
+
+ def follow_operator
+ @follow ||= FollowOperator.new self
+ end
+
+ def update
+ @first = @follow = nil
+ end
+
+end
+
+if $0 == __FILE__
+ eval DATA.read, nil, $0, __LINE__+4
+end
+
+require 'test/unit'
+
+class TestCaseGrammar < Test::Unit::TestCase
+
+ include Grammar::Symbols
+
+ def fifo s
+ Set[*s.split('')]
+ end
+
+ def test_fifo
+ assert_equal Set[], fifo('')
+ assert_equal Set[EPSILON, END_OF_INPUT, 'x', 'Y'], fifo('?xY$')
+ end
+
+ TEST_GRAMMAR_1 = <<-EOG
+S - ABCD
+A - a
+A -
+B - b
+B -
+C - c
+C -
+D - S
+D -
+ EOG
+
+ def test_symbols
+ assert EPSILON
+ assert END_OF_INPUT
+ end
+
+ def test_first_1
+ g = Grammar.new TEST_GRAMMAR_1
+
+ f = nil
+ assert_nothing_raised { f = g.first }
+ assert_equal(Set['a', EPSILON], f['A'])
+ assert_equal(Set['b', EPSILON], f['B'])
+ assert_equal(Set['c', EPSILON], f['C'])
+ assert_equal(Set['a', 'b', 'c', EPSILON], f['D'])
+ assert_equal(f['D'], f['S'])
+ end
+
+ def test_follow_1
+ g = Grammar.new TEST_GRAMMAR_1
+
+ f = nil
+ assert_nothing_raised { f = g.follow }
+ assert_equal(Set['a', 'b', 'c', END_OF_INPUT], f['A'])
+ assert_equal(Set['a', 'b', 'c', END_OF_INPUT], f['B'])
+ assert_equal(Set['a', 'b', 'c', END_OF_INPUT], f['C'])
+ assert_equal(Set[END_OF_INPUT], f['D'])
+ assert_equal(Set[END_OF_INPUT], f['S'])
+ end
+
+
+ TEST_GRAMMAR_2 = <<-EOG
+S - Ed
+E - EpT
+E - EmT
+E - T
+T - TuF
+T - TdF
+T - F
+F - i
+F - n
+F - aEz
+ EOG
+
+ def test_first_2
+ g = Grammar.new TEST_GRAMMAR_2
+
+ f = nil
+ assert_nothing_raised { f = g.first }
+ assert_equal(Set['a', 'n', 'i'], f['E'])
+ assert_equal(Set['a', 'n', 'i'], f['F'])
+ assert_equal(Set['a', 'n', 'i'], f['T'])
+ assert_equal(Set['a', 'n', 'i'], f['S'])
+ end
+
+ def test_follow_2
+ g = Grammar.new TEST_GRAMMAR_2
+
+ f = nil
+ assert_nothing_raised { f = g.follow }
+ assert_equal(Set['m', 'd', 'z', 'p'], f['E'])
+ assert_equal(Set['m', 'd', 'z', 'p', 'u'], f['F'])
+ assert_equal(Set['m', 'd', 'z', 'p', 'u'], f['T'])
+ assert_equal(Set[END_OF_INPUT], f['S'])
+ end
+
+ LLError = Grammar::LLError
+
+ TEST_GRAMMAR_3 = <<-EOG
+E - TD
+D - pTD
+D -
+T - FS
+S - uFS
+S -
+S - p
+F - aEz
+F - i
+ EOG
+
+ NoError = Class.new(Exception)
+
+ def test_first_3
+ g = Grammar.new TEST_GRAMMAR_3
+
+ # Grammar 3 is LL(1), so all first-sets must be disjoint.
+ f = nil
+ assert_nothing_raised { f = g.first }
+ assert_equal(Set['a', 'i'], f['E'])
+ assert_equal(Set[EPSILON, 'p'], f['D'])
+ assert_equal(Set['a', 'i'], f['F'])
+ assert_equal(Set['a', 'i'], f['T'])
+ assert_equal(Set[EPSILON, 'u', 'p'], f['S'])
+ for m in g.meta_symbols
+ r = g.rules[m]
+ firsts = r.map { |x| f[x] }.to_set
+ assert_nothing_raised do
+ firsts.inject(Set.new) do |already_used, another_first_set|
+ raise LLError, 'not disjoint!' unless already_used.disjoint? another_first_set
+ already_used.merge another_first_set
+ end
+ end
+ end
+ end
+
+ def test_follow_3
+ g = Grammar.new TEST_GRAMMAR_3
+
+ # Grammar 3 is not LL(1), because epsilon is in FIRST(S),
+ # but FIRST(S) and FOLLOW(S) are not disjoint.
+ f = nil
+ assert_nothing_raised { f = g.follow }
+ assert_equal(Set['z', END_OF_INPUT], f['E'])
+ assert_equal(Set['z', END_OF_INPUT], f['D'])
+ assert_equal(Set['z', 'p', 'u', END_OF_INPUT], f['F'])
+ assert_equal(Set['p', 'z', END_OF_INPUT], f['T'])
+ assert_equal(Set['p', 'z', END_OF_INPUT], f['S'])
+ for m in g.meta_symbols
+ first_m = g.first[m]
+ next unless first_m.include? EPSILON
+ assert_raise(m == 'S' ? LLError : NoError) do
+ if first_m.disjoint? f[m]
+ raise NoError # this is fun :D
+ else
+ raise LLError
+ end
+ end
+ end
+ end
+
+ TEST_GRAMMAR_3b = <<-EOG
+E - TD
+D - pTD
+D - PTD
+D -
+T - FS
+S - uFS
+S -
+F - aEz
+F - i
+P - p
+ EOG
+
+ def test_first_3b
+ g = Grammar.new TEST_GRAMMAR_3b
+
+ # Grammar 3b is NOT LL(1), since not all first-sets are disjoint.
+ f = nil
+ assert_nothing_raised { f = g.first }
+ assert_equal(Set['a', 'i'], f['E'])
+ assert_equal(Set[EPSILON, 'p'], f['D'])
+ assert_equal(Set['p'], f['P'])
+ assert_equal(Set['a', 'i'], f['F'])
+ assert_equal(Set['a', 'i'], f['T'])
+ assert_equal(Set[EPSILON, 'u'], f['S'])
+ for m in g.meta_symbols
+ r = g.rules[m]
+ firsts = r.map { |x| f[x] }
+ assert_raise(m == 'D' ? LLError : NoError) do
+ firsts.inject(Set.new) do |already_used, another_first_set|
+ raise LLError, 'not disjoint!' unless already_used.disjoint? another_first_set
+ already_used.merge another_first_set
+ end
+ raise NoError
+ end
+ end
+ end
+
+ def test_follow_3b
+ g = Grammar.new TEST_GRAMMAR_3b
+
+ # Although Grammar 3b is NOT LL(1), the FOLLOW-condition is satisfied.
+ f = nil
+ assert_nothing_raised { f = g.follow }
+ assert_equal(fifo('z$'), f['E'], 'E')
+ assert_equal(fifo('z$'), f['D'], 'D')
+ assert_equal(fifo('ai'), f['P'], 'P')
+ assert_equal(fifo('z$pu'), f['F'], 'F')
+ assert_equal(fifo('z$p'), f['T'], 'T')
+ assert_equal(fifo('z$p'), f['S'], 'S')
+ for m in g.meta_symbols
+ first_m = g.first[m]
+ next unless first_m.include? EPSILON
+ assert_raise(NoError) do
+ if first_m.disjoint? f[m]
+ raise NoError # this is fun :D
+ else
+ raise LLError
+ end
+ end
+ end
+ end
+
+ def test_ll1?
+ assert_equal false, Grammar.new(TEST_GRAMMAR_3).ll1?, 'Grammar 3'
+ assert_equal false, Grammar.new(TEST_GRAMMAR_3b).ll1?, 'Grammar 3b'
+ end
+
+ def test_new
+ assert_nothing_raised { Grammar.new '' }
+ assert_nothing_raised { Grammar.new TEST_GRAMMAR_1 }
+ assert_nothing_raised { Grammar.new TEST_GRAMMAR_2 }
+ assert_nothing_raised { Grammar.new TEST_GRAMMAR_3 }
+ assert_nothing_raised { Grammar.new TEST_GRAMMAR_1 + TEST_GRAMMAR_2 + TEST_GRAMMAR_3 }
+ assert_raise(ArgumentError) { Grammar.new 'S - ?' }
+ end
+end
+
+# vim:foldmethod=syntax
+
+#!/usr/bin/env ruby
+
+require 'fox12'
+
+include Fox
+
+class Window < FXMainWindow
+ def initialize(app)
+ super(app, app.appName + ": First Set Calculation", nil, nil, DECOR_ALL, 0, 0, 800, 600, 0, 0)
+
+ # {{{ menubar
+ menubar = FXMenuBar.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X)
+
+ filemenu = FXMenuPane.new(self)
+
+ FXMenuCommand.new(filemenu, "&Start\tCtl-S\tStart the application.", nil, getApp()).connect(SEL_COMMAND, method(:start))
+ FXMenuCommand.new(filemenu, "&Quit\tAlt-F4\tQuit the application.", nil, getApp(), FXApp::ID_QUIT)
+ FXMenuTitle.new(menubar, "&File", nil, filemenu)
+ # }}} menubar
+
+ # {{{ statusbar
+ @statusbar = FXStatusBar.new(self, LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|STATUSBAR_WITH_DRAGCORNER)
+ # }}} statusbar
+
+ # {{{ window content
+ horizontalsplitt = FXSplitter.new(self, SPLITTER_VERTICAL|LAYOUT_SIDE_TOP|LAYOUT_FILL)
+
+
+ @productions = FXList.new(horizontalsplitt, nil, 0, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FIX_HEIGHT|LIST_SINGLESELECT)
+ @productions.height = 100
+
+ @result = FXTable.new(horizontalsplitt, nil, 0, LAYOUT_FILL)
+ @result.height = 200
+ @result.setTableSize(2, 2, false)
+ @result.rowHeaderWidth = 0
+
+ header = @result.columnHeader
+ header.setItemText 0, 'X'
+ header.setItemText 1, 'FIRST(X)'
+ for item in header
+ item.justification = FXHeaderItem::CENTER_X
+ end
+
+ @debug = FXText.new(horizontalsplitt, nil, 0, LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|LAYOUT_FIX_HEIGHT)
+ @debug.height = 200
+
+ # }}} window content
+ end
+
+ def load_grammar grammar
+ @tracer = FirstTracer.new(self)
+ @grammar = Grammar.new grammar, @tracer
+ @rules_indexes = Hash.new
+ @grammar.rules.each_with_index do |rule, i|
+ @productions.appendItem rule.inspect
+ @rules_indexes[rule] = i
+ end
+ end
+
+ def create
+ super
+ show(PLACEMENT_SCREEN)
+ end
+
+ def rule rule
+ @productions.selectItem @rules_indexes[rule]
+ sleep 0.1
+ end
+
+ def iterate i
+ setTitle i.to_s
+ sleep 0.1
+ end
+
+ def missing what
+ @debug.appendText what + "\n"
+ sleep 0.1
+ end
+
+ def start sender, sel, pointer
+ Thread.new do
+ begin
+ @grammar.first
+ rescue => boom
+ @debug.appendText [boom.to_s, *boom.backtrace].join("\n")
+ end
+ end
+ end
+
+end
+
+$: << 'grammar'
+require 'grammar'
+
+require 'first_tracer'
+
+app = FXApp.new("Shinobu", "cYcnus")
+
+# fenster erzeugen
+window = Window.new app
+
+unless ARGV.empty?
+ grammar = File.read(ARGV.first)
+else
+ grammar = <<-EOG1
+Z --> S
+S --> Sb
+S --> bAa
+A --> aSc
+A --> a
+A --> aSb
+ EOG1
+end
+
+window.load_grammar grammar
+
+app.create
+app.run
+
+require 'erb'
+require 'ftools'
+require 'yaml'
+require 'redcloth'
+
+module WhyTheLuckyStiff
+ class Book
+ attr_accessor :author, :title, :terms, :image, :teaser,
+ :chapters, :expansion_paks, :encoding, :credits
+ def [] x
+ @lang.fetch(x) do
+ warn warning = "[not translated: '#{x}'!]"
+ warning
+ end
+ end
+ end
+
+ def Book::load( file_name )
+ YAML::load( File.open( file_name ) )
+ end
+
+ class Section
+ attr_accessor :index, :header, :content
+ def initialize( i, h, c )
+ @index, @header, @content = i, h, RedCloth::new( c.to_s )
+ end
+ end
+
+ class Sidebar
+ attr_accessor :title, :content
+ end
+
+ YAML::add_domain_type( 'whytheluckystiff.net,2003', 'sidebar' ) do |taguri, val|
+ YAML::object_maker( Sidebar, 'title' => val.keys.first, 'content' => RedCloth::new( val.values.first ) )
+ end
+ class Chapter
+ attr_accessor :index, :title, :sections
+ def initialize( i, t, sects )
+ @index = i
+ @title = t
+ i = 0
+ @sections = sects.collect do |s|
+ if s.respond_to?( :keys )
+ i += 1
+ Section.new( i, s.keys.first, s.values.first )
+ else
+ s
+ end
+ end
+ end
+ end
+
+ YAML::add_domain_type( 'whytheluckystiff.net,2003', 'book' ) do |taguri, val|
+ ['chapters', 'expansion_paks'].each do |chaptype|
+ i = 0
+ val[chaptype].collect! do |c|
+ i += 1
+ Chapter::new( i, c.keys.first, c.values.first )
+ end
+ end
+ val['teaser'].collect! do |t|
+ Section::new( 1, t.keys.first, t.values.first )
+ end
+ val['terms'] = RedCloth::new( val['terms'] )
+ YAML::object_maker( Book, val )
+ end
+
+ class Image
+ attr_accessor :file_name
+ end
+
+ YAML::add_domain_type( 'whytheluckystiff.net,2003', 'img' ) do |taguri, val|
+ YAML::object_maker( Image, 'file_name' => "i/" + val )
+ end
+end
+
+#
+# Convert the book to HTML
+#
+if __FILE__ == $0
+ unless ARGV[0]
+ puts "Usage: #{$0} [/path/to/save/html]"
+ exit
+ end
+
+ site_path = ARGV[0]
+ book = WhyTheLuckyStiff::Book::load( 'poignant.yml' )
+ chapter = nil
+
+ # Write index page
+ index_tpl = ERB::new( File.open( 'index.erb' ).read )
+ File.open( File.join( site_path, 'index.html' ), 'w' ) do |out|
+ out << index_tpl.result
+ end
+
+ book.chapters = book.chapters[0,3] if ARGV.include? '-fast'
+
+ # Write chapter pages
+ chapter_tpl = ERB::new( File.open( 'chapter.erb' ).read )
+ book.chapters.each do |chapter|
+ File.open( File.join( site_path, "chapter-#{ chapter.index }.html" ), 'w' ) do |out|
+ out << chapter_tpl.result
+ end
+ end
+ exit if ARGV.include? '-fast'
+
+ # Write expansion pak pages
+ expak_tpl = ERB::new( File.open( 'expansion-pak.erb' ).read )
+ book.expansion_paks.each do |pak|
+ File.open( File.join( site_path, "expansion-pak-#{ pak.index }.html" ), 'w' ) do |out|
+ out << expak_tpl.result( binding )
+ end
+ end
+
+ # Write printable version
+ print_tpl = ERB::new( File.open( 'print.erb' ).read )
+ File.open( File.join( site_path, "print.html" ), 'w' ) do |out|
+ out << print_tpl.result
+ end
+
+ # Copy css + images into site
+ copy_list = ["guide.css"] +
+ Dir["i/*"].find_all { |image| image =~ /\.(gif|jpg|png)$/ }
+
+ File.makedirs( File.join( site_path, "i" ) )
+ copy_list.each do |copy_file|
+ File.copy( copy_file, File.join( site_path, copy_file ) )
+ end
+end
+
+#!/usr/bin/env ruby
+
+require 'fox'
+begin
+ require 'opengl'
+rescue LoadError
+ require 'fox/missingdep'
+ MSG = <<EOM
+ Sorry, this example depends on the OpenGL extension. Please
+ check the Ruby Application Archives for an appropriate
+ download site.
+EOM
+ missingDependency(MSG)
+end
+
+
+include Fox
+include Math
+
+Deg2Rad = Math::PI / 180
+
+D_MAX = 6
+SQUARE_SIZE = 2.0 / D_MAX
+SQUARE_DISTANCE = 4.0 / D_MAX
+AMPLITUDE = SQUARE_SIZE
+LAMBDA = D_MAX.to_f / 2
+
+class GLTestWindow < FXMainWindow
+
+ # How often our timer will fire (in milliseconds)
+ TIMER_INTERVAL = 500
+
+ # Rotate the boxes when a timer message is received
+ def onTimeout(sender, sel, ptr)
+ @angle += 10.0
+# @size = 0.5 + 0.2 * Math.cos(Deg2Rad * @angle)
+ drawScene()
+ @timer = getApp().addTimeout(TIMER_INTERVAL, method(:onTimeout))
+ end
+
+ # Rotate the boxes when a chore message is received
+ def onChore(sender, sel, ptr)
+ @angle += 10.0
+# @angle %= 360.0
+# @size = 0.5 + 0.2 * Math.cos(Deg2Rad * @angle)
+ drawScene()
+ @chore = getApp().addChore(method(:onChore))
+ end
+
+ # Draw the GL scene
+ def drawScene
+ lightPosition = [15.0, 10.0, 5.0, 1.0]
+ lightAmbient = [ 0.1, 0.1, 0.1, 1.0]
+ lightDiffuse = [ 0.9, 0.9, 0.9, 1.0]
+ redMaterial = [ 0.0, 0.0, 1.0, 1.0]
+ blueMaterial = [ 0.0, 1.0, 0.0, 1.0]
+
+ width = @glcanvas.width.to_f
+ height = @glcanvas.height.to_f
+ aspect = width/height
+
+ # Make context current
+ @glcanvas.makeCurrent()
+
+ GL.Viewport(0, 0, @glcanvas.width, @glcanvas.height)
+
+ GL.ClearColor(1.0/256, 0.0, 5.0/256, 1.0)
+ GL.Clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT)
+ GL.Enable(GL::DEPTH_TEST)
+
+ GL.Disable(GL::DITHER)
+
+ GL.MatrixMode(GL::PROJECTION)
+ GL.LoadIdentity()
+ GLU.Perspective(30.0, aspect, 1.0, 100.0)
+
+ GL.MatrixMode(GL::MODELVIEW)
+ GL.LoadIdentity()
+ GLU.LookAt(5.0, 10.0, 15.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
+
+ GL.ShadeModel(GL::SMOOTH)
+ GL.Light(GL::LIGHT0, GL::POSITION, lightPosition)
+ GL.Light(GL::LIGHT0, GL::AMBIENT, lightAmbient)
+ GL.Light(GL::LIGHT0, GL::DIFFUSE, lightDiffuse)
+ GL.Enable(GL::LIGHT0)
+ GL.Enable(GL::LIGHTING)
+
+ GL.Rotated(0.1*@angle, 0.0, 1.0, 0.0)
+ for x in -D_MAX..D_MAX
+ for y in -D_MAX..D_MAX
+ h1 = (x + y - 2).abs
+ h2 = (y - x + 1).abs
+ GL.PushMatrix
+ c = [1, 0, 0, 1]
+ GL.Material(GL::FRONT, GL::AMBIENT, c)
+ GL.Material(GL::FRONT, GL::DIFFUSE, c)
+
+ GL.Translated(
+ y * SQUARE_DISTANCE,
+ AMPLITUDE * h1,
+ x * SQUARE_DISTANCE
+ )
+
+ GL.Begin(GL::TRIANGLE_STRIP)
+ GL.Normal(1.0, 0.0, 0.0)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.End
+
+ GL.PopMatrix
+
+ GL.PushMatrix
+ c = [0, 0, 1, 1]
+ GL.Material(GL::FRONT, GL::AMBIENT, c)
+ GL.Material(GL::FRONT, GL::DIFFUSE, c)
+
+ GL.Translated(
+ y * SQUARE_DISTANCE,
+ AMPLITUDE * h2,
+ x * SQUARE_DISTANCE
+ )
+
+ GL.Begin(GL::TRIANGLE_STRIP)
+ GL.Normal(1.0, 0.0, 0.0)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.End
+
+ GL.PopMatrix
+
+ GL.PushMatrix
+ c = [0.0 + (x/10.0), 0.0 + (y/10.0), 0, 1]
+ GL.Material(GL::FRONT, GL::AMBIENT, c)
+ GL.Material(GL::FRONT, GL::DIFFUSE, c)
+
+ GL.Translated(
+ y * SQUARE_DISTANCE,
+ 0,
+ x * SQUARE_DISTANCE
+ )
+
+ GL.Begin(GL::TRIANGLE_STRIP)
+ GL.Normal(1.0, 0.0, 0.0)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(-SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, -SQUARE_SIZE)
+ GL.Vertex(+SQUARE_SIZE, +SQUARE_SIZE, +SQUARE_SIZE)
+ GL.End
+
+ GL.PopMatrix
+ end
+ end
+
+ # Swap if it is double-buffered
+ if @glvisual.isDoubleBuffer
+ @glcanvas.swapBuffers
+ end
+
+ # Make context non-current
+ @glcanvas.makeNonCurrent
+ end
+
+ def initialize(app)
+ # Invoke the base class initializer
+ super(app, "OpenGL Test Application", nil, nil, DECOR_ALL, 0, 0, 1024, 768)
+
+ # Construct the main window elements
+ frame = FXHorizontalFrame.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|LAYOUT_FILL_Y)
+ frame.padLeft, frame.padRight = 0, 0
+ frame.padTop, frame.padBottom = 0, 0
+
+ # Left pane to contain the glcanvas
+ glcanvasFrame = FXVerticalFrame.new(frame,
+ LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT)
+ glcanvasFrame.padLeft, glcanvasFrame.padRight = 10, 10
+ glcanvasFrame.padTop, glcanvasFrame.padBottom = 10, 10
+
+ # Label above the glcanvas
+ FXLabel.new(glcanvasFrame, "OpenGL Canvas Frame", nil,
+ JUSTIFY_CENTER_X|LAYOUT_FILL_X)
+
+ # Horizontal divider line
+ FXHorizontalSeparator.new(glcanvasFrame, SEPARATOR_GROOVE|LAYOUT_FILL_X)
+
+ # Drawing glcanvas
+ glpanel = FXVerticalFrame.new(glcanvasFrame, (FRAME_SUNKEN|FRAME_THICK|
+ LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT))
+ glpanel.padLeft, glpanel.padRight = 0, 0
+ glpanel.padTop, glpanel.padBottom = 0, 0
+
+ # A visual to draw OpenGL
+ @glvisual = FXGLVisual.new(getApp(), VISUAL_DOUBLEBUFFER)
+
+ # Drawing glcanvas
+ @glcanvas = FXGLCanvas.new(glpanel, @glvisual, nil, 0,
+ LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT)
+ @glcanvas.connect(SEL_PAINT) {
+ drawScene
+ }
+ @glcanvas.connect(SEL_CONFIGURE) {
+ if @glcanvas.makeCurrent
+ GL.Viewport(0, 0, @glcanvas.width, @glcanvas.height)
+ @glcanvas.makeNonCurrent
+ end
+ }
+
+ # Right pane for the buttons
+ buttonFrame = FXVerticalFrame.new(frame, LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_LEFT)
+ buttonFrame.padLeft, buttonFrame.padRight = 10, 10
+ buttonFrame.padTop, buttonFrame.padBottom = 10, 10
+
+ # Label above the buttons
+ FXLabel.new(buttonFrame, "Button Frame", nil,
+ JUSTIFY_CENTER_X|LAYOUT_FILL_X)
+
+ # Horizontal divider line
+ FXHorizontalSeparator.new(buttonFrame, SEPARATOR_RIDGE|LAYOUT_FILL_X)
+
+ # Spin according to timer
+ spinTimerBtn = FXButton.new(buttonFrame,
+ "Spin &Timer\tSpin using interval timers\nNote the app
+ blocks until the interal has elapsed...", nil,
+ nil, 0, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT)
+ spinTimerBtn.padLeft, spinTimerBtn.padRight = 10, 10
+ spinTimerBtn.padTop, spinTimerBtn.padBottom = 5, 5
+ spinTimerBtn.connect(SEL_COMMAND) {
+ @spinning = true
+ @timer = getApp().addTimeout(TIMER_INTERVAL, method(:onTimeout))
+ }
+ spinTimerBtn.connect(SEL_UPDATE) { |sender, sel, ptr|
+ @spinning ? sender.disable : sender.enable
+ }
+
+ # Spin according to chore
+ spinChoreBtn = FXButton.new(buttonFrame,
+ "Spin &Chore\tSpin as fast as possible using chores\nNote even though the
+ app is very responsive, it never blocks;\nthere is always something to
+ do...", nil,
+ nil, 0, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT)
+ spinChoreBtn.padLeft, spinChoreBtn.padRight = 10, 10
+ spinChoreBtn.padTop, spinChoreBtn.padBottom = 5, 5
+ spinChoreBtn.connect(SEL_COMMAND) {
+ @spinning = true
+ @chore = getApp().addChore(method(:onChore))
+ }
+ spinChoreBtn.connect(SEL_UPDATE) { |sender, sel, ptr|
+ @spinning ? sender.disable : sender.enable
+ }
+
+ # Stop spinning
+ stopBtn = FXButton.new(buttonFrame,
+ "&Stop Spin\tStop this mad spinning, I'm getting dizzy", nil,
+ nil, 0, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT)
+ stopBtn.padLeft, stopBtn.padRight = 10, 10
+ stopBtn.padTop, stopBtn.padBottom = 5, 5
+ stopBtn.connect(SEL_COMMAND) {
+ @spinning = false
+ if @timer
+ getApp().removeTimeout(@timer)
+ @timer = nil
+ end
+ if @chore
+ getApp().removeChore(@chore)
+ @chore = nil
+ end
+ }
+ stopBtn.connect(SEL_UPDATE) { |sender, sel, ptr|
+ @spinning ? sender.enable : sender.disable
+ }
+
+ # Exit button
+ exitBtn = FXButton.new(buttonFrame, "&Exit\tExit the application", nil,
+ getApp(), FXApp::ID_QUIT,
+ FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT)
+ exitBtn.padLeft, exitBtn.padRight = 10, 10
+ exitBtn.padTop, exitBtn.padBottom = 5, 5
+
+ # Make a tooltip
+ FXTooltip.new(getApp())
+
+ # Initialize private variables
+ @spinning = false
+ @chore = nil
+ @timer = nil
+ @angle = 0.0
+ @size = 0.5
+ end
+
+ # Create and initialize
+ def create
+ super
+ show(PLACEMENT_SCREEN)
+ end
+end
+
+if __FILE__ == $0
+ # Construct the application
+ application = FXApp.new("GLTest", "FoxTest")
+
+ # To ensure that the chores-based spin will run as fast as possible,
+ # we can disable the chore in FXRuby's event loop that tries to schedule
+ # other threads. This is OK for this program because there aren't any
+ # other Ruby threads running.
+
+ #application.disableThreads
+
+ # Construct the main window
+ GLTestWindow.new(application)
+
+ # Create the app's windows
+ application.create
+
+ # Run the application
+ application.run
+end
+
+class Facelet
+ attr_accessor :color
+ def initialize(color)
+ @color = color
+ end
+
+ def to_s
+ @color
+ end
+end
+
+class Edge
+ attr_accessor :facelets, :colors
+
+ def initialize(facelets)
+ @facelets = facelets
+ @colors = @facelets.map { |fl| fl.color }
+ end
+
+ def apply(edge)
+ @facelets.each_with_index { |fl, i|
+ fl.color = edge.colors[i]
+ }
+ end
+
+ def inspect
+ "\n%s %s\n%s %s %s" % facelets
+ end
+end
+
+class Side
+ attr_reader :num, :facelets
+ attr_accessor :sides
+
+ def initialize(num)
+ @num = num
+ @sides = []
+ @facelets = []
+ @fl_by_side = {}
+ end
+
+ # facelets & sides
+ # 0
+ # 0 1 2
+ # 3 3 4 5 1
+ # 6 7 8
+ # 2
+
+ def facelets=(facelets)
+ @facelets = facelets.map { |c| Facelet.new(c) }
+ init_facelet 0, 3,0
+ init_facelet 1, 0
+ init_facelet 2, 0,1
+ init_facelet 3, 3
+ init_facelet 5, 1
+ init_facelet 6, 2,3
+ init_facelet 7, 2
+ init_facelet 8, 1,2
+ end
+
+ def <=>(side)
+ self.num <=> side.num
+ end
+
+ def init_facelet(pos, *side_nums)
+ sides = side_nums.map { |num| @sides[num] }.sort
+ @fl_by_side[sides] = pos
+ end
+
+ def []=(color, *sides)
+ @facelets[@fl_by_side[sides.sort]].color = color
+ end
+
+ def values_at(*sides)
+ sides.map { |sides| @facelets[@fl_by_side[sides.sort]] }
+ end
+
+ def inspect(range=nil)
+ if range
+ @facelets.values_at(*(range.to_a)).join(' ')
+ else
+ <<-EOS.gsub(/\d/) { |num| @facelets[num.to_i] }.gsub(/[ABCD]/) { |side| @sides[side[0]-?A].num.to_s }
+ A
+ 0 1 2
+ D 3 4 5 B
+ 6 7 8
+ C
+ EOS
+ end
+ end
+
+ def get_edge(side)
+ trio = (-1..1).map { |x| (side + x) % 4 }
+ prev_side, this_side, next_side = @sides.values_at(*trio)
+ e = Edge.new(
+ self .values_at( [this_side], [this_side, next_side] ) +
+ this_side.values_at( [self, prev_side], [self ], [self, next_side] )
+ )
+ #puts 'Edge created for side %d: ' % side + e.inspect
+ e
+ end
+
+ def turn(dir)
+ #p 'turn side %d in %d' % [num, dir]
+ edges = (0..3).map { |n| get_edge n }
+ for i in 0..3
+ edges[i].apply edges[(i-dir) % 4]
+ end
+ end
+end
+
+class Cube
+ def initialize
+ @sides = []
+ %w(left front right back top bottom).each_with_index { |side, i|
+ eval("@sides[#{i}] = @#{side} = Side.new(#{i})")
+ }
+ @left.sides = [@top, @front, @bottom, @back]
+ @front.sides = [@top, @right, @bottom, @left]
+ @right.sides = [@top, @back, @bottom, @front]
+ @back.sides = [@top, @left, @bottom, @right]
+ @top.sides = [@back, @right, @front, @left]
+ @bottom.sides = [@front, @right, @back, @left]
+ end
+
+ def read_facelets(fs)
+ pattern = Regexp.new(<<-EOP.gsub(/\w/, '\w').gsub(/\s+/, '\s*'))
+ (w w w)
+ (w w w)
+ (w w w)
+(r r r) (g g g) (b b b) (o o o)
+(r r r) (g g g) (b b b) (o o o)
+(r r r) (g g g) (b b b) (o o o)
+ (y y y)
+ (y y y)
+ (y y y)
+ EOP
+ md = pattern.match(fs).to_a
+
+ @top.facelets = parse_facelets(md.values_at(1,2,3))
+ @left.facelets = parse_facelets(md.values_at(4,8,12))
+ @front.facelets = parse_facelets(md.values_at(5,9,13))
+ @right.facelets = parse_facelets(md.values_at(6,10,14))
+ @back.facelets = parse_facelets(md.values_at(7,11,15))
+ @bottom.facelets = parse_facelets(md.values_at(16,17,18))
+ end
+
+ def turn(side, dir)
+ #p 'turn %d in %d' % [side, dir]
+ @sides[side].turn(dir)
+ #puts inspect
+ end
+
+ def inspect
+ <<-EOF.gsub(/(\d):(\d)-(\d)/) { @sides[$1.to_i].inspect(Range.new($2.to_i, $3.to_i)) }
+ 4:0-2
+ 4:3-5
+ 4:6-8
+0:0-2 1:0-2 2:0-2 3:0-2
+0:3-5 1:3-5 2:3-5 3:3-5
+0:6-8 1:6-8 2:6-8 3:6-8
+ 5:0-2
+ 5:3-5
+ 5:6-8
+ EOF
+ end
+
+private
+ def parse_facelets(rows)
+ rows.join.delete(' ').split(//)
+ end
+end
+
+#$stdin = DATA
+
+gets.to_i.times do |i|
+ puts "Scenario ##{i+1}:"
+ fs = ''
+ 9.times { fs << gets }
+ cube = Cube.new
+ cube.read_facelets fs
+ gets.to_i.times do |t|
+ side, dir = gets.split.map {|s| s.to_i}
+ cube.turn(side, dir)
+ end
+ puts cube.inspect
+ puts
+end
+
+# 2004 by murphy <korny@cYcnus.de>
+# GPL
+class Scenario
+ class TimePoint
+ attr_reader :data
+ def initialize *data
+ @data = data
+ end
+
+ def [] i
+ @data[i] or 0
+ end
+
+ include Comparable
+ def <=> tp
+ r = 0
+ [@data.size, tp.data.size].max.times do |i|
+ r = self[i] <=> tp[i]
+ return r if r.nonzero?
+ end
+ 0
+ end
+
+ def - tp
+ r = []
+ [@data.size, tp.data.size].max.times do |i|
+ r << self[i] - tp[i]
+ end
+ r
+ end
+
+ def inspect
+ # 01/01/1800 00:00:00
+ '%02d/%02d/%04d %02d:%02d:%02d' % @data.values_at(1, 2, 0, 3, 4, 5)
+ end
+ end
+
+ ONE_HOUR = TimePoint.new 0, 0, 0, 1, 0, 0
+
+ APPOINTMENT_PATTERN = /
+ ( \d{4} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} ) \s
+ ( \d{4} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} ) \s ( \d{2} )
+ /x
+
+ def initialize io
+ @team_size = io.gets.to_i
+ @data = [ [TimePoint.new(1800, 01, 01, 00, 00, 00), @team_size] ]
+ @team_size.times do # each team member
+ io.gets.to_i.times do # each appointment
+ m = APPOINTMENT_PATTERN.match io.gets
+ @data << [TimePoint.new(*m.captures[0,6].map { |x| x.to_i }), -1]
+ @data << [TimePoint.new(*m.captures[6,6].map { |x| x.to_i }), +1]
+ end
+ end
+ @data << [TimePoint.new(2200, 01, 01, 00, 00, 00), -@team_size]
+ end
+
+ def print_time_plan
+ n = 0
+ appointment = nil
+ no_appointment = true
+ @data.sort_by { |x| x[0] }.each do |x|
+ tp, action = *x
+ n += action
+ # at any time during the meeting, at least two team members need to be there
+ # and at most one team member is allowed to be absent
+ if n >= 2 and (@team_size - n) <= 1
+ appointment ||= tp
+ else
+ if appointment
+ # the meeting should be at least one hour in length
+ if TimePoint.new(*(tp - appointment)) >= ONE_HOUR
+ puts 'appointment possible from %p to %p' % [appointment, tp]
+ no_appointment = false
+ end
+ appointment = false
+ end
+ end
+ end
+ puts 'no appointment possible' if no_appointment
+ end
+end
+
+# read the data
+DATA.gets.to_i.times do |si| # each scenario
+ puts 'Scenario #%d:' % (si + 1)
+ sc = Scenario.new DATA
+ sc.print_time_plan
+ puts
+end
+
+#__END__
+2
+3
+3
+2002 06 28 15 00 00 2002 06 28 18 00 00 TUD Contest Practice Session
+2002 06 29 10 00 00 2002 06 29 15 00 00 TUD Contest
+2002 11 15 15 00 00 2002 11 17 23 00 00 NWERC Delft
+4
+2002 06 25 13 30 00 2002 06 25 15 30 00 FIFA World Cup Semifinal I
+2002 06 26 13 30 00 2002 06 26 15 30 00 FIFA World Cup Semifinal II
+2002 06 29 13 00 00 2002 06 29 15 00 00 FIFA World Cup Third Place
+2002 06 30 13 00 00 2002 06 30 15 00 00 FIFA World Cup Final
+1
+2002 06 01 00 00 00 2002 06 29 18 00 00 Preparation of Problem Set
+2
+1
+1800 01 01 00 00 00 2200 01 01 00 00 00 Solving Problem 8
+0
+
+require 'token_consts'
+require 'symbol'
+require 'ctype'
+require 'error'
+
+class Fixnum
+ # Treat char as a digit and return it's value as Fixnum.
+ # Returns nonsense for non-digits.
+ # Examples:
+ # <code>
+ # RUBY_VERSION[0].digit == '1.8.2'[0].digit == 1
+ # </code>
+ #
+ # <code>
+ # ?6.digit == 6
+ # </code>
+ #
+ # <code>
+ # ?A.digit == 17
+ # </code>
+ def digit
+ self - ?0
+ end
+end
+
+##
+# Stellt einen einfachen Scanner für die lexikalische Analyse der Sprache Pas-0 dar.
+#
+# @author Andreas Kunert
+# Ruby port by murphy
+class Scanner
+
+ include TokenConsts
+
+ attr_reader :line, :pos
+
+ # To allow Scanner.new without parameters.
+ DUMMY_INPUT = 'dummy file'
+ def DUMMY_INPUT.getc
+ nil
+ end
+
+ ##
+ # Erzeugt einen Scanner, der als Eingabe das übergebene IO benutzt.
+ def initialize input = DUMMY_INPUT
+ @line = 1
+ @pos = 0
+
+ begin
+ @input = input
+ @next_char = @input.getc
+ rescue IOError # TODO show the reason!
+ Error.ioError
+ raise
+ end
+ end
+
+ ##
+ # Liest das n + def read_next_char
+ begin
+ @pos += 1
+ @current_char = @next_char
+ @next_char = @input.getc
+ rescue IOError
+ Error.ioError
+ raise
+ end
+ end
+
+ ##
+ # Sucht das nächste Symbol, identifiziert es, instantiiert ein entsprechendes
+ # PascalSymbol-Objekt und gibt es zurück.
+ # @see Symbol
+ # @return das gefundene Symbol als PascalSymbol-Objekt
+ def get_symbol
+ current_symbol = nil
+ until current_symbol
+ read_next_char
+
+ if @current_char.alpha?
+ identifier = @current_char.chr
+ while @next_char.alpha? or @next_char.digit?
+ identifier << @next_char
+ read_next_char
+ end
+ current_symbol = handle_identifier(identifier.upcase)
+ elsif @current_char.digit?
+ current_symbol = number
+ else
+ case @current_char
+ when ?\s
+ # ignore
+ when ?\n
+ new_line
+ when nil
+ current_symbol = PascalSymbol.new EOP
+ when ?{
+ comment
+
+ when ?:
+ if @next_char == ?=
+ read_next_char
+ current_symbol = PascalSymbol.new BECOMES
+ else
+ current_symbol = PascalSymbol.new COLON
+ end
+
+ when ?<
+ if (@next_char == ?=)
+ read_next_char
+ current_symbol = PascalSymbol.new LEQSY
+ elsif (@next_char == ?>)
+ read_next_char
+ current_symbol = PascalSymbol.new NEQSY
+ else
+ current_symbol = PascalSymbol.new LSSSY
+ end
+
+ when ?>
+ if (@next_char == ?=)
+ read_next_char
+ current_symbol = PascalSymbol.new GEQSY
+ else
+ current_symbol = PascalSymbol.new GRTSY
+ end
+
+ when ?. then current_symbol = PascalSymbol.new PERIOD
+ when ?( then current_symbol = PascalSymbol.new LPARENT
+ when ?, then current_symbol = PascalSymbol.new COMMA
+ when ?* then current_symbol = PascalSymbol.new TIMES
+ when ?/ then current_symbol = PascalSymbol.new SLASH
+ when ?+ then current_symbol = PascalSymbol.new PLUS
+ when ?- then current_symbol = PascalSymbol.new MINUS
+ when ?= then current_symbol = PascalSymbol.new EQLSY
+ when ?) then current_symbol = PascalSymbol.new RPARENT
+ when ?; then current_symbol = PascalSymbol.new SEMICOLON
+ else
+ Error.error(100, @line, @pos) if @current_char > ?\s
+ end
+ end
+ end
+ current_symbol
+ end
+
+private
+ ##
+ # Versucht, in dem gegebenen String ein Schlüsselwort zu erkennen.
+ # Sollte dabei ein Keyword gefunden werden, so gibt er ein PascalSymbol-Objekt zurück, das
+ # das entsprechende Keyword repräsentiert. Ansonsten besteht die Rückgabe aus
+ # einem SymbolIdent-Objekt (abgeleitet von PascalSymbol), das den String 1:1 enthält
+ # @see symbol
+ # @return falls Keyword gefunden, zugehöriges PascalSymbol, sonst SymbolIdent
+ def handle_identifier identifier
+ if sym = KEYWORD_SYMBOLS[identifier]
+ PascalSymbol.new sym
+ else
+ SymbolIdent.new identifier
+ end
+ end
+
+ MAXINT = 2**31 - 1
+ MAXINT_DIV_10 = MAXINT / 10
+ MAXINT_MOD_10 = MAXINT % 10
+ ##
+ # Versucht, aus dem gegebenen Zeichen und den folgenden eine Zahl zusammenzusetzen.
+ # Dabei wird der relativ intuitive Algorithmus benutzt, die endgültige Zahl bei
+ # jeder weiteren Ziffer mit 10 zu multiplizieren und diese dann mit der Ziffer zu
+ # addieren. Sonderfälle bestehen dann nur noch in der Behandlung von reellen Zahlen.
+ # <BR>
+ # Treten dabei kein Punkt oder ein E auf, so gibt diese Methode ein SymbolIntCon-Objekt
+ # zurück, ansonsten (reelle Zahl) ein SymbolRealCon-Objekt. Beide Symbole enthalten
+ # jeweils die Zahlwerte.
+ # <BR>
+ # Anmerkung: Diese Funktion ist mit Hilfe der Java/Ruby-API deutlich leichter zu realisieren.
+ # Sie wurde dennoch so implementiert, um den Algorithmus zu demonstrieren
+ # @see symbol
+ # @return SymbolIntcon- oder SymbolRealcon-Objekt, das den Zahlwert enthält
+ def number
+ is_integer = true
+ integer_too_long = false
+ exponent = 0
+ exp_counter = -1
+ exp_sign = 1
+
+ integer_mantisse = @current_char.digit
+
+ while (@next_char.digit? and integer_mantisse < MAXINT_DIV_10) or
+ (integer_mantisse == MAXINT_DIV_10 and @next_char.digit <= MAXINT_MOD_10)
+ integer_mantisse *= 10
+ integer_mantisse += @next_char.digit
+ read_next_char
+ end
+
+ real_mantisse = integer_mantisse
+
+ while @next_char.digit?
+ integer_too_long = true
+ real_mantisse *= 10
+ real_mantisse += @next_char.digit
+ read_next_char
+ end
+ if @next_char == ?.
+ read_next_char
+ is_integer = false
+ unless @next_char.digit?
+ Error.error 101, @line, @pos
+ end
+ while @next_char.digit?
+ real_mantisse += @next_char.digit * (10 ** exp_counter)
+ read_next_char
+ exp_counter -= 1
+ end
+ end
+ if @next_char == ?E
+ is_integer = false
+ read_next_char
+ if @next_char == ?-
+ exp_sign = -1
+ read_next_char
+ end
+ unless @next_char.digit?
+ Error.error 101, @line, @pos
+ end
+ while @next_char.digit?
+ exponent *= 10
+ exponent += @next_char.digit
+ read_next_char
+ end
+ end
+
+ if is_integer
+ if integer_too_long
+ Error.error 102, @line, @pos
+ end
+ SymbolIntcon.new integer_mantisse
+ else
+ SymbolRealcon.new real_mantisse * (10 ** (exp_sign * exponent))
+ end
+ end
+
+ ##
+ # Sorgt für ein Überlesen von Kommentaren.
+ # Es werden einfach alle Zeichen bis zu einer schließenden Klammer eingelesen
+ # und verworfen.
+ def comment
+ while @current_char != ?}
+ forbid_eop
+ new_line if @current_char == ?\n
+ read_next_char
+ end
+ end
+
+ def new_line
+ @line += 1
+ @pos = 0
+ end
+
+ def forbid_eop
+ if eop?
+ Error.error 103, @line, @pos
+ end
+ exit
+ end
+
+ def eop?
+ @current_char.nil?
+ end
+end
+
+##
+# Läßt ein Testprogramm ablaufen.
+# Dieses erzeugt sich ein Scanner-Objekt und ruft an diesem kontinuierlich bis zum Dateiende
+# get_symbol auf.
+if $0 == __FILE__
+ scan = Scanner.new(File.new(ARGV[0] || 'test.pas'))
+ loop do
+ c = scan.get_symbol
+ puts c
+ break if c.typ == TokenConsts::EOP
+ end
+end
+
|