biointerchange 0.1.0

data/lib/biointerchange/textmining/content.rb

@@ -0,0 +1,69 @@
+module BioInterchange::TextMining
+
+class Content
+
+  # Constants that describe content types.
+  UNSPECIFIED =  0
+  DOCUMENT    =  1
+  PAGE        =  2
+  TITLE       =  3
+  AUTHOR      =  4
+  ABSTRACT    =  5
+  SECTION     =  6
+  PARAGRAPH   =  7
+  SENTENCE    =  8
+  PHRASE      =  9
+  WORD        = 10
+  CHARACTER   = 11
+
+  # Creates a new document content representation at a specific location of the document.
+  #
+  # +offset+:: zero-based offset of the represented content within the document (absolute location within the document)
+  # +length+:: length of the represented content, where a length of zero denotes a boundary between two characters
+  # +type+:: classifaction of the content
+  def initialize(offset, length, type = UNSPECIFIED, process = nil)
+    @offset = offset
+    @length = length
+    @type = type
+    @process = process
+  end
+
+  # Sets the context of this content.
+  #
+  # +context+:: a +BioInterchange::TextMining::Document+ or +BioInterchange::TextMining::Content+ instance in which this content is enclosed in
+  def setContext(context)
+    @context = context
+  end
+
+  # Returns the offset of the content as absolute position within the document.
+  def offset
+    @offset
+  end
+
+  # Returns the length of the content, which is measured in characters.
+  def length
+    @length
+  end
+
+  # Returns the type of the content, if known, or +BioInterchange::TextMining::Content::UNSPECIFIED otherwise.
+  def type
+    @type
+  end
+
+  # Returns the process associated with this content, if previously provided, or nil otherwise.
+  def process
+    @process
+  end
+
+  # Returns a URI that identifies this content.
+  def uri
+    raise BioInterchange::Exceptions::ImplementationModelError, 'An URI can only be returned for content with a context (i.e., use setContext(context) first).' unless @context
+    process = '-'
+    process = "(#{@process.uri.sub(/^.*?:\/\//, '')})" if @process
+    "biointerchange://textmining/content/#{@context.uri.sub(/^.*?:\/\//, '')}/#{@offset},#{@length},#{@type},#{process}"
+  end
+
+end
+
+end
+

data/lib/biointerchange/textmining/document.rb

@@ -0,0 +1,36 @@
+module BioInterchange::TextMining
+
+class Document
+
+  # Creates a blank document representation.
+  #
+  # +uri+:: source of the document
+  def initialize(uri)
+    @uri = uri
+
+    # Will hold content:
+    @content = []
+  end
+
+  # Returns the URI of the document.
+  def uri
+    @uri
+  end
+
+  # Adds content to the document.
+  #
+  # +content+:: content of type +BioInterchange::TextMining::Content+ that should be added to the document
+  def add(content)
+    raise BioInterchange::Exceptions::ImplementationModelError, 'Content has to be of kind BioInterchange::TextMining::Content' unless content.kind_of?(BioInterchange::TextMining::Content)
+    @content << content
+  end
+
+  # Returns the document contents as an array.
+  def contents
+    @content.clone.freeze
+  end
+
+end
+
+end
+

data/lib/biointerchange/textmining/pdfx_xml_reader.rb

@@ -0,0 +1,161 @@
+module BioInterchange::TextMining
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+class PdfxXmlReader < BioInterchange::TextMining::TMReader
+  
+  # Reads input stream and returns associated +BioInterchange::TextMining::Document+ model
+  #
+  # Presently I assume a single document per xml file,
+  # and that <section> tags cannot nest. I also assume
+  # that a Content::DOCUMENT type is everything between 
+  # the <article> tags. 
+  #
+  # +inputstream+:: Input IO stream to deserialize 
+  def deserialize(inputstream)
+  
+    #super(inputstream)
+    
+    raise BioInterchange::Exceptions::ImplementationReaderError, 'InputStream not of type IO, cannot read.' unless inputstream.kind_of?(IO) or inputstream.kind_of?(String)
+    
+    @input = inputstream
+    
+    pdfx
+    
+  end
+
+
+
+private
+
+  def pdfx
+    list = MyListener.new
+    REXML::Document.parse_stream(@input, list)
+    return list.document
+  end
+    
+
+	
+	
+	class MyListener
+	
+	  include REXML::StreamListener
+    
+    def initialize
+      @map = {}
+      
+      #sections can nest, so "stack" them
+      @map['sec_s'] = []
+      @map['sec_l'] = []
+    end
+    
+    
+    def tag_start(name, attr)
+      #puts "tag_start: #{name}"
+      if name =~ /^job$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Input document XML has multiple <job> tags, cannot parse multiple documents within a single file.' if @map['id_done']
+        @map['id'] = true
+      elsif name =~ /^article-title$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Input document XML has multiple <article-title> tags defined, cannot parse multiple documents within a single file.' if @map['title_done']
+        @map['title'] = true
+        @map['title_s'] = @map['art_l']
+        @map['title_l'] = 0
+      elsif name =~ /^abstract$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Input document XML has multiple <abstract> tags defined, cannot parse multiple documents within a single file.' if @map['abs_done']
+        @map['abs'] = true
+        @map['abs_s'] = @map['art_l']
+        @map['abs_l'] = 0
+      elsif name =~ /^body$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Input document XML has multiple <body> tags defined, cannot parse multiple documents within a single file.' if @map['body_done']
+        @map['body'] = true
+        @map['body_s'] = @map['art_l']
+        @map['body_l'] = 0
+      elsif name =~ /^article$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Input document XML has multiple <article> tags defined, cannot parse multiple documents within a single file.' if @map['art_done']
+        @map['art'] = true
+        @map['art_s'] = 0
+        @map['art_l'] = 0
+      elsif name =~ /^section$/
+        raise BioInterchange::Exceptions::InputFormatError, 'Error with section stack, stacks not equal in size: Possibly not a well formed XML input file. Check <section> tags all match up and do not overlap (nesting is fine).' unless  @map['sec_s'].size == @map['sec_l'].size
+        @map['sec_s'].push @map['art_l']
+        @map['sec_l'].push 0
+      end
+    end
+  
+  
+    def text(data)
+      
+      if @map['art']
+        @map['art_l'] += data.length
+      end
+      
+      if @map['id']
+        @doc = BioInterchange::TextMining::Document.new("http://pdfx.cs.man.ac.uk/" + data)
+      elsif @map['title']
+        @map['title_l'] += data.length
+      elsif @map['abs']
+        @map['abs_l'] += data.length
+      end
+      if @map['body']
+        @map['body_l'] += data.length
+      end
+      if @map['sec_l'].size != 0
+        #add length to *all* current sections
+        @map['sec_l'].size.times do |i|
+          @map['sec_l'][i] += data.length
+        end
+      end
+      
+    end
+    
+    #TODO add deal with <author> type tags
+    
+    def tag_end(name)
+      #puts "tag_end: #{name}"
+      if name =~ /^job$/
+        @map['id'] = false
+        @map['id_done'] = true
+      elsif name =~ /^article-title$/
+        @map['title'] = false
+        dc = BioInterchange::TextMining::Content.new(@map['title_s'], @map['title_l'], BioInterchange::TextMining::Content::TITLE, @process)
+        dc.setContext(@doc)
+        @doc.add(dc)
+        @map['title_done'] = true
+      elsif name =~ /^abstract$/
+        @map['abs'] = false
+        dc = BioInterchange::TextMining::Content.new(@map['abs_s'], @map['abs_l'], BioInterchange::TextMining::Content::ABSTRACT, @process)
+        dc.setContext(@doc)
+        @doc.add(dc)
+        @map['abs_done'] = true
+      elsif name =~ /^body$/
+        @map['body'] = false
+        dc = BioInterchange::TextMining::Content.new(@map['body_s'], @map['body_l'], BioInterchange::TextMining::Content::SECTION, @process)
+        dc.setContext(@doc)
+        @doc.add(dc)
+        @map['body_done'] = true
+      elsif name =~ /^article$/
+        @map['art'] = false
+        dc = BioInterchange::TextMining::Content.new(@map['art_s'], @map['art_l'], BioInterchange::TextMining::Content::DOCUMENT, @process)
+        dc.setContext(@doc)
+        @doc.add(dc)
+        @map['art_done'] = true
+      elsif name =~ /^section$/
+        raise 'Error with section stack, stacks not equal in size' unless  @map['sec_s'].size == @map['sec_l'].size
+        dc = BioInterchange::TextMining::Content.new(@map['sec_s'].pop, @map['sec_l'].pop, BioInterchange::TextMining::Content::SECTION, @process)
+        dc.setContext(@doc)
+        @doc.add(dc)
+      end
+    end
+    
+    def document
+      @doc
+    end
+    
+  end
+  
+
+
+end
+
+end

data/lib/biointerchange/textmining/process.rb

@@ -0,0 +1,57 @@
+module BioInterchange::TextMining
+
+class Process
+
+  # Constants that describe process types.
+  UNSPECIFIED = 0
+  SOFTWARE    = 1
+  WEBSERVICE  = 2
+  MANUAL      = 3
+
+  # Dictionary of viable metadata keys.
+  VERSION     = 0
+
+  # Creates a new process representation.
+  #
+  # +name+:: identification of the software/service/curator involved in the process, e.g. "ABNER" or "Peter Smith"
+  # +uri+:: details about the processes origin, e.g. "http://pages.cs.wisc.edu/~bsettles/abner/" or "peter.smith@example.org"
+  # +date+:: date-time when the process was carried out, which may be nil if the date-time is unknown
+  # +type+:: classification of the described process
+  # +metadata+:: a hash that holds additional information about the process via dictionary defined keywords, e.g. { Process::VERSION => '0.0.1alpha' }
+  def initialize(name, uri, type = UNSPECIFIED, metadata = {}, date = nil)
+    @name = name
+    @uri = uri
+    @date = date
+    @type = type
+    @metadata = metadata
+  end
+
+  # Returns the name of the process.
+  def name
+    @name
+  end
+
+  # Returns the URI that has further details about the process, which can also be the form of an email address
+  # in cases where the process describes human driven annotation.
+  def uri
+    @uri
+  end
+
+  # Returns the date-time when this process was carried out, or nil otherwise if the information is not available.
+  def date
+    @date
+  end
+
+  # Returns the type of this process.
+  def type
+    @type
+  end
+
+  # Returns additional meta-data associated with this process.
+  def metadata
+    @metadata.clone.freeze
+  end
+
+end
+
+end

data/lib/biointerchange/textmining/pubannos_json_reader.rb

@@ -0,0 +1,72 @@
+module BioInterchange::TextMining
+
+require 'rubygems'
+require 'json'
+
+class PubannosJsonReader < BioInterchange::TextMining::TMReader
+
+  def deserialize(inputstream)
+    if inputstream.kind_of?(IO) then
+      pubannos(inputstream.read)
+    elsif inputstream.kind_of?(String) then
+      pubannos(inputstream)
+    else
+      #else raise exception
+      super(inputstream)
+    end
+  end
+
+private 
+
+  # Specific method for parsing of *Pubannotations* json format
+  def pubannos(data)
+    
+    result = JSON.parse(data)
+    
+    if result.has_key? 'Error'
+      raise BioInterchange::Exceptions::InputFormatError, 'Error parsing the JSON input file: #{result["Error"]}'
+    end
+    
+    
+    text = result['text']
+    #doc_uri = "http://pubannotation.dbcls.jp/pmdocs/" + result['pmid'].to_s
+    doc_uri = result['docurl']
+    
+    doc = Document.new(doc_uri)
+    docContent = Content.new(0, text.length, Content::DOCUMENT, @process)
+    docContent.setContext(doc)
+    doc.add(docContent)
+    
+    #so our document requires content of type document or abstract
+    #should it hold the content string?
+    
+    if result['catanns']
+      result['catanns'].each do |annot| 
+        start_offset = annot['begin']
+        end_offset = annot['end']
+        length = end_offset - start_offset
+        created_time = annot['created_at']
+        updated_time = annot['updated_at']
+        category = annot['category']
+        #annset_id = annot['annset_id']
+        #doc_id = annot['doc_id']
+        #id = annot['id']
+        
+        entity = text.slice(start_offset..end_offset)
+      
+        #phrase = type for NE
+        con = Content.new(start_offset, length, Content::PHRASE, @process)
+        con.setContext(doc)
+        doc.add(con)
+        
+        #set process.date = updated_time?
+      end
+    end
+    
+    doc
+  end
+  
+
+end
+
+end

data/lib/biointerchange/textmining/text_mining_rdf_ntriples.rb

@@ -0,0 +1,197 @@
+require 'rdf'
+require 'rdf/ntriples'
+require 'date'
+
+module BioInterchange::TextMining
+
+class RDFWriter < BioInterchange::Writer
+
+  # Creates a new instance of a RDFWriter that will use the provided output stream to serialize RDF.
+  #
+  # +ostream+:: instance of an IO class or derivative that is used for RDF serialization
+  def initialize(ostream)
+    raise BioInterchange::Exceptions::ImplementationWriterError, 'The output stream is not an instance of IO or its subclasses.' unless ostream.kind_of?(IO)
+    @ostream = ostream
+  end
+
+  # Serializes a model as RDF.
+  #
+  # +model+:: a generic representation of input data that is derived from BioInterchange::TextMining::Document
+  def serialize(model)
+    if model.instance_of?(BioInterchange::TextMining::Document) then
+      serialize_document(model)
+    else
+      raise BioInterchange::Exceptions::ImplementationWriterError, 'The provided model cannot be serialized at the moment. ' +
+                           'Supported classes are BioInterchange::TextMining::Document (and that\'s it for now).'
+    end
+  end
+
+private
+
+  # Generates an URI for a given process and its contents.
+  #
+  # +process+:: process instance
+  # +kind+:: kind of the URI that should be generated, for example, whether the URI should represent the name, date, etc.
+  def process_uri(process, kind)
+    base_uri = 'biointerchange://textmining/process'
+    case kind
+    when :process
+      RDF::URI.new("#{base_uri}/self/#{process.uri.sub(/^.*?:\/\//, '')}")
+    when :name
+      RDF::URI.new("#{base_uri}/name/#{process.uri.sub(/^.*?:\/\//, '')}")
+    when :uri
+      RDF::URI.new("#{base_uri}/uri/#{process.uri.sub(/^.*?:\/\//, '')}")
+    when :date
+      RDF::URI.new("#{base_uri}/date/#{process.uri.sub(/^.*?:\/\//, '')}")
+    else
+      raise BioInterchange::Exceptions::ImplementationWriterError, "There is no implementation for serializing a process as #{kind}."
+    end
+  end
+  
+  # Generates an URI for a given content and its contents.
+  #
+  # +content+:: content instance
+  # +kind+:: kind of the URI that should be generated, for example, whether the URI should represent the name, date, etc.
+  def content_uri(content, kind)
+    base_uri = 'biointerchange://textmining/content'
+    case kind
+    #when :content
+    #  RDF::URI.new("#{base_uri}/self/#{content.uri.sub(/^.*?:\/\//, '')}")
+    when :start
+      RDF::URI.new("#{base_uri}/start/#{content.uri.sub(/^.*?:\/\//, '')}")
+    when :stop
+      RDF::URI.new("#{base_uri}/stop/#{content.uri.sub(/^.*?:\/\//, '')}")
+    #when :type
+    #  RDF::URI.new("#{base_uri}/type/#{content.uri.sub(/^.*?:\/\//, '')}")
+    else
+      raise BioInterchange::Exceptions::ImplementationWriterError, "There is no implementation for serializing a content as #{kind}."
+    end
+  end
+
+  # Serializes RDF for a textual document representation using the Semanticsciene Integrated Ontology
+  # (http://code.google.com/p/semanticscience/wiki/SIO).
+  #
+  # +model+:: an instance of +BioInterchange::TextMining::Document+
+  def serialize_document(model)
+    graph = RDF::Graph.new
+    document_uri = RDF::URI.new(model.uri)
+    graph.insert(RDF::Statement.new(document_uri, RDF.type, BioInterchange::SIO.document))
+    model.contents.each { |content|
+      serialize_content(graph, document_uri, content)
+    }
+    RDF::NTriples::Writer.dump(graph, @ostream)
+  end
+
+
+  # Serializes a Content object for a given document URI.
+  #
+  # +graph+:: RDF graph to which content is added
+  # +document_uri+:: the document URI to which the added content belongs to
+  # +content+:: an instance that describes the content
+  def serialize_content(graph, document_uri, content)
+    content_uri = RDF::URI.new(content.uri)
+    graph.insert(RDF::Statement.new(document_uri, BioInterchange::SIO.has_attribute, content_uri))
+    serialize_process(graph, document_uri, content_uri, content.process) if content.process
+    
+    sio_url = BioInterchange::SIO.language_entity
+    case content.type
+    when Content::UNSPECIFIED
+      sio_url = BioInterchange::SIO.language_entity
+    when Content::DOCUMENT
+      sio_url = BioInterchange::SIO.document
+    when Content::PAGE
+      sio_url = BioInterchange::SIO.document_section
+    when Content::TITLE
+      sio_url = BioInterchange::SIO.title
+    when Content::AUTHOR
+      sio_url = BioInterchange::SIO.author_section
+    when Content::ABSTRACT
+      sio_url = BioInterchange::SIO.abstract_section
+    when Content::SECTION
+      sio_url = BioInterchange::SIO.document_section
+    when Content::PARAGRAPH
+      sio_url = BioInterchange::SIO.paragraph
+    when Content::SENTENCE
+      sio_url = BioInterchange::SIO.sentence
+    when Content::PHRASE
+      sio_url = BioInterchange::SIO.phrase
+    when Content::WORD
+      sio_url = BioInterchange::SIO.word
+    when Content::CHARACTER
+      sio_url = BioInterchange::SIO.character
+    end
+    
+    graph.insert(RDF::Statement.new(content_uri, RDF.type, sio_url))
+    
+    graph.insert(RDF::Statement.new(content_uri, BioInterchange::SIO.has_attribute, serialize_content_start(graph, document_uri, content_uri, content)))
+    graph.insert(RDF::Statement.new(content_uri, BioInterchange::SIO.has_attribute, serialize_content_stop(graph, document_uri, content_uri, content)))
+  
+  end
+
+  # Serializes a process object for a specific document uri
+  #
+  #
+  def serialize_process(graph, document_uri, content_uri, process)
+    process_uri = process_uri(process, :process)
+    graph.insert(RDF::Statement.new(content_uri, BioInterchange::SIO.is_direct_part_of, process_uri))
+    # If this is an email address, then create a FOAF representation, otherwise, do something else:
+    if process.type == BioInterchange::TextMining::Process::MANUAL then
+      graph.insert(RDF::Statement.new(process_uri, RDF.type, RDF::FOAF.Person))
+      graph.insert(RDF::Statement.new(process_uri, RDF::FOAF.name, RDF::Literal.new(process.name)))
+      graph.insert(RDF::Statement.new(process_uri, RDF::FOAF.name, RDF::URI.new(process.uri)))
+    else
+      graph.insert(RDF::Statement.new(process_uri, RDF.type, BioInterchange::SIO.process))
+      graph.insert(RDF::Statement.new(process_uri, BioInterchange::SIO.has_attribute, serialize_process_name(graph, document_uri, content_uri, process_uri, process)))
+      graph.insert(RDF::Statement.new(process_uri, BioInterchange::SIO.has_attribute, serialize_process_uri(graph, document_uri, content_uri, process_uri, process)))
+      graph.insert(RDF::Statement.new(process_uri, BioInterchange::SIO.has_attribute, serialize_process_date(graph, document_uri, content_uri, process_uri, process))) if process.date
+    end
+  end
+
+  #
+  #
+  #
+  def serialize_process_name(graph, document_uri, content_uri, process_uri, process)
+    kind_uri = process_uri(process, :name)
+    graph.insert(RDF::Statement.new(kind_uri, RDF.type, BioInterchange::SIO.name))
+    graph.insert(RDF::Statement.new(kind_uri, BioInterchange::SIO.has_attribute, RDF::Literal.new("#{process.name}")))
+  end
+
+  #
+  #
+  #
+  def serialize_process_uri(graph, document_uri, content_uri, process_uri, process)
+    kind_uri = process_uri(process, :uri)
+    graph.insert(RDF::Statement.new(kind_uri, RDF.type, BioInterchange::SIO.software_entity))
+    graph.insert(RDF::Statement.new(kind_uri, BioInterchange::SIO.has_attribute, RDF::URI.new(process.uri)))
+  end
+
+  #
+  #
+  #
+  def serialize_process_date(graph, document_uri, content_uri, process_uri, process)
+    kind_uri = process_uri(process, :date)
+    graph.insert(RDF::Statement.new(kind_uri, RDF::DC.date, RDF::Literal.new(Date.parse(process.date))))
+  end
+
+  #
+  #
+  #
+  def serialize_content_start(graph, document_uri, content_uri, content)
+    kind_uri = content_uri(content, :start)
+    graph.insert(RDF::Statement.new(kind_uri, RDF::type, BioInterchange::SIO.start_position))
+    graph.insert(RDF::Statement.new(kind_uri, BioInterchange::SIO.has_attribute, RDF::Literal.new(content.offset)))
+  end
+  
+  #
+  #
+  #
+  def serialize_content_stop(graph, document_uri, content_uri, content)
+    kind_uri = content_uri(content, :stop)
+    graph.insert(RDF::Statement.new(kind_uri, RDF::type, BioInterchange::SIO.stop_position))
+    graph.insert(RDF::Statement.new(kind_uri, BioInterchange::SIO.has_attribute, RDF::Literal.new((content.offset+content.length).to_s)))
+  end
+
+end
+
+end
+

data/lib/biointerchange/textmining/text_mining_reader.rb

@@ -0,0 +1,41 @@
+module BioInterchange::TextMining
+
+class TMReader < BioInterchange::Reader
+
+  # Create a new instance of a text-mining data reader. Sets @process to a new +BioInterchange::TextMining::Process+ object.
+  #
+  # +name+:: Name of the process which generated this data
+  # +name_uri+:: URI of the resource that generated this data
+  # +date+:: Optional date of data creation
+  # +processtype+:: Type of process that created this content
+  # +version+:: Optional version number of resource that created this data (nil if manually curated, for example).
+  def initialize(name, name_uri, date = nil, processtype = BioInterchange::TextMining::Process::UNSPECIFIED, version = nil)
+  
+    metadata = {}
+    metadata[BioInterchange::TextMining::Process::VERSION] = version
+    @process = BioInterchange::TextMining::Process.new(name, name_uri, processtype, metadata, date)
+    
+  end
+  
+  
+  # Reads input stream and returns associated model. Super call this method before before overriding to provide access to a @data string containing the inputstream text.
+  #
+  # +inputstream+:: Input IO stream to deserialize 
+  def deserialize(inputstream)
+    raise BioInterchange::Exceptions::ImplementationReaderError, 'InputStream not of type IO, cannot read.' unless inputstream.kind_of?(IO)
+  end
+  
+  # Automatically tries to determine a suitable process from the given name ID, which is assumed
+  # to be either an email address or web-site.
+  #
+  # +name_id+:: name ID that we want to represent by a suitable process
+  def self.determine_process(name_id)
+    process = BioInterchange::TextMining::Process::UNSPECIFIED
+    process = BioInterchange::TextMining::Process::MANUAL if name_id.match(/[^@]+@[^@]+/)
+    process = BioInterchange::TextMining::Process::SOFTWARE if name_id.match(/[a-zA-Z]+:\/\//)
+    process
+  end
+  
+end
+
+end

data/lib/biointerchange/writer.rb

@@ -0,0 +1,23 @@
+module BioInterchange
+
+class Writer
+
+  # Creates a new instance of a writer that will use the provided output stream to serialize object model instances.
+  #
+  # +ostream+:: instance of IO or derivative class
+  def initialize(ostream)
+    raise BioInterchange::Exceptions::ImplementationWriterError, 'The output stream is not an instance of IO or its subclasses.' unless ostream.kind_of?(IO)
+    @ostream = ostream
+  end
+
+  # Serializes an object model instance.
+  #
+  # +model+:: an object model instance
+  def serialize(model)
+    raise BioInterchange::Exceptions::ImplementationWriterError, 'You must implement this method, which takes an object model and serializes it into the previously provided output stream.'
+  end
+
+end
+
+end
+

data/lib/biointerchange.rb

@@ -0,0 +1,3 @@
+
+require 'biointerchange/core'
+

data/spec/exceptions_spec.rb

@@ -0,0 +1,27 @@
+
+require 'rspec'
+
+load 'lib/biointerchange/core.rb'
+load 'lib/biointerchange/exceptions.rb'
+
+describe BioInterchange::Exceptions do
+  describe 'error and exception creation tests' do
+    it 'raising of InputFormatError' do
+      expect { raise BioInterchange::Exceptions::InputFormatError }.to raise_error(BioInterchange::Exceptions::BioInterchangeError)
+    end
+    
+    it 'raising of ImplementationReaderError' do
+      expect { raise BioInterchange::Exceptions::ImplementationReaderError }.to raise_error(BioInterchange::Exceptions::ImplementationError)
+    end
+    
+    it 'raising of ImplementationModelError' do
+      expect { raise BioInterchange::Exceptions::ImplementationModelError }.to raise_error(BioInterchange::Exceptions::ImplementationError)
+    end
+    
+    it 'raising of ImplementationWriterError' do
+      expect { raise BioInterchange::Exceptions::ImplementationWriterError }.to raise_error(BioInterchange::Exceptions::ImplementationError)
+    end
+    
+  end
+end
+