rdf-mapper 0.0.1

data/lib/lib/model/property.rb

@@ -0,0 +1,78 @@
+module RDFMapper
+  class Model
+    class Property
+
+      def initialize(instance, options = {}, *args)
+        @instance = instance
+        @options = options
+        @value = nil
+        @new = true
+      end
+
+      ##
+      # Checks if property has default (nil) value.
+      #
+      # @params [Boolean]
+      ##
+      def new?
+        @new
+      end
+
+      ##
+      # Assigns a new value to the property.
+      #
+      # @param [Object] value
+      # @return [Object]
+      ##
+      def replace(value)
+        @new = false
+        if value.kind_of? Array
+          value = value.first
+        end
+        if value.kind_of? RDF::Literal
+          value = value.object
+        end
+        @value = case @options[:type]
+          when :text      then value.to_s
+          when :integer   then value.to_i
+          when :float     then value.to_f
+          when :uri       then RDF::URI.new(value.to_s)
+          else value.to_s
+        end
+      end
+
+      ##
+      # [-]
+      ##
+      def object(*args)
+        @value
+      end
+      
+      ##
+      # [-]
+      ##
+      def to_statements(options = {})
+        { :subject => @instance.id,
+          :predicate => @options[:type],
+          :object => RDF::Literal.new(@value) }
+      end
+
+      ##
+      # Developer-friendly representation of the instance
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        @value.inspect
+      end
+
+      ##
+      # [-]
+      ##
+      def method_missing(symbol, *args, &block)
+        @value.send(symbol, *args, &block)
+      end
+
+    end # Property
+  end # Model
+end # RDFMapper

data/lib/lib/scope/collection.rb

@@ -0,0 +1,165 @@
+module RDFMapper
+  module Scope
+    ##
+    # This class contains collections of models. It is primarily used in
+    # search queries (find(:all) queries will yield instances of this
+    # class) and associations.
+    #
+    # It implements most commonly used Array and Enumerable methods.
+    ##
+    class Collection
+      
+      attr_reader :loader #Temporary
+      
+      def initialize(cls, options)
+        @loader = Loader.new(cls, options)
+        @models = []
+        @cls = cls
+      end
+      
+      ##
+      # Set data adapter for the query and return self. This will override
+      # the default model adapter. It is intended to be used as a chain method:
+      #
+      #   Person.find(:all).from(:rest)          #=>  #<PersonCollection:217132856>
+      #   Person.find(:all).from(:rest).length   #=>  10
+      #
+      # @param [Symbol] adapter (:rails, :sparql, :rest)
+      # @param [Hash] options options to pass on to the adapter constructor
+      #
+      # @return [self]
+      ##
+      def from(adapter, options = {})
+        @loader.from(adapter, options)
+        self
+      end
+      
+      ##
+      # Returns first object of the collection. Note that the
+      # object is not yet loaded at this point.
+      #
+      # @return [Object]
+      ##
+      def first
+        at(0)
+      end
+
+      ##
+      # Returns first object of the collection. Note that the
+      # object is not yet loaded at this point.
+      #
+      # @return [Object]
+      ##
+      def last
+        at(-1)
+      end
+
+      ##
+      # Returns the object at `index`. Note that the object is
+      # not yet loaded at this point.
+      #
+      # @param [Integer] index
+      # @return [Object]
+      ##
+      def [](index)
+        at(index)
+      end
+      
+      ##
+      # Returns the object at `index`. Note that the object is
+      # not yet loaded at this point.
+      #
+      # @param [Integer] index
+      # @return [Object]
+      ##
+      def at(index)
+        @models[index] ||= @loader.get(index)
+      end
+
+      ##
+      # Returns true if collection has no objects.
+      #
+      # @param [Boolean]
+      ##
+      def empty?
+        length == 0
+      end
+
+      ##
+      # Returns the number of objects in a collection.
+      #
+      # @return [Integer]
+      ##
+      def length
+        @loader.length
+      end
+
+      ##
+      # Calls block once for each object in a collection, passing
+      # that element as a parameter.
+      #
+      # @yield [Object]
+      # @return [self]
+      ##
+      def each(&block)
+        items.each { |x| block.call(x) }
+        self
+      end
+      
+      ##
+      # Invokes block once for each object in a collection. Creates
+      # a new array containing the values returned by the block
+      #
+      # @yield [Object]
+      # @return [Array]
+      ##
+      def map(&block)
+        items.map { |x| block.call(x) }
+      end
+      
+      ##
+      # Returns true if collection contains specified object.
+      #
+      # @param [Object] object instance of RDFMapper::Model
+      # @return [Boolean]
+      ##
+      def exists?(object)
+        items.include?(object)
+      end
+      
+      ##
+      # Converts collection into Array.
+      #
+      # @return [Array]
+      ##
+      def to_a
+        items
+      end
+      
+      alias_method :size, :length
+      alias_method :collect, :map
+      alias_method :slice, :[]
+      alias_method :include?, :exists?
+
+      ##
+      # Developer-friendly representation of the instance
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        "#<%sCollection:%s>" % [@cls, object_id]
+      end
+
+
+      private
+      
+      ##
+      # Loads entire collection (if needed) and returns all objects.
+      ##
+      def items #nodoc
+        (0..length-1).map { |x| at(x) }
+      end
+
+    end # Collection
+  end # Scope
+end # RDFMapper

data/lib/lib/scope/condition.rb

@@ -0,0 +1,132 @@
+module RDFMapper
+  module Scope
+    ##
+    # [-]
+    ##
+    class Condition
+      
+      attr_reader :eq
+      
+      def initialize(cls, att, value, eq = '=')
+        @cls, @att, @value, @eq = cls, att, value, eq
+      end
+      
+      ##
+      # [-]
+      ##
+      def name
+        if @att == :id
+          return @att
+        end
+        unless att = @cls.has?(@att)
+          raise RuntimeError, 'Undefined attribute %s for %s' % [@att, @cls]
+        else
+          att.name
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def value(required = [])
+        association? ? association(required) : literal
+      end
+      
+      alias_method :check, :value
+      
+      ##
+      # [-]
+      ##
+      def to_triples(subject)
+        to_statements(subject).map do |statement|
+          [ statement[:subject], statement[:predicate], statement[:object] ]
+        end
+      end
+      
+      ##
+      # [-]
+      ##
+      def to_statements(subject)
+        if association?
+          object = association.id
+          rdf_type = association.to_triples(:short => true)
+        else
+          object = RDF::Query::Variable.new
+          object.bind(value, eq)
+          rdf_type = []
+        end
+        rdf_type + [{
+          :subject => subject,
+          :predicate => @cls.has?(@att).type,
+          :object => object
+        }]
+      end
+      
+      ##
+      # Developer-friendly representation of the instance.
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        "#<Condition:(%s%s%s)>" % [name, eq, value]
+      end
+      
+            
+      private
+      
+      ##
+      # [-]
+      ##
+      def association(required = [], value = nil) #nodoc
+        if value.nil?
+          value = @value
+        end
+        if value.kind_of? Array or value.kind_of? RDFMapper::Scope::Collection
+          return value.map do |item|
+            association(required, item)
+          end
+        end
+        unless value.kind_of? RDFMapper::Model
+          att = @cls.associations[name]
+          value = att.model.find(value.to_s)
+        end
+        required.each do |att|
+          if value[att].nil?
+            raise RuntimeError, 'Expected %s to have %s' % [value, att] if value.reload[att].nil?
+          end
+        end
+        value
+      end
+      
+      ##
+      # [-]
+      ##
+      def literal(value = nil) #nodoc
+        if value.nil?
+          value = @value
+        end
+        if value.kind_of? Array 
+          return value.map do |item|
+            literal(item)
+          end
+        end
+        if value.kind_of? RDF::Literal
+          value.object
+        elsif value.kind_of? RDF::URI
+          value.to_s
+        else
+          value
+        end
+      end
+      
+      ##
+      # Return the association name that has `name_or_key` as foreign key or name.
+      ##
+      def association? #nodoc
+        att = @cls.associations[name]
+        not (att.nil? or att.property?)
+      end
+      
+    end # Condition
+  end # Scope
+end # RDFMapper

data/lib/lib/scope/loader.rb

@@ -0,0 +1,111 @@
+module RDFMapper
+  module Scope
+    ##
+    # Loader is responsible for loading and updating model attributes. An instance
+    # of Loader is assigned to each search query and association.
+    ##
+    class Loader
+
+      def initialize(cls, options = {})
+        @conditions = Query.new(cls, options)
+        @objects = []
+        @cls = cls
+      end
+      
+      ##
+      # Checks if model ID is specified within conditions. Returns
+      # RDF::URI if found, nil otherwise.
+      #
+      # @return [RDF::URI]
+      # @return [nil]
+      ##
+      def has_id?
+        @conditions[:id].nil? ? nil : RDF::URI.new(@conditions[:id])
+      end
+      
+      ##
+      # Sets data adapter for this loader. This will override default model adapter.
+      #
+      # @param [Symbol] adapter (:rails, :sparql, :rest)
+      # @param [Hash] options options to pass on to the adapter constructor
+      # @return [Object] adapter instance 
+      ##
+      def from(adapter, options = {})
+        @adapter = RDFMapper::Adapters.register(adapter, @cls, options)
+      end
+
+      ##
+      # Returns the number of loaded objects.
+      #
+      # @return [Integer]
+      ##
+      def length
+        load.length
+      end
+      
+      ##
+      # Creates a new 'scoped' instance of RDFMapper::Model.
+      #
+      # @param [Integer] index
+      # @return [Object]
+      ##
+      def get(index)
+        instance = @cls.new(@objects[index])
+        RDFMapper::Scope.apply(instance, self, index)
+      end
+      
+      ##
+      # Updates an existing 'scoped' instance of RDFMapper::Model
+      # (sets ID and attributes).
+      #
+      # @param [Integer] index
+      # @param [Object] instance
+      # @return [Object]
+      ##
+      def update(index, instance = nil) #nodoc
+        atts = load[index]
+        if atts.nil?
+          return instance.send(:nil!)
+        end
+        instance.send(:id=, atts[:id])
+        instance.attributes = atts
+        instance
+      end
+      
+      ##
+      # Developer-friendly representation of the instance
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        "#<%sLoader:%s>" % [@cls, object_id]
+      end
+
+      private
+
+      ##
+      # Returns adapter class to be used when loading. It's either the
+      # default model adapter or the one explicitly specified via `from`.
+      ##
+      def adapter #nodoc
+        @adapter || @cls.adapter
+      end
+      
+      ##
+      # Loads and returns objects. Objects are 'cached' and not reloaded
+      # upon subsequent requests.
+      ##
+      def load #nodoc
+        if @loaded
+          return @objects
+        end
+        if adapter.nil?
+          raise RuntimeError, "No adapter specified for %s" % @cls
+        end
+        @loaded = true
+        @objects = adapter.load(@conditions)
+      end
+    
+    end # Loader
+  end # Scope
+end # RDFMapper

data/lib/lib/scope/model.rb

@@ -0,0 +1,129 @@
+module RDFMapper
+  module Scope
+    
+    require 'lib/scope/loader'
+    require 'lib/scope/collection'
+    require 'lib/scope/query'
+    require 'lib/scope/condition'
+    
+    
+    def self.apply(instance, loader, index)
+      instance.extend(Model)
+      instance.send(:scoped!, loader, index)
+    end
+    
+    ##
+    # Extension of RDFMapper::Model that implements lazy-loading. All models
+    # in collections and search queries will implement this module by default.
+    ##
+    module Model
+      
+      ##
+      # Returns instance's unique ID (as RDF::URI).
+      ##
+      def id
+        super || @loader.has_id? || load.id
+      end
+      
+      ##
+      # Set data adapter for the query and return self. This will override
+      # the default model adapter. It is intended to be used as a chain method:
+      #
+      #   Person.find(:first).from(:rails)          #=>  #<Person:217132856>
+      #   Person.find(:first).from(:rails).name     #=>  'John'
+      #
+      # @param [Symbol] adapter (:rails, :sparql, :rest)
+      # @param [Hash] options options to pass on to the adapter constructor
+      #
+      # @return [self]
+      ##
+      def from(adapter, options = {})
+        @loader.from(adapter, options)
+        self
+      end
+      
+      ##
+      # In addition to the original method, preloads the model.
+      ##
+      def [](name)
+        super || (@loaded ? nil : load[name])
+      end
+      
+      ##
+      # Returns a hash of all the attributes with their names as keys and
+      # the attributes' values as values. If model is unloaded, it will
+      # preload it before returning its attributes.
+      # 
+      # @return [Hash] all attributes of an instance (name => value)
+      ##
+      def attributes
+        check_for_nil_error
+        @loaded ? super : load.attributes
+      end
+      
+      ##
+      # Checks if the instance is `nil`. Will load the instance to find it out.
+      #
+      # @return [Boolean]
+      ##
+      def nil?
+        @nil or (not @loaded and load.nil?)
+      end
+      
+      ##
+      # Developer-friendly representation of the instance.
+      #
+      # @return [String]
+      ##
+      def inspect #nodoc
+        "#<Scoped|%s:%s>" % [self.class, object_id]
+      end
+      
+      
+      private
+      
+      ##
+      # Sets Loader instance and object's index in a collection. Called
+      # automatically when lazy-loading module is applied.
+      ##
+      def scoped!(loader, index) #nodoc
+        @loader, @index = loader, index
+        @loaded, @nil = false, false
+        self
+      end
+      
+      ##
+      # Flags the instance as `nil`. Returns self.
+      ##
+      def nil!
+        @nil = true
+        self
+      end
+      
+      ##
+      # In addition to the original method, preloads the model.
+      ##
+      def get_attribute(name, *args)
+        @loaded ? super : load.send(name, *args)
+      end
+      
+      ##
+      # Loads the model.
+      ##
+      def load
+        check_for_nil_error
+        return self if @loaded
+        @loaded = true
+        @loader.update(@index, self)
+      end
+      
+      ##
+      # Checks if the instance is `nil`. Raises an error if true.
+      ##
+      def check_for_nil_error
+        raise RuntimeError, 'Instance %s is NIL' % self if @nil
+      end
+      
+    end
+  end # Scope
+end # RDFMapper