rtm 0.1.1 → 0.1.3

data/lib/rtm/backend/active_record/topic_map.rb

@@ -54,6 +54,8 @@ module RTM::AR
     end
     
     def self.create(base_locator, params={})
+      bl_uri = URI.parse(base_locator)
+      raise "The locator for the Topic Map must be absolute! \"#{base_locator}\" is not an absolute locator." unless bl_uri.absolute?
       tm = self.wrap(TMDM::TopicMap.find_or_create_by_base_locator(base_locator))
       yield tm if block_given?
       tm
@@ -119,6 +121,7 @@ module RTM::AR
     
     # internal helper for by_item_identifier, doesn't wrap result
     def _by_item_identifier(iid)
+      iid = RTM::LocatorHelpers.iid2iri(iid) if RTM::LocatorHelpers.is_a_iid?(iid)
       ii = __getobj__.locators.find_by_reference(resolve(iid)) #, :include => [ :topic_map_construct ])
       return ii.topic_map_construct if ii
       nil
@@ -132,6 +135,7 @@ module RTM::AR
     
     # internal helper for topic_by_item_identifier!, doesn't wrap result
     def _topic_by_item_identifier!(iid)
+      iid = RTM::LocatorHelpers.iid2iri(iid) if RTM::LocatorHelpers.is_a_iid?(iid)
       ii = __getobj__.locators.find_or_create_by_reference(resolve(iid))#, :include => [ :topic_map_construct ])
       return ii.topic_map_construct if ii.topic_map_construct && ii.topic_map_construct_type =~ /::Topic$/
       top2 = _topic_by_subject_identifier(resolve(iid))
@@ -187,6 +191,8 @@ module RTM::AR
       raise "Locator may not be nil" unless iri
       if RTM::LocatorHelpers.is_a_slo?(iri)
         _topic_by_subject_locator(iri)
+      elsif RTM::LocatorHelpers.is_a_iid?(iri)
+        _topic_by_item_identifier(iri)
       elsif URI.parse(iri).absolute?
         _topic_by_subject_identifier(iri)
       else
@@ -198,13 +204,22 @@ module RTM::AR
       raise "Locator may not be nil" unless iri
       if RTM::LocatorHelpers.is_a_slo?(iri)
         _topic_by_subject_locator!(iri)
+      elsif RTM::LocatorHelpers.is_a_iid?(iri)
+        _topic_by_item_identifier!(iri)
       elsif URI.parse(iri).absolute?
         _topic_by_subject_identifier!(iri)
       else
         _topic_by_item_identifier!(iri)
       end
     end
-
+    
+    %w[topic association role name occurrence variant].each do |x|
+      eval <<-EOI
+        def _#{x}_by_id(id)
+          __getobj__.#{x}s.find(id)
+        end
+      EOI
+    end
     public
     # returns an item identifier from the topic_map if it exists
     def item_identifier(iid)
@@ -248,8 +263,11 @@ module RTM::AR
     #
     # Returns nil if the Topic does not exist.
     #
+    # It's also possible to pass a number, which is used to fetch a topic using the internal id. In this case, an exception is thrown, if the topic does not exist.
+    #
     def topic_by_locator(iri)
       return iri if iri.is_a? Topic
+      return topic_by_id(iri) if iri.is_a? Integer
 #      @tblc ||= {}
 #      t = @tblc[iri]
 #      return t if t
@@ -263,9 +281,11 @@ module RTM::AR
     # its (absolute) subject identifier or its (absolute and by "=" prepended) subject locator)
     #
     # If there is no topic with this item identifier, subject identifier or subject locator, it is created.
+    # Please be aware, the creation does not work with the internal (numeric) ids.
     # 
     def topic_by_locator!(iri)
       return iri if iri.is_a? Topic
+      return topic_by_id(iri) if iri.is_a? Integer
 #      @tblc ||= {}
 #      t = @tblc[iri]
 #      return t if t
@@ -275,6 +295,15 @@ module RTM::AR
     end
     alias :get! :topic_by_locator!
     
+    %w[topic association role name occurrence variant].each do |x|
+      eval <<-EOI
+        def #{x}_by_id(id)
+          #{x.camelize}.wrap(_#{x}_by_id(id))
+        end
+        alias :#{x[0].chr}id :#{x}_by_id
+      EOI
+    end
+
     # I am not sure if this is at all correct. TMDM doesn't say a word about it
     # and the approach to compare topic maps is CXTM. I chose this because we 
     # should (at least at the time of writing) have only one topic with a given

data/lib/rtm/backend/active_record/traverse_associations.rb

@@ -0,0 +1,86 @@
+module RTM::AR
+  module TraverseAssociations
+    def define_association(prop, options={})
+      r = options[:rule]
+      module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION__)", 1)
+        def direct_#{prop}_roles
+          # prefetch typing topics
+          rtype = @ips_#{prop}_rtype ||= self.topic_map.get("#{r[:role_type]}")
+          atype = @ips_#{prop}_atype ||= self.topic_map.get("#{r[:association_type]}")
+          otype = @ips_#{prop}_otype ||= self.topic_map.get("#{r[:other_role_type]}")
+          # return nothing if any of the typing topics does not exist
+          return [] unless rtype && atype && otype
+          # we do that only here and not earlier because some might me nil
+          rtype = rtype.id
+          atype = atype.id
+          otype = otype.id
+          self.__getobj__.roles.map{|r|
+            r.ttype_id != nil &&
+              r.ttype_id == rtype &&
+              r.parent.roles.size == #{r[:association_arity]} &&
+              r.parent != nil &&
+              r.parent.ttype_id == atype &&
+              (r2 = r.parent.roles.select{|r2| r2.ttype_id != nil &&
+                r2.ttype_id == otype}.first) &&
+              r2}.select{|r2| r2}.map{|r2| AssociationRole.wrap(r2)}
+        end
+        def direct_#{prop}
+          direct_#{prop}_roles.map{|r2| r2.player}.uniq
+        end
+      EOS
+      
+      if r[:transitive]
+        module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION2__)", 1)
+          def #{prop}
+            d = todo = self.direct_#{prop}
+            while todo.size > 0
+              todo = todo.map{|dt| dt.direct_#{prop}}.flatten.uniq - d
+              d += todo
+            end
+            d
+            #d2 = self.direct_#{prop}.map {|dt| dt.#{prop}}.flatten
+            #(d+d2).uniq
+          end
+        EOS
+      else
+        if r[:infer] && r[:infer_other] # this part is not testet at all!
+          module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION3a__)", 1)
+            def #{prop}
+              dps = (self + self.#{r[:infer]}).flatten.uniq
+              dcps = dps.map{|d2| d2.direct_#{prop}}
+              (dcps + dcps.map{|d2| d2.#{r[:infer_other]}}).flatten.uniq
+            end
+          EOS
+        elsif r[:infer]
+          module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION3__)", 1)
+            def #{prop}
+              (self.direct_#{prop} + self.#{r[:infer]}.map{|d2| d2.direct_#{prop}}).flatten.uniq
+            end
+          EOS
+        elsif r[:infer_other]
+          module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION4__)", 1)
+            def #{prop}
+              d = self.direct_#{prop}
+              (d + d.map{|d2| d2.#{r[:infer_other]}}).flatten.uniq
+            end
+          EOS
+        end
+      end
+      if r[:add]
+        module_eval(<<-EOS, "(__AR_DELEGATOR_DEFINE_ASSOCIATION_ADD_REMOVE__)", 1)
+          def add_#{r[:add]}(t)
+            a = self.topic_map.create_association("#{r[:association_type]}")
+            a.create_role self, "#{r[:role_type]}"
+            a.create_role t, "#{r[:other_role_type]}"
+            a
+            # TODO add_x in define_association needs to trigger reload of the topics somewhere
+          end
+          def remove_#{r[:add]}(t)
+            direct_#{prop}_roles.select{|r| r.player == t}.each{|r| r.parent.remove}
+            # TODO remove_x in define_association needs to trigger reload of the topics somewhere
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/rtm/io/from_xtm2_libxml.rb

@@ -33,7 +33,7 @@ module XML
   # Acts as Callback structure for the LibXML-Ruby SAX Parser and calls
   # a REXML SAX2Listener API.
   class LibXMLSax2wrapper
-    include XML::SaxParser::Callbacks
+    include LibXML::XML::SaxParser::Callbacks
     def initialize(rexml_sax2listener)
       @dest = rexml_sax2listener
       @ns = Hash.new("http://www.topicmaps.org/xtm/")

data/lib/rtm/locator_helpers.rb

@@ -19,5 +19,21 @@ module RTM
     def self.is_a_slo?(iri)
       iri.to_s[0] == "="[0]
     end
+
+    def self.iid2iri(slo)
+      slo = slo.to_s
+      slo = slo[1..-1].lstrip if slo[0] == "^"[0] # remove = if slo starts with it
+      slo
+    end
+    def self.iri2iid(iri)
+      return "^#{iri}" if slo[0] == "="[0]
+      iri
+    end
+
+    # returns true if the String or Locator given starts with "^".
+    # This catches only the prefixing-style, not the local-identifier (non-absolute-iri) style
+    def self.is_a_iid?(iri)
+      iri.to_s[0] == "^"[0]
+    end    
   end
 end

data/lib/rtm/sugar/role/counterparts.rb

@@ -0,0 +1,51 @@
+module RTM::Sugar
+  module Role
+    module Counterparts
+      # This method fetches all roles from the parent association of this role, except itself (i.e. current role).
+      # A filter-hash may be used to filter for the type of the other role (:otype =>topic_reference).
+      # Examples:
+      # this_role.counterparts # returns all
+      # this_role.counterparts(:otype => some_topic) # returns only other roles which have type some_topic
+      # this_role.counterparts(:otype => "some_reference") # as above, looking up the reference first
+      def counterparts(filter={})
+        self.parent.roles.reject{|r| r.id==self.id}.
+                    select{|r| filter[:otype] ? r.type == self.topic_map.get(filter[:otype]) : true}
+      end
+
+      # This methods fetches all players of the parent association of this role, except the player of itself.
+      # It accepts a filter-hash like the counterparts-method.
+      def counterplayers(*args)
+        self.counterparts(*args).map{|r| r.player}
+      end
+
+      # Fetches the other role, if the parent association is binary.
+      def counterpart
+        n = self.parent.roles.size
+        raise "Association must be unary or binary to use counterpart method. Please use counterparts for n-ary associations." if n > 2
+        return nil if n == 1
+        self.counterparts.first
+      end
+      
+      # Fetches the player of the other role, if the parent association is binary.
+      def counterplayer
+        n = self.parent.roles.size
+        raise "Association must be unary or binary to use counterplayer method. Please use counterplayers for n-ary associations." if n > 2
+        return nil if n == 1
+        self.counterparts.first.player
+      end
+      
+      # Fetches all roles of the (binary) parent associations which play the same role in the same with the counterplayer
+      # TODO: filter not only otype but also atype and rtype.
+      def peers
+        cp = self.counterpart
+        cp.player.roles.select{|r| r.type == cp.type}.map{|r| r.counterpart}
+      end
+      # Fetches all players of roles being in the same association with another topic as self
+      # Example: current_role is a role of player "me" and type "employee"
+      # current_role.peerplayers # returns all employees of my company (including me)
+      def peerplayers
+        self.peers.map{|r| r.player}
+      end
+    end
+  end
+end

data/lib/rtm/sugar/topic/characteristics.rb

@@ -0,0 +1,15 @@
+module RTM::Sugar
+  module Topic
+    module Characteristics
+      def characteristics
+        topic_names.to_a + occurrences.to_a
+      end
+      def internal_occurrences
+        occurrences.select{|o| o.datatype != RTM::PSI[:IRI]}
+      end
+      def external_occurrences
+        occurrences.select{|o| o.datatype == RTM::PSI[:IRI]}
+      end      
+    end
+  end
+end

data/lib/rtm/sugar/topic/counterparts.rb

@@ -0,0 +1,15 @@
+module RTM::Sugar
+  module Topic
+    module Counterparts
+      def counterparts(filter={})
+        self.roles.
+             select{|r| filter[:rtype] ? r.type == self.topic_map.get(filter[:rtype]) : true}.
+             select{|r| filter[:atype] ? r.parent.type == self.topic_map.get(filter[:atype]) : true}.
+             inject([]){|all,r| all+=r.counterparts(filter)}                  
+      end
+      def counterplayers(*args)
+        return self.counterparts(*args).map{|r| r.player}
+      end
+    end
+  end
+end

data/lib/rtm/sugar/topic/hash_access.rb

@@ -0,0 +1,55 @@
+module RTM::Sugar
+  module Topic
+    module HashAccess
+      def [](cref)
+        raise "Characteristic reference must be a String" unless cref.is_a? String
+        is_name, type_reference, scope_reference = resolve_characteristic(cref)
+        if is_name
+          type_reference = RTM::PSI[:name_type] if type_reference == :any
+          names.select{|n| n.type == topic_map.get(type_reference)}
+        else
+          raise "No occurrence type given" if type_reference == :any
+          occurrences.select{|o| o.type == topic_map.get(type_reference)}
+        end
+      end
+
+      def []=(cref, value)
+        is_name, type_reference, scope_reference = resolve_characteristic(cref)
+        if is_name
+          nametype = type_reference || topic_map.get!(RTM::PSI[:name_type])
+          n = create_name(value, nametype)
+          n
+        else
+          raise "No occurrence type given" if type_reference == :any
+          o = create_occurrence(value, type_reference)
+          o
+        end
+      end
+      
+      private
+      def resolve_characteristic(ref)
+        ref =~ /^(-\s*)?(.+)?$/
+        is_name = $1 ? true : false
+        type, scope = resolve_type_and_scope($2)
+        [is_name, type, scope]
+      end
+      
+      def resolve_type_and_scope(ref)
+        return [ref, :ucs] if ref.is_a? Topic
+        type, scope = ref.split('@', -1)
+        if type.blank?
+          type = :any
+        else
+          type.strip!
+        end
+        if scope
+          scope = scope.strip.split(/\s+/)
+          scope = :ucs if scope.blank?
+        else
+          scope = :any
+        end
+        [type, scope]
+      end
+    end
+  end
+end

data/lib/rtm/sugar/topic/identifier_direct.rb

@@ -0,0 +1,11 @@
+module RTM::Sugar
+  module Topic
+    module IdentifierDirect
+      def identifiers
+        subject_identifiers.map{|si| si.to_s} +
+          subject_locators.map{|sl| "=#{sl.to_s}"} +
+          item_identifiers.map{|ii| "^#{ii.to_s}"}
+      end
+    end
+  end
+end

data/lib/rtm/sugar/topic/predefined_associations.rb

@@ -0,0 +1,42 @@
+module RTM::Sugar
+  module Topic
+    module PredefinedAssociations
+      extend RTM::AR::TraverseAssociations    
+      # maybe these pairs could be declared each with a single statement and a reversible option
+      define_association :types, :type => :Topic, :rule => {
+        :transitive => false,
+        :role_type => RTM::PSI[:instance],
+        :association_type => RTM::PSI[:type_instance],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:type],
+        :infer_other => :supertypes,
+        :add => :type,
+      }
+      define_association :instances, :type => :Topic, :rule => {
+        :transitive => false,
+        :role_type => RTM::PSI[:type],
+        :association_type => RTM::PSI[:type_instance],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:instance],
+        :infer => :subtypes,
+        :add => :instance,
+      }
+      define_association :supertypes, :type => :Topic, :rule => {
+        :transitive => true,
+        :role_type => RTM::PSI[:subtype],
+        :association_type => RTM::PSI[:supertype_subtype],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:supertype],
+        :add => :supertype,
+      }
+      define_association :subtypes, :type => :Topic, :rule => {
+        :transitive => true,
+        :role_type => RTM::PSI[:supertype],
+        :association_type => RTM::PSI[:supertype_subtype],
+        :association_arity => 2,
+        :other_role_type => RTM::PSI[:subtype],
+        :add => :subtype,
+      }
+    end
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,153 @@
+# 
+# Some basic tests... feel free to add more :)
+#
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rtm'
+
+class BaseTest < Test::Unit::TestCase
+  # There are a bunch of global assertions in here so it cannot be parallelized
+  # with other tests, that's why it is all in one. What can we do about that?
+  def test_connect
+    assert RTM.connect, "Connection to memory backend failed"
+    assert_equal 0, RTM[].size, "There should be no topic maps in a newly created environment."
+    base_locator = "http://rtm.rubyforge.org/tests/base_test"
+    m = RTM.create base_locator
+    assert_equal 1, RTM[].size, "After creation of a topic map, there should be one."
+    assert_kind_of RTM::TopicMap, m, "RTM.create should create something which includes RTM::TopicMap"
+    assert_equal base_locator, m.base_locator, "The base_locator should be initialized properly."
+    assert m.respond_to?(:topics), "The topic map should respond to :topics"
+    assert m.respond_to?(:associations), "The topic map should respond to :topics"
+    assert_equal 0, m.topics.size, "A new topic map should have no topics."
+    assert_equal 0, m.associations.size, "A new topic map should have no associations."
+    assert m.reifier.nil?, "A new topic map should not be reified yet."
+    assert_equal 0, m.item_identifiers.size, "A new topic map should "
+    
+    # assigning a reifier
+    m.reifier = "a_topic_which_reifies_the_topic_map"
+    assert_equal 1, m.topics.size, "A topic should have been created to reify the topic map."
+    assert_kind_of RTM::Topic, m.reifier, "A reifier should be a Topic."
+    
+    assert_equal m, m.topics.first.reified, "The only topic out there should reify the map (not generally, but here)."
+    assert_equal m.base_locator, m.topics.first.reified.base_locator, "The only topic out there should reify the map. Check base locator."
+    assert_equal m.__getobj__, m.topics.first.reified.__getobj__, "The only topic out there should reify the map. Look inside."
+    
+    t = m.create_topic
+    assert_equal 2, m.topics.size, "There should be 2 topics after creating the second one."
+    assert_kind_of RTM::Topic, t, "The created topic should really be one."
+    assert_kind_of RTM::TopicMap, m
+    assert_equal m, t.parent, "The Topic Map should be the parent of our new topic."
+    # The next tests may look a bit unneeded, but they at least also test the properties be available and initialized somehow.
+    assert_equal 0, t.item_identifiers.size, "New topic has no item_identifiers."
+    assert_equal 0, t.subject_identifiers.size, "New topic has no subject_identifiers."
+    assert_equal 0, t.subject_locators.size, "New topic has no subject_locators."
+    assert !t.valid?, "Without item identifiers nor subject identifiers the topic must not be valid."
+    assert_equal 0, t.names.size, "New topic has no names."
+    assert_equal 0, t.occurrences.size, "New topic has no occurrences."
+    assert_equal 0, t.roles_played.size, "New topic plays no roles."
+    assert_nil t.reified, "New topic does not reify a statement."
+    
+    n = t.create_name
+    assert_equal 1, t.names.size, "The topic should have one name now."
+    assert_kind_of RTM::TopicName, n
+    assert_kind_of RTM::Topic, n.parent, "You won't believe but this should be a Topic and right now it not..."
+    # TODO the following assertion does not work - it crashes pp... but why?
+    #assert_equal t, n.parent, "The parent of the name should be the topic on which it was created."
+    assert_equal 0, n.item_identifiers.size, "I wonder if someone will ever read that."
+    assert_kind_of RTM::TopicName, n, "The topic name shoud be a TopicName... makes sence, he?"
+    assert_equal 0, n.variants.size, "According to Lars Heuer and Robert Barta that should always be 0, not only now."
+    assert_nil n.value, "We haven't set a value yet, where should it come from."
+    assert_nil n.type, "I am really tired of writing this stuff."
+    assert_equal 0, n.scope.size, "Should I really be more serious with this stuff?"
+    assert_nil n.reifier, "No, I guess not... who could ever stand that."
+    
+    v = n.create_variant
+    assert_equal 1, n.variants.size, "The topic should have one name now."
+    assert_kind_of RTM::Variant, v
+    assert_kind_of RTM::TopicName, v.parent, "You won't believe but this should be a Topic and right now it not..."
+    # TODO the following assertion does not work - it crashes pp... but why?
+    #assert_equal t, v.parent, "The parent of the name should be the topic on which it was created."
+    assert_equal 0, v.item_identifiers.size, "I wonder if someone will ever read that."
+    assert_kind_of RTM::Variant, v, "The variant should be a Variant... makes sence, he?"
+    assert_nil v.value, "We haven't set a value yet, where should it come from."
+    assert_nil v.datatype, "No datatype set, yet."
+    assert_equal 0, v.scope.size, "Should I really be more serious with this stuff?"
+    assert_nil v.reifier, "No, I guess not... who could ever stand that."
+    assert !v.valid?
+    
+    o = t.create_occurrence
+    assert_equal 1, t.occurrences.size, "The topic should have one name now."
+    assert_kind_of RTM::Occurrence, o
+    assert_kind_of RTM::Topic, o.parent, "You won't believe but this should be a Topic and right now it not..."
+    # TODO the following assertion does not work - it crashes pp... but why?
+    #assert_equal t, o.parent, "The parent of the name should be the topic on which it was created."
+    assert_equal 0, o.item_identifiers.size, "I wonder if someone will ever read that."
+    assert_kind_of RTM::Occurrence, o, "The occurrence shoud be a Occurrence... makes sence, he?"
+    assert_nil o.value, "We haven't set a value yet, where should it come from."
+    assert_nil o.type, "I am really tired of writing this stuff."
+    assert_nil o.datatype
+    assert_equal 0, n.scope.size, "Should I really be more serious with this stuff?"
+    assert_nil n.reifier, "No, I guess not... who could ever stand that."
+    
+    a = m.create_association
+    assert_nil a.type
+    assert_equal 0, a.roles.size
+    assert_kind_of RTM::Association, a
+    assert_kind_of RTM::TopicMap, a.parent
+    assert_equal m, a.parent
+    assert_equal 0, a.scope.size
+    assert !a.valid?
+    
+    r1 = a.create_role
+    assert_nil r1.type
+    assert_nil r1.player
+    assert_kind_of RTM::AssociationRole, r1
+    assert_kind_of RTM::Association, r1.parent
+    assert_equal 1, a.roles.size
+    
+    
+    t.item_identifiers << "nr1"
+    assert_equal 1, t.item_identifiers.size
+    fii = t.item_identifiers.first
+    assert_equal "http://rtm.rubyforge.org/tests/base_test#nr1", fii.to_s
+    assert_kind_of RTM::Locator, fii
+    assert_kind_of RTM::ItemIdentifier, fii #needed?
+    # TODO: invalidate cache/reload value somehow
+    #assert_equal 1, m.item_identifiers.size, "If you see this, it is probably because TopicMap#item_identifiers.size is cached which is wrong in this case."
+    
+    t.subject_identifiers << "si1"
+    fsi = t.subject_identifiers.first
+    assert_equal "si1", fsi.to_s
+    assert_kind_of RTM::Locator, fsi
+    assert_kind_of RTM::SubjectIdentifier, fsi #needed?
+    
+    t.subject_locators << "sl1"
+    fsl = t.subject_locators.first
+    assert_equal "sl1", fsl.to_s
+    assert_kind_of RTM::Locator, fsl
+    assert_kind_of RTM::SubjectLocator, fsl #needed?
+    
+    # create roles with topics
+    # some more stuff.
+    
+    
+    # to be in associations_test later:
+    tm = RTM.create "urn:/associations_test"
+    a1 = tm.create_association "urn:/assoc_type_with_absolute_uri"
+    assert_not_nil a1.type
+    assert_equal a1.type, tm.get("urn:/assoc_type_with_absolute_uri")
+    
+    a2 = tm.create_association :type => "urn:/assoc_type_with_absolute_uri_using_hash"
+    assert_not_nil a2.type
+    assert_equal a2.type, tm.get("urn:/assoc_type_with_absolute_uri_using_hash")
+    
+    a3 = tm.create_association "relative_type"
+    assert_not_nil a3.type
+    assert_equal a3.type, tm.get("relative_type")
+    
+    
+  end
+end