sdl4r 0.9.1

data/lib/sdl4r/reader.rb

@@ -0,0 +1,171 @@
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the
+# terms of the GNU Lesser General Public License version 2.1 as published by
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+module SDL4R
+
+  # Gives access to the characters read to the Parser.
+  # This class was designed to gather the handling of the UTF-8 issues in one place and shield the
+  # Parser class from these problems.
+  class Reader
+
+    RUBY_1_8_OR_LESS = require 'jcode'
+
+
+    # +io+  an open IO from which the characters are read.
+    def initialize(io)
+      raise ArgumentError, "io == nil" if io.nil?
+
+      @io = io
+      @line = nil
+      @line_chars = nil
+      @line_no = 0
+      @pos = 0
+    end
+
+    attr_reader :line_no, :pos, :line;
+
+    def line_length
+      return @line_chars.nil? ? 0 : @line_chars.length
+    end
+
+    # Reads next line in stream skipping comment lines and blank lines.
+    #
+    # Returns the next line or nil at the end of the file.
+    def read_line
+      @line_chars = nil
+
+      while @line = read_raw_line()
+        # Skip empty and commented lines
+        break unless @line.empty? or @line =~ /^#/
+      end
+
+      return @line
+    end
+    
+    # Returns the string that goes from the current position of this Reader to the end of the line
+    # or nil if the current position doesn't allow that.
+    def rest_of_line
+      return @line[@pos..-1]
+    end
+    
+    # Indicates whether the end of file has been reached.
+    def end_of_file?
+      return @line.nil?
+    end
+    
+    # Indicates whether there are more characters in the current line
+    def more_chars_in_line?
+      return @pos < line_length - 1
+    end
+
+    # Returns whether the end of the current +line+ as been reached.
+    def end_of_line?
+      return @pos >= line_length
+    end
+
+    # Skips the current line by going just after its end.
+    def skip_line
+      @pos = line_length
+    end
+    
+    # Skips the whitespaces that follow the current position.
+    def skip_whitespaces
+      while (@pos + 1) < line_length and
+          (@line[@pos + 1] == ?\s or @line[@pos + 1] == ?\t)
+        @pos += 1
+      end
+    end
+
+    # Returns the character at position +pos+ in the current line.
+    # Returns nil if there is no current line or if +pos+ is after the end of the line.
+    def get_line_char(pos)
+      if @line_chars and pos < line_length
+        return @line_chars[pos]
+      else
+        return nil
+      end
+    end
+    
+    # Returns the character at the current position or nil after end-of-line or end-of -file.
+    def current_char
+      return get_line_char(@pos)
+    end
+    
+    # Go to the next character in the stream.
+    def skip_char
+      @pos += 1 if @pos < line_length
+    end
+    
+    # Go to the next character and returns it (or nil if end-of-line or -file has been reached).
+    def read_char
+      skip_char()
+      return current_char
+    end
+    
+    # Returns to the previous char if possible.
+    def previous_char
+      @pos -= 1 if @pos >= -1
+    end
+
+    # Returns the next index of the expression (string, regexp, fixnum) in the current line, starting
+    # from after the current position if no position is specified.
+    def find_next_in_line(searched, start_pos = nil)
+      start_pos = @pos + 1 unless start_pos
+      return @line.index(searched, start_pos)
+    end
+    
+    # Skips the specified position in the current line.
+    def skip_to(new_pos)
+      @pos = new_pos
+    end
+    
+    
+    # Returns a subpart of the current line starting from +from+ and stopping at +to+ (excluded).
+    def substring(from, to = -1)
+      return @line[from..to]
+    end
+
+    # Reads and returns a "raw" line including lines with comments and blank lines.
+    #
+    # Returns the next line or nil if at the end of the file.
+    #
+    # This method changes the value of @line, @lineNo and @pos.
+    def read_raw_line
+      @line = @io.gets()
+
+      # We ensure that only \n is used as an end-of-line by replacing \r and \r\n.
+      if @line
+        if not @line.gsub!(/\r\n/m, "\n")
+          @line.gsub!(/\r/m, "\n")
+        end
+      end
+
+      @pos = 0;
+      @line_chars = nil
+      if @line
+        @line_no += 1
+        @line_chars = @line.scan(/./m)
+      end
+      return @line
+    end
+    
+    # Closes this Reader and its underlying +IO+.
+    def close
+      @io.close
+    end
+  end
+
+end

data/lib/sdl4r/sdl.rb

@@ -0,0 +1,242 @@
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the 
+# terms of the GNU Lesser General Public License version 2.1 as published by  
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+require 'jcode'
+require 'base64'
+require 'rational'
+require 'date'
+
+# Various SDL related utility methods
+# 
+module SDL4R
+  
+  MAX_INTEGER_32 = 2**31 - 1
+  MIN_INTEGER_32 = -(2**31)
+  
+  MAX_INTEGER_64 = 2**63 - 1
+  MIN_INTEGER_64 = -(2**63)
+
+  
+  # Returns the milliseonds part of a DateTime (by translating the +sec_fraction+ part) as an
+  # integer.
+  def self.get_date_milliseconds(date)
+    sec_fraction = date.sec_fraction() # in days
+    # 86400000 is the number of milliseconds in a day
+    return (sec_fraction * 86400000).round()
+  end
+
+  BASE64_WRAP_LINE_LENGTH = 72
+
+  # Creates an SDL string representation for a given object and returns it.
+  # 
+  # +o+:: the object to format
+  # +add_quotes+:: indicates whether quotes will be added to Strings and characters
+  #   (true by default)
+  # +line_prefix+:: the line prefix to use ("" by default)
+  # +indent+:: the indent string to use ("\t" by default)
+  #
+  def self.format(o, add_quotes = true, line_prefix = "", indent = "\t")
+    if o.is_a?(String)
+      if add_quotes
+        o_length = 0
+        o.scan(/./m) { o_length += 1 } # counts the number of chars (as opposed of bytes)
+        if o_length == 1
+          return "'" + escape(o, "'") + "'"
+        else
+          return '"' + escape(o, '"') + '"'
+        end
+      else
+        return escape(o)
+      end
+      
+    elsif o.is_a?(Bignum)
+      return o.to_s + "BD"
+      
+    elsif o.is_a?(Integer)
+      if MIN_INTEGER_32 <= o and o <= MAX_INTEGER_32
+        return o.to_s
+      elsif MIN_INTEGER_64 <= o and o <= MAX_INTEGER_64
+        return o.to_s + "L"
+      else
+        return o.to_s + "BD"
+      end
+      
+    elsif o.is_a?(Float)
+      return o.to_s + "F"
+      
+    elsif o.is_a?(Rational)
+      return o.to_f.to_s + "F"
+
+    elsif defined? Flt::DecNum and o.is_a?(Flt::DecNum)
+      return o.to_s + "BD"
+
+    elsif o.nil?
+      return "null"
+
+    elsif o.is_a?(SdlBinary)
+      encoded_o = Base64.encode64(o.bytes)
+      encoded_o.gsub!(/[\r\n]/m, "") # Remove the EOL inserted every 60 chars
+
+      if add_quotes
+        if encoded_o.length > BASE64_WRAP_LINE_LENGTH
+          # FIXME: we should a constant or some parameter instead of hardcoded spaces
+          wrap_lines_in_ascii(encoded_o, BASE64_WRAP_LINE_LENGTH, "#{line_prefix}#{indent}")
+          encoded_o.insert(0, "[#{$/}")
+          encoded_o << "#{$/}#{line_prefix}]"
+        else
+          encoded_o.insert(0, "[")
+          encoded_o << "]"
+        end
+      end
+
+      return encoded_o
+      
+    # Below, we use "#{o.year}" instead of "%Y" because "%Y" always emit 4 chars at least even if
+    # the date is before 1000.
+    elsif o.is_a?(DateTime) || o.is_a?(Time)
+      milliseconds = o.is_a?(DateTime) ? get_date_milliseconds(o) : (o.usec / 10).to_i
+
+      if milliseconds == 0
+        if o.zone
+          return o.strftime("#{o.year}/%m/%d %H:%M:%S%Z")
+        else
+          return o.strftime("#{o.year}/%m/%d %H:%M:%S")
+        end
+      else
+        if o.zone
+          return o.strftime("#{o.year}/%m/%d %H:%M:%S." + milliseconds.to_s.ljust(3, '0') + "%Z")
+        else
+          return o.strftime("#{o.year}/%m/%d %H:%M:%S." + milliseconds.to_s.ljust(3, '0'))
+        end
+      end
+
+    elsif o.is_a?(Date)
+      return o.strftime("#{o.year}/%m/%d")
+      
+    else
+      return o.to_s
+    end
+  end
+
+  # Wraps lines in "s" (by modifying it). This method only supports 1-byte character strings.
+  #
+  def self.wrap_lines_in_ascii(s, line_length, line_prefix = nil)
+    # We could use such code if it supported any value for "line_prefix": unfortunately it is capped
+    # at 64 in the regular expressions.
+    #
+    # return "#{line_prefix}" + encoded_o.scan(/.{1,#{line_prefix}}/).join("#{$/}#{line_prefix}")
+
+    eol_size = "#{$/}".size
+
+    i = 0
+    while i < s.size
+      if i > 0
+        s.insert(i, $/)
+        i += eol_size
+      end
+
+      if line_prefix
+        s.insert(i, line_prefix)
+        i += line_prefix.size
+      end
+
+      i += line_length
+    end
+  end
+
+  ESCAPED_QUOTES = {
+    "\"" => "\\\"",
+    "'" => "\\'",
+    "`" => "\\`",
+  }
+
+  ESCAPED_CHARS = {
+    "\\" => "\\\\",
+    "\t" => "\\t",
+    "\r" => "\\r",
+    "\n" => "\\n",
+  }
+  ESCAPED_CHARS.merge!(ESCAPED_QUOTES)
+
+  # Returns an escaped version of +s+ (i.e. where characters which need to be
+  # escaped, are escaped).
+  #
+  def self.escape(s, quote_char = nil)
+    escaped_s = ""
+
+    s.each_char { |c|
+      escaped_char = ESCAPED_CHARS[c]
+      if escaped_char
+        if ESCAPED_QUOTES.has_key?(c)
+          if quote_char && c == quote_char
+            escaped_s << escaped_char
+          else
+            escaped_s << c
+          end
+        else
+            escaped_s << escaped_char
+        end
+      else
+        escaped_s << c
+      end
+    }
+    
+    return escaped_s
+  end
+    
+  # This method was kept from the Java code but it is not sure if it should have a usefulness yet.
+  #
+  def self.coerce_or_fail(o)
+    return o
+  end
+  
+  # Validates an SDL identifier String.  SDL Identifiers must start with a
+  # Unicode letter or underscore (_) and contain only unicode letters,
+  # digits, underscores (_), and dashes(-).
+  # 
+  # @param identifier The identifier to validate
+  # @throws IllegalArgumentException if the identifier is not legal
+  #
+  # TODO: support UTF-8 identifiers
+  #
+  def self.validate_identifier(identifier)
+    if identifier.nil? or identifier.empty?
+      raise ArgumentError, "SDL identifiers cannot be null or empty."
+    end
+
+    # in Java, was if(!Character.isJavaIdentifierStart(identifier.charAt(0)))
+    unless identifier =~ /^[a-zA-Z_]/
+      raise ArgumentError,
+        "'" + identifier[0..0] +
+        "' is not a legal first character for an SDL identifier. " +
+        "SDL Identifiers must start with a unicode letter or " +
+        "an underscore (_)."
+    end
+    
+    unless identifier.length == 1 or identifier =~ /^[a-zA-Z_][a-zA-Z_0-9\-]*$/
+      for i in 1..identifier.length
+        unless identifier[i..i] =~ /^[a-zA-Z_0-9\-]$/
+          raise ArgumentError,
+            "'" + identifier[i..i] + 
+            "' is not a legal character for an SDL identifier. " +
+            "SDL Identifiers must start with a unicode letter or " +
+            "underscore (_) followed by 0 or more unicode " +
+            "letters, digits, underscores (_), or dashes (-)"
+        end
+      end
+    end
+  end
+end

data/lib/sdl4r/sdl_binary.rb

@@ -0,0 +1,78 @@
+# Simple Declarative Language (SDL) for Ruby
+# Copyright 2005 Ikayzo, inc.
+#
+# This program is free software. You can distribute or modify it under the
+# terms of the GNU Lesser General Public License version 2.1 as published by
+# the Free Software Foundation.
+#
+# This program is distributed AS IS and WITHOUT WARRANTY. OF ANY KIND,
+# INCLUDING MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program; if not, contact the Free Software Foundation, Inc.,
+# 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+
+module SDL4R
+
+  #
+  # Represents a binary value.
+  # This class was introduced to avoid the confusion between a Ruby String and a binary literal.
+  #
+  class SdlBinary
+
+    attr_accessor :bytes
+
+    # +value+: a String containing the bytes
+    def initialize(bytes)
+      @bytes = bytes
+    end
+    
+    def ==(o)
+      return true if self.equal?(o)
+      return false if not o.instance_of?(self.class)
+      return self.bytes == o.bytes
+    end
+
+    def eql?(o)
+      self == o
+    end
+
+    def hash
+      return bytes.hash
+    end
+
+    # Returns the bytes base64-encoded.
+    def to_s
+      return Base64.encode64(bytes)
+    end
+
+    # Decodes the specified base-64 encoded string and returns a corresponding SdlBinary
+    # instance.
+    # +s+ might not include the conventional starting and ending square brackets.
+    def self.decode64(s)
+      s = s.delete("\n\r\t ")
+
+      binary = Base64.decode64(s)
+      
+      if binary.empty? and not s.empty?
+        raise ArgumentError, "bad binary literal"
+      end
+
+      return SdlBinary.new(binary)
+    end
+  end
+
+  # Try to coerce 'o' into a SdlBinary.
+  # Raise an ArgumentError if it fails.
+  def self.SdlBinary(o)
+    if o.kind_of? SdlBinary
+      return o
+    elsif o.kind_of? String
+      return SdlBinary.new(o)
+    else
+      raise ArgumentError, "can't coerce argument"
+    end
+  end
+end