sdl4r 0.9.8 → 0.9.9

data/CHANGELOG

@@ -1,4 +1,17 @@
-== v0.9.9 (建設中)
+== v0.9.10 (建設中)
+== v0.9.9 (19-11-2010)
+
+=== Major changes:
+
+* SDL4R#to_attribute_map renamed to SDL4R#to_attribute_hash (as the doc stated previously).
+* Symbols are now converted to Strings when used as SDL values. It is therefore possible to write:
+
+    tag.set_attribute("type", :square) #tag.attribute("type") => "square"
+
+=== Minor changes:
+
+* New methods: Tag#has_attributes? and Tag#has_values?
+
 == v0.9.8 (16-sep-2010)
 
 === Major changes:

data/README

@@ -71,7 +71,7 @@ attributes, and (if it has a body) child tags.  In the example above, the
 attributes, and no bodies.
 
 SDL is often used for simple key-value mappings.  To simplify things Tag
-has the methods getValue and setValue which operate on the first element in
+has the methods value and value= which operate on the first element in
 the values list.  Also notice SDL understands types which are determined
 using type inference.
 
@@ -112,7 +112,7 @@ demonstrates the use of anonymous tags.
 
     # If we have a handle on the "greetings" tag we can access the
     # anonymous child tag by calling
-    #    Tag child1 = greetingTag.getChild("content");
+    #    Tag child1 = greetingTag.child("content");
 
 == String literals
 
@@ -299,7 +299,7 @@ An example SDL file:
 
     # To retrieve the files as a list of strings
     #
-    #     List files = tag.getChild("files").getChildrenValues("content");
+    #     List files = tag.child("files").children_values("content");
     #
     # We us the name "content" because the files tag has two children, each of
     # which are anonymous tags (values with no name.)  These tags are assigned
@@ -312,7 +312,7 @@ An example SDL file:
 
     # To retrieve the values from the matrix (as a list of lists)
     #
-    #     List rows = tag.getChild("matrix").getChildrenValues("content");
+    #     List rows = tag.child("matrix").children_values("content");
 
 
 Example of getting the "location" attribute from the "daughter" tag

data/Rakefile

@@ -17,13 +17,13 @@ spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.summary = "Simple Declarative Language for Ruby library"
   s.name = 'sdl4r'
-  s.version = '0.9.8'
+  s.version = '0.9.9'
   s.requirements << 'none'
   s.require_path = 'lib'
   s.authors = ['Philippe Vosges', 'Daniel Leuck']
   s.email = 'sdl-users@ikayzo.org'
   s.rubyforge_project = 'sdl4r'
-  s.homepage = 'http://www.ikayzo.org/confluence/display/SDL/Home'
+  s.homepage = 'http://sdl4r.rubyforge.org/'
   s.files = FileList['lib/sdl4r.rb', 'lib/sdl4r/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*', 'doc/**/*'].to_a
   s.test_files = FileList[ 'test/**/*test.rb' ].to_a
   s.description = <<EOF
@@ -44,16 +44,19 @@ end
 #   - once with the provided command (i.e. 7zip if zip is not available)
 #   - once with "zip" disregarding the configuration (that attempt fails if you do not have the
 #     "zip" command)
-Rake::PackageTask.new(spec.name, spec.version) do |p|
-  p.need_zip = true
-  p.need_tar = false
-  p.need_tar_gz = false
-  p.need_tar_bz2 = false
-
-  # If "zip" is not available, we try 7-zip.
-  system("zip")
-  p.zip_command = "7z a -tzip" if $?.exitstatus == 127
-end
+#Rake::PackageTask.new(spec.name, spec.version) do |p|
+#  p.need_zip = true
+#  p.need_tar = false
+#  p.need_tar_gz = false
+#  p.need_tar_bz2 = false
+#
+#  # If "zip" is not available, we try 7-zip.
+#puts "========================================================"
+#  system("zip")
+#  p.zip_command = "7z a -tzip" if $?.exitstatus == 127
+#  system("tar")
+#  p.tar_command = "7z a -ttar" if $?.exitstatus == 127
+#end
 
 Rake::RDocTask.new do |rd|
   files = ['README', 'LICENSE', 'CHANGELOG', 'lib/**/*.rb', 'doc/**/*.rdoc', 'test/**/*.rb']

data/TODO

@@ -73,7 +73,8 @@
     ["ns", "attr"] <=> attribute("ns", "attr")
     Should we allow attribute("ns:attr")?
     ==> Mmmm, but it could also mean "get child with that name". Let's wait.
-[ ] IDEA: marshaller? easy object <=> SDL read/write?
+[x] IDEA: marshaller? easy object <=> SDL read/write?
+    SEE SPECS @ Ikayzo: http://www.ikayzo.org/confluence/display/SDL/Draft+-+Serialization+with+SDL
 [ ] Check the coverage and make the tests better.
     ==> Might be better to use some other tool than
 [ ] IDEA: add an option to the XML export allowing to write anonymous nodes as XML tag content?
@@ -84,7 +85,8 @@
 [ ] Look into performances, compared to YAML or XML parsers
 [ ] Future: SDL + ERB to have dynamic config templates
     see http://github.com/binarylogic/settingslogic
-[ ] Future: object dump/load as YAML does
+[x] Future: object dump/load as YAML does
+    SEE SPECS @ Ikayzo: http://www.ikayzo.org/confluence/display/SDL/Draft+-+Serialization+with+SDL
     - add to_sdl(4r) to Object
 
     - for each object:
@@ -148,5 +150,10 @@
         vegetable {}
 
     ==> It seems this is not supported by the Java parser. Is it invalid/valid syntax?
-        It will be in the next version of SDL.
-[x] BUG: '$' is a valid identifier character and it is not accepted.
+    ==> It will be in the next version of SDL.
+[x] BUG: '$' is a valid identifier character and it is not accepted.
+====================================================================================================
+[x] Check that if you write 2 values, a date and a timespan, you get both normally when you load.
+    ==> Considered as a bug in the language spec by Dan.
+[x] BUG: negative years seem not to be supported in dates (somehow mistaken for integers: -4712/01/01)
+[ ] Allow Symbols as attribute/child names

data/lib/sdl4r/parser.rb

@@ -200,25 +200,25 @@ module SDL4R
           next_token = ((i + 1) < size)? tokens[i + 1] : nil
           if token.type == :DATE && next_token && next_token.type == :TIME
             date = token.object_for_literal()
-            time_zone_with_zone = next_token.object_for_literal()
+            time_span_with_zone = next_token.object_for_literal()
 						
-            if time_zone_with_zone.day != 0
+            if time_span_with_zone.day
               # as there are days specified, it can't be a full precision date
               tag.add_value(date);
               tag.add_value(
                 SdlTimeSpan.new(
-                  time_zone_with_zone.day,
-                  time_zone_with_zone.hour,
-                  time_zone_with_zone.min,
-                  time_zone_with_zone.sec))
+                  time_span_with_zone.day || 0,
+                  time_span_with_zone.hour,
+                  time_span_with_zone.min,
+                  time_span_with_zone.sec))
 							
 							
-              if time_zone_with_zone.time_zone_offset
+              if time_span_with_zone.time_zone_offset
                 parse_error("TimeSpan cannot have a timeZone", t.line, t.position)
               end
 							
             else
-              tag.add_value(combine(date, time_zone_with_zone))
+              tag.add_value(combine(date, time_span_with_zone))
             end
 						
             i += 1
@@ -235,12 +235,7 @@ module SDL4R
                   token.position)
               end
 							
-              tag.add_value(
-                SdlTimeSpan.new(
-                  value.day,
-                  value.hour,
-                  value.min,
-                  value.sec))
+              tag.add_value(SdlTimeSpan.new(value.day || 0, value.hour, value.min, value.sec))
             else
               tag.add_value(value)
             end
@@ -370,7 +365,7 @@ module SDL4R
             date = token.object_for_literal()
             time_span_with_zone = tokens[i + 1].object_for_literal()
 						
-            if time_span_with_zone.day != 0
+            if time_span_with_zone.day
               expecting_but_got(
                 "TIME (component of date/time) in attribute value",
                 "TIME SPAN",
@@ -393,7 +388,7 @@ module SDL4R
               end
 							
               time_span = SdlTimeSpan.new(
-                time_span_with_zone.day,
+                time_span_with_zone.day || 0,
                 time_span_with_zone.hour,
                 time_span_with_zone.min,
                 time_span_with_zone.sec)
@@ -471,33 +466,31 @@ module SDL4R
     # [days, hours, minutes, seconds, time_zone_offset].
     # 'days', 'hours' and 'minutes' are integers.
     # 'seconds' and 'time_zone_offset' are rational numbers.
-    # 'days' and 'seconds' are equal to 0 if they're not specified in ((|literal|)).
+    # 'days' and 'seconds' are equal to 0 if they're not specified in +literal+.
     # 'time_zone_offset' is equal to nil if not specified.
     #
-    # ((|allowDays|)) indicates whether the specification of days is allowed
-    # in ((|literal|))
-    # ((|allowTimeZone|)) indicates whether the specification of the timeZone is
-    # allowed in ((|literal|))
+    # +allowDays+ indicates whether the specification of days is allowed
+    # in +literal+
+    # +allowTimeZone+ indicates whether the specification of the timeZone is
+    # allowed in +literal+
     #
-    # All components are returned disregarding the values of ((|allowDays|)) and
-    # ((|allowTimeZone|)).
+    # All components are returned disregarding the values of +allowDays+ and
+    # +allowTimeZone+.
     #
-    # Raises an ArgumentError if ((|literal|)) has a bad format.
+    # Raises an ArgumentError if +literal+ has a bad format.
     def Parser.parse_time_span_and_time_zone(literal, allowDays, allowTimeZone)
       overall_sign = (literal =~ /^-/)? -1 : +1
 
       if literal =~ /^(([+\-]?\d+)d:)/
         if allowDays
           days = Integer($2)
-          days_specified = true
           time_part = literal[($1.length)..-1]
         else
           # detected a day specification in a pure time literal
           raise ArgumentError, "unexpected day specification in #{literal}"
         end
       else
-        days = 0;
-        days_specified = false
+        days = nil
         time_part = literal
       end
 			
@@ -544,7 +537,7 @@ module SDL4R
         end
 
         # take the sign into account
-        hours *= overall_sign if days_specified # otherwise the sign is already applied to the hours
+        hours *= overall_sign if days # otherwise the sign is already applied to the hours
         minutes *= overall_sign
         seconds *= overall_sign
 				
@@ -557,7 +550,7 @@ module SDL4R
 		
     # Parses the given literal (String) into a returned DateTime object.
     #
-    # Raises an ArgumentError if ((|literal|)) has a bad format.
+    # Raises an ArgumentError if +literal+ has a bad format.
     def Parser.parse_date_time(literal)
       raise ArgumentError("date literal is nil") if literal.nil?
 			
@@ -607,7 +600,7 @@ module SDL4R
     
     def Parser.parse_date(literal)
       # here, we're being stricter than strptime() alone as we forbid trailing chars
-      if literal =~ /^(\d+)\/(\d+)\/(\d+)$/
+      if literal =~ /^(-?\d+)\/(\d+)\/(\d+)$/
         begin
           return Date.strptime(literal, "%Y/%m/%d")
         rescue ArgumentError
@@ -618,10 +611,9 @@ module SDL4R
       raise ArgumentError, "Malformed Date <#{literal}>"
     end
 		
-    # Returns a String that contains the binary content corresponding to ((|literal|)).
+    # Returns a String that contains the binary content corresponding to +literal+.
     #
-    # ((|literal|)) : a base-64 encoded literal (e.g.
-    # "[V2hvIHdhbnRzIHRvIGxpdmUgZm9yZXZlcj8=]")
+    # +literal+ : a base-64 encoded literal (e.g. "[V2hvIHdhbnRzIHRvIGxpdmUgZm9yZXZlcj8=]")
     def Parser.parse_binary(literal)
       clean_literal = literal[1..-2] # remove square brackets
       return SdlBinary.decode64(clean_literal)

data/lib/sdl4r/parser/token.rb

@@ -64,7 +64,7 @@ module SDL4R
             @type=:BINARY
             @object = Parser.parse_binary(text)
 
-          elsif text =~ /^\d+\/\d+\/\d+$/
+          elsif text =~ /^-?\d+\/\d+\/\d+$/
             @type = :DATE;
             @object = Parser.parse_date_time(text)
 

data/lib/sdl4r/sdl4r.rb

@@ -45,23 +45,17 @@ module SDL4R
   # +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
+    case o
+    when String
+      return format_string(o)
       
-    elsif o.is_a?(Bignum)
+    when Symbol
+      return format_string(o.to_s)
+      
+    when Bignum
       return o.to_s + "BD"
       
-    elsif o.is_a?(Integer)
+    when 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
@@ -70,21 +64,21 @@ module SDL4R
         return o.to_s + "BD"
       end
       
-    elsif o.is_a?(Float)
+    when Float
       return (o.to_s + "F")
       
-    elsif o.is_a?(Rational)
+    when Rational
       return o.to_f.to_s + "F"
 
-    elsif o.is_a?(BigDecimal)
+    when BigDecimal
       s = o.to_s('F')
       s.sub!(/\.0$/, "")
       return "#{s}BD"
 
-    elsif o.nil?
+    when NilClass
       return "null"
 
-    elsif o.is_a?(SdlBinary)
+    when SdlBinary
       encoded_o = Base64.encode64(o.bytes)
       encoded_o.gsub!(/[\r\n]/m, "") # Remove the EOL inserted every 60 chars
 
@@ -104,7 +98,7 @@ module SDL4R
       
     # 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)
+    when DateTime, Time
       milliseconds = get_datetime_milliseconds(o)
 
       if milliseconds == 0
@@ -123,7 +117,7 @@ module SDL4R
         end
       end
 
-    elsif o.is_a?(Date)
+    when Date
       return o.strftime("#{o.year}/%m/%d")
       
     else
@@ -152,6 +146,7 @@ module SDL4R
   # SdlTimeSpan, SdlBinary,
   #
   # Rationals are turned into Floats using Rational#to_f.
+  # Symbols are turned into Strings using Symbol#to_s.
   #
   def self.coerce_or_fail(o)
     case o
@@ -159,6 +154,9 @@ module SDL4R
     when Rational
       return o.to_f
 
+    when Symbol
+      return o.to_s
+
     when NilClass,
         String,
         Numeric,
@@ -176,6 +174,19 @@ module SDL4R
 
     raise ArgumentError, "#{o.class.name} is not coercible to an SDL type"
   end
+
+  # Indicates whether 'o' is coercible to a SDL litteral type.
+  # See #coerce_or_fail
+  #
+  def self.is_coercible?(o)
+    begin
+      coerce_or_fail(o)
+      true
+      
+    rescue ArgumentError
+      false
+    end
+  end
   
   # Validates an SDL identifier String.  SDL Identifiers must start with a
   # Unicode letter or underscore (_) and contain only unicode letters,
@@ -272,7 +283,7 @@ module SDL4R
 	#
 	#   # { "value" => 1, "debugging" => true, "time" => SdlTimeSpan.new(12, 24, 01) }
 	#
-  def self.to_attribute_map(s)
+  def self.to_attribute_hash(s)
     raise ArgumentError, "'s' cannot be null" if s.nil?
     return read("atts " + s).child.attributes
   end
@@ -282,6 +293,23 @@ module SDL4R
   class << self
     private
 
+    # Returns the specified string 's' formatted as a SDL string.
+    # See SDL4R#format.
+    #
+    def format_string(s, add_quotes = true)
+        if add_quotes
+          s_length = 0
+          s.scan(/./m) { s_length += 1 } # counts the number of chars (as opposed to bytes)
+          if s_length == 1
+            return "'" + escape(s, "'") + "'"
+          else
+            return '"' + escape(s, '"') + '"'
+          end
+        else
+          return escape(s)
+        end
+    end
+
     # Wraps lines in "s" (by modifying it). This method only supports 1-byte character strings.
     #
     def wrap_lines_in_ascii(s, line_length, line_prefix = nil)

data/lib/sdl4r/sdl_time_span.rb

@@ -247,12 +247,12 @@ module SDL4R
     #     24d:12:13:09.234 (24 days, 12 hours, 13 minutes, 9 seconds,
     #         234 milliseconds)
     #
-    def to_s
+    def to_s(force_show_days = false)
       _days = days
       _milliseconds = milliseconds
       
       s = nil
-      if _days == 0
+      if _days == 0 and not force_show_days
         if _milliseconds == 0
           s = sprintf("%d:%02d:%02d", hours, minutes.abs, seconds.abs)
         else

data/lib/sdl4r/serializer.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+
+#--
+# 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
+
+  require 'ostruct'
+
+  require File.dirname(__FILE__) + '/sdl4r'
+  require File.dirname(__FILE__) + '/tag'
+
+  # Allows to serialize/deserialize between SDL and Ruby Objects.
+  #
+  # == Authors
+  # Philippe Vosges
+  #
+  class Serializer
+
+    def serialize(o, tag = Tag.new(SDL4R::ROOT_TAG_NAME))
+      raise ArgumentError, '"tag" must be a Tag' unless tag.is_a?(Tag)
+      
+      o = o.marshal_dump if o.is_a? OpenStruct
+
+      if o.is_a? Hash
+        o.each_pair { |key, value|
+          serialize_variable(key.to_s, value, tag)
+        }
+
+      else
+        o.instance_variables.each { |name|
+          value = o.instance_variable_get(name)
+          name = name[1..name.size] if name =~ /^@/
+          serialize_variable(name, value, tag)
+        }
+      end
+
+      tag
+    end
+
+    def deserialize(tag, o = OpenStruct.new)
+      is_open_struct_or_hash = o.is_a?(OpenStruct) or o.is_a?(Hash)
+
+      # TODO Deserialization from anonymous child tags
+
+      # Deserialization from values
+      if tag.has_values?
+        if tag.has_children? or tag.has_attributes?
+          variable_value = tag.values
+
+          if o.instance_variable_defined?("@value") or not o.instance_variable_defined?("@values")
+            # value is preferred
+            variable_name = "value"
+            variable_value = variable_value[0] if variable_value.length == 1
+          else
+            variable_name = "values"
+          end
+
+          if is_open_struct_or_hash or o.instance_variable_defined?(variable_name)
+            set_object_variable(o, variable_name, variable_value)
+          end
+
+        else
+          # the tag only has values
+          return variable_value.length == 1 ? variable_value[0] : variable_value
+        end
+      end
+
+      # Deserialization from attributes
+      tag.attributes do |attribute_namespace, attribute_name, attribute_value|
+        if is_open_struct_or_hash or o.instance_variable_defined?("@#{attribute_name}")
+          set_object_variable(o, attribute_name, attribute_value)
+        end
+      end
+
+      # Deserialization from (not anonymous) child tags
+      tag.children do |child|
+#        if child.namespace != '' or child.name != SDL4R::ANONYMOUS_TAG_NAME
+          variable_name = "@#{child.name}"
+
+          # Check wether this variable is assignable
+          if is_open_struct_or_hash or o.instance_variable_defined?(variable_name)
+            variable_value = nil
+
+            if child.has_values? and not child.has_children? and not child.has_attributes?
+              # If the object only has values (no children, no atttributes):
+              #  then the values are the variable value
+              variable_value = child.values
+              variable_value = variable_value[0] if variable_value.length == 1
+
+            else
+              # Consider this tag as an object
+              previous_value = o.instance_variable_get(variable_name)
+              if previous_value.nil?
+                variable_value = deserialize(child)
+              elsif SDL4R::is_coercible?(previous_value)
+                variable_value = deserialize(child)
+              else
+                variable_value = deserialize(child, previous_value)
+              end
+            end
+
+            set_object_variable(o, child.name, variable_value)
+          end
+#        end
+      end
+
+      return o
+    end
+
+    private
+
+    def serialize_variable(name, value, tag)
+      if SDL4R::is_coercible?(value)
+        # SDL litteral type
+        tag.set_attribute(name, value)
+      else
+        # Simple object
+        serialize(value, tag.new_child(name))
+      end
+    end
+
+    def set_object_variable(o, name, value)
+      case o
+      when Hash
+        o[name] = value
+
+      when OpenStruct
+        o.send "#{name}=", value
+
+      else
+        o.instance_variable_set("@#{name}", value)
+      end
+    end
+  end
+end