use one model and table for reference and version relations. #296

app/controllers/api/v6/references_controller.rb

@@ -22,7 +22,7 @@ class Api::V6::ReferencesController < Api::BaseController
   end
 
   def index
-    collection = ReferenceRelation.includes(:work, :related_work)
+    collection = Relation.includes(:work, :related_work)
     collection = @work.reference_relations if @work
 
     if params[:work_ids]

app/controllers/api/v6/versions_controller.rb

@@ -20,7 +20,7 @@ class Api::V6::VersionsController < Api::BaseController
   end
 
   def index
-    collection = VersionRelation.includes(:work, :related_work)
+    collection = Relation.includes(:work, :related_work)
     collection = @work.version_relations if @work
 
     if params[:work_ids]

app/decorators/version_relation_decorator.rb → app/decorators/relation_decorator.rb

@@ -1,4 +1,4 @@
-class VersionRelationDecorator < Draper::Decorator
+class RelationDecorator < Draper::Decorator
   delegate_all
   decorates_association :work
   decorates_association :related_work

app/decorators/relation_type_decorator.rb

@@ -4,4 +4,8 @@ class RelationTypeDecorator < Draper::Decorator
   def id
     to_param
   end
+
+  def subgroup
+    level > 0 ? "reference" : "version"
+  end
 end

app/models/reference_relation.rb → app/models/relation.rb

@@ -1,4 +1,4 @@
-class ReferenceRelation < ActiveRecord::Base
+class Relation < ActiveRecord::Base
   belongs_to :work
   belongs_to :related_work, class_name: "Work"
   belongs_to :relation_type

app/models/relation_type.rb

@@ -1,12 +1,11 @@
 class RelationType < ActiveRecord::Base
-  has_many :reference_relations, dependent: :nullify
-  has_many :version_relations, dependent: :nullify
+  has_many :relations, dependent: :nullify
 
   validates :name, :presence => true, :uniqueness => true
-  validates :title, :presence => true, :uniqueness => true
+  validates :title, :presence => true
 
-  scope :referencable, -> { where(describes_reference: true) }
-  scope :versionable, -> { where(describes_reference: false) }
+  scope :referencable, -> { where("level > 0") }
+  scope :versionable, -> { where("level = 0") }
 
   def to_param
     name

app/models/work.rb

@@ -18,9 +18,10 @@ class Work < ActiveRecord::Base
   has_many :sources, :through => :retrieval_statuses
   has_many :alerts, :dependent => :destroy
   has_many :api_responses
-  has_many :reference_relations, :dependent => :destroy
+  has_many :relations
+  has_many :reference_relations, -> { where "level > 0" }, class_name: 'Relation', :dependent => :destroy
+  has_many :version_relations, -> { where "level = 0" }, class_name: 'Relation', :dependent => :destroy
   has_many :references, :through => :reference_relations
-  has_many :version_relations, :dependent => :destroy
   has_many :versions, :through => :version_relations
   has_many :similar_works, :through => :reference_relations
 
@@ -110,20 +111,18 @@ def update_relations(data)
         inverse_relation_name = "_#{relation_type.name}"
       end
       inverse_relation_type = RelationType.where(name: inverse_relation_name).first
-      inverse_relation_type_id = inverse_relation_type ? inverse_relation_type.id : nil
-      level = (relation_type.name == "is_identical_to") ? 0 : 1
-
-      ReferenceRelation.where(work_id: id,
-                              related_work_id: related_work.id,
-                              source_id: source.id).first_or_create(
-                                relation_type_id: relation_type.id,
-                                level: level)
-      if level > 0
-        ReferenceRelation.where(work_id: related_work.id,
-                                related_work_id: id,
-                                source_id: source.id).first_or_create(
-                                  relation_type_id: inverse_relation_type_id)
-      end
+      next unless inverse_relation_type.present?
+
+      Relation.where(work_id: id,
+                     related_work_id: related_work.id,
+                     source_id: source.id).first_or_create(
+                       relation_type_id: relation_type.id,
+                       level: relation_type.level)
+      Relation.where(work_id: related_work.id,
+                     related_work_id: id,
+                     source_id: source.id).first_or_create(
+                       relation_type_id: inverse_relation_type.id,
+                       level: inverse_relation_type.level)
     end
   end
 

app/views/api/v6/relation_types/index.json.jbuilder

@@ -7,6 +7,6 @@ end
 
 json.relation_types @relation_types do |relation_type|
   json.cache! ['v6', relation_type], skip_digest: true do
-    json.(relation_type, :id, :title, :inverse_title, :inverse, :timestamp)
+    json.(relation_type, :id, :title, :inverse_title, :subgroup, :timestamp)
   end
 end

app/views/api/v6/relation_types/show.json.jbuilder

@@ -6,6 +6,6 @@ end
 
 json.relation_type do
   json.cache! ['v6', @relation_type], skip_digest: true do
-    json.(@relation_type, :id, :title, :inverse_title, :inverse, :timestamp)
+    json.(@relation_type, :id, :title, :inverse_title, :subgroup, :timestamp)
   end
 end

app/views/sources/show.html.erb

@@ -22,8 +22,8 @@
         <%= render :partial => 'summary_show', :locals => { :name => @source.name } %>
       </div>
     </div>
-    <div class="tab-pane" id="most_cited">
-      <%= render :partial => 'most_cited' %>
+    <div class="tab-pane" id="most_referenced">
+      <%= render :partial => 'most_referenced' %>
     </div>
     <div class="tab-pane" id="events">
       <%= render :partial => 'events_show' %>

db/data_migrate/20150403121917_add_relation_type_title.rb

@@ -11,7 +11,7 @@ def up
     is_metadata_for = RelationType.where(name: 'is_metadata_for').first_or_create(
       title: 'Is metadata for', inverse_title: 'Has metadata')
     is_new_version_of = RelationType.where(name: 'is_new_version_of').first_or_create(
-      title: 'Is new version of', inverse_title: 'Is previous version of', describes_reference: false)
+      title: 'Is new version of', inverse_title: 'Is previous version of', level: 0)
     is_part_of = RelationType.where(name: 'is_part_of').first_or_create(
       title: 'Is part of', inverse_title: 'Has part')
     references = RelationType.where(name: 'references').first_or_create(
@@ -21,9 +21,9 @@ def up
     compiles = RelationType.where(name: 'compiles').first_or_create(
       title: 'Compiles', inverse_title: 'Is compiled by')
     is_variant_form_of = RelationType.where(name: 'is_variant_form_of').first_or_create(
-      title: 'Is variant form of', inverse_title: 'Is original form of', describes_reference: false)
+      title: 'Is variant form of', inverse_title: 'Is original form of', level: 0)
     is_identical_to = RelationType.where(name: 'is_identical_to').first_or_create(
-      title: 'Is identical to', inverse_title: 'Is identical to', describes_reference: false)
+      title: 'Is identical to', inverse_title: 'Is identical to', level: 0)
     reviews = RelationType.where(name: 'reviews').first_or_create(
       title: 'Reviews', inverse_title: 'Is reviewed by')
     is_derived_from = RelationType.where(name: 'is_derived_from').first_or_create(
@@ -34,43 +34,27 @@ def up
       title: 'Is supplemented by', inverse_title: 'Supplements', inverse: true)
     _continues = RelationType.where(name: '_continues').first_or_create(
       title: 'Is continued by', inverse_title: 'Continues', inverse: true)
-    is_metadata_for = RelationType.where(name: '_is_metadata_for').first_or_create(
+    _is_metadata_for = RelationType.where(name: '_is_metadata_for').first_or_create(
       title: 'Has metadata', inverse_title: 'Is metadata of', inverse: true)
-    is_new_version_of = RelationType.where(name: '_is_new_version_of').first_or_create(
-      title: 'Is previous version of', inverse_title: 'Is new version of', inverse: true, describes_reference: false)
-    is_part_of = RelationType.where(name: '_is_part_of').first_or_create(
+    _is_new_version_of = RelationType.where(name: '_is_new_version_of').first_or_create(
+      title: 'Is previous version of', inverse_title: 'Is new version of', inverse: true, level: 0)
+    _is_part_of = RelationType.where(name: '_is_part_of').first_or_create(
       title: 'Has part', inverse_title: 'Is part of', inverse: true)
-    references = RelationType.where(name: '_references').first_or_create(
+    _references = RelationType.where(name: '_references').first_or_create(
       title: 'Is referenced by', inverse_title: 'References', inverse: true)
-    documents = RelationType.where(name: '_documents').first_or_create(
+    _documents = RelationType.where(name: '_documents').first_or_create(
       title: 'Is documented by', inverse_title: 'Documents', inverse: true)
-    compiles = RelationType.where(name: '_compiles').first_or_create(
+    _compiles = RelationType.where(name: '_compiles').first_or_create(
       title: 'Is compiled by', inverse_title: 'Compiles', inverse: true)
-    is_variant_form_of = RelationType.where(name: '_is_variant_form_of').first_or_create(
-      title: 'Is original form of', inverse_title: 'Is variant form of', inverse: true, describes_reference: false)
-    reviews = RelationType.where(name: '_reviews').first_or_create(
+    _is_variant_form_of = RelationType.where(name: '_is_variant_form_of').first_or_create(
+      title: 'Is original form of', inverse_title: 'Is variant form of', inverse: true, level: 0)
+    _is_identical_to = RelationType.where(name: '_is_identical_to').first_or_create(
+      title: 'Is identical to', inverse_title: 'Is identical to', inverse: true, level: 0)
+    _reviews = RelationType.where(name: '_reviews').first_or_create(
       title: 'Is reviewed by', inverse_title: 'Reviews', inverse: true)
-    is_derived_from = RelationType.where(name: '_is_derived_from').first_or_create(
+    _is_derived_from = RelationType.where(name: '_is_derived_from').first_or_create(
       title: 'Is source of', inverse_title: 'Is derived from', inverse: true)
 
-    # custom relation types needed for lagotto
-    corrects = RelationType.where(name: 'corrects').first_or_create(
-      title: 'Corrects', inverse_title: 'Is corrected by', describes_reference: false)
-    discusses = RelationType.where(name: 'discusses').first_or_create(
-      title: 'Discusses', inverse_title: 'Is discussed by')
-    bookmarks = RelationType.where(name: 'bookmarks').first_or_create(
-      title: 'Bookmarks', inverse_title: 'Is bookmarked by')
-    recommends = RelationType.where(name: 'recommends').first_or_create(
-      title: 'Recommends', inverse_title: 'Is recommended by')
-    corrects = RelationType.where(name: '_corrects').first_or_create(
-      title: 'Is corrected by', inverse_title: 'Corrects', inverse: true, describes_reference: false)
-    discusses = RelationType.where(name: '_discusses').first_or_create(
-      title: 'Is discussed by', inverse_title: 'Discusses', inverse: true)
-    bookmarks = RelationType.where(name: '_bookmarks').first_or_create(
-      title: 'Is bookmarked by', inverse_title: 'Bookmarks', inverse: true)
-    recommends = RelationType.where(name: '_recommends').first_or_create(
-      title: 'Is recommended by', inverse_title: 'Recommends', inverse: true)
-
     computer_program = WorkType.where(name: 'computer_program').first_or_create(
       title: 'Computer Program')
   end

db/migrate/20150425020020_add_versions_table.rb

@@ -1,22 +1,13 @@
 class AddVersionsTable < ActiveRecord::Migration
   def up
-    rename_table :relationships, :reference_relations
-    add_column :relation_types, :describes_reference, :boolean, default: true
-
-    create_table "version_relations", force: :cascade do |t|
-      t.integer  "work_id",          limit: 4,             null: false
-      t.integer  "related_work_id",  limit: 4,             null: false
-      t.integer  "source_id",        limit: 4
-      t.integer  "relation_type_id", limit: 4,             null: false
-      t.datetime "created_at",                             null: false
-      t.datetime "updated_at",                             null: false
-      t.integer  "level",            limit: 4, default: 1
-    end
+    rename_table :relationships, :relations
+    add_column :relation_types, :level, :integer, default: 1
+    remove_column :relation_types, :inverse
   end
 
   def down
-    rename_table :reference_relations, :relationships
-    remove_column :relation_types, :describes_reference
-    drop_table :version_relations
+    rename_table :relations, :relationships
+    remove_column :relation_types, :level
+    add_column :relation_types, :inverse, :boolean, default: false
   end
 end

db/schema.rb

@@ -164,7 +164,16 @@
 
   add_index "publishers", ["member_id"], name: "index_publishers_on_member_id", unique: true, using: :btree
 
-  create_table "reference_relations", force: :cascade do |t|
+  create_table "relation_types", force: :cascade do |t|
+    t.string   "name",          limit: 255,             null: false
+    t.datetime "created_at",                            null: false
+    t.datetime "updated_at",                            null: false
+    t.string   "title",         limit: 255
+    t.string   "inverse_title", limit: 255
+    t.integer  "level",         limit: 4,   default: 1
+  end
+
+  create_table "relations", force: :cascade do |t|
     t.integer  "related_work_id",  limit: 4,             null: false
     t.integer  "work_id",          limit: 4,             null: false
     t.integer  "source_id",        limit: 4
@@ -174,17 +183,7 @@
     t.integer  "level",            limit: 4, default: 1
   end
 
-  add_index "reference_relations", ["work_id", "related_work_id"], name: "index_relationships_on_work_id_related_work_id", using: :btree
-
-  create_table "relation_types", force: :cascade do |t|
-    t.string   "name",                limit: 255,                 null: false
-    t.datetime "created_at",                                      null: false
-    t.datetime "updated_at",                                      null: false
-    t.string   "title",               limit: 255
-    t.string   "inverse_title",       limit: 255
-    t.boolean  "inverse",             limit: 1,   default: false
-    t.boolean  "describes_reference", limit: 1,   default: true
-  end
+  add_index "relations", ["work_id", "related_work_id"], name: "index_relationships_on_work_id_related_work_id", using: :btree
 
   create_table "reports", force: :cascade do |t|
     t.string   "name",        limit: 255
@@ -332,16 +331,6 @@
   add_index "users", ["email"], name: "index_users_on_email", unique: true, using: :btree
   add_index "users", ["reset_password_token"], name: "index_users_on_reset_password_token", unique: true, using: :btree
 
-  create_table "version_relations", force: :cascade do |t|
-    t.integer  "work_id",          limit: 4,             null: false
-    t.integer  "related_work_id",  limit: 4,             null: false
-    t.integer  "source_id",        limit: 4
-    t.integer  "relation_type_id", limit: 4,             null: false
-    t.datetime "created_at",                             null: false
-    t.datetime "updated_at",                             null: false
-    t.integer  "level",            limit: 4, default: 1
-  end
-
   create_table "work_types", force: :cascade do |t|
     t.string   "name",       limit: 255, null: false
     t.datetime "created_at",             null: false