slidefield 0.1

data/test/test_object_data.rb

@@ -0,0 +1,108 @@
+require File.expand_path '../helper', __FILE__
+
+class TestObjectData < MiniTest::Test
+  def test_initialize
+    o = SlideField::ObjectData.new :test, 'location'
+    assert_equal :test, o.type
+    assert_equal 'location', o.loc
+  end
+
+  def test_variables
+    o = SlideField::ObjectData.new :test, 'loc'
+    refute o.has? :test
+    assert_nil o.get(:test)
+    assert_nil o.var_type(:test)
+    assert_nil o.var_loc(:test)
+
+    o.set :test, 'hello world', 'line 42 char 24', :string
+    assert o.has? :test
+    assert_equal 'hello world', o.get(:test)
+    assert_equal :string, o.var_type(:test)
+    assert_equal 'line 42 char 24', o.var_loc(:test)
+
+    o.set :test, 'hello tester'
+    assert_equal 'hello tester', o.get(:test)
+    assert_equal :string, o.var_type(:test)
+    assert_equal 'line 42 char 24', o.var_loc(:test)
+  end
+
+  def test_children
+    parent = SlideField::ObjectData.new :parent, 'loc'
+    assert_equal [], parent.children
+
+    child1 = SlideField::ObjectData.new :child, 'loc'
+    child2 = SlideField::ObjectData.new :child, 'loc'
+    child3 = SlideField::ObjectData.new :uniqueOfHisKind, 'loc'
+
+    parent << child1
+    parent << child2
+    parent << child3
+
+    assert_equal [child1, child2, child3], parent.children
+    assert_equal [child1, child2], parent[:child]
+    assert_equal [child3], parent[:uniqueOfHisKind]
+
+    assert_equal parent, child1.parent
+    assert_equal parent, child2.parent
+    assert_equal parent, child3.parent
+  end
+
+  def test_inheritance
+    parent = SlideField::ObjectData.new :parent, 'loc'
+    parent.set 'variable', 'value', 'loc', :type
+
+    child = SlideField::ObjectData.new :child, 'loc'
+    parent << child
+
+    assert parent.has?('variable')
+    refute child.has?('variable')
+    assert_equal 'value', child.get('variable')
+    assert_equal :type, child.var_type('variable')
+    assert_equal 'loc', child.var_loc('variable')
+  end
+
+  def test_context_string
+    o1 = SlideField::ObjectData.new :test, 'loc'
+    o1.context = 'context1'
+
+    o2 = SlideField::ObjectData.new :test, 'loc'
+    o2.context = 'context2'
+    o1 << o2
+
+    o3 = SlideField::ObjectData.new :test, 'loc'
+    o3.context = 'context2'
+    o2 << o3
+
+    o4 = SlideField::ObjectData.new :test, 'loc'
+    o4.context = 'context1'
+    o3 << o4
+
+    assert_equal "[context1]", o1.context_string
+    assert_equal "[context1] [context2]", o2.context_string
+    assert_equal "[context1] [context2]", o3.context_string
+    assert_equal "[context1] [context2] [context1]", o4.context_string
+  end
+
+  def test_rules
+    o = SlideField::ObjectData.new :slide, 'loc'
+    assert_instance_of SlideField::ObjectRules::Slide, o.rules
+  end
+
+  def test_ancestor
+    parent = SlideField::ObjectData.new :parent, 'loc'
+    assert_equal [], parent.children
+
+    child1 = SlideField::ObjectData.new :child1, 'loc'
+    child2 = SlideField::ObjectData.new :child2, 'loc'
+    child3 = SlideField::ObjectData.new :child3, 'loc'
+
+    parent << child1
+    child1 << child2
+    child2 << child3
+
+    assert_equal parent, child1.ancestor(:parent)
+    assert_equal parent, child2.ancestor(:parent)
+    assert_equal child1, child3.ancestor(:child1)
+    assert_nil parent.ancestor(:parent)
+  end
+end

data/test/test_object_manager.rb

@@ -0,0 +1,48 @@
+require File.expand_path '../helper', __FILE__
+
+module SlideField::ObjectManager
+  class CatchTest < Base
+    def load(what)
+      raise what
+    end
+  end
+end
+
+class TestObjectManager < MiniTest::Test
+  def test_new
+    window = nil
+
+    obj1 = SlideField::ObjectData.new :slide, 'loc'
+    obj2 = SlideField::ObjectData.new :text, 'loc'
+    obj3 = SlideField::ObjectData.new :unknown, 'loc'
+
+    klass1 = SlideField::ObjectManager::Slide
+    klass2 = SlideField::ObjectManager::Text
+
+    assert_instance_of klass1, man1 = SlideField::ObjectManager.new(obj1, window)
+    assert_instance_of klass2, SlideField::ObjectManager.new(obj2, window)
+    assert_nil SlideField::ObjectManager.new(obj3, window)
+  end
+
+  def test_slide_non_graphic_children
+    obj1 = SlideField::ObjectData.new :slide, 'loc'
+    obj2 = SlideField::ObjectData.new :unknown, 'loc'
+
+    obj1 << obj2
+
+    manager = SlideField::ObjectManager.new obj1, nil
+    manager.load
+  end
+
+  def test_catch
+    obj = SlideField::ObjectData.new :catchTest, 'loc'
+    obj.context = 'context'
+
+    manager = SlideField::ObjectManager.new obj, nil
+    error = assert_raises SlideField::RuntimeError do
+      manager.execute :load, 'error message'
+    end
+
+    assert_equal "[context] An error occured while executing the 'load' event on the object 'catchTest' at loc:\n\t(RuntimeError) error message", error.message
+  end
+end

data/test/test_object_rules.rb

@@ -0,0 +1,87 @@
+require File.expand_path '../helper', __FILE__
+
+module SlideField::ObjectRules
+  class RulesTest < Base
+    def rules
+      property :var1, :string, "default"
+      property :var2, :integer, nil
+      property :var3, :string, "value"
+
+      child :obj1
+      child :obj2, 1
+      child :obj3, 1, 2
+      super
+    end
+  end
+end
+
+class TestObjectRules < MiniTest::Test
+  def test_accessor
+    klass = SlideField::ObjectRules::RulesTest
+    assert_instance_of klass, SlideField::ObjectRules[:rulesTest]
+  end
+
+  def test_unknown
+    assert_nil SlideField::ObjectRules[:thisDoesNotExist]
+  end
+
+  def test_cache
+    klass = SlideField::ObjectRules::RulesTest
+    first = klass.get
+    second = klass.get
+
+    assert_same first, second
+  end
+
+  def test_properties_names
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:var1, :var2, :var3], rules.properties_names
+  end
+
+  def test_properties_types
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:string, :integer], rules.properties_types
+  end
+
+
+  def test_required_properties
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:var2], rules.required_properties
+  end
+
+  def test_optional_properties
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:var1, :var3], rules.optional_properties
+  end
+
+
+  def test_type_of_property
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal :string, rules.type_of_property(:var1)
+    assert_equal nil, rules.type_of_property(:unknown)
+  end
+
+  def test_matching_properties
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:var1, :var3], rules.matching_properties(:string)
+  end
+
+  def test_default_value
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal "default", rules.default_value(:var1)
+    assert_equal nil, rules.default_value(:unknown)
+  end
+
+  def test_accepted_children
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [:obj1, :obj2, :obj3, :include, :debug], rules.accepted_children
+  end
+
+  def test_requirements_of_child
+    rules = SlideField::ObjectRules::RulesTest.get
+    assert_equal [0, 0], rules.requirements_of_child(:obj1)
+    assert_equal [1, 0], rules.requirements_of_child(:obj2)
+    assert_equal [1, 2], rules.requirements_of_child(:obj3)
+    assert_equal nil, rules.requirements_of_child(:obj4)
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,408 @@
+require File.expand_path '../helper', __FILE__
+
+class TestParser < MiniTest::Test
+  def expect(input, tokens)
+    assert_equal tokens, parse(input)
+  end
+
+  def parse(input)
+    clean_tokens SlideField::Parser.new.parse(input)
+  end
+
+  def clean_tokens(tokens)
+    case tokens
+    when Array
+      tokens.collect {|e|
+        clean_tokens e
+      }
+    when Hash
+      tokens.merge(tokens) {|k,e|
+        clean_tokens e
+      }
+    when Parslet::Slice
+      tokens.to_s
+    end
+  end
+
+  def test_var_identifier
+    tokens = [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }
+    ]
+
+    expect 'var=val', tokens
+    expect 'var = val', tokens
+    expect 'var = val  ', tokens
+    expect "var\t=\tval", tokens
+    expect "var\t=\tval % comment", tokens
+    expect "var\t%{%}=%{%}val", tokens
+    expect "  var=val", tokens
+    expect "\t\tvar=val", tokens
+    expect "var=val;", tokens
+    expect "var=val;%comment", tokens
+
+    expect 'var+=val', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'+=',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }
+    ]
+    expect 'var-=val', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'-=',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }
+    ]
+    expect 'var*=val', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'*=',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }
+    ]
+    expect 'var/=val', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'/=',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }
+    ]
+  end
+
+  def test_var_integer
+    expect 'var=42', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :integer=>'42'}
+      }
+    ]
+
+    expect 'var=-42', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :integer=>'-42'}
+      }
+    ]
+  end
+
+  def test_var_string
+    expect 'var="value"', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :string=>'"value"'}
+      }
+    ]
+
+    expect 'var="say \"hello\""', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :string=>'"say \\"hello\\""'}
+      }
+    ]
+  end
+
+  def test_var_point
+    expect 'var=42x24', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :point=>'42x24'}
+      }
+    ]
+
+    expect 'var=-42x24', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :point=>'-42x24'}
+      }
+    ]
+
+    expect 'var=42x-24', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :point=>'42x-24'}
+      }
+    ]
+  end
+
+  def test_var_color
+    expect 'var=#C0FF33FF', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :color=>'#C0FF33FF'}
+      }
+    ]
+
+    expect 'var=#c0ff33ff', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :color=>'#c0ff33ff'}
+      }
+    ]
+  end
+
+  def test_var_boolean
+    expect 'var=:true', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :boolean=>':true'}
+      }
+    ]
+
+    expect 'var=:false', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :boolean=>':false'}
+      }
+    ]
+  end
+
+  def test_var_object
+    expect 'var=\\test', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :object=>{:type=>'test'}}
+      }
+    ]
+
+    expect 'var=\\test {}', [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{:filters=>[], :object=>{:type=>'test', :body=>[]}}
+      }
+    ]
+
+    expect "var=\\test {\n\tvar=val\n}", [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{
+          :filters=>[],
+          :object=>{:type=>'test', :body=>[
+            {:assignment=>{
+              :variable=>'var',
+              :operator=>'=',
+              :value=>{:filters=>[], :identifier=>'val'}}
+            }
+          ]}
+        }
+      }
+    ]
+  end
+
+  def test_filter
+    tokens = [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{
+          :filters=>[{:name=>'filter_name'}],
+          :identifier=>'val'
+        }
+      }
+    ]
+
+    expect 'var=(filter_name)val', tokens
+    expect 'var=(filter_name)  val', tokens
+    expect 'var= (filter_name)  val', tokens
+    expect "var= (filter_name)\t\tval", tokens
+    expect "var= (filter_name)%{%}val", tokens
+    expect "var= ( filter_name )val", tokens
+
+    tokens = [
+      :assignment=>{
+        :variable=>'var',
+        :operator=>'=',
+        :value=>{
+          :filters=>[{:name=>'first'}, {:name=>'second'}],
+          :identifier=>'val'
+        }
+      }
+    ]
+
+    expect "var=(first)(second)val", tokens
+    expect "var=(first) (second)val", tokens
+  end
+
+  def test_object
+    expect '\\test', [
+      {:object=>{:type=>'test'}}
+    ]
+
+    expect '\\test % comment', [
+      {:object=>{:type=>'test'}}
+    ]
+
+    expect '\\TEST', [
+      {:object=>{:type=>'TEST'}}
+    ]
+
+    expect '\\te_st', [
+      {:object=>{:type=>'te_st'}}
+    ]
+
+    expect '\\t3s7', [
+      {:object=>{:type=>'t3s7'}}
+    ]
+
+    tokens = [
+      {:object=>{:type=>'test', :body=>[]}}
+    ]
+
+    expect '\\test{}', tokens
+    expect '\\test { } ', tokens
+    expect "\\test\t{\t}\t", tokens
+    expect "\\test\n{\n}", tokens
+    expect '\\test%{%}{%{%}}', tokens
+  end
+
+  def test_object_value
+    tokens = [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :identifier=>'val'}
+      }}
+    ]
+
+    expect '\\test val', tokens
+    expect "\\test\tval", tokens
+    expect "\\test%{%}val", tokens
+    assert_raises Parslet::ParseFailed do
+      parse "\\test\nval"
+    end
+
+    expect '\\test 42', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :integer=>'42'}
+      }}
+    ]
+
+    expect '\\test4-2', [
+      {:object=>{
+        :type=>'test4',
+        :value=>{:filters=>[], :integer=>'-2'}
+      }}
+    ]
+
+    expect '\\test "string"', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :string=>'"string"'}
+      }}
+    ]
+
+    expect '\\test 24x42', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :point=>'24x42'}
+      }}
+    ]
+
+    expect '\\test #FFFFFFFF', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :color=>'#FFFFFFFF'}
+      }}
+    ]
+
+    expect '\\test :true', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[], :boolean=>':true'}
+      }}
+    ]
+
+    expect '\\test (filter)val', [
+      {:object=>{
+        :type=>'test',
+        :value=>{:filters=>[{:name=>'filter'}], :identifier=>'val'}
+      }}
+    ]
+  end
+
+  def test_object_body
+    expect '\\test{\\child;}', [
+      {:object=>{:type=>'test', :body=>[
+        {:object=>{:type=>'child'}}
+      ]}}
+    ]
+
+    assert_raises Parslet::ParseFailed do
+      parse '\\test{\\child}'
+    end
+
+    expect "\\test{\n\t\\child\n}", [
+      {:object=>{:type=>'test', :body=>[
+        {:object=>{:type=>'child'}}
+      ]}}
+    ]
+
+    expect "\\test{\n\t\\child { \\subchild; }\n}", [
+      {:object=>{:type=>'test', :body=>[
+        {:object=>{:type=>'child', :body=>[
+          {:object=>{:type=>'subchild'}}
+        ]}}
+      ]}}
+    ]
+
+    expect "\\test{var=val;}", [
+      {:object=>{:type=>'test', :body=>[
+        {:assignment=>{
+          :variable=>'var',
+          :operator=>'=',
+          :value=>{:filters=>[], :identifier=>'val'}}
+        }
+      ]}}
+    ]
+
+    assert_raises Parslet::ParseFailed do
+      parse '\\test{var=val}'
+    end
+  end
+
+  def test_template
+    expect '\\&test', [
+      {:object=>{:template=>'&', :type=>'test'}}
+    ]
+  end
+
+  def test_comments
+    assert_raises Parslet::ParseFailed do
+      parse "%{"
+    end
+
+    parse "% {"
+  end
+
+  def test_separator
+    assert_raises Parslet::ParseFailed do
+      parse "life = 42 life = 42"
+    end
+
+    expect "\\test; \\test", [
+      {:object=>{:type=>'test'}},
+      {:object=>{:type=>'test'}}
+    ]
+
+    parse "\\test; life = 42"
+    parse "life = 42; \\test"
+  end
+end