bivy 0.0.5

data/jrn_abbrev/html_to_yaml.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby -w
+
+
+# outputs a string that ruby will read in as a hash
+def to_hash_string(hash)
+  string = []
+  string << "Medline_to_Full = {"
+  hash.sort.each do |k,v|
+    string << "'#{k}' => '#{v}',"
+  end
+  string << "}"
+  string.join("\n")
+end
+
+
+a_to_j = {}  ## should be uniq mapping here
+
+
+Dir["*.html"].each do |file|
+  puts "FILE: #{file}"
+  num_matches = 0
+  IO.read(file).scan(/<TR><TD>(.*?)<\/TD><TD>(.*?)<\/TD>/m) do |match|
+    pair = match.map do |m|
+    
+      # The last sub is because of some bad html they have in their journal
+      # ...<TR><TD>Annu Rev Plant Physiol Plant Mol Biol
+      m.gsub(/<\/?i>/,'').gsub(/<\/?A.*?>/,'').strip.sub(/ \(.*\)$/,'').sub(/<TR><TD>.*$/, '')
+    end
+    num_matches += 1
+    #if a_to_j.key? pair[0] ; puts "ALREADY HAVE KEY! " end
+    a_to_j[pair[0]] = pair[1]
+  end
+  IO.read(file).scan(/<TR>\n<TD>(.*?)<\/TD>\n<TD>(.*?)<\/TD>/) do |match|
+    pair = match.map do |m|
+
+      # The last sub is because of some bad html they have in their journal
+      # ...<TR><TD>Annu Rev Plant Physiol Plant Mol Biol
+      m.gsub(/<\/?i>/,'').gsub(/<\/?A.*?>/,'').strip.sub(/ \(.*\)$/,'').sub(/<TR><TD>.*$/, '')
+    end
+    num_matches += 1
+    #if a_to_j.key? pair[0] ; puts "ALREADY HAVE KEY! " end
+    a_to_j[pair[0]] = pair[1]
+  end
+
+  puts "#{num_matches} MATHCEES"
+end
+
+File.open("for_ruby_class.rb", 'w') do |fh| 
+  fh.print( to_hash_string(a_to_j)) 
+end

data/lib/bibliography.rb

@@ -0,0 +1,144 @@
+require 'citation'
+require 'pubmed'
+
+class Bibliography
+
+  attr_accessor :citations
+
+  def initialize(citations=nil)
+    if citations
+      @citations = citations
+    end
+  end
+
+  # returns an array of citations from other that are not uniq compared self
+  def not_uniq(other)
+    scit = self.citations
+    ocit = other.citations
+    pass_id = not_uniq_by(scit, ocit, :ident)
+    passed = [scit, ocit].map do |ar|
+      ar.select {|v| v.respond_to? :pmid}
+    end
+    passed.push( *(not_uniq_by(passed[0], passed[1], :ident)) )
+    passed.uniq!
+    passed
+  end
+
+  def not_uniq_by(cits1, cits2, att)
+    self_by_att = cits1.group_by(&att)
+    other_by_att = cits2.group_by(&att)
+    not_un = [] 
+    other_by_att.each do |k,v| 
+      if self_by_att.key? k
+        not_un.push( *v )
+      end
+    end
+    not_un 
+  end
+
+  # adds a list of citations.  It will ONLY add citations whose identifiers
+  # do not already exist.  Citations which already have a duplicate identifier
+  # will be returned.  nil is returned if no citation objects have clashing
+  # id's
+  def add(*citations)
+    clashing = []
+    hsh = to_hash
+    citations.each do |cit|
+      if hsh.key? cit.ident
+        clashing << cit
+      else
+        @citations.push(cit)
+      end
+    end
+    if clashing.size > 0
+      clashing
+    else
+      nil
+    end
+  end
+
+  # if file, loads it
+  def self.from_yaml(file_or_string)
+    hash = 
+      if File.exist? file_or_string
+        YAML.load_file(file_or_string)
+      else
+        YAML.load(file_or_string)
+      end
+    # we were given a nonexistent file and the yaml is not a hash
+    # in this case we need to create an empty bib object
+    unless hash.is_a? Hash
+      hash = {}
+    end
+    citations = hash.map do |id,vals|
+      vals['ident'] = id 
+      bibtype = vals['bibtype']
+      klass = 
+        if vals.key? 'pmid'
+          PubMed
+        else
+          Citation.const_get(bibtype.capitalize)
+        end
+        #when 'article'
+        #  else
+        #    Citation::Article
+        #  end
+        #when 'book'
+        #  Citation::Book
+        #else
+        #  abort "Unrecognized bibtype!"
+        #end
+      vals['bibtype'] = bibtype.to_sym
+      cit = klass.new(vals)
+      #if cit.authors =~ /Paris/
+      #  p cit.authors
+      #  abort
+      #end
+      #if cit.authors.is_a? Array
+      #  cit.authors = cit.author_strings_to_objects
+      #end
+      cit
+    end
+    bib = Bibliography.new(citations)
+  end
+
+  # selects as internal citations only those matching the array of idents
+  # returns the citations
+  def select_by_id!(ids)
+    # should mimic index_by
+    hash = @citations.group_by(&:ident) ; hash.each {|k,v| hash[k] = v.last }
+    new_cits = ids.map do |id|
+      unless hash.key? id ; abort "Cannot find '#{id}' in citations!" end
+      hash[id]
+    end
+    @citations = new_cits
+  end
+
+  # hashes by ident
+  def to_hash
+    hsh = {}
+    @citations.each do |cit|
+       cthash = cit.to_hash
+       cthash.delete('ident')
+       hsh[cit.ident] = cthash
+    end
+    hsh
+  end
+
+  # if given a file, writes to the file, otherwise returns the string
+  def to_yaml(file=nil)
+    hsh = to_hash
+    string = hsh.to_yaml
+    if file
+      File.open(file, 'w') {|v| v.print string }
+    end
+    string
+  end
+
+  # a format_obj can respond to the call obj.format(citation, format_type)
+  # and :header and :footer
+  def write(format_obj)
+    format_obj.header + format_obj.format(@citations) + format_obj.footer
+  end
+
+end

data/lib/bivy.rb

@@ -0,0 +1,4 @@
+
+module Bivy
+  VERSION = '0.0.3'
+end

data/lib/citation.rb

@@ -0,0 +1,194 @@
+
+require 'journal'
+
+class Citation
+  # quotes are director or parenthetical
+  attr_accessor :bibtype, :ident, :quotes, :abstract
+  # authors should be an array of Author objects, or a string for an exact
+  # line
+  attr_reader :authors
+  
+  def initialize(hash=nil)
+    @authors = nil
+    @quotes = []
+    # Citation::Article -> :article
+    @bibtype = self.class.to_s.split('::')[-1].downcase.to_sym
+    if hash
+      hash.each do |x,v|
+        send("#{x}=".to_sym, v)
+      end
+    end
+  end
+
+  def to_hash
+    hash = {}
+    others = instance_variables.select {|v| v != '@authors'}
+    others.each do |var|
+      hash[var[1..-1]] = instance_variable_get(var)
+    end
+    hash['bibtype'] = hash['bibtype'].to_s
+    hash['authors'] = instance_variable_get('@authors').map {|v| v.to_s }
+    hash
+  end
+
+  ## We shouldn't have to do this one, it should be handled in our setter!!
+  #def author_strings_to_objects
+  #  if @authors
+  #    @authors.map do |st|
+  #      if st.is_a? Citation::Author
+  #        st
+  #      else
+  #        Citation::Author.from_s(st)
+  #      end
+  #    end
+  #  else
+  #    []
+  #  end
+  #end
+
+  # given an array of strings or objects, ensures objects, given string it
+  # will set as a string
+  def authors=(array)
+    if array.is_a? Array
+      @authors = array.map do |auth|
+        if auth.is_a? String
+          Citation::Author.from_s(auth)
+        elsif auth.is_a? Citation::Author
+          auth
+        else
+          abort "Don't recognize: #{auth.class} for #{auth}"
+        end
+      end
+    else
+      # this is a string
+      @authors = array
+    end
+  end
+
+  # make the yaml look like a hash
+  def to_yaml
+    to_hash.to_yaml
+  end
+
+end
+
+module JournalLike
+  attr_accessor :journal_medline, :journal_full, :journal_iso
+
+  # unless the @journal_full or @journal_iso attributes are filled in already
+  # will attemtp:
+  # This method will search Journal::Medline_to_ISO and
+  # Journal::Medline_to_Full and fill in the other entries, otherwise, it will
+  # given a medline format journal name, fills in the 3 journal attributes
+  def set_journal_from_medline(jrnl)
+    @journal_medline = jrnl
+    if @journal_full == nil
+      if Journal::Medline_to_Full.key?(jrnl)
+        @journal_full = Journal::Medline_to_Full[jrnl]
+      else
+        @journal_full = jrnl
+      end
+    end
+    if @journal_iso == nil 
+      if Journal::Medline_to_ISO.key?(jrnl)
+        @journal_iso = Journal::Medline_to_ISO[jrnl]
+      else
+        @journal_iso = jrnl
+      end
+    end
+  end
+
+  def has_journal?
+    journal_medline != nil
+  end
+
+
+end
+
+class Citation::Article < Citation
+  include JournalLike
+  # ident = unique identifier for placing in papers
+  attr_accessor :title, :year, :month, :vol, :issue, :pages
+  
+  def ==(other)
+    if self.respond_to? :pmid
+      if other.respond_to?(:pmid) && (self.pmid == other.pmid)
+        return true
+      else
+        return false
+      end
+    else
+      %w(title year month vol issue pages journal_medline bibtype).each do |v|
+        if self.send(v.to_sym) != other.send(v.to_sym)
+          return false
+        end
+      end
+    end
+    return true
+  end
+
+  def pages_full
+    st_p, end_p = @pages.split('-')
+    if !@pages.include?('.') && end_p && end_p.to_i < st_p.to_i  # 123-29
+      diff = st_p.size - end_p.size
+      new_end_p = st_p[0,diff] + end_p
+      [st_p, new_end_p].join('-')
+    else
+      @pages
+    end
+  end
+end
+
+
+class Citation::Article_to_be_submitted < Citation
+  include JournalLike
+  attr_accessor :title
+end
+
+class Citation::Workshop < Citation
+  attr_accessor :title, :name, :year, :pages
+end
+
+class Citation::Book < Citation
+  attr_accessor :title, :publisher, :year
+end
+
+class Citation::Webpage < Citation
+  attr_accessor :title, :year, :month, :day, :url
+  # month, year, day are all for the creation of the media itself
+  # date last accessed (String: 'yyyy-mm-dd')
+  attr_accessor :accessed
+end
+
+
+class Citation::Author
+
+  ## INITIALS should be with NO spaces, all caps
+  attr_reader :last, :initials
+  def initialize(last, initials)
+    @last = last
+    @initials = initials
+  end
+  def inspect
+    "<#{@last}, #{initials}>"
+  end
+
+  def to_s
+    "#{@last}, #{@initials}"    
+  end
+
+  # TODO: make this smarter for initials
+  def self.from_s(string)
+    pieces = string.split(', ')
+    last = pieces.shift
+    initials = pieces.join(', ')
+    self.new(last, initials)
+  end
+
+  def ==(other)
+    [self.last, self.initials] == [other.last, other.initials]
+  end
+
+end
+
+

data/lib/format.rb

@@ -0,0 +1,120 @@
+
+module Format
+  Symbol_to_class_string = { }
+
+  MediaForwarding = {
+    :i => true,
+    :b => true,
+    :u => true,
+    :header => true,
+    :footer => true,
+    :periodize => true,
+    :par => true,
+    :br => true,
+  }
+
+  def self.new(media_obj, tp=:jtp)
+    require "format/#{tp}"
+    klass_st = ((x = Symbol_to_class_string[tp]) ? x : tp.to_s.capitalize)
+    klass = Format.const_get(klass_st)
+    include_super = true
+    obj = klass.new(media_obj)
+  end
+
+  def method_missing(*args)
+    meth = args.first
+    if MediaForwarding.key?(meth)
+      @media_obj.send(*args)
+    elsif @cit and @cit.respond_to?(meth)  
+      @cit.send(*args)
+    else
+      raise NoMethodError, "method '#{meth}' called with args (#{args[1..-1].join(',')})"
+    end
+  end
+
+  def initialize(media_obj)
+    @media_obj = media_obj
+    @cit = nil
+  end
+
+  # The method should take an array of strings, each formatted in whatever
+  # method, and ensure that each string ends in a period.  This is annoying to
+  # define, but it simplifies the writing of citation formats dramatically
+  #def periodize(array)
+  #  array.map do |st|
+  #    if st[-1,1] == '.'
+  #      st 
+  #    else
+  #      st << '.'
+  #    end
+  #  end
+  #end
+
+  def punctuate_initials(initials, punc='.')
+    initials.split('').map { |i|  i + punc }.join('')
+  end
+
+  def format(cits)
+    as_strings = cits.map do |cit|
+      @cit = cit
+      finish(send(@cit.bibtype))
+    end
+    @media_obj.list(as_strings)
+  end
+
+  # if given an array, will finish it with compaction and periodizing
+  # otherwise, won't touch it
+  def finish(arg)
+    if arg.is_a? Array
+      periodize(arg.compact).join(' ')
+    else
+      arg
+    end
+  end
+
+  # probably only the first argument would you ever change
+  # if delim is nil, then et al. format is used (1 author, fine, 2 authors
+  # connect with 'and', 3 authors = et al
+  def author_list(after_initials='.', separate_last_and_initials=' ', delim=", ", and_word="and", join_with_ands=false)
+    if authors.is_a? String
+      authors
+    else 
+      names = []
+      names = authors.map do |auth|
+        auth.last + separate_last_and_initials + punctuate_initials(auth.initials, after_initials)
+      end
+      if delim.nil?
+        case authors.size
+        when 1
+          names.first
+        when 2
+          names.join(" #{and_word} ")
+        else
+          names.first + ' ' + i('et al.')
+        end
+      else
+        if join_with_ands   
+          names[0...-1].join(delim) + " #{and_word} " + names[-1]
+        else
+          names.join(delim)
+        end
+      end
+    end
+  end
+
+  #############################
+  # universal format methods
+  #############################
+  
+  # parenthesizes any 'true' object that has to_s method, otherwise ''
+  def par(st)
+    if st
+      "(#{st})"
+    else
+      ''
+    end
+  end
+ 
+end
+
+