rtm 0.1.6 → 0.2.0

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

@@ -1,62 +0,0 @@
-module RTM::AR
-  class TopicMapConstruct < TMDelegator
-    include RTM::TopicMapConstruct
-
-    def self.abstract_class?
-      self == TopicMapConstruct
-    end
-    property_set :item_identifiers, :aka => [:ii, :iid, :source_locators], :type => :ItemIdentifier, :wrap => true,
-      #:create => :item_identifier, :create_aka => :cii
-      :add => true, :remove => true
-
-    delegate :remove, :to => :destroy
-
-    delegate :id
-    #    property_parent :parent # mmh..
-
-    property :topic_map, :rw => true, :type => :TopicMap, :wrap => true
-
-    #class_delegate :create
-
-    def self.wrap(obj)
-      return nil unless obj
-      raise "Double wrapping" if obj.respond_to?(:__getobj__)
-      case obj.class.name
-      when "RTM::AR::TMDM::Topic"
-        Topic.wrap(obj)
-      when "RTM::AR::TMDM::Variant"
-        Variant.wrap(obj)
-      when "RTM::AR::TMDM::TopicName"
-        TopicName.wrap(obj)
-      when "RTM::AR::TMDM::Occurrence"
-        Occurrence.wrap(obj)
-      when "RTM::AR::TMDM::Association"
-        Association.wrap(obj)
-      when "RTM::AR::TMDM::AssociationRole"
-        AssociationRole.wrap(obj)
-      when "RTM::AR::TMDM::TopicMap"
-        TopicMap.wrap(obj)
-      else
-        raise "Can't wrap object. Class for wrapping #{obj.class} unknown (object: #{obj})"
-      end
-    end
-    
-    def self.find(*args)
-      res = RTM::AR::TMDM.const_get(name.split("::").last).find(*args)
-      if res.respond_to? :each
-        TopicMapConstructs.wrap(res)
-      else
-        TopicMapConstruct.wrap(res)
-      end
-    end
-  end
-
-  class Reifiable < TopicMapConstruct
-    include RTM::Reifiable
-
-    def self.abstract_class?
-      self == Reifiable
-    end
-    property :reifier, :type => :Topic, :rw => :true, :wrap => true
-  end
-end

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

@@ -1,345 +0,0 @@
-module RTM::AR
-  class TMDelegator
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def __getobj__
-      @obj
-    end
-
-    def __setobj__(obj)
-      @obj = obj
-    end
-    
-    def self.delegate(sym, options={})
-      to = options[:to] || sym
-      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
-        def #{sym}(*args, &block)
-          __getobj__.send(:#{to}, *args, &block)
-        end
-      EOS
-
-      if options[:rw]
-        module_eval(<<-EOS, "(__TMDELEGATOR2__)", 1)
-          def #{sym}=(*args, &block)
-            __getobj__.send(:#{to}=, *args, &block)
-            #{options[:save] ? "__getobj__.save" : "" }
-          end
-        EOS
-      end
-
-      if options[:aka]
-        options[:aka] = [options[:aka]] unless options[:aka].respond_to? :each
-        options[:aka].each do |aka|
-          module_eval(<<-EOS, "(__TMDELEGATOR3__)", 1)
-            alias :#{aka} :#{sym}
-          EOS
-
-          if options[:rw]
-            module_eval(<<-EOS, "(__TMDELEGATOR3__)", 1)
-              alias :#{aka}= :#{sym}=
-            EOS
-          end
-        end
-      end
-    end
-
-    def self.class_delegate(sym, options={})
-      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
-        class << self
-          def #{sym}(*args, &block)
-            __getobj__.send(:#{sym}, *args, &block)
-          end
-        end
-      EOS
-
-      if options[:aka]
-        options[:aka] = [options[:aka]] unless options[:aka].respond_to? :each
-        options[:aka].each do |aka|
-          module_eval(<<-EOS, "(__TMDELEGATOR2__)", 1)
-            class << self
-              alias :#{aka} :#{sym}
-            end
-          EOS
-        end
-      end
-    end
-
-    def self.parent(sym, options={})
-      module_eval(<<-EOS, "(__TMDELEGATOR__)", 1)
-        def #{sym}
-          TopicMapConstruct.wrap(__getobj__.send(:#{sym}))
-        end
-      EOS
-      aka_property(sym, [:parent, :p])
-    end
-
-    def self.property_set(prop, options={})
-#      puts "In #{self.name.to_s.ljust(20)} we have type #{options[:type].to_s.ljust(20)} for property #{prop}"
-      if options[:wrap]
-        #puts "#{self}: #{options[:type]}"
-        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_W__)", 1)          
-          def #{prop}(*args)
-           if args.size == 0
-             # fetch normal
-             #{options[:type]}s.wrap(__getobj__.#{prop}, self, :#{options[:type]})
-           else
-             # fetch with filter
-             #puts args.inspect
-             # TODO enhance/fix condition transform code
-             a = {}.merge(args.first)
-             if a[:type] && !a[:ttype]
-               a[:ttype] = a[:type]
-               a.delete(:type)
-             end
-             a.each do |k,v|
-               if v.respond_to?(:__getobj__)
-                 a[(k.to_s + "_id").to_sym] = v.id
-               end
-             end
-             #{options[:type]}s.wrap(__getobj__.#{prop}.find(:all, :conditions=> a), self, :#{options[:type]})
-           end
-          end
-EOS
-      else
-        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_NW__)", 1)          
-          def #{prop}
-           __getobj__.#{prop}
-          end
-        EOS
-      end
-
-      if options[:create]
-        # some :create_args:
-        # 
-        # create_locator reference:string
-        # [ :name => :reference, :type => :String]
-        #
-        # create_topic_name value:String, scope:Collection
-        # create_topic_name value:String, type: Topic, scope:Collection
-        # [ {:name => :value, :type => :String}, {:name => :type, :type => :Topic, :optional => true}, {:name => :scope, :type => :Collection} ]
-        #
-        # create_occurrence value:String, type: Topic, scope:Collection
-        # create_occurrence resource: Locator, type: Topic, scope:Collection
-        # [ {:name => :value, :type => [:String, :Locator]}, {:name => :type, :type => :Topic}, {:name => :scope, :type => :Collection} ]
-        #
-        # create_association_role player:topic, type: topic
-        # [ {:name => :player, :type => :Topic}, {:name => :type, :type => :Topic}]
-        #
-        # create_variant value:string, :scope:Collection
-        # create_variant resource:locator, :scope:Collection
-        # [ {:name => :value, :type => [:String, :Locator]}, {:name => :scope, :type => :Collection}]
-
-        module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY_SET_CREATE__)", 1)
-          def create_#{ options[:create]}(*args, &block)
-            arg_defs = #{ (options[:create_args] || nil ).inspect}
-
-            a = parse_args(args, arg_defs)
-
-            a = enhance_args_hash(a, arg_defs) if arg_defs
-
-            a = a.reject{|k,v| v.nil?}
-
-            # hack to change :type to :ttype for AR backend
-            # puts a.inspect unless a.is_a? Hash
-            if a[:type] && !a[:ttype]
-              a[:ttype] = a[:type]
-              a.delete(:type)
-            end
-            if [:Locator,:ItemIdentifier, :SubjectIdentifier, :SubjectLocator].include?(:#{options[:type]})
-              unless a[:topic_map]
-                a[:topic_map] = topic_map.__getobj__
-              end
-            end
-
-            if block_given?
-              obj = #{options[:type]}.wrap( __getobj__.#{options[:create]}s.new(a) )
-              yield obj
-              obj.save
-            else
-              obj = #{options[:type]}.wrap( __getobj__.#{options[:create]}s.create(a) )
-            end
-            obj
-          end
-        EOS
-
-        if options[:create_aka]
-          aka_property("create_#{options[:create]}", options[:create_aka])
-        end
-      end
-      
-      if options[:add]
-        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_ADD__)", 1)
-          def add_#{prop.to_s.singularize}(*args, &block)
-            #{prop}.add(*args, &block)
-          end
-RUBY
-        aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "add_#{a}"})
-        aka_property("add_#{prop.to_s.singularize}", options[:aka].map{|a| "a#{a}"})
-      end
-
-      if options[:remove]
-        module_eval(<<-RUBY, "(__AR_DELEGATOR_PROPERTY_SET_REMOVE__)", 1)
-          def remove_#{prop.to_s.singularize}(*args, &block)
-            #{prop}.remove(*args, &block)
-          end
-RUBY
-        aka_property("remove_#{prop.to_s.singularize}", options[:aka].map{|a| "remove_#{a}"})
-        aka_property("remove_#{prop.to_s.singularize}", options[:aka].map{|a| "r#{a}"})
-      end
-
-      # TODO: aliases for property_set.add as add_property
-
-      aka_property(prop, options[:aka]) if options[:aka]
-    end
-
-    private
-    def parse_args(args, arg_defs)
-      a = {}
-      a = args.pop if args.last.is_a? Hash
-      # We are finished if there are no more parameters or we have no arg_def.
-      # Special case: non optional parameters must have been in the Hash, just a hash is also allowed.
-      return a if args.size == 0 || arg_defs == nil
-
-      # we have some args
-      if args.size == arg_defs.size # all are given
-        return args2hash(a, args,arg_defs)
-      elsif args.size == arg_defs.reject { |d| d[:optional]}
-        return args2hash(a, args, arg_defs.reject {|d| d[:optional]})
-      end
-      #warn("Functions with more than one optional parameter are not supported. This will only work if the left out ones are the last.")
-      return args2hash(a, args,arg_defs)
-    end
-
-    def args2hash(a, args, arg_defs)
-      arg_defs.zip(args) do |argd,arg|
-        a[argd[:name]] = arg
-      end
-
-      return a
-    end
-
-    def enhance_args_hash(a, arg_defs)
-      #puts "enhance_args: #{a.inspect} ---\n#{arg_defs.inspect}"
-      return a if a.empty?
-      arg_defs.each do |argd|
-        #puts "enhancing #{argd[:name]}, which is a #{a[argd[:name]].class}"
-        if argd[:type] == :Topic 
-         if a[argd[:name]].is_a? String
-            a[argd[:name]] = topic_map._topic_by_locator!(a[argd[:name]])
-         elsif a[argd[:name]].is_a?(RTM::Topic)
-            a[argd[:name]] = a[argd[:name]].__getobj__
-         end
-        end
-        if argd[:type] == :Locator || (argd[:type].respond_to?(:include?) && argd[:type].include?(:Locator))
-          a[argd[:name]] = a[argd[:name]].to_s
-        end
-      end
-      a
-    end
-
-    public
-    def self.property(prop, options={})
-      module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY__)", 1)
-        def #{prop}
-          #{options[:wrap]? "#{options[:type]}.wrap":""}( __getobj__.#{prop})
-        end
-      EOS
-
-      if options[:rw]
-        case options[:type]
-        when :Topic
-          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
-            def #{prop}=(obj)
-              obj = topic_map.topic_by_locator!(obj) unless obj.is_a? #{options[:type]}
-              __getobj__.#{prop} = obj.__getobj__
-              __getobj__.save
-            end
-          EOS
-        when :TopicMap
-          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
-            def #{prop}=(obj)
-              obj = RTM.create obj.to_s unless obj.is_a? #{options[:type]}
-              __getobj__.#{prop} = obj.__getobj__
-              __getobj__.save
-            end
-          EOS
-        when :String, :Locator
-          module_eval(<<-EOS, "(__AR_DELEGATOR_PROPERTY2__)", 1)
-            def #{prop}=(obj)
-              __getobj__.#{prop} = obj.to_s
-              __getobj__.save
-            end
-          EOS
-        else
-          raise "Don't know how to do wrapping for #{options[:type]}"
-        end
-        
-      end
-
-      aka_property(prop, options[:aka]) if options[:aka]
-    end
-
-    def self.aka_property(prop, aka)
-      aka = [aka].flatten
-      aka.each do |a|
-        #puts "generating alias #{a} for #{prop}"
-        module_eval(<<-EOS, "(__AR_DELEGATOR_AKA_PROPERTY__)", 1)
-          alias :#{a} :#{prop}
-        EOS
-      end
-    end
-
-    def self.equality(eqfields, options={})
-      field_condition = eqfields.map {|f| "self.#{f} == o.#{f}" }.join(" && ")
-      module_eval(<<-EOS, "(__AR_EQUALITY__)", 1)
-        def ==(o)
-          return false unless o
-          return true if #{field_condition}
-          false
-        end
-      EOS
-    end
-    def eql?(o)
-      return false unless o
-      return true if self.class == o.class && self.id == o.id
-      false
-    end
-    def hash
-      return self.id.hash
-    end
-    
-    def self.wrapper_cache
-      module_eval(<<-EOS, "(__AR_WRAPPER_CACHE__)", 1)
-        def self.wrap(obj)
-          return nil unless obj
-          raise "Double wrapping" if obj.respond_to?(:__getobj__)
-          t = self.wrapped(obj)
-          if t
-            t.__setobj__(obj)
-            return t
-          end
-          self.new(obj)
-        end
-
-        def self.wrapped(unwrapped_obj)
-          @@wrapped ||= {}
-          return @@wrapped[unwrapped_obj.id] if unwrapped_obj.respond_to? :id
-          @@wrapped[unwrapped_obj]
-        end
-        def self.reset_wrapped
-          @@wrapped = {}
-        end
-        def initialize(*args)
-          super
-          @@wrapped ||= {}
-          @@wrapped[self.id]=self
-        end
-      EOS
-    end
-
-    alias :i :id
-    delegate :reload
-  end
-end

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

@@ -1,195 +0,0 @@
-module RTM::AR
-  class TMSetDelegator < TMDelegator
-    include Enumerable
-    #    attr_reader :content_class_name
-    def initialize(obj,parent,type)
-      @obj = obj
-      @parent = parent
-      @type = type
-    end
-
-    # This class method wraps a Set completely while the instance method wraps one single contained object
-    def self.wrap(obj, parent=nil, type=nil)
-      return nil unless obj
-      raise "Double wrapping" if obj.respond_to?(:__getobj__)
-      self.new(obj, parent, type)
-    end
-
-    def add(obj)
-      return unless obj
-
-      old = @obj.detect { |x| x == obj } # can't that be done easier?
-      if old
-        old.merge obj
-      else
-        if obj.respond_to? :__getobj__
-          @obj << obj.__getobj__
-        else
-          case @type
-          when :Topic
-            @obj << @parent.topic_map.get!(obj).__getobj__
-            @parent.__getobj__.reload
-
-          when :ItemIdentifier
-            if @parent.class.name.to_s =~ /::Topic$/
-              tbi = @parent.topic_map._item_identifier(obj)
-              if tbi && tmc=tbi.topic_map_construct
-                if tmc.class.name =~ /::Topic$/
-                  return @parent if tmc == @parent.__getobj__
-                  result = Topic.wrap(tmc).merge @parent
-                  return result
-                else
-                  raise "Duplicate Item Identifier"
-                end
-              end
-              tbsi = @parent.topic_map._subject_identifier(obj.to_s)
-              if tbsi
-                if t=tbsi.topic
-                  return @parent if t == @parent.__getobj__
-                  result = Topic.wrap(t).merge @parent
-                  # after merging, we still need to add the II
-                  result.__getobj__.item_identifiers.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-                  return result
-                end
-              end
-            end
-            result = @obj << @parent.topic_map._item_identifier!(obj.to_s)
-            return result
-
-          when :SubjectIdentifier
-            # check for existing item identifier
-            tbi = @parent.topic_map._item_identifier(obj)
-            if tbi && tmc=tbi.topic_map_construct
-              if tmc.class.name =~ /::Topic$/
-                return @parent if tmc == @parent.__getobj__
-                result = Topic.wrap(tmc).merge @parent
-                # after merging, we still need to add the SI
-                result.__getobj__.subject_identifiers.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-                return result
-              else
-                warn("This subject identifier IRI already belongs to another topic map construct (not a topic)")
-              end
-            end
-            # check for existing subject identifier
-            tbsi = @parent.topic_map._subject_identifier(obj.to_s)
-            if tbsi
-              if true && t=tbsi.topic #the single = is intentional, the "true &&" just makes netbeans not raise a warning
-                return @parent if t == @parent.__getobj__
-                result = Topic.wrap(t).merge @parent
-                return result
-              end
-            end
-            @obj.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-
-          when :SubjectLocator
-            tbsl = @parent.topic_map._subject_locator(obj.to_s)
-            if tbsl
-              if true && t=tbsl.topic #the single = is intentional, the "true &&" just makes netbeans not raise a warning
-                return @parent if t == @parent.__getobj__
-                result = Topic.wrap(t).merge @parent
-                return result
-              end
-            end
-            @obj.create(:reference => obj.to_s, :topic_map_id => @parent.topic_map.__getobj__.id)
-
-          end
-        end
-      end
-    end
-    alias :<< :add
-    
-    def add_all(objs)
-      return unless objs
-      objs.each {|obj| add(obj)}
-      true
-    end
-
-    def each(&b)
-      @obj.each { |e| yield wrap(e)}
-    end
-
-    def size
-      @obj.size
-    end
-    alias :length :size
-    
-    def empty?
-      @obj.empty?
-    end
-
-    def delete(obj)
-      obj = obj.__getobj__ if obj.respond_to? :__getobj__
-      case @type
-      when :ItemIdentifier, :SubjectIdentifier, :SubjectLocator
-        obj = @obj.find_by_reference(@parent.topic_map.resolve(obj.to_s)) if obj.is_a? String
-      end
-      @obj.delete(obj)
-      # item_identifiers: remove also from topicMap
-      #removed_event obj if respond_to? :removed_event
-    end
-    alias :remove :delete
-
-    def include?(obj)
-      return @obj.include?(obj)
-      #@obj.each { |e| return true if e == obj } # T#ODO support for get
-      #false
-    end
-
-    def first
-      wrap(@obj.entries.first)
-    end
-    def last
-      wrap(@obj.entries.last)
-    end
-
-    def to_s
-      "[#{@obj.entries.map { |e| wrap(e).to_s }.join(", ") }]"
-    end
-    def [](i)
-      wrap(@obj[i])
-    end
-
-    def content_class
-      #      @content_class ||= RTM.const_get(@content_class_name)
-      @content_class ||= RTM.const_get("#{@content_class_name}MemImpl")
-    end
-    
-    def find(*args)
-      res = @obj.find(*args)
-      if res.respond_to? :each
-        TopicMapConstructs.wrap(res)
-      else
-        TopicMapConstruct.wrap(res)
-      end
-    end
-    
-    def &(other)
-      @obj.to_a & other.to_a
-    end
-    
-    alias :old_method_missing :method_missing
-    def method_missing(method_name, *args)
-      if @obj.size > 0 && first.respond_to?(method_name) && (![:__getobj__, :__setobj__].include?(method_name))
-        a = []
-        inject(a) {|all,single| all << single.send(method_name, *args)}
-        a
-      else
-        old_method_missing(method_name, *args)
-      end
-    end
-    
-    alias :old_respond_to? :respond_to?
-    def respond_to?(method_name)
-      resp = old_respond_to?(method_name)
-      return resp if resp # i.e. if true
-      return false if [:__getobj__, :__setobj__].include?(method_name)
-      # ... and ask first child otherwise
-      @obj.size > 0 && first.respond_to?(method_name)
-    end
-
-    # TMSetDelegator#to_a doesn't help as thought, but maybe we come back to that l8r...
-    #def to_a
-    #  @obj.map {|o| wrap(o)}
-    #end
-  end
-end