rdf-mapper 0.0.1

data/lib/lib/adapters/sparql.rb

@@ -0,0 +1,105 @@
+module RDFMapper
+  module Adapters
+    ##
+    # [-]
+    ##
+    class SPARQL < Base
+      
+      ##
+      # [-]
+      ##
+      def initialize(cls, options = {})
+        @rdf, @options = cls, options
+      end
+      
+      ##
+      # [-]
+      ##
+      def load(query)
+        Query.new(query, @options).find
+      end
+      
+      class Query
+        
+        include RDFMapper::Logger
+        
+        ##
+        # [-]
+        ##
+        def initialize(query, options = {})
+          @query, @options = query, options
+          @rdf = @query.cls
+        end
+        
+        ##
+        # [-]
+        ##
+        def find
+          describe
+        end
+        
+
+        private
+        
+        ##
+        # [-]
+        ##
+        def describe
+          data = sparql_writer(:describe) do |writer|
+            triples = @query.to_triples
+            writer.write_triples(triples)
+            # Target always comes first in first triple
+            primary = triples.first.first
+            writer.targets << primary
+          end
+          repository = {}
+          download(data).each_triple do |triple|
+            s, p, o = triple
+            repository[s.to_s] ||= {}
+            repository[s.to_s][p.to_s] ||= []  
+            repository[s.to_s][p.to_s] << o
+          end
+          objects(repository)
+        end
+        
+        ##
+        # [-]
+        ##
+        def objects(repository)
+          repository.select do |uri, atts|
+            atts.key?(RDF.type.to_s)
+          end.select do |uri, atts|
+            @rdf.type == atts[RDF.type.to_s].first
+          end.map do |uri, atts|
+            atts.delete(RDF.type.to_s)
+            atts[:id] = uri
+            atts
+          end
+        end
+        
+        ##
+        # [-]
+        ##
+        def sparql_writer(type, &block)
+          RDF::Writer.for(:sparql).buffer({ :type => type }, &block)
+        end
+        
+        ##
+        # [-]
+        ##
+        def download(request)
+          data = RDFMapper::HTTP.post(@options[:server], request)
+
+          if data =~ /\<sparql/
+            RDF::Reader.for(:sparql_results)
+          elsif data =~ /\<rdf:RDF/
+            RDF::Reader.for(:xml)
+          else
+            raise RuntimeError, 'Unknown content type'
+          end.new(data)
+        end
+        
+      end # Query
+    end # SPARQL
+  end # Adapters
+end # RDFMapper

data/lib/lib/associations/base.rb

@@ -0,0 +1,95 @@
+module RDFMapper
+  module Associations
+    
+    autoload :BelongsTo,      'lib/associations/belongs_to'
+    autoload :HasMany,        'lib/associations/has_many'
+    autoload :HasOne,         'lib/associations/has_one'
+    autoload :HasAndBelongs,  'lib/associations/has_and_belongs'
+
+    ##
+    # Base class for all association types. Contains default constructor.
+    ##
+    class Base
+      
+      include RDFMapper::Logger
+      
+      def initialize(instance, options = {})
+        @instance = instance
+        @association = options[:cls]
+        @options = options
+      end
+      
+      ##
+      # [-]
+      ##
+      def replace(value)
+        raise NotImplementedError, 'Expected association to override `replace`'
+      end
+      
+      ##
+      # [-]
+      ##
+      def object(force = false)
+        value.nil? and value.empty? if force
+        self
+      end
+      
+      ##
+      # [-]
+      ##
+      def to_statements(options = {})
+        options[:skip] ||= []
+        if value.kind_of? Array
+          items = value
+        else
+          items = [value]
+        end
+        items.reject do |item|
+          options[:skip].include?(items)
+        end.map do |item|
+          node = if options[:full]
+            item.to_statements(:skip => @instance)
+          else
+            item.to_statements(:short => true)
+          end
+          node + [{
+            :subject => @instance.id,
+            :predicate => @options[:type],
+            :object => item.id
+          }]
+        end.flatten
+      end
+      
+      ##
+      # Developer-friendly representation of the instance
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        value.inspect
+      end
+      
+      
+      private
+
+      ##
+      # [-]
+      ##
+      def value
+        raise NotImplementedError, 'Expected association to override `value`'
+      end
+      
+      ##
+      # [-]
+      ##
+      def method_missing(symbol, *args, &block)
+        if value.respond_to? symbol
+          value.send(symbol, *args, &block)
+        else
+          raise RuntimeError, 'Undefined method `%s`' % symbol
+        end
+      end
+      
+    end # Base
+  end # Associations
+end # RDFMapper

data/lib/lib/associations/belongs_to.rb

@@ -0,0 +1,64 @@
+module RDFMapper
+  module Associations
+    ##
+    # [-]
+    ##
+    class BelongsTo < Base
+
+      ##
+      # [-]
+      ##
+      def id
+        value.id
+      end
+      
+      ##
+      # [-]
+      ##
+      def nil?
+        value.nil?
+      end
+      
+      ##
+      # [-]
+      ##
+      def kind_of?(type)
+        value.kind_of?(type)
+      end
+      
+      ##
+      # Replaces current association with a new object
+      ##
+      def replace(value)
+        if value.kind_of? String
+          @key = RDF::URI.new(value)
+        end
+        if value.kind_of? RDF::URI
+          @key = value
+        end
+        if value.kind_of? RDFMapper::Model
+          @value = value
+        else
+          nil
+        end
+      end
+
+
+      private
+
+      ##
+      # [-]
+      ##
+      def value
+        unless @value.nil?
+          return @value
+        end
+        if @key.nil?
+          return nil
+        end
+        replace(@association.find(@key))
+      end
+
+    end # BelongsTo
+  end # Associations
+end # RDFMapper

data/lib/lib/associations/has_and_belongs.rb

@@ -0,0 +1,17 @@
+module RDFMapper
+  module Associations
+    ##
+    # [-]
+    ##
+    class HasAndBelongs
+
+      ##
+      # [-]
+      ##
+      def initialize(instance, options = {})
+        raise NotImplementedError, 'has_and_belongs_to is not yet implemented'
+      end
+
+    end # HasAndBelongs
+  end # Associations
+end # RDFMapper

data/lib/lib/associations/has_many.rb

@@ -0,0 +1,147 @@
+module RDFMapper
+  module Associations
+    ##
+    # [-]
+    ##
+    class HasMany < Base
+      
+      ##
+      # Replaces the collections content by deleting and adding
+      # objects as appropriate.
+      ##
+      def replace(objects)
+        new_objects = filter(objects.to_a)
+        return @value if new_objects.empty?
+        
+        new_objects.each do |child|
+          self << child
+        end
+        
+        @value ||= []
+        @value.each do |child|
+          delete(child) unless new_objects.include?(child)
+        end
+        
+        @value
+      end
+      
+      ##
+      # Adds one or more objects to the collection by setting their
+      # foreign keys to the collection's primary key.
+      ##
+      def <<(*objects)
+        objects.to_a.select do |child|
+          child.kind_of? RDFMapper::Model
+        end.each do |child|
+          unless include?(child)
+            child[reverse] = @instance
+            @value << child
+          end
+        end
+        self
+      end
+      
+      alias_method :push, :<<
+      
+      ##
+      # Removes one or more objects from the collection by removing
+      # the association between objects
+      ##
+      def delete(*objects)
+        objects.each do |child|
+          if include?(child)
+            child[reverse] = nil
+            @value.delete(child)
+          end
+        end
+        self
+      end
+      
+      ##
+      # Removes every object from the collection.
+      ##
+      def clear
+        delete(@value)
+      end
+
+      ##
+      # Finds an associated object according to the same rules as
+      # RDFMapper::Model.find.
+      ##
+      def find
+        raise NotImplementedError, '`find` not yet implemented' # TODO
+      end
+      
+      ##
+      # Returns one or more new objects of the collection type that
+      # have been instantiated with attributes and linked to this object
+      # through a foreign key, but have not yet been saved.
+      ##
+      def build
+        raise NotImplementedError, '`build` not yet implemented' # TODO
+      end
+      
+      ##
+      # Returns a new object of the collection type that has been
+      # instantiated with attributes, linked to this object through
+      # a foreign key, and that has already been saved.
+      ##
+      def create
+        raise NotImplementedError, '`create` not yet implemented' # TODO
+      end
+
+      ##
+      # Returns true if a given object is present in the collection
+      ##
+      def include?(object)
+        @value ||= []
+        @value.include?(object)
+      end
+            
+      ##
+      # [-]
+      ##
+      def to_a
+        value
+      end
+      
+      
+      private
+      
+      def filter(objects)
+        objects.select do |child|
+          child.kind_of? RDFMapper::Model
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def value
+        unless @value.nil?
+          return @value
+        end
+        if @instance.id.nil?
+          return []
+        end
+        replace @association.find(:all, {
+          :conditions => { reverse => @instance },
+          :skip => [reverse]
+        })
+      end
+      
+      ##
+      # [-]
+      ##
+      def reverse
+        @reverse ||= @association.has?(nil, @instance)
+        if @reverse.nil?
+          raise RuntimeError, 'Expected %s to belong to %s' % [@association, @instance.class]
+        else
+          @reverse.name
+        end
+      end
+      
+    end # HasMany
+  end # Associations
+end # RDFMapper

data/lib/lib/associations/has_one.rb

@@ -0,0 +1,17 @@
+module RDFMapper
+  module Associations
+    ##
+    # [-]
+    ##
+    class HasOne
+
+      ##
+      # [-]
+      ##
+      def initialize(instance, options = {})
+        raise NotImplementedError, 'has_one is not yet implemented'
+      end
+
+    end # HasOne
+  end # Associations
+end # RDFMapper

data/lib/lib/model/association.rb

@@ -0,0 +1,59 @@
+module RDFMapper
+  class Model
+    class << self
+      
+      ##
+      # Specifies a one-to-many association. The following methods for retrieval
+      # and query of collections of associated objects will be added:
+      #
+      # * collection(force_load = false) -- Returns an array of all the associated
+      #   objects. An empty array is returned if none are found.
+      #
+      # * collection<<(object, ...) -- Adds one or more objects to the collection by
+      #   setting their foreign keys to the collection‘s primary key.
+      #
+      # * collection.delete(object, ...) -- Removes one or more objects from the
+      #   collection by removing the association between objects.
+      #
+      # * collection=objects -- Replaces the collections content by deleting and
+      #   adding objects as appropriate.
+      #
+      # * collection.clear -- Removes every object from the collection.
+      #
+      # * collection.empty? -- Returns true if there are no associated objects.
+      #
+      # * collection.size -- Returns the number of associated objects.
+      #
+      # @param [Symbol] name name of the association
+      #
+      # @param [Symbol] options[:class_name] class name of the association. Use it
+      # only if that name can't be inferred from the association name
+      #
+      # @return [Object] instance of RDFMapper::Attribute
+      ##
+      def has_many(name, options = {})
+        attribute(name, options.merge(:association => :has_many))
+      end
+
+      ##
+      # Specifies a one-to-one association with another class. The following
+      # methods for retrieval and query of the associated object will be added:
+      #
+      # * association(force_reload = false) -- Returns the associated object.
+      #   nil is returned if none is found.
+      #
+      # * association=(associate) -- Assigns the associate object.
+      #
+      # @param [Symbol] name name of the association
+      #
+      # @param [Symbol] options[:class_name] class name of the association. Use it
+      # only if that name can't be inferred from the association name
+      ##
+      def belongs_to(name, options = {})
+        attribute(name, options.merge(:association => :belongs_to))
+      end
+      
+    end
+  end # Model
+end # RDFMapper
+

data/lib/lib/model/attribute.rb

@@ -0,0 +1,186 @@
+module RDFMapper
+  class Model
+    ##
+    # Contains configuration and convenience methods for model attributes.
+    # Instances of this class are assigned to classes (not instances!) of
+    # RDFMapper::Model.
+    ##
+    class Attribute
+      
+      include RDFMapper::Logger
+
+      attr_reader :name
+
+      ##
+      # Constructor is called for each attribute of a model at the time
+      # the model is defined.
+      # 
+      # @param [Object] cls class of the model
+      # @param [String] name name of the attribute
+      # @param [Hash] options options to pass on to the property / association constructor
+      #
+      # @return [self]
+      ##
+      def initialize(cls, name, options)
+        @cls = cls
+        @name = name
+        @options = options.dup
+      end
+      
+      ##
+      # Checks if this attribute is a `belongs_to` association.
+      #
+      # @return [Boolean]
+      ##
+      def belongs_to?
+        not property? and not multiple?
+      end
+
+      ##
+      # Checks if this attribute is a property (i.e. not an association).
+      #
+      # @return [Boolean]
+      ##
+      def property?
+        @options[:association].nil?
+      end
+
+      ##
+      # Returns attribute's RDF predicate.
+      #
+      # @return [RDF::URI]
+      # @return [nil] if not specified and model has no namespace
+      ##
+      def type
+        # Type is 'cached': lookups based on namespace can be quite slow
+        @type ||= unless @options[:predicate].nil?
+          RDF::URI.new(@options[:predicate].to_s)
+        else
+          # Keep this weird comparison. RDF::Vocabulary doesn't recognize `nil?` or `==` 
+          (nil == @cls.namespace) ? nil : @cls.namespace[@name]
+        end
+      end
+      
+      ##
+      # Returns class of the associated model. Uses either the `:class_name`
+      # option or relies on association name. It follows ActiveRecord naming
+      # conventions(e.g. has_many should be plural, belongs_to - singular).
+      #
+      # @return [Object] a subclass of RDFMapper::Model
+      # @return [nil] if association is not found or this is a property attribute
+      ##
+      def model
+        # A bit of 'caching': lookups based on namespace can be quite slow
+        unless @model.nil?
+          return @model
+        end
+        
+        # Should return nil if this is not an association
+        if property?
+          return nil
+        end
+
+        if @model = model_from_options || model_from_namespace
+          @model
+        else
+          raise RuntimeError, 'Could not find association model for %s (%s :%s)' % [@cls, @options[:association], @name]
+        end
+      end
+      
+      ##
+      # Returns the class or an instance of a class associated with this
+      # attribute.
+      
+      # When model instance is not specified, it will return Associations::HasMany,
+      # Associations::BelongsTo, Property, etc. Alternatively, when RDFMapper::Model
+      # is specified, it will return an instance of these classes.
+      #
+      # @param [Object] instance instance of RDFMapper::Model
+      # @return [Object] class of this attribute
+      # @return [Object] instance of this attribute 
+      ##
+      def value(instance = nil)
+        if nil == instance
+          return attribute_type
+        end
+        attribute_type.new(instance, @options.merge({
+          :cls => model,
+          :type => type,
+          :name => name
+        }))
+      end
+
+      ##
+      # Checks if this attribute has the same predicate and / or value.
+      # Value is accepted both as an instance and a class.
+      ##
+      def matches?(predicate, value = nil)
+        if type.nil?                      # Always false if attribute predicate is not defined
+          return false
+        end
+        if value == nil                   # Checking predicates
+          return type.to_s == predicate.to_s
+        end
+        unless value.respond_to? :new     # Converting instance to a class
+          value = value.class
+        end
+        if model.nil?               # Value is not nil, but model is undefined
+          return false
+        end
+        if value.type != model.type # Value type and model type should match
+          return false
+        end
+        if predicate.nil?                 # Value and model types match
+          true
+        else
+          predicate == type
+        end
+      end
+      
+      
+      private
+
+      ##
+      # Returns attribute's class (e.g. Associations::HasMany, Property) based
+      # on the supplied `options[:association]`
+      ##
+      def attribute_type #nodoc
+        case @options[:association]
+          when :has_many          then Associations::HasMany
+          when :belongs_to        then Associations::BelongsTo
+          when :has_one           then Association::HasOne
+          when :has_and_belongs   then Association::HasAndBelongs
+          else Property
+        end
+      end
+
+      ##
+      # Derives the name of associated model from `options[:class_name]` and
+      # returns its class.
+      ##
+      def model_from_options #nodoc
+        @options[:class_name].nil? ? nil : @options[:class_name].constantize
+      end
+
+      ##
+      # Derives the name of associated model from association name and
+      # returns its class
+      ##
+      def model_from_namespace #nodoc
+        name = multiple? ? @name.to_s.classify : @name.to_s.pluralize.classify
+        # Keep this weird comparison. RDF::Vocabulary doesn't recognize `nil?` or `==` 
+        (nil == @cls.namespace) ? nil : @cls[@cls.namespace[name]]
+      end
+
+      ##
+      # Checks if this attribute is an association with multiple objects
+      # (i.e. `has_many` or `has_and_belongs_to`). Used for deriving association
+      # name (plural / singular)
+      ##
+      def multiple? #nodoc
+        @options[:association] == :has_many || @options[:association] == :has_and_belongs
+      end
+      
+    end # Attribute
+  end # Model
+end # RDFMapper