activerubic 0.8.0 → 0.8.1

data/lib/objectmanager/rdfs/image.rb

@@ -0,0 +1,272 @@
+# Schema model for a resource of type MEDIA::image.
+#
+# This model serves to be a simpler form for custom data to be addressed without using the RDF Schema (RDFS) definition. This is fairly hackish and is not intended to be reviewed. This model is required to be here, however, because ActiveRubic needs to have access to this model, as it is passing around objects of this type through the DRb.
+#
+# A different model for images is useful in Rails environment where different multimedia types should be built into various containers, even though the internal accessors are translated from the RDF Schema. Currently the schema is hard-coded, as stated above. This should be fairly easy to fix...
+class Image < RDFS::Resource
+
+  # adding accessor to the class uri:
+  # the uri of the rdf resource being represented by this class
+  class << self
+    attr_accessor :class_uri
+  end
+
+  # uri of the resource (for instances of this class: rdf resources)
+  attr_reader :uri
+
+  # Creates a new Image.
+  #
+  # parameters:
+  #  1  resource ( RDFS::Resource or URI )
+  #  2  options ( Hash; )
+
+    # parameters:
+  #  1  resource ( RDFS::Resource or URI String )
+  def initialize( resource, options={} )
+    @@log.deep "Formulating new Image #{resource} from #{resource.class}"
+    @uri = case resource
+    when MEDIA::image
+      @@log.warn "Redundant new OWL::Class, resource already was one."
+      resource.uri
+    when RDFS::Resource
+      resource.uri
+    when String
+      resource
+    else
+      raise ActiveRdfError, "Resource #{resource} (#{resource.class}) is improperly formulated"
+      return nil
+    end
+
+#     @data_stores = options[ :from ] || RUBIC_DATASTORES
+  end
+
+  self.class_uri = Namespace.lookup(:media, :image)
+
+  def self.uri; class_uri.uri; end
+  def self.==(other)
+    other.respond_to?(:uri) ? other.uri == self.uri : false
+  end
+
+  #####                        ######
+  ##### start of instance-level code
+  #####                        ######
+
+  attr_accessor :marker_icon
+
+  # muuNimi
+  def aliases
+    begin
+      s = self.label.dup
+      s.shift # remove the first label
+      unless s.nil?
+        return s.join(', ')
+      else
+        return String.new
+      end
+    rescue
+      @@log.error $!
+      return String.new
+    end
+  end
+  alias :alias :aliases
+
+  def location
+    begin
+      if @location.nil? then
+        @location = my( DCTERMS::spatial )
+      end
+      return @location
+    rescue
+      return Array.new
+    end
+  end
+
+  # the target instance
+  def about
+    begin
+      if @about.nil? then
+        @about = my( RDF::subject ).uniq
+      end
+      return @about
+    rescue
+      return Array.new
+    end
+  end
+  alias :subject :about
+  alias :subjects :about
+
+  def original
+    begin
+      if @original.nil? then
+        @original = my( IMAGE::original ).first.uri
+      end
+      return @original
+    rescue
+      @@log.warn "Original not found for #{self.uri}"
+      return '/images/not_found/full.jpg'
+    end
+  end
+
+  # the 'full' web url
+  def url
+    begin
+      if @url.nil? then
+        @url = my( IMAGE::url ).first.uri
+      end
+      return @url
+    rescue
+      @@log.warn "Full web size image not found for #{self.uri}"
+      return '/images/not_found/full.jpg'
+    end
+  end
+  alias :large :url
+  alias :full :url
+
+  def preview
+    begin
+      if @preview.nil? then
+        @preview = my( IMAGE::preview ).first.uri
+      end
+      if (( @preview.empty? ) || ( @preview.nil? ))
+        # hack for psm_images. todo: think over how to solve missing resolutions
+        return self.uri
+      else
+        return @preview
+      end
+    rescue
+      @@log.warn "Preview not found for #{self.uri}"
+      return '/images/not_found/preview.jpg'
+    end
+  end
+  alias :medium :preview
+
+  #TODO: rescale to 350x262
+  def small
+    begin
+      if @small.nil? then
+        @small = my( IMAGE::small ).first.uri
+      end
+      if (( @small.empty? ) || ( @small.nil? ))
+        return self.thumb
+      else
+        return @small
+      end
+    rescue
+      @@log.warn "Small image not found for #{self.uri}"
+      return '/images/not_found/small.jpg'
+    end
+  end
+
+  def thumb
+    begin
+      if @thumb.nil? then
+        @thumb = my( IMAGE::thumbnail ).first.uri
+      end
+      return @thumb
+    rescue
+      @@log.warn "Thumbnail not found for #{self.uri}"
+      return '/images/not_found/thumb.jpg'
+    end
+  end
+  alias :thumbnail :thumb
+
+  def date
+    begin
+      if @date.nil? then
+        @date = my( EXIF::dateTime ).first
+      end
+      return @date
+    rescue
+      return nil
+    end
+  end
+
+  # for timeranges
+  def timerange_start
+    begin
+      if @timerange_start.nil? then
+        @timerange_start = my( BT::picture_timerange_start ).first
+      end
+      return @timerange_start
+    rescue
+      return nil
+    end
+  end
+  def timerange_end
+    begin
+      if @timerange_end.nil? then
+        @timerange_end = my( BT::picture_timerange_end ).first
+      end
+      return @timerange_end
+    rescue
+      return nil
+    end
+  end
+
+  def copyright
+    begin
+      if @c.nil? then
+        @c = my( IPTC::CopyrightNotice ).first
+      end
+      return @c
+    rescue
+      return nil
+    end
+  end
+
+  def rating
+    begin
+      if @rating.nil? then
+        @rating = my( IPTC::Rating ).first
+      end
+      return @rating
+    rescue
+      return nil
+    end
+  end
+
+  def model
+    begin
+      if @m.nil? then
+        @m = my( EXIF::Model ).first
+      end
+      return @m
+    rescue
+      return nil
+    end
+  end
+  alias :camera_model :model
+
+  def credit
+    begin
+      if @credit.nil? then
+        @credit = my( DC::creator ).first
+      end
+      return @credit
+    rescue
+      return nil
+    end
+  end
+  alias :photographer :credit
+  alias :creator :credit
+
+  # returns the keywords of the subject
+  def keywords
+    begin
+      # the class variable is set if this query has been executed already
+      if @keywords.nil? then
+        @keywords = Array.new
+        @keywords << my( IPTC::Keywords )
+        @keywords << my( DC::keywords )
+        @keywords << my( DC::subject )
+        @keywords.flatten!.uniq!
+      end
+      return @keywords
+    rescue
+      return nil
+    end
+  end
+
+
+
+end

data/lib/objectmanager/rdfs/resource.rb

@@ -0,0 +1,287 @@
+require 'active_rdf'
+require 'objectmanager/object_manager'
+# the modified namespace is loaded before registering the namespaces
+# require 'objectmanager/namespace'
+require 'queryengine/query'
+
+module RDFS
+  # Represents an RDF resource and manages manipulations of that resource.
+  # Extends the ActiveRDF object by introducing a layer of data handling methods for RDFS resources.
+  #
+  # Other objects that currently extend this class:
+  # - OWL::ObjectProperty
+  #
+  # See also:: ActiveRubic, OWL::Class and OWL::Thing.
+  class RDFS::Resource
+
+    # adding accessor to the class uri:
+    # the uri of the rdf resource being represented by this class
+    class << self
+      attr_accessor :class_uri
+    end
+
+    # uri of the resource (for instances of this class: rdf resources)
+    attr_reader :uri
+
+    # creates new resource representing an RDF resource
+    #
+    # parameters:
+    # - 1  resource ( RDFS::Resource or URI String )
+    def initialize( resource, options={} )
+      @@log.deep "Formulating new RDFS::Resource #{resource} from #{resource.class}"
+      @uri = case resource
+      when RDFS::Resource then
+        @@log.warn "Redundant new RDFS::Resource, resource already was one."
+        resource.uri
+      when String then
+        resource
+      else
+        raise ActiveRdfError, "Resource #{resource} (#{resource.class}) is improperly formulated"
+        return nil
+      end
+    end
+
+    # setting our own class uri to rdfs:resource
+    # (has to be done after defining our RDFS::Resource.new
+    # because it cannot be found in Namespace.lookup otherwise)
+    self.class_uri = Namespace.lookup(:rdfs, :Resource)
+
+    def self.uri; class_uri.uri; end
+    def self.==(other)
+      other.respond_to?(:uri) ? other.uri == self.uri : false
+    end
+
+    #####                        ######
+    ##### start of instance-level code
+    #####                        ######
+
+    # Returns the Namespace localname of the resource.
+    def localname
+      Namespace.localname( self.uri )
+    end
+    alias :uri_id :localname
+  
+    # Strips protocol from the URI.
+    def stripped_uri
+      return self.uri.gsub( /.*:\/\//, '' )
+    end
+
+    # HACK for the Image class. See the comments over there to find out why this method uses hard-coded values (FIXME).
+    def is_image?
+      if self.types.include? MEDIA::image
+        return true
+      else
+        return false
+      end
+    end
+
+    # returns the resource ancestors in the OWL graph
+    def ancestors
+      begin
+        # the class variable is set if this query has been executed already
+        if @ancestors.nil? then
+          @ancestors = ActiveRubic::Base.find( :ancestors, :subject => self )
+        end
+        return @ancestors
+      rescue
+        return Array.new
+      end
+    end
+
+    # returns the resource parents in the OWL graph
+    def parents
+      begin
+        if @parents.nil?
+          @parents = ActiveRubic::Base.find( :parents, :subject => self )
+        end
+        return @parents
+      rescue
+        return Array.new
+      end
+    end
+
+    # children and descendants are only defined for OWL::Class
+
+    # get all object properties
+    def properties
+      @@log.debug "Looking up properties for #{self.uri}"
+      begin
+        # the class variable is set if this query has been executed already
+        if @properties.nil? then
+          @properties = ActiveRubic::Base.find( :properties, :subject => self )
+        end
+        return @properties
+      rescue
+        return Array.new
+      end
+    end
+
+    # Checks if the resource has latitude and longitude, in which case returns self in an Array.
+    #
+    # Perhaps this should return GMarkers or a GeoRuby object.
+    def geopoints( options={} )
+#       limit = options[ :limit ]
+      @@log.debug "Looking up marker for #{self.uri}"
+      if ( self.has_markers? )
+        return [ self ]
+      else
+        return Array.new
+      end
+    end
+    alias :markers :geopoints
+
+    # returns a single geopoint
+    def geopoint
+      return self.geopoints.first
+    end
+    alias :marker     :geopoint
+    alias :wgs84      :geopoint
+    alias :location   :geopoint
+
+    def gmarker # :nodoc:
+    end
+
+    # Returns true if the object has lat and long, otherwise false.
+    def is_mappable?
+      if self.lat and self.long
+        return true
+      else
+        return false
+      end
+    end
+    alias :has_markers? :is_mappable?  # :nodoc:
+    alias :has_coordinates? :is_mappable?  # :nodoc:
+  
+    # Returns (the first) GEO::lat as Float.
+    # uses the private method get_lat_and_long.
+    def latitude
+#       STDERR.puts "get lat"
+      begin
+        if @lat.nil? then
+          get_lat_and_long
+        end
+#         @@log.debug "lat: #{@lat.first}"
+        return @lat.first if @lat.any?
+      rescue
+        return nil
+      end
+    end
+    alias :lat :latitude
+
+    # Returns (the first) GEO::long as Float.
+    # uses the private method get_lat_and_long.
+    def longitude
+      begin
+        if @long.nil? then
+          get_lat_and_long
+        end
+        return @long.first if @long.any?
+      rescue
+        return nil
+      end
+    end
+    alias :long :longitude
+
+    private
+    # submethod which collects the lat and long.
+    def get_lat_and_long
+      begin
+        @lat = my( GEO::lat )
+        @long = my( GEO::long )
+
+        # convert to Float
+        # NOTE: nil.to_f will yield 0.0
+        @lat.dup.each_with_index do |lat,index|
+          @lat[ index ] == lat.to_f unless lat.nil?
+        end
+
+        @long.dup.each_with_index do |long,index|
+          @long[ index ] == long.to_f unless long.nil?
+        end
+
+        self.lat = @lat
+        self.long = @long
+
+      rescue
+      end
+    end
+
+    public
+
+    # returns the resources in the range of a property.
+    #
+    # parameters:
+    # - 1   property (OWL::ObjectProperty)
+    def range( property )
+      begin
+        results = ActiveRubic::Base.find( :within_range, :subject => self, :property => property )
+        return results
+      rescue
+        Array.new
+      end
+    end
+
+    # Returns resource RDF::type(s).
+    def types
+      begin
+        if @types.nil? then
+          @types = my( RDF::type )
+        end
+        return @types
+      rescue
+        return Array.new
+      end
+    end
+    alias :type :types
+
+    # returns true if the resource types include OWL::Class, false otherwise
+    def is_class?
+      begin
+        if @is_class.nil? then
+          @@log.rubic "Detecting whether #{self} is a class or an instance.."
+
+          if ( self.types.include? OWL::Class ) then
+            @is_class = true
+          else
+            @is_class = false
+          end
+        end
+        return @is_class
+      rescue
+        @@log.error $!
+      end
+    end
+
+    # returns true if the resource types include OWL::ObjectProperty, false otherwise
+    def is_property?
+      begin
+        if @is_property.nil? then
+          @@log.rubic "Detecting whether #{self} is a property.."
+          if ( self.types.include? OWL::ObjectProperty ) then
+            @is_property = true
+          else
+            @is_property = false
+          end
+        end
+        return @is_property
+      rescue
+        @@log.error $!
+      end
+    end
+
+    # Returns the results wrapped in RDFS::Resource model -- this is OK
+    # when working with OWL-DL, where properties can only be assigned to
+    # resources (AFAIK) whereas in OWL-FULL the results could be also
+    # classes and other properties .. this makes less queries so is faster.
+    def resources_for_property( p )
+      begin
+        return my( p.uri )
+      rescue
+        @@log.error $!
+      end
+    end
+    alias :values_for_property :resources_for_property
+    alias :predicate :resources_for_property
+
+  end # class
+end # module