llsd 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007-2011, Linden Research, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/lib/llsd.rb

@@ -0,0 +1,186 @@
+require 'rexml/document'
+require 'date'
+
+# Class for parsing and generating llsd xml
+class LLSD
+  class SerializationError < StandardError; end
+
+  LLSD_ELEMENT = 'llsd'
+
+  BOOLEAN_ELEMENT = 'boolean'
+  INTEGER_ELEMENT = 'integer'
+  REAL_ELEMENT = 'real'
+  UUID_ELEMENT = 'uuid'
+  STRING_ELEMENT = 'string'
+  BINARY_ELEMENT = 'binary'
+  DATE_ELEMENT = 'date'
+  URI_ELEMENT = 'uri'
+  KEY_ELEMENT = 'key'
+  UNDEF_ELEMENT = 'undef'
+
+  ARRAY_ELEMENT = 'array'
+  MAP_ELEMENT = 'map'
+
+  # PARSING AND ENCODING FUNCTIONS
+
+  def self.to_xml(obj)
+    llsd_element = REXML::Element.new LLSD_ELEMENT
+    llsd_element.add_element(serialize_ruby_obj(obj))
+
+    doc = REXML::Document.new
+    doc << llsd_element
+    doc.to_s
+  end
+
+  def self.parse(xml_string)
+    # turn message into dom element
+    doc = REXML::Document.new xml_string
+
+    # get the first element inside the llsd element
+    # if there is more than one element then return nil
+
+    # return parse dom element on first element
+    parse_dom_element doc.root.elements[1]
+  end
+
+  private
+
+  def self.serialize_ruby_obj(obj)
+    # if its a container (hash or map)
+
+    case obj
+    when Hash
+      map_element = REXML::Element.new(MAP_ELEMENT)
+      obj.each do |key, value|
+        key_element = REXML::Element.new(KEY_ELEMENT)
+        key_element.text = key.to_s
+        value_element = serialize_ruby_obj value
+
+        map_element.add_element key_element
+        map_element.add_element value_element
+      end
+
+      map_element
+
+    when Array
+      array_element = REXML::Element.new(ARRAY_ELEMENT)
+      obj.each { |o| array_element.add_element(serialize_ruby_obj(o)) }
+      array_element
+
+    when Fixnum, Integer
+      integer_element = REXML::Element.new(INTEGER_ELEMENT)
+      integer_element.text = obj.to_s
+      integer_element
+
+    when TrueClass, FalseClass
+      boolean_element = REXML::Element.new(BOOLEAN_ELEMENT)
+
+      if obj
+        boolean_element.text = 'true'
+      else
+        boolean_element.text = 'false'
+      end
+
+      boolean_element
+
+    when Float
+      real_element = REXML::Element.new(REAL_ELEMENT)
+      real_element.text = obj.to_s
+      real_element
+
+    when Date
+      date_element = REXML::Element.new(DATE_ELEMENT)
+      date_element.text = obj.new_offset(of=0).strftime('%Y-%m-%dT%H:%M:%SZ')
+      date_element
+
+    when String
+      if !obj.empty?
+        string_element = REXML::Element.new(STRING_ELEMENT)
+        string_element.text = obj.to_s
+        string_element
+      else
+        STRING_ELEMENT
+      end
+
+    when NilClass
+      UNDEF_ELEMENT
+
+    else
+      raise SerializationError, "#{obj.class.to_s} class cannot be serialized into llsd xml - please serialize into a string first"
+    end
+  end
+
+  def self.parse_dom_element(element)
+    # pseudocode:
+
+    #   if it is a container
+    #     if its an array
+    #       collect parse_dom_element applied to each child into an array
+    #     else (its a map)
+    #       collect parse_dom_element applied to each child into an hash
+    #   else (its an atomic element)
+    #     then extract the value to a native type
+    #
+    #   return the value
+
+    case element.name
+    when ARRAY_ELEMENT
+      element_value = []
+      element.elements.each {|child| element_value << (parse_dom_element child) }
+
+    when MAP_ELEMENT
+      element_value = {}
+      element.elements.each do |child|
+        if child.name == 'key'
+          element_value[child.text] = parse_dom_element child.next_element
+        end
+      end
+
+    else
+      element_value = convert_to_native_type(element.name, element.text, element.attributes)
+    end
+
+    element_value
+  end
+
+  def self.convert_to_native_type(element_type, unconverted_value, attributes)
+    case element_type
+    when INTEGER_ELEMENT
+      unconverted_value.to_i
+
+    when REAL_ELEMENT
+      unconverted_value.to_f
+
+    when BOOLEAN_ELEMENT
+      if unconverted_value == 'false' or unconverted_value.nil? # <boolean />
+        false
+      else
+        true
+      end
+
+    when STRING_ELEMENT
+      if unconverted_value.nil? # <string />
+        ''
+      else
+        unconverted_value
+      end
+
+    when DATE_ELEMENT
+      if unconverted_value.nil?
+        DateTime.strptime('1970-01-01T00:00:00Z')
+      else
+        DateTime.strptime(unconverted_value)
+      end
+
+    when UUID_ELEMENT
+      if unconverted_value.nil?
+        '00000000-0000-0000-0000-000000000000'
+      else
+        unconverted_value
+      end
+
+    else
+      unconverted_value
+    end
+  end
+end

data/lib/llsd/version.rb

@@ -0,0 +1,3 @@
+class LLSD
+  VERSION = '0.1.0'
+end

data/test/llsd_test.rb

@@ -0,0 +1,284 @@
+require 'test_helper'
+
+class LLSDUnitTest < Test::Unit::TestCase
+  def test_map
+    map_xml = <<EOF
+    <llsd>
+      <map>
+        <key>foo</key>
+        <string>bar</string>
+      </map>
+    </llsd>
+EOF
+
+    map_within_map_xml = <<EOF
+    <llsd>
+      <map>
+        <key>doo</key>
+        <map>
+          <key>goo</key>
+          <string>poo</string>
+        </map>
+      </map>
+    </llsd>
+EOF
+
+    blank_map_xml = <<EOF
+    <llsd>
+      <map/>
+    </llsd>
+EOF
+
+    ruby_map = {'foo' => 'bar'}
+    ruby_map_within_map = {'doo' => {'goo' => 'poo'}}
+    ruby_blank_map = {}
+
+    assert_equal ruby_map, LLSD.parse(map_xml)
+    assert_equal ruby_map_within_map, LLSD.parse(map_within_map_xml)
+    assert_equal ruby_blank_map, LLSD.parse(blank_map_xml)
+
+    assert_equal strip(map_xml), LLSD.to_xml(ruby_map)
+    assert_equal strip(map_within_map_xml), LLSD.to_xml(ruby_map_within_map)
+  end
+
+  def test_array
+    array_xml = <<EOF
+    <llsd>
+      <array>
+        <string>foo</string>
+        <string>bar</string>
+      </array>
+    </llsd>
+EOF
+
+    array_within_array_xml = <<EOF
+    <llsd>
+      <array>
+        <string>foo</string>
+        <string>bar</string>
+        <array>
+          <string>foo</string>
+          <string>bar</string>
+        </array>
+      </array>
+    </llsd>
+EOF
+
+    blank_array_xml = <<EOF
+    <llsd>
+      <array/>
+    </llsd>
+EOF
+
+    ruby_array = ['foo', 'bar']
+    ruby_array_within_array = ['foo', 'bar', ['foo', 'bar']]
+    ruby_blank_array = []
+
+    assert_equal ruby_array, LLSD.parse(array_xml)
+    assert_equal ruby_array_within_array, LLSD.parse(array_within_array_xml)
+    assert_equal ruby_blank_array, LLSD.parse(blank_array_xml)
+
+    assert_equal strip(array_xml), LLSD.to_xml(ruby_array)
+    assert_equal strip(array_within_array_xml), LLSD.to_xml(ruby_array_within_array)
+  end
+
+  def test_string
+    normal_xml = <<EOF
+    <llsd>
+      <string>foo</string>
+    </llsd>
+EOF
+
+    blank_xml = <<EOF
+    <llsd>
+      <string/>
+    </llsd>
+EOF
+
+    assert_equal 'foo', LLSD.parse(normal_xml)
+    assert_equal '', LLSD.parse(blank_xml)
+
+    assert_equal strip(normal_xml), LLSD.to_xml('foo')
+    assert_equal strip(blank_xml), LLSD.to_xml('')
+  end
+
+  def test_integer
+    pos_int_xml = <<EOF
+    <llsd>
+      <integer>289343</integer>
+    </llsd>
+EOF
+
+    neg_int_xml = <<EOF
+    <llsd>
+      <integer>-289343</integer>
+    </llsd>
+EOF
+
+    blank_int_xml = <<EOF
+    <llsd>
+      <integer/>
+    </llsd>
+EOF
+
+    ruby_pos_int = 289343
+    ruby_neg_int = -289343
+
+    assert_equal ruby_pos_int, LLSD.parse(pos_int_xml)
+    assert_equal ruby_neg_int, LLSD.parse(neg_int_xml)
+    assert_equal 0, LLSD.parse(blank_int_xml)
+
+    assert_equal strip(pos_int_xml), LLSD.to_xml(ruby_pos_int)
+    assert_equal strip(neg_int_xml), LLSD.to_xml(ruby_neg_int)
+  end
+
+  def test_real
+    pos_real_xml = <<EOF
+    <llsd>
+      <real>2983287453.38483</real>
+    </llsd>
+EOF
+
+    neg_real_xml = <<EOF
+    <llsd>
+      <real>-2983287453.38483</real>
+    </llsd>
+EOF
+
+    blank_real_xml = <<EOF
+    <llsd>
+      <real/>
+    </llsd>
+EOF
+    ruby_pos_real = 2983287453.38483
+    ruby_neg_real = -2983287453.38483
+
+    assert_equal ruby_pos_real, LLSD.parse(pos_real_xml)
+    assert_equal ruby_neg_real, LLSD.parse(neg_real_xml)
+    assert_equal 0, LLSD.parse(blank_real_xml)
+
+    assert_equal strip(pos_real_xml), LLSD.to_xml(ruby_pos_real)
+    assert_equal strip(neg_real_xml), LLSD.to_xml(ruby_neg_real)
+  end
+
+  def test_boolean
+    true_xml = <<EOF
+    <llsd>
+      <boolean>true</boolean>
+    </llsd>
+EOF
+
+    false_xml = <<EOF
+    <llsd>
+      <boolean>false</boolean>
+    </llsd>
+EOF
+
+    blank_xml = <<EOF
+    <llsd>
+      <boolean/>
+    </llsd>
+EOF
+
+    assert_equal true, LLSD.parse(true_xml)
+    assert_equal false, LLSD.parse(false_xml)
+    assert_equal false, LLSD.parse(blank_xml)
+
+    assert_equal strip(true_xml), LLSD.to_xml(true)
+    assert_equal strip(false_xml), LLSD.to_xml(false)
+  end
+
+  def test_date
+    valid_date_xml = <<EOF
+    <llsd>
+      <date>2006-02-01T14:29:53Z</date>
+    </llsd>
+EOF
+
+    blank_date_xml = <<EOF
+    <llsd>
+      <date/>
+    </llsd>
+EOF
+
+    ruby_valid_date = DateTime.strptime('2006-02-01T14:29:53Z')
+    ruby_blank_date = DateTime.strptime('1970-01-01T00:00:00Z')
+
+    assert_equal ruby_valid_date, LLSD.parse(valid_date_xml)
+    assert_equal ruby_blank_date, LLSD.parse(blank_date_xml)
+
+    assert_equal strip(valid_date_xml), LLSD.to_xml(ruby_valid_date)
+  end
+
+  # because the following types dont have "native" types in ruby, they convert to string
+
+  def test_binary
+    base64_binary_xml = <<EOF
+    <llsd>
+      <binary>dGhlIHF1aWNrIGJyb3duIGZveA==</binary>
+    </llsd>
+EOF
+
+    # <binary/> should return blank binary blob... in ruby I guess this is just nil
+
+    assert_equal 'dGhlIHF1aWNrIGJyb3duIGZveA==', LLSD.parse(base64_binary_xml)
+  end
+
+  def test_uuid
+    valid_uuid_xml = <<EOF
+    <llsd>
+      <uuid>d7f4aeca-88f1-42a1-b385-b9db18abb255</uuid>
+    </llsd>
+EOF
+
+    blank_uuid_xml = <<EOF
+    <llsd>
+      <uuid/>
+    </llsd>
+EOF
+
+    assert_equal 'd7f4aeca-88f1-42a1-b385-b9db18abb255', LLSD.parse(valid_uuid_xml)
+    assert_equal '00000000-0000-0000-0000-000000000000', LLSD.parse(blank_uuid_xml)
+  end
+
+  def test_uri
+    valid_uri_xml = <<EOF
+    <llsd>
+      <uri>http://www.example.com:4201/agents</uri>
+    </llsd>
+EOF
+
+    blank_uri_xml = <<EOF
+    <llsd>
+      <uri/>
+    </llsd>
+EOF
+
+    # <uri/> should return an empty link, which in ruby I guess is just nil
+    assert_equal 'http://www.example.com:4201/agents', LLSD.parse(valid_uri_xml)
+    assert_equal nil, LLSD.parse(blank_uri_xml)
+  end
+
+  def test_undefined
+    undef_xml = <<EOF
+    <llsd>
+      <undef/>
+    </llsd>
+EOF
+
+    assert_equal nil, LLSD.parse(undef_xml)
+    assert_equal strip(undef_xml), LLSD.to_xml(nil)
+  end
+
+  def test_llsd_serialization_exception
+    # make an object not supported by llsd
+    ruby_range = Range.new 1, 2
+
+    # assert than an exception is raised
+    assert_raise(LLSD::SerializationError) { LLSD.to_xml(ruby_range) }
+  end
+
+  def strip(str)
+    str.delete "\n "
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'test/unit'
+require 'llsd'

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: llsd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Beck Linden
+- Joshua Linden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-28 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: beck@lindenlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/llsd.rb
+- lib/llsd/version.rb
+- test/llsd_test.rb
+- test/test_helper.rb
+homepage: https://github.com/becklinden/llsd
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An implementation of LLSD (Linden lab Structured Data) in Ruby
+test_files: []