wontomedia 0.1.1 → 0.2.0

data/Rakefile

@@ -107,6 +107,9 @@ namespace :test do
   end
   Rake::Task['test:units'].comment =
     "Run the model tests in test/unit/app/models"
+
+  # but it's still a stupid naming convention:
+  task :models => :units
 end
 
 
@@ -172,11 +175,12 @@ namespace :test do
     ruby File.join( "policy", "ckFilesUtils", "ckCustomizationFilesPresent.rb" )
   end
 
-  # alias
-  task :integrations => :integration
+  # aliases
+  task :integrations => :integration  # multiple tests -> plural task name
+  task :controllers => :functionals   # Rails naming convention #fail
 
   desc "Execute all the tests for Ruby code."
-  task :ruby_tests => [ "test:devs", "test:dbmigrations", "test:functionals",
+  task :ruby_tests => [ "test:devs", "test:db", "test:controllers",
     "test:integrations", "build", "cucumber:static_ok"]
 end # namespace :test
 
@@ -184,10 +188,10 @@ end # namespace :test
 
 # replace Rail's basic test task so that we get a reasonable execution order
 Rake::Task[:test].clear!
-desc 'Run all unit, functional, integration, and policy checks'
+desc 'Run all unit, integration, and policy checks'
 task :tests => [ "test:policies", "asset:packager:build_all",
                     # above two have side effects necessary for setup
-                 "test:devs", "test:dbmigrations", "test:functionals",
+                 "test:devs", "test:db", "test:controllers",
                  "test:javascripts", "test:integrations", "build",
                  "cucumber:ok" ]
 # alias

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
-:minor: 1
-:patch: 1
+:minor: 2
+:patch: 0

data/app/controllers/admin_controller.rb

@@ -108,31 +108,54 @@ class AdminController < ApplicationController
     flash[:error] =""
 
     params[:connection_upload][:connectionfile].readlines.each do |n3line|
-      # this is a really, *really* bad N3 parser. Almost certainly won't
-      # handly any but the most trivial input (like what we export :-)
-      if n3line =~ /<#([^>]+)>[^<]+<#([^>]+)>[^<]+<#([^>]+)>[^.]+\./
+      err_str = nil;
+
+          # this is a really, *really* bad N3 parser. Almost certainly won't
+          # handly any but the most trivial input (like what we export :-)
+      # handle connections whose objects are scalar constants
+      if n3line =~ /<#([^>]+)>[^<]+<#([^>]+)>[^"]+"([^"]+)"[^.]+\./
+        e = Connection.new(
+          :subject     => Item.find_by_name($1),
+          :predicate   => Item.find_by_name($2),
+          :scalar_obj  => $3,
+          :kind_of_obj => Connection::OBJECT_KIND_SCALAR,
+          :flags       => 0
+                     )
+        if e.nil?
+          err_str = "Couldn't create connection for #{$1} #{$2} '#{$3}'.\n"
+        else
+          if e.save
+            count += 1
+          else
+            err_str = "Couldn't save connection for #{$1} #{$2} '#{$3}'.\n"
+          end
+        end
+      # handle connections whose objects are Items
+      elsif n3line =~ /<#([^>]+)>[^<]+<#([^>]+)>[^<]+<#([^>]+)>[^.]+\./
         e = Connection.new(
-          :subject   => Item.find_by_name($1),
-          :predicate => Item.find_by_name($2),
-          :obj       => Item.find_by_name($3),
-          :flags     => 0
+          :subject     => Item.find_by_name($1),
+          :predicate   => Item.find_by_name($2),
+          :obj         => Item.find_by_name($3),
+          :kind_of_obj => Connection::OBJECT_KIND_ITEM,
+          :flags       => 0
                      )
         if e.nil?
           err_str = "Couldn't create connection for #{$1} #{$2} #{$3}.\n"
-          logger.error(err_str)
-          flash[:error] << err_str
         else
           if e.save
             count += 1
           else
             err_str = "Couldn't save connection for #{$1} #{$2} #{$3}.\n"
-            logger.error(err_str)
-            flash[:error] << err_str
           end
         end
       else
         unparsed += 1
       end
+
+      if (err_str)
+        logger.error(err_str)
+        flash[:error] << err_str
+      end
     end
 
     flash[:notice] = "Created #{count} new connections."

data/app/controllers/connections_controller.rb

@@ -63,7 +63,11 @@ class ConnectionsController < ApplicationController
 
     if @connection.save
       flash[:notice] = 'Connection was successfully created.'
-      redirect_to(@connection)
+      if params[:goto]
+        redirect_to('/' + params[:goto])
+      else
+        redirect_to(@connection)
+      end
     else
       populate_for_new_update
       @this_is_non_information_page = true
@@ -84,7 +88,9 @@ class ConnectionsController < ApplicationController
     # populate these here because I didn't want view causing db queries
     @subject = @connection.subject
     @predicate = @connection.predicate
-    @obj = @connection.obj
+    if @connection.kind_of_obj == Connection::OBJECT_KIND_ITEM
+      @obj = @connection.obj
+    end
     @connection_desc = @connection.connection_desc
   end
 

data/app/controllers/items_controller.rb

@@ -26,6 +26,7 @@
 # starts.  It can be deleted, this file reloaded, and then ItemHelper
 # references will work normally.  Go figure. -- gei 2010/2/24
 require Rails.root.join( 'lib', 'helpers', 'item_helper')
+require Rails.root.join( 'lib', 'helpers', 'connection_helper')
 require 'yaml'
 
 # See also the matching model Item
@@ -33,6 +34,7 @@ class ItemsController < ApplicationController
   # GET /
   def home
     @nouns = ItemHelper.nouns
+    @class_list = contributor_class_items
     render :layout => "home"
   end
 
@@ -67,8 +69,9 @@ class ItemsController < ApplicationController
 
   # GET /items/new
   def new
-    @this_is_non_information_page = true
     @item = Item.new
+    setup_for_new
+    setup_for_form
   end
 
   # GET /items/new-pop
@@ -83,27 +86,31 @@ class ItemsController < ApplicationController
   # +views+; see their source for additional details.
   def newpop
     @item = Item.new
-    @type = params[:type]
+    @popup_type = params[:popup_type]
+    setup_for_new
+    setup_for_form
     render :layout => "popup"
   end
 
   # POST /items
   def create
     type_string = params[:item][:sti_type]
+    if type_string.nil?
+      recover_from_create_failure(
+        'Could not create. Item must have "Type" filled in.' )
+    end
     params[:item].delete :sti_type # don't mass-assign protected blah, blah
+
     @item = ItemHelper.new_typed_item(type_string, params[:item])
     @popup_flag = true if params[:popup_flag]
 
     if @item.nil?
-      flash.now[:error] =
-'Could not create. Item must have a type of either "Category" or "Individual".'
-      @item = Item.new(params[:item]) # keep info already entered
-      @item.sti_type = type_string
-      @this_is_non_information_page = true
+      recover_from_create_failure 'Could not create.', type_string
       render :action => (@popup_flag ? "newpop" : "new" )
     elsif @item.name =~ /[:.]/ || !@item.save
-      @item.errors.add :name, "cannot contain a period (.) or a colon (:)."
-      @this_is_non_information_page = true
+      recover_from_create_failure '' do
+        @item.errors.add :name, "cannot contain a period (.) or a colon (:)."
+      end
       render :action => (@popup_flag ? "newpop" : "new" )
     else
       if @popup_flag
@@ -178,7 +185,7 @@ class ItemsController < ApplicationController
   #     view can expect that all of the *predicate_id* values in the
   #     Connections in this array will be different.
   #   - The next array in @connection_list contains all of the
-  #     Connection objects whose *object_id* values are equal to
+  #     Connection objects whose *obj_id* values are equal to
   #     *@item*.  Like all the other, this array won't be placed into
   #     @connection_list if it would be empty.  Also, in the event of
   #     that a Connection references *@item* as both its subject and
@@ -243,20 +250,64 @@ class ItemsController < ApplicationController
         new_connection = Connection.new(
           :subject_id => connection.obj_id,
           :predicate_id => inverse_property_id,
-          :obj_id => connection.subject_id
+          :obj_id => connection.subject_id,
+          :kind_of_obj => Connection::OBJECT_KIND_ITEM
         )
         used_as_subj << new_connection
         @inverses_map[new_connection] = connection
       end
     end
 
+    # add blank-object connections to serve as basis for connection "quick add"
+    @intances_of_type_item_classes = {}
+    if class_item = @item.instance_of
+      find_applied_properties( class_item ).each do |property_item|
+        if connection = Connection.first( :conditions =>
+            [ "subject_id = ? AND predicate_id = ?",
+            property_item.id, Item.find_by_name('has_scalar_object').id ])
+          new_kind = Connection::OBJECT_KIND_SCALAR
+          new_type_item = connection.obj
+
+        elsif Connection.first( :conditions =>
+            [ "subject_id = ? AND predicate_id = ?",
+            property_item.id, Item.find_by_name('has_item_object').id ])
+          new_kind = Connection::OBJECT_KIND_ITEM
+          new_type_item = connection = Connection.first( :conditions =>
+            [ "subject_id = ? AND predicate_id = ?",
+            property_item.id, Item.find_by_name('property_object_is').id ])
+
+          unless connection.nil?
+            new_type_item = connection.obj
+
+            unless @intances_of_type_item_classes[new_type_item]
+              @intances_of_type_item_classes[new_type_item] =
+                Connection.all( :conditions => [
+                  "predicate_id = ? AND obj_id = ?",
+                  Item.find_by_name('is_instance_of').id,
+                  new_type_item.id ]).
+                map do |connection|
+                  connection.subject
+                end
+            end
+          end
+        else
+          new_type_item = new_kind = nil
+        end
+
+        used_as_subj << Connection.new({ :subject_id => @item.id,
+          :predicate_id => property_item.id, :kind_of_obj => new_kind,
+          :type_item => new_type_item })
+      end
+    end
+
+
     # find all of the Items referenced by the connections the view will list
     @item_hash = {}
     [ used_as_subj, used_as_pred, used_as_obj ].each do |connection_array|
       connection_array.each do |connection|
         [ connection.subject, connection.predicate, connection.obj ].
           each do |item|
-          unless @item_hash.has_key? item.id
+          unless item.nil? or @item_hash.has_key? item.id
             @item_hash[item.id] = item
           end
         end
@@ -271,67 +322,28 @@ class ItemsController < ApplicationController
     value_id = Item.find_by_name("value_relationship").id
     spo_id   = Item.find_by_name("sub_property_of").id
 
-    # first group, all connections *from* this item with value-type predicates
-    connections = []
-    used_as_subj.each do |connection|
-      if TrippleNavigation.check_properties(
-          :does => connection.predicate_id, :via => spo_id,
-          :inherit_from => value_id )
-        connections << connection
-      end
-    end
-    used_as_subj -= connections # if done incrementally, breaks iterator
+      # first group, all connections *from* this item
+    # start with explicit connections
+    connections = used_as_subj
+    # sort and add as a group to array-of-arrays for view
     unless connections.empty?
-      @connection_list << connections
-    end
-
-
-    # next N groups: 1 group for connections *from* this item with >1 of
-    #   same pred.
-    #figure out which predicates occur >1, how many they occur, sort & group
-    pred_counts = {}
-    connection_using_pred = {}
-    used_as_subj.each do |connection|
-      if pred_counts[connection.predicate_id].nil?
-        pred_counts[connection.predicate_id] = 1
-      else
-        pred_counts[connection.predicate_id] += 1
-      end
-      connection_using_pred[connection.predicate_id] = connection
-    end
-    subj_connections = pred_counts.keys
-    subj_connections.sort! { |a,b| pred_counts[b] <=> pred_counts[a] }
-    array_of_singles = []
-    subj_connections.each do |predicate_id|
-      if pred_counts[predicate_id] > 1
-        connections = []
-        used_as_subj.each do |connection|
-            # lazy, more hashes would eliminate rescan
-          if connection.predicate_id == predicate_id
-            connections << connection
-          end
-        end
-        unless connections.empty?
-          @connection_list << connections
+      count_hash = {}
+      connections.each do |con|
+        if count_hash[con.predicate_id].nil?
+          count_hash[con.predicate_id] = 0
         end
-      else
-        array_of_singles << connection_using_pred[predicate_id]
+        count_hash[con.predicate_id] += 1
       end
-    end
 
-    # last group of connections *from* current item:
-    #   all connections w/ used-once pred's
-    unless array_of_singles.empty?
-      @connection_list << array_of_singles
+      @connection_list << ( connections.sort do |a,b|
+          ConnectionHelper.compare( a, b, count_hash )
+        end )
     end
 
 
+      # next groups
     used_as_obj.sort! do |a,b|
-      if a.predicate_id == b.predicate_id
-        a.obj_id <=> b.obj_id
-      else
-        a.predicate_id <=> b.predicate_id
-      end
+      a.predicate_id <=> b.predicate_id
     end
     unless used_as_obj.empty?
       @connection_list << used_as_obj
@@ -357,7 +369,7 @@ class ItemsController < ApplicationController
       return
     end
 
-    @this_is_non_information_page = true
+    setup_for_form
   end
 
   # PUT /items/1
@@ -384,7 +396,7 @@ class ItemsController < ApplicationController
           params[:item][:name] =~ /[:.]/                     )  ||
         !@item.update_attributes(params[:item])
       @item.errors.add :name, "cannot contain a period (.) or a colon (:)."
-      @this_is_non_information_page = true
+      setup_for_form
       render :action => "edit"
     else
       flash[:notice] = 'Item was successfully updated.'
@@ -404,7 +416,19 @@ class ItemsController < ApplicationController
     if (@item.flags & Item::DATA_IS_UNALTERABLE) != 0
       flash[:error] = 'This Item cannot be altered.'
       redirect_to item_by_name_path(@item.name)
-    elsif !(Connection.all( :conditions =>
+      return
+    end
+
+    class_item = @item.class_item
+    if class_item
+      Connection.first( :conditions =>
+        [ "subject_id = ? AND predicate_id = ? AND obj_id = ?",
+          @item.id,
+          Item.find_by_name('is_instance_of'),
+          class_item.id ] ).destroy
+    end
+
+    if !(Connection.all( :conditions =>
         [ "subject_id = ? OR predicate_id = ? OR obj_id = ?",
           @item.id, @item.id, @item.id ]).empty?)
       flash[:error] = 'This Item is in use by 1+ Connections. ' +
@@ -455,4 +479,125 @@ class ItemsController < ApplicationController
 
     render :text => ("<id>" + id.to_s + "</id>\n")
   end
+
+private
+
+  def all_class_items
+    # Get the special property items "sub_class_of" and
+    # "is_instance_of"; find all of the connections that use them as
+    # predicates; find all of the items that are those connections'
+    # subjects ("s_c_o") or objects (both).  At some point we might
+    # want to allow sub-properties of the two special ones to also
+    # imply that items represent classes.
+
+    class_list = []
+    [ 'sub_class_of', 'is_instance_of' ].each do |property_name|
+      Connection.all( :conditions => [ "predicate_id = ?",
+          Item.find_by_name(property_name).id ]).each do |connection|
+
+        # look at objects of both special properties (assuming con. valid)
+        if connection.kind_of_obj == Connection::OBJECT_KIND_ITEM
+          class_list << connection.obj
+        end
+
+        #and at subjects of just
+        if property_name == 'sub_class_of'
+          class_list << connection.subject
+        end
+      end
+    end
+
+    class_list.uniq
+  end
+
+  def contributor_class_items
+    list = all_class_items.select do |class_item|
+      (class_item.flags & Item::DATA_IS_UNALTERABLE) == 0
+    end
+
+    iio_item_id = Item.find_by_name('is_instance_of').id
+    counts = {}
+    list.each do |class_item|
+      counts[class_item] = Connection.all( :conditions => [
+        "predicate_id = ? AND obj_id = ?", iio_item_id, class_item.id ] ).length
+    end
+
+    list.sort{|a,b| counts[b] <=> counts[a]}
+  end
+
+  def map_of_item_types_for_class_items( class_items )
+    citi_item_id = Item.find_by_name('class_item_type_is').id
+    class_to_item_map = {}
+    class_items.each do |class_item|
+      connection = Connection.first( :conditions => [
+        "subject_id = ? AND predicate_id = ?",
+        class_item.id, citi_item_id ] )
+
+      unless connection.nil?
+        class_to_item_map[class_item] =
+          ItemHelper.sti_type_for_ItemType( connection.obj.name )
+      end
+    end
+
+    class_to_item_map
+  end
+
+  def setup_for_form
+    @class_list = all_class_items
+    @class_to_item_map = map_of_item_types_for_class_items @class_list
+    @this_is_non_information_page = true
+  end
+
+  def setup_for_new
+    if params[:class_item]
+      id = params[:class_item]
+      class_item = Item.find_by_id(id)
+      if class_item
+        @item.class_item_id = id
+
+        if params[:sti_type].nil?   # probably no class_item_type_is to find
+          citi_item_id = Item.find_by_name('class_item_type_is').id
+          connection = Connection.first( :conditions => [
+            "subject_id = ? AND predicate_id = ?",
+            class_item.id, citi_item_id ] )
+          unless connection.nil?
+            @item.sti_type =
+              ItemHelper.sti_type_for_ItemType( connection.obj.name )
+          end
+        end
+      end
+    end
+
+    if params[:sti_type]
+      @item.sti_type = params[:sti_type]
+    end
+  end
+
+  def recover_from_create_failure( message_string, type_string = nil )
+    flash.now[:error] = message_string
+    @item = Item.new(params[:item]) # keep info already entered
+    @item.sti_type = type_string unless type_string.nil?
+    yield if block_given?
+    setup_for_form
+  end
+
+  def find_applied_properties( class_item )
+    recursive_find_applied_properties(
+      class_item, Item.find_by_name('applies_to_class') ).flatten
+  end
+  def recursive_find_applied_properties( class_item, joining_prop )
+    con_array = Connection.all( :conditions => [
+      "predicate_id = ? AND obj_id = ?",
+      joining_prop.id, class_item.id ] )
+    return [] if con_array.nil?
+    con_array.map do |connection|
+      item = connection.subject
+      if item.sti_type == ItemHelper::ITEM_PROPERTY_CLASS_NAME
+        item
+      else # prop is_instance_of prop-class; prop-class applied_to_class 'us'
+        recursive_find_applied_properties( item,
+          Item.find_by_name('is_instance_of') )
+      end
+    end
+  end
 end