wontomedia 0.1.1 → 0.2.0

data/app/helpers/format_helper.rb

@@ -153,12 +153,17 @@ module FormatHelper
   end
 
   def logo_image
+    result = ''
+    if WontoMedia.site_logo_title
+      result += "<div width='99%'>#{WontoMedia.site_logo_title}</div>\n"
+    end
     logo_name = (File.exists?(
       Rails.root.join( 'public', 'images', 'logo.jpg'))) ?
         '/images/logo.jpg' :
         '/images/logo.png'
-    image_tag( logo_name, :alt=>'Logo', :width=>'99%',
+    result += image_tag( logo_name, :alt=>'Logo', :width=>'99%',
       :style=>'margin-bottom: 0.7ex;' )
+    result
   end
 
 
@@ -178,4 +183,20 @@ module FormatHelper
     page_name +
     WontoMedia.site_content_url_postfix
   end
+
+  def ruby_hash_to_javascript( js_name, ruby_hash, prefix = 'id' )
+    has_started = false
+    js  = "<script type='text/javascript'>\n"
+    js += "  #{js_name} = {\n"
+
+    ruby_hash.keys.each do |class_item|
+      js += ",\n" if has_started
+      has_started = true
+      js += "  #{prefix}#{class_item.id}: '#{ruby_hash[class_item]}'"
+    end
+
+    js += "\n"
+    js += "  };\n"
+    js +  "</script>"
+  end
 end

data/app/helpers/items_helper.rb

@@ -102,4 +102,47 @@ module ItemsHelper
       end
     end
   end
+
+  # produce an array of all the system's class items suitable for the
+  # "options" argument to select_tag, sorted as follows:
+  # * first:  no-selection option
+  # * 2nd:  +@item+'s currently-selected class, if any
+  # * non-built-in classes, sorted alphabetically
+  # * built-in classes
+  def class_options_list_for(item)
+    option_array = [ [ "- class of item -", "" ] ]
+
+    this_class_item = item.class_item
+    unless this_class_item.nil?
+      option_array.concat [[ h("#{this_class_item.name}"), this_class_item.id ]]
+    end
+
+    groups = @class_list.group_by do |item|
+      if this_class_item && item.id == this_class_item.id
+        :discard
+      elsif (item.flags & Item::DATA_IS_UNALTERABLE) == 0
+        :contributor
+      else
+        :builtin
+      end
+    end
+
+    if groups[:contributor]
+      option_array.concat(
+        groups[:contributor].sort{ |a,b|
+          a.name.upcase <=> b.name.upcase }.map{ |item|
+            [ h("#{item.name}"), item.id ] } )
+      option_array.concat [ [ "  ----", "invalid" ] ]
+    end
+
+    if groups[:builtin]
+      option_array.concat(
+        groups[:builtin].sort{ |a,b|
+          a.name <=> b.name }.map{ |item|
+            [ h("#{item.name}"), item.id ] } )
+    end
+
+    options_for_select( option_array,
+      this_class_item.nil? ? "" : this_class_item.id )
+  end
 end

data/app/models/connection.rb

@@ -36,16 +36,26 @@ class Connection < ActiveRecord::Base
   # This constant is a bit mask for Item.flags.  A non-zero value
   # indicates that the Item instance should not be user-modifiable.
   DATA_IS_UNALTERABLE = 1
+  OBJECT_KIND_ITEM = 'item'
+  OBJECT_KIND_SCALAR = 'scalar'
+
+
+  # convenience attribute allows item representing a connection's object's
+  # type (if specified by a relationship somewhere in the database) to
+  # be attached to the connection once it has been looked up once
+  attr_accessor :type_item
 
 
   before_validation :complex_validations
-#  validates_presence_of :subject, :predicate, :obj
+#  validates_presence_of :subject, :predicate
 #explicitly do the equivalent of the above in complex_validations because
 #c_v has to be a "before" callback (so it's return value is checked), which
 #means other validations aren't run yet, so can't count on these IDs to
 #be present/valid.  Ugh.
+
+#  validates_inclusion_of :kind_of_obj, :in => %w(item scalar)
 #  validates_uniqueness_of :subject_id, :scope => [:predicate_id, :obj_id]
-#this works, but is subsumed by checks in c_v, so eliminated duplication
+#these work, but are subsumed by checks in c_v, so eliminated duplication
 
   belongs_to :subject,   :class_name => "Item"
   belongs_to :predicate, :class_name => "Item"
@@ -74,134 +84,152 @@ private
   # checks fail, this method returns +false+ and places the
   # appropriate message(s) in the +errors+ flash.
   def complex_validations() #:doc:
-    [ [subject_id, :subject], [predicate_id, :predicate],
-      [obj_id, :obj] ].each do |tocheck|
-      field, symbol = *tocheck
-      if field.nil?
-        errors.add symbol, "can't be blank."
-        return false
+    if kind_of_obj == OBJECT_KIND_ITEM
+      [ [subject_id, :subject], [predicate_id, :predicate],
+        [obj_id, :obj] ].each do |tocheck|
+        field, symbol = *tocheck
+        if field.nil?
+          errors.add symbol, "can't be blank."
+          return false
+        end
       end
-    end
 
-        # is there an existing connection with a predicate that is a
-        # sub-property or super-property of the current predicate?
-    # check for duplicate connection and all super-properties
-    TrippleNavigation.relation_and_all_superproperties(
-        predicate_id) do |super_prop|
-      unless (Connection.all( :conditions => [
-          "subject_id = ? AND predicate_id = ? AND obj_id = ?",
-          subject_id, super_prop, obj_id ] ).empty? )
-        errors.add :subject, 'relationship (or equivalent) already exists.'
-        return false
+          # is there an existing connection with a predicate that is a
+          # sub-property or super-property of the current predicate?
+      # check for duplicate connection and all super-properties
+      TrippleNavigation.relation_and_all_superproperties(
+          predicate_id) do |super_prop|
+        unless (Connection.all( :conditions => [
+            "subject_id = ? AND predicate_id = ? AND obj_id = ?",
+            subject_id, super_prop, obj_id ] ).empty? )
+          errors.add :subject, 'relationship (or equivalent) already exists.'
+          return false
+        end
       end
-    end
 
-    # check for sub-properties
-    TrippleNavigation.relation_and_all_subproperties(
-        predicate_id) do |sub_prop|
-      unless (Connection.all( :conditions => [
-          "subject_id = ? AND predicate_id = ? AND obj_id = ?",
-          subject_id, sub_prop, obj_id ] ).empty? )
-        errors.add :subject, 'equivalent relationship already exists.'
-        return false
+      # check for sub-properties
+      TrippleNavigation.relation_and_all_subproperties(
+          predicate_id) do |sub_prop|
+        unless (Connection.all( :conditions => [
+            "subject_id = ? AND predicate_id = ? AND obj_id = ?",
+            subject_id, sub_prop, obj_id ] ).empty? )
+          errors.add :subject, 'equivalent relationship already exists.'
+          return false
+        end
       end
-    end
 
 
-        # is there an existing implied opposing connection?
-    # find all connections back-connecting our subject and object, determine
-    # if any of their predicates has an (inherited)
-    # inverse_relationship to current predicate
-    if connections = Connection.all( :conditions => [
-        "subject_id = ? AND obj_id = ?", obj_id, subject_id ] )
+          # is there an existing implied opposing connection?
+      # find all connections back-connecting our subject and object, determine
+      # if any of their predicates has an (inherited)
+      # inverse_relationship to current predicate
+      if connections = Connection.all( :conditions => [
+          "subject_id = ? AND obj_id = ?", obj_id, subject_id ] )
 
-      inverse_id = Item.find_by_name("inverse_relationship").id
+        inverse_id = Item.find_by_name("inverse_relationship").id
 
-      connections.each do |e|
-        TrippleNavigation.relation_and_all_superproperties(
-            predicate_id) do |proposed_rel|
+        connections.each do |e|
           TrippleNavigation.relation_and_all_superproperties(
-              e.predicate_id) do |existing_rel|
-            if Connection.all( :conditions => [
-              "subject_id = ? AND predicate_id = ? AND obj_id = ?",
-                proposed_rel, inverse_id, existing_rel ] ).length > 0
-              errors.add :subject, 'already has this relationship implied.'
-              return false
+              predicate_id) do |proposed_rel|
+            TrippleNavigation.relation_and_all_superproperties(
+                e.predicate_id) do |existing_rel|
+              if Connection.all( :conditions => [
+                "subject_id = ? AND predicate_id = ? AND obj_id = ?",
+                  proposed_rel, inverse_id, existing_rel ] ).length > 0
+                errors.add :subject, 'already has this relationship implied.'
+                return false
+              end
             end
           end
         end
       end
-    end
 
 
-    #used in many subsequent tests
-    spo_id  = Item.find_by_name("sub_property_of").id
+      #used in many subsequent tests
+      spo_id  = Item.find_by_name("sub_property_of").id
 
 
-        # would this create an "individual parent_of category" relationship?
-    subItem = Item.find(subject_id)
-    objItem = Item.find(obj_id)
-    # check for "individual parent_of category"
-    if subItem.sti_type == ItemHelper::ITEM_INDIVIDUAL_CLASS_NAME  &&
-       objItem.sti_type == ItemHelper::ITEM_CATEGORY_CLASS_NAME
-      if TrippleNavigation.check_properties(
-          :does => predicate_id,
-          :inherit_from => Item.find_by_name("parent_of").id,
-          :via => spo_id)
-        errors.add :predicate,
-                   'an individual cannot be the parent of a category.'
-        return false
+          # would this create an "individual parent_of category" relationship?
+      subItem = Item.find(subject_id)
+      objItem = Item.find(obj_id)
+      # check for "individual parent_of category"
+      if subItem.sti_type == ItemHelper::ITEM_INDIVIDUAL_CLASS_NAME  &&
+         objItem.sti_type == ItemHelper::ITEM_CATEGORY_CLASS_NAME
+        if TrippleNavigation.check_properties(
+            :does => predicate_id,
+            :inherit_from => Item.find_by_name("parent_of").id,
+            :via => spo_id)
+          errors.add :predicate,
+                     'an individual cannot be the parent of a category.'
+          return false
+        end
       end
-    end
 
-    # check for "category child_of individual"
-    if subItem.sti_type == ItemHelper::ITEM_CATEGORY_CLASS_NAME  &&
-       objItem.sti_type == ItemHelper::ITEM_INDIVIDUAL_CLASS_NAME
-      if TrippleNavigation.check_properties(
-          :does => predicate_id,
-          :inherit_from => Item.find_by_name("child_of").id,
-          :via => spo_id)
-        errors.add :predicate,
-                   'a category cannot be the child of an individual.'
-        return false
+      # check for "category child_of individual"
+      if subItem.sti_type == ItemHelper::ITEM_CATEGORY_CLASS_NAME  &&
+         objItem.sti_type == ItemHelper::ITEM_INDIVIDUAL_CLASS_NAME
+        if TrippleNavigation.check_properties(
+            :does => predicate_id,
+            :inherit_from => Item.find_by_name("child_of").id,
+            :via => spo_id)
+          errors.add :predicate,
+                     'a category cannot be the child of an individual.'
+          return false
+        end
       end
-    end
 
 
-        # would this create a loop (including connection-to-self) of
-        # hierarchical or ordered relationships?
-    # if this is the kind of property we have to worry about?
-    [
-      Item.find_by_name("parent_of").id,
-      Item.find_by_name("child_of").id,
-      Item.find_by_name("sub_property_of").id,
-      Item.find_by_name("predecessor_of").id,
-      Item.find_by_name("successor_of").id
-    ].each do |prop_id|
-      if TrippleNavigation.check_properties(
-          :does => predicate_id, :inherit_from => prop_id, :via => spo_id)
+          # would this create a loop (including connection-to-self) of
+          # hierarchical or ordered relationships?
+      # if this is the kind of property we have to worry about?
+      [
+        Item.find_by_name("parent_of").id,
+        Item.find_by_name("child_of").id,
+        Item.find_by_name("sub_property_of").id,
+        Item.find_by_name("predecessor_of").id,
+        Item.find_by_name("successor_of").id
+      ].each do |prop_id|
         if TrippleNavigation.check_properties(
-            :does => obj_id, :link_to => subject_id,
-            :through_children_of => prop_id )
-          errors.add :subject, 'this relationship would create a loop.'
-          return false
+            :does => predicate_id, :inherit_from => prop_id, :via => spo_id)
+          if TrippleNavigation.check_properties(
+              :does => obj_id, :link_to => subject_id,
+              :through_children_of => prop_id )
+            errors.add :subject, 'this relationship would create a loop.'
+            return false
+          end
         end
       end
-    end
 
-        # is this a "bad" connection-to-self?
-    if subject_id == obj_id
-      [ "inverse_relationship", "hierarchical_relationship",
-        "ordered_relationship" ].each do |relation_name|
-        if TrippleNavigation.check_properties(
-            :does         => predicate_id,
-            :inherit_from => Item.find_by_name(relation_name).id,
-            :via          => spo_id  )
-          errors.add :subject,
-'cannot create an ordered/hierarchical relationship from an item to itself'
+          # is this a "bad" connection-to-self?
+      if subject_id == obj_id
+        [ "inverse_relationship", "hierarchical_relationship",
+          "ordered_relationship" ].each do |relation_name|
+          if TrippleNavigation.check_properties(
+              :does         => predicate_id,
+              :inherit_from => Item.find_by_name(relation_name).id,
+              :via          => spo_id  )
+            errors.add :subject,
+  'cannot create an ordered/hierarchical relationship from an item to itself'
+            return false
+          end
+        end
+      end
+
+
+    elsif kind_of_obj == OBJECT_KIND_SCALAR
+      [ [subject_id, :subject], [predicate_id, :predicate],
+        [scalar_obj, :scalar_obj] ].each do |tocheck|
+        field, symbol = *tocheck
+        if field.nil?
+          errors.add symbol, "can't be blank."
           return false
         end
       end
+
+
+    else
+      errors.add :kind_of_obj, "isn't valid (#{kind_of_obj})"
+      return false
     end
 
 

data/app/models/item.rb

@@ -43,8 +43,10 @@ class Item < ActiveRecord::Base
   DATA_IS_UNALTERABLE = 1
 
 
+  # support sub-classes for Individual, Category, Property, Qualified
   self.inheritance_column = "sti_type"
 
+
     # name
   validates_presence_of   :name, :message => "Item's name cannot be blank."
   validates_length_of     :name, :maximum => 80,
@@ -83,4 +85,98 @@ class Item < ActiveRecord::Base
     # column default specified in the database schema
     self[:flags] or 0
   end
+
+
+  @class_item = nil
+  @class_has_been_set = false
+  after_save :after_save_callback # update class-defining connection after
+                                  # main object saves; rollback still works
+  def class_item
+    if @class_has_been_set
+      @class_item                 # ignore db content if this has been set
+                                  # explicitly.  This will eventually be
+                                  # saved or discarded
+    else
+      iio_item = Item.find_by_name('is_instance_of')
+      class_assignment = Connection.first( :conditions => [
+        "subject_id = ? AND predicate_id = ?", id, iio_item.id ] )
+      if class_assignment.nil? or
+         class_assignment.kind_of_obj != Connection::OBJECT_KIND_ITEM
+        return nil
+      else
+        return class_assignment.obj
+      end
+    end
+  end
+  def class_item_id
+    item = class_item
+    return item.nil? ? nil : item.id
+  end
+  def class_item=( new_class_item )
+    @class_item = new_class_item
+    @class_has_been_set = true
+  end
+  def class_item_id=( new_class_id )
+    @class_item = new_class_id.nil? ? nil : Item.find_by_id( new_class_id )
+    @class_has_been_set = true
+  end
+
+  def is_class?
+    return( !( Connection.first( :conditions => [
+                 "predicate_id = ? AND obj_id = ?",
+                  Item.find_by_name('is_instance_of').id,
+                  id ] ).nil? )                              or
+            !( Connection.first( :conditions => [
+                 "predicate_id = ? AND (subject_id = ? OR obj_id = ?)",
+                  Item.find_by_name('sub_class_of').id,
+                  id, id ] ).nil? )
+          )
+  end
+
+  def superclass_of
+    defining_connection = Connection.first( :conditions => [
+      "subject_id = ? AND predicate_id = ?",
+      id, Item.find_by_name('sub_class_of').id ] )
+    return defining_connection.obj unless defining_connection.nil?
+    return nil
+  end
+
+  def instance_of
+    connection = Connection.first( :conditions => [
+      "subject_id = ? AND predicate_id = ?",
+      id, Item.find_by_name('is_instance_of').id ] )
+    return nil if connection == nil
+    return connection.obj
+  end
+
+private
+
+  def after_save_callback
+    if @class_has_been_set
+      iio_item = Item.find_by_name('is_instance_of')
+      class_assignment = Connection.first( :conditions => [
+        "subject_id = ? AND predicate_id = ?", id, iio_item.id ] )
+      if class_assignment && @class_item == class_assignment.obj
+        return true # class-defining connection already in db -> done
+      end
+
+      if class_assignment             # if we're here, current db is different
+        class_assignment.destroy      # so get rid of it
+      end
+
+      begin
+        class_assignment = Connection.new( {
+          :subject_id => id,
+          :predicate_id => iio_item.id,
+          :obj_id => @class_item.id,
+          :kind_of_obj => Connection::OBJECT_KIND_ITEM } )
+        @class_has_been_set = false
+        return class_assignment.save
+      rescue
+        return false
+      end
+    end
+
+    return true
+  end
 end