frbr 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Ross Singer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,47 @@
+A very basic representation of the FRBR Group 1, 2, and 3 entities and the relationships between them.
+
+This library is not intended to provide the actual bibliographic attributes of the entities, just establish model and the relationships.
+
+Everything is defined as a Module that you would mixin into some other object.
+
+A basic example:
+
+# Set up our bibliographic objects that we want to FRBR-ize
+class Story
+  attr_accessor :title
+end
+
+class Book
+  attr_accessor :language, format
+end
+  
+class BookEdition
+  attr_accessor :isbn, :date_published
+end
+
+class Person
+  attr_accessor :name
+ end
+  
+
+story = Story.new
+story.title = "The Old Man and the Sea"
+story.extend(FRBR::Work) # these modules could also be included directly in the class
+
+person = Person.new
+person.name = "Ernest Hemingway"
+person.extend(FRBR::Person)
+story.add_creator(person) # or person.add_creation(story)
+
+book = Book.new
+book.language = 'English'
+book.format = 'text'
+book.extend(FRBR::Expression)
+book.realization_of(story) # or story.add_realization(book)
+
+edition = BookEdition.new
+edition.isbn = '0099273969'
+edition.date_published = '2000'
+edition.extend(FRBR::Manifestation)
+edition.embodiment_of(book) # or book.add_embodiment(edition)
+

data/lib/frbr/concept.rb

@@ -0,0 +1,11 @@
+module FRBR
+  module Concept
+    include FRBR::Group3
+    def self.included(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)
+    end    
+  end
+end

data/lib/frbr/corporate_body.rb

@@ -0,0 +1,12 @@
+module FRBR
+  module CorporateBody
+    include FRBR::Group2
+    include FRBR::Group3    
+    def self.included(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)
+    end    
+  end
+end

data/lib/frbr/event.rb

@@ -0,0 +1,11 @@
+module FRBR
+  module Event
+    include FRBR::Group3 
+    def self.included(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)
+    end       
+  end
+end

data/lib/frbr/expression.rb

@@ -0,0 +1,105 @@
+module FRBR
+  module Expression
+    include FRBR::Group1
+    include FRBR::Group3
+    attr_reader :realizers, :realization_of, :embodiments
+    
+    alias :work :realization_of
+    alias :manifestations :embodiments
+    
+    def is_realization_of(work)
+      raise ArgumentError, "Must be a realization of a work" unless work.is_a?(FRBR::Work)
+      @realization_of = work
+      work.add_realization(self) unless work.realizations && work.realizations.index(self)
+    end
+    
+    alias_method :is_expression_of, :is_realization_of
+    
+    def clear_realization_of
+      if @realization_of && !@realization_of.nil? 
+        if @realization_of.realizations && @realization_of.realizations.index(self)
+          @realization_of.remove_realization(self) 
+        end
+        @realization_of = nil
+      end
+    end
+    
+    alias_method :clear_expression_of, :clear_realization_of
+    
+    def add_realizer(realizer)
+      raise ArgumentError, "Realizer must be a Group 2 entity" unless realizer.is_a?(FRBR::Group2)
+      @realizers ||= []
+      @realizers << realizer unless @realizers.index(realizer)
+      realizer.add_realization(self) unless realizer.realizer_of?(self)
+    end
+    
+    def remove_realizer(realizer)
+      @realizers.delete(realizer)
+      realizer.remove_realization(self) if realizer.realizer_of?(self)
+    end    
+    
+    def has_realizer?(agent)
+      return true if @realizers && @realizers.index(agent)
+      return false
+    end
+    
+    def add_embodiment(manifestation)
+      raise ArgumentError, "Embodiments must be manifestations" unless manifestation.is_a?(FRBR::Manifestation)
+      @embodiments ||= []
+      @embodiments << manifestation unless @embodiments.index(manifestation)
+      manifestation.is_embodiment_of(self)
+    end
+    
+    alias_method :add_manifestation, :add_embodiment
+    
+    def remove_embodiment(manifestation)
+      @embodiments.delete(manifestation) if @embodiments
+      manifestation.clear_embodiment_of
+    end
+    
+    alias_method :remove_manifestation, :remove_embodiment
+    
+    def add_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.add_relationship_to_entity(expression, relationship.to_sym, FRBR::Expression, true)
+    end
+    
+    def remove_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.remove_relationship_from_entity(expression, relationship.to_sym, FRBR::Expression, true)
+    end
+    
+    def equivalents
+      equivalents = []
+      if self.realization_of
+        self.realization_of.realizations.each do | expression |
+          next if expression == self
+          equivalents << expression
+        end
+      end
+      equivalents
+    end
+        
+    def self.valid_relationships
+      {:translation=>:translation_of, :revision=>:revision_of, :arrangement=>:arrangement_of, :derivative=>:based_on, :preceded_by=>:succeeded_by, :described_in=>:describes, :augmentation=>:augmentation_of, :contains=>:contained_in, :complemented_by=>:complements, :adaptation=>:adaptation_of, :imitation=>:imitation_of, :related=>:related}      
+    end
+    private
+    def self.included(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases      
+    end
+    def self.extended(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases
+    end    
+
+    def self.add_method_aliases
+      self.valid_relationships.to_a.flatten.each do |rel|
+        next if rel == :related
+        alias_method "add_#{rel}".to_sym, :add_related
+        alias_method "remove_#{rel}".to_sym, :remove_related
+        alias_method rel, :related        
+      end
+    end   
+  end
+end

data/lib/frbr/family.rb

@@ -0,0 +1,12 @@
+module FRBR
+  module Family
+    include FRBR::Group2
+    include FRBR::Group3
+    def self.included(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)
+    end    
+  end
+end

data/lib/frbr/groups.rb

@@ -0,0 +1,204 @@
+module FRBR
+  module Group1
+    attr_reader :relationships
+    def self.check_frbr_validity(o, mod_name)
+      raise TypeError, "Group 1 entities cannot also be Group 2 entities" if o.is_a?(FRBR::Group2)
+      unless mod_name == "FRBR::Group1"
+        entities = [FRBR::Work, FRBR::Expression, FRBR::Manifestation, FRBR::Item, FRBR::Concept, FRBR::Event, FRBR::Object, FRBR::Place]
+        entities.delete(Kernel.constant(mod_name))
+        entities.each do |e|
+          raise TypeError, "#{mod_name} cannot also be a #{e.to_s}" if o.is_a?(e)
+        end
+      end
+      [FRBR::Concept, FRBR::Event, FRBR::Object, FRBR::Place].each do |subject|
+        raise TypeError, "#{subject} cannot be a Group 1 entity" if o.is_a?(subject)
+      end
+    end
+    
+    def related
+      return @relationships[this_method.to_sym]
+    end    
+          
+    protected
+    def add_relationship_to_entity(entity, relationship, entity_type, reify)
+      unless entity_type.valid_relationships[relationship] || entity_type.valid_relationships.values.index(relationship)
+        raise ArgumentError, "relationship must be one of: #{entity_type.valid_relationships.to_a.flatten.join(", ")}"
+      end
+      raise ArgumentError, "Relationship must be to another #{entity_type}" unless entity.is_a?(entity_type)
+      @relationships ||={}
+      @relationships[relationship] ||= []
+      @relationships[relationship] << entity unless @relationships[relationship].index(entity)      
+      if reify
+        if entity_type.valid_relationships[relationship]
+          entity.add_relationship_to_entity(self, entity_type.valid_relationships[relationship], entity_type, false)
+        else
+          entity.add_relationship_to_entity(self, entity_type.valid_relationships.invert[relationship], entity_type, false)
+        end
+      end
+    end      
+    
+    def remove_relationship_from_entity(entity, relationship, entity_type, reify)
+      @relationships[relationship].delete(entity) if @relationships && @relationships[relationship]
+      if reify
+        if entity_type.valid_relationships[relationship]
+          entity.remove_relationship_from_entity(self, entity_type.valid_relationships[relationship], entity_type, false)
+        else
+          entity.remove_relationship_from_entity(self, entity_type.valid_relationships.invert[relationship], entity_type, false)
+        end
+      end        
+    end
+    
+    def self.extended(o)
+      self.check_frbr_validity(o, self.name)
+    end    
+    
+    def this_method
+      caller[0]=~/`(.*?)'/
+      $1
+    end  
+  end
+  module Group2
+    attr_reader :created, :realized, :produced, :owner_of, :related_agents
+    
+    def self.check_frbr_validity(o, mod_name)
+      raise TypeError, "Group 2 entities cannot also be Group 1 entities" if o.is_a?(FRBR::Group1)
+      unless mod_name == "FRBR::Group2"
+        entities = [FRBR::Person, FRBR::CorporateBody, FRBR::Family, FRBR::Concept, FRBR::Event, FRBR::Object, FRBR::Place]
+        entities.delete(Kernel.constant(mod_name))
+        entities.each do |e|
+          raise TypeError, "#{mod_name} cannot also be a #{e.to_s}" if o.is_a?(e)
+        end
+      end
+      [FRBR::Concept, FRBR::Event, FRBR::Object, FRBR::Place].each do |subject|
+        raise TypeError, "#{subject} cannot be a Group 2 entity" if o.is_a?(subject)
+      end
+    end
+    
+    def self.extended(o)
+      self.check_frbr_validity(o, self.name)
+    end    
+    
+    def creator_of?(thing)
+      return true if @created && @created.index(thing)
+      return false
+    end
+    
+    def add_creation(work)
+      raise ArgumentError, "Only Works can be created" unless work.is_a?(FRBR::Work)
+      @created ||=[]
+      @created << work unless @created.index(work)
+      work.add_creator(self) unless work.has_creator?(work)
+    end
+    
+    def remove_creation(work)
+      @created.delete(work) if @created
+      work.creators.delete(self) if work.has_creator?(self)
+    end
+    
+    def realizer_of?(thing)
+      return true if @realized && @realized.index(thing)
+      return false
+    end
+    
+    def add_realization(expression)    
+      raise ArgumentError, "Only Expressions can be realized" unless expression.is_a?(FRBR::Expression)
+      @realized ||=[]
+      @realized << expression unless @realized.index(expression)
+      expression.add_realizer(self) unless expression.has_realizer?(self)
+    end      
+    
+    def remove_realization(expression)
+      @realized.delete(expression) if @realized
+      expression.remove_realizer(self) if expression.has_realizer?(self)
+    end
+    
+    def producer_of?(thing)
+      return true if @produced && @produced.index(thing)
+      return false
+    end
+    
+    def add_production(manifestation)
+      raise ArgumentError, "Only Manifestations can be produced" unless manifestation.is_a?(FRBR::Manifestation)
+      @produced ||= []
+      @produced << manifestation unless @produced.index(manifestation)
+      manifestation.add_producer(self) unless manifestation.has_producer?(self)
+    end
+    
+    def remove_production(manifestation)
+      @produced.delete(manifestation) if @produced
+      manifestation.remove_producer(self) if manifestation.has_producer?(self)
+    end
+    
+    def owner_of?(thing)
+      return true if @owner_of && @owner_of.index(thing)
+      return false
+    end
+    
+    def add_ownership(item)
+      raise ArgumentError, "Only Items can be owned" unless item.is_a?(FRBR::Item)
+      @owner_of ||= []
+      @owner_of << item unless @owner_of.index(item)
+      item.add_owner(self) unless item.has_owner?(self)
+    end
+    
+    def remove_ownership(item)
+      @owner_of.delete(item) if @owner_of
+      item.remove_owned_by(self) if item.has_owner?(self)
+    end
+    
+    def add_related_agent(agent)
+      raise ArgumentError, "Related agents must be Group 2 entities" unless agent.is_a?(FRBR::Group2)
+      @related_agents ||=[]
+      @related_agents << agent unless @related_agents.index(agent)
+      agent.add_related_agent(self) unless agent.related_agents && agent.related_agents.index(self)
+    end
+    
+    def remove_related_agent(agent)
+      @related_agents.delete(agent) if @related_agents
+      agent.remove_related_agent(self) if agent.related_agents && agent.related_agents.index(self)
+    end
+  end
+  module Group3
+    attr_reader :subject_of, :related_subjects
+    
+    def self.check_frbr_validity(o, mod_name)
+
+      unless mod_name == "FRBR::Group3"
+        entities = [FRBR::Work, FRBR::Expression, FRBR::Manifestation, FRBR::Item,
+          FRBR::Person, FRBR::CorporateBody, FRBR::Family, 
+          FRBR::Concept, FRBR::Event, FRBR::Object, FRBR::Place]
+        entities.delete(Kernel.constant(mod_name))
+        entities.each do |e|
+          raise TypeError, "#{mod_name} cannot also be a #{e.to_s}" if o.is_a?(e)
+        end
+      end
+    end
+        
+    def add_subject_of(work)
+      raise ArgumentError, "Group 3 entities can only be subjects of Works" unless work.is_a?(FRBR::Work)
+      @subject_of ||= []
+      @subject_of << work unless @subject_of.index(work)
+      work.add_subject(self) unless work.subjects && work.subjects.index(self)
+    end
+    
+    def remove_subject_of(work)
+      return unless @subject_of
+      @subject_of.delete(work) if @subject_of && @subject_of.index(work)
+      work.remove_subject(self) if work.subjects && work.subjects.index(self)
+    end
+    
+    def add_related_subject(thing)
+      raise ArgumentError, "Group 3 entities can only be related to other Group 3 entities" unless thing.is_a?(FRBR::Group3)
+      @related_subjects ||= []
+      @related_subjects << thing unless @related_subjects && @related_subjects.index(thing)
+      thing.add_related_subject(self) unless thing.related_subjects && thing.related_subjects.index(self)
+    end
+    
+    def remove_related_subject(thing)
+      return unless @related_subjects
+      @related_subjects.delete(thing)
+      thing.remove_related_subject(self) if thing.related_subjects && thing.related_subjects.index(self)
+    end      
+  end
+end
+

data/lib/frbr/item.rb

@@ -0,0 +1,88 @@
+module FRBR
+  module Item
+    include FRBR::Group1
+    include FRBR::Group3
+    attr_reader :exemplar_of, :owners
+    alias :manifestation :exemplar_of
+    
+    def equivalents
+      equivalents = []
+      if self.exemplar_of
+        self.exemplar_of.exemplars.each do | item |
+          next if item == self
+          equivalents << item
+        end
+      end
+      equivalents
+    end  
+    
+    def is_exemplar_of(manifestation)  
+      raise ArgumentError, "Must be the exemplar of a manifestation" unless manifestation.is_a?(FRBR::Manifestation)
+      @exemplar_of = manifestation
+      manifestation.add_exemplar(self) unless manifestation.exemplars && manifestation.exemplars.index(self)
+    end
+    
+    alias_method :is_item_of, :is_exemplar_of
+    
+    def clear_exemplar_of
+      if @exemplar_of && !@exemplar_of.nil?
+        if @exemplar_of.exemplars && @exemplar_of.exemplars.index(self)
+          @exemplar_of.remove_exemplar(self)
+        end
+        @exemplar_of = nil
+      end
+    end
+    
+    def has_owner?(agent)      
+      return true if @owners && @owners.index(agent)
+      return false
+    end
+    
+    alias_method :clear_item_of, :clear_exemplar_of
+    
+    def add_owner(owner)
+      raise ArgumentError, "Owner must be a Group 2 entity" unless owner.is_a?(FRBR::Group2)
+      @owners ||= []
+      @owners << owner unless @owners.index(owner)
+      owner.add_ownership(self) unless owner.owner_of?(self)
+    end
+    
+    def remove_owner(owner)
+      @owners.delete(owner)
+      owner.remove_ownership(self) if owner.owner_of?(self)
+    end
+        
+    def add_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.add_relationship_to_entity(expression, relationship.to_sym, FRBR::Item, true)
+    end
+    
+    def remove_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.remove_relationship_from_entity(expression, relationship.to_sym, FRBR::Item, true)
+    end    
+
+    def self.valid_relationships
+      {:reconfiguration=>:reconfiguration_of, :accompanied_by=>:accompanies, :described_in=>:describes, :contains=>:contained_in, :reproduction=>:reproduction_of, :related=>:related}      
+    end    
+
+    private
+    def self.included(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases      
+    end
+    def self.extended(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases
+    end    
+    
+    def self.add_method_aliases
+      self.valid_relationships.to_a.flatten.each do |rel|
+        next if rel == :related
+        alias_method "add_#{rel}".to_sym, :add_related
+        alias_method "remove_#{rel}".to_sym, :remove_related
+        alias_method rel, :related        
+      end
+    end   
+  end
+end

data/lib/frbr/manifestation.rb

@@ -0,0 +1,106 @@
+module FRBR
+  module Manifestation
+    include FRBR::Group1
+    include FRBR::Group3
+    attr_reader :producers, :embodiment_of, :exemplars
+    
+    alias :expression :embodiment_of
+    alias :items :exemplars
+    
+    def equivalents
+      equivalents = []
+      if self.embodiment_of
+        self.embodiment_of.embodiments.each do | manifestation |
+          next if manifestation == self
+          equivalents << manifestation
+        end
+      end
+      equivalents
+    end  
+    
+    def is_embodiment_of(expression)      
+      raise ArgumentError, "Must be the embodiment of an expression" unless expression.is_a?(FRBR::Expression)
+      @embodiment_of = expression
+      expression.add_embodiment(self) unless expression.embodiments && expression.embodiments.index(self)
+    end
+    
+    alias_method :is_manifestation_of, :is_embodiment_of
+    
+    def clear_embodiment_of
+      if @embodiment_of && !@embodiment_of.nil?
+        if @embodiment_of.embodiments && @embodiment_of.embodiments.index(self)
+          @embodiment_of.remove_embodiment(self)
+        end
+        @embodiment_of = nil
+      end
+    end
+    
+    alias_method :clear_manifestation_of, :clear_embodiment_of
+    
+    def add_exemplar(item)
+      raise ArgumentError, "Exemplar must an item" unless item.is_a?(FRBR::Item)
+      @exemplars ||= []
+      @exemplars << item unless @exemplars.index(item)
+      item.is_exemplar_of(self)
+    end
+    
+    alias_method :add_item, :add_exemplar
+    
+    def remove_exemplar(item)
+      @exemplars.delete(item) if @exemplars
+      item.clear_exemplar_of
+    end
+    
+    alias_method :remove_item, :remove_exemplar
+    
+    def add_producer(producer)
+      raise ArgumentError, "Producer must be a Group 2 entity" unless producer.is_a?(FRBR::Group2)
+      @producers ||= []
+      @producers << producer unless @producers.index(producer)
+      producer.add_production(self) unless producer.producer_of?(self)
+    end
+    
+    def remove_producer(producer)
+      @producers.delete(producer)
+      producer.remove_production(self) if producer.producer_of?(self)
+    end 
+    
+    def has_producer?(agent)  
+      return true if @producers && @producers.index(agent)
+      return false
+    end
+    
+    def add_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.add_relationship_to_entity(expression, relationship.to_sym, FRBR::Manifestation, true)
+    end
+    
+    def remove_related(expression)
+      (action, relationship) = this_method.split("_")
+      self.remove_relationship_from_entity(expression, relationship.to_sym, FRBR::Manifestation, true)
+    end     
+    
+    def self.valid_relationships
+      {:accompanied_by=>:accompanies, :described_in=>:describes, :contains=>:contained_in, :reproduction=>:reproduction_of, :related=>:related}      
+    end    
+
+    private
+    def self.included(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases      
+    end
+    def self.extended(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases
+    end    
+    
+    def self.add_method_aliases
+      self.valid_relationships.to_a.flatten.each do |rel|
+        next if rel == :related
+        alias_method "add_#{rel}".to_sym, :add_related
+        alias_method "remove_#{rel}".to_sym, :remove_related
+        alias_method rel, :related        
+      end
+    end    
+  end
+end

data/lib/frbr/object.rb

@@ -0,0 +1,11 @@
+module FRBR
+  module Object
+    include FRBR::Group3   
+    def self.included(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)
+    end     
+  end
+end

data/lib/frbr/person.rb

@@ -0,0 +1,12 @@
+module FRBR
+  module Person
+    include FRBR::Group2
+    include FRBR::Group3
+    def self.included(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group2.check_frbr_validity(o, self.name)
+    end    
+  end
+end

data/lib/frbr/place.rb

@@ -0,0 +1,11 @@
+module FRBR
+  module Place
+    include FRBR::Group3    
+    def self.included(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)  
+    end
+    def self.extended(o)
+      FRBR::Group3.check_frbr_validity(o, self.name)
+    end    
+  end
+end

data/lib/frbr/work.rb

@@ -0,0 +1,86 @@
+module FRBR
+  module Work
+    include FRBR::Group1 
+    include FRBR::Group3
+    attr_reader :creators, :subjects, :realizations, :related_works, :valid_relationships
+    alias :expressions :realizations
+
+    def add_creator(creator)
+      raise ArgumentError, "Creator must be a Group 2 entity" unless creator.is_a?(FRBR::Group2)
+      @creators ||= []
+      @creators << creator unless @creators.index(creator)
+      creator.add_creation(self) unless creator.creator_of?(self)
+    end
+    
+    def remove_creator(creator)
+      @creators.delete(creator)
+      creator.remove_creation(self) if creator.creator_of?(self)
+    end
+    
+    def has_creator?(agent)
+      return true if @creators && @creators.index(agent)
+      return false
+    end
+    
+    def add_realization(expression)
+      raise ArgumentError, "Only Expressions can be realizations" unless expression.is_a?(FRBR::Expression)
+      @realizations ||= []
+      @realizations << expression unless @realizations.index(expression)
+      expression.is_realization_of(self)
+    end
+    
+    alias_method :add_expression, :add_realization
+    
+    def remove_realization(expression)
+      @realizations.delete(expression) if realizations
+      expression.clear_realization_of
+    end
+    
+    alias_method :remove_expression, :remove_realization
+    
+    def add_subject(subject)
+      raise ArgumentError, "Subject must be a Group 3 entity" unless subject.is_a?(FRBR::Group3)
+      @subjects ||= []
+      @subjects << subject
+      subject.add_subject_of(self) unless subject.subject_of && subject.subject_of.index(self)
+    end
+    
+    def remove_subject(subject)
+      @subjects.delete(subject) if @subjects
+      subject.remove_subject_of(self) if subject.subject_of && subject.subject_of.index(self)
+    end    
+    
+    def add_related(work)
+      (action, relationship) = this_method.split("_")
+      self.add_relationship_to_entity(work, relationship.to_sym, FRBR::Work, true)
+    end
+    
+    def remove_related(work)
+      (action, relationship) = this_method.split("_")
+      self.remove_relationship_from_entity(work, relationship.to_sym, FRBR::Work, true)
+    end
+    
+    def self.valid_relationships
+      {:derivative=>:based_on, :described_in=>:describes, :complemented_by=>:complements, :augmented_by=>:augments, :contains=>:contained_in, :preceded_by=>:succeeded_by, :adaptation_of=>:adaptation, :related=>:related}      
+    end    
+
+    private
+    def self.included(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases      
+    end
+    def self.extended(o)
+      FRBR::Group1.check_frbr_validity(o, self.name)
+      add_method_aliases
+    end    
+    
+    def self.add_method_aliases
+      self.valid_relationships.to_a.flatten.each do |rel|
+        next if rel == :related
+        alias_method "add_#{rel}".to_sym, :add_related
+        alias_method "remove_#{rel}".to_sym, :remove_related
+        alias_method rel, :related
+      end
+    end
+  end
+end

data/lib/frbr.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/frbr/groups'
+require File.dirname(__FILE__) + '/frbr/concept'
+require File.dirname(__FILE__) + '/frbr/corporate_body'
+require File.dirname(__FILE__) + '/frbr/event'
+require File.dirname(__FILE__) + '/frbr/family'
+require File.dirname(__FILE__) + '/frbr/object'
+require File.dirname(__FILE__) + '/frbr/person'
+require File.dirname(__FILE__) + '/frbr/place'
+require File.dirname(__FILE__) + '/frbr/work'
+require File.dirname(__FILE__) + '/frbr/expression'
+require File.dirname(__FILE__) + '/frbr/manifestation'
+require File.dirname(__FILE__) + '/frbr/item'
+
+
+module Kernel
+  def self.constant(const)
+    const = const.to_s.dup
+    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: frbr
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ross Singer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-20 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: A set of modules for creating simple FRBR (Functional Requirements for Bibliographic Resources) relationships between objects.  Includes Group 1, 2 and 3 entities.
+email: rossfsinger@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- lib/frbr.rb
+- lib/frbr/concept.rb
+- lib/frbr/corporate_body.rb
+- lib/frbr/event.rb
+- lib/frbr/expression.rb
+- lib/frbr/family.rb
+- lib/frbr/groups.rb
+- lib/frbr/item.rb
+- lib/frbr/manifestation.rb
+- lib/frbr/object.rb
+- lib/frbr/person.rb
+- lib/frbr/place.rb
+- lib/frbr/work.rb
+has_rdoc: true
+homepage: http://github.com/rsinger/ruby-frbr
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A set of modules for creating simple FRBR relationships between objects.
+test_files: []
+