mead 0.0.5

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/Gemfile

@@ -0,0 +1,27 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "rmagick", ">= 0"
+gem "nokogiri", "= 1.4.3.1"
+gem "json", ">= 0"
+gem "trollop", ">= 0"
+
+gem "fastercsv", ">= 0", :platforms => :ruby_18
+
+gem "gbarcode", ">= 0.98.20", :platforms => :ruby_18
+
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem "reek", "~> 1.2.8"
+  gem "roodi", "~> 2.1.0"
+  gem "fakeweb", ">= 0"
+  gem "ruby-debug"
+end

data/Gemfile.lock

@@ -0,0 +1,56 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    columnize (0.3.2)
+    fakeweb (1.3.0)
+    fastercsv (1.5.4)
+    gbarcode (0.98.20)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.5.0)
+    linecache (0.43)
+    nokogiri (1.4.3.1)
+    rake (0.8.7)
+    rcov (0.9.9)
+    reek (1.2.8)
+      ruby2ruby (~> 1.2)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    rmagick (2.13.1)
+    roodi (2.1.0)
+      ruby_parser
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.5)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    shoulda (2.11.3)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  fakeweb
+  fastercsv
+  gbarcode (>= 0.98.20)
+  jeweler (~> 1.5.1)
+  json
+  nokogiri (= 1.4.3.1)
+  rcov
+  reek (~> 1.2.8)
+  rmagick
+  roodi (~> 2.1.0)
+  ruby-debug
+  shoulda
+  trollop

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 North Carolina State University
+
+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.rdoc

@@ -0,0 +1,86 @@
+= mead
+
+Metadata from Encoded Archival Description.
+
+The core of this code is an identifier which expresses the location of an object
+in a physical collection. This identifier can be used as a filename for 
+digitized objects during scanning. Later descriptive metadata from EAD XML can
+be extracted. This descriptive metadata can then be applied to stub records for 
+each digital object, which can quickly make digitized objects as discoverable as
+the archival description makes the physical collections.
+
+== Functionality
+
+- Parse EAD XML and output all identifiers (with other metadata) for all the 
+component parts. This export can be CSV or JSON.
+- Resolve a filename-identifier to a location in the physical collection and
+extract related metadata up through the hierarchy
+- Create barcodes based on an identifiers.
+- Validate whether an identifier is well-formed and valid by resolving to a 
+component part in the EAD XML.
+- Commandline tools for each of these functions.
+
+== Installation
+
+- clone from github and build the gem from source at this time
+
+== Identifier specification in brief
+
+These identifiers encode information about where original objects in the physical
+collection are located. To make this work for as wide a range of encoded EAD XML
+and archival arrangement and processing practice as we could, it includes many
+pieces of information to help insure uniqueness within a collection.
+
+Indentifiers are made up of 6 possible segments. Segments are separated by a
+single dash - to aid in readability. Take the sample identifier
+mc00240-001-ff0001-000-001_0001
+
+1.  mc00240: Collection number. 
+    The first section identifies the collection and 
+    is usually the eadid of the collection. mc00240 refers to 
+    http://www.lib.ncsu.edu/findingaids/mc00240
+
+2.  001: Series number. 
+    This is the number of the series of which the physical 
+    item is a part. It is a three digit, left zero padded number.
+
+3.  ff0001: Container code & number. 
+    The third segment is made up of a two letter
+    code for different container types. The list of current codes can be seen in
+    lib/mead.rb as Mead::CONTAINER_MAPPING. (These are the codes NCSU uses for 
+    encoding containers in EAD XML.) The second part is a three digit, left zero
+    padded number. This example would be flatfolder 1.
+
+4.  000: Folder number. 
+    In this case there is no second container, so the folder
+    number is 000. If there was a container with the "folder" value for the type 
+    attribute and text content of "3", then this segment would be 003. In the case
+    where the value is other than "folder" the container code is used in front. So
+    a "mapcase" container could be "mc003" when the map case is the third map case
+    in the parent container.
+
+5.  001: Item number. 
+    This is the number of the item in the container. It is an
+    arbitrary incremented number. Multiple pages of multipage document would 
+    be considered as one item and so would get the same item number.
+
+6.  _0001: Sequence number (optional). 
+    If there is a multipage document then this
+    section can be used. This is the sequence or page number. It is preceded with 
+    an underscore.
+
+
+== TODO
+
+- Test for use by other institutions. I'm happy to help make this code work for
+the needs of other institutions.
+- Get more examples for more tests.
+- Better exceptions.
+
+== Author 
+
+Jason Ronallo
+
+== Copyright
+
+Copyright (c) 2010 North Carolina State University. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "mead"
+  gem.homepage = "http://github.com/jronallo/mead"
+  gem.license = "MIT"
+  gem.summary = %Q{Extract identifiers and metadata from EAD XML.}
+  gem.description = %Q{Extract identifiers and metadata from EAD XML.}
+  gem.email = "jronallo@gmail.com"
+  gem.authors = ["Jason Ronallo"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+require 'roodi'
+require 'roodi_task'
+RoodiTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mead #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.0.5

data/bin/automead

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pp'
+require 'rubygems'
+require 'mead'
+require 'mead/trollop'
+require 'trollop'
+include Mead::TrollopOptions
+
+opts = Trollop::options do
+  banner <<-EOS
+This script takes a mead (an identifier of a particular format) and returns 
+metadata for it.
+
+Usage Example:
+  automead --mead mc00240-001-ff0052-000-001 --baseurl http://www.lib.ncsu.edu/findingaids --ruby [options]
+
+Default output is pretty printed Ruby. Multiple outputs can be specified.
+
+where options are:
+EOS
+  opt :mead, "A mead-style identifier", :required => true, :type => String
+  opt :baseurl, 'Specify just the base URL for grabbing the EAD XML if it is of the format baseurl/eadid.xml.', :type => String
+  opt :url, 'Specify the whole URL for grabbing the EAD XML.', :type => String
+  opt :file, 'File path to EAD XML.', :type => String
+  opt :ruby, 'Output as pretty printed Ruby. Default.'
+  opt :json, 'Output as JSON'
+end
+
+check_options(opts)
+location = get_location(opts)
+
+mead = Mead::Identifier.new(opts[:mead], location)
+
+if mead.valid?
+  pp mead.metadata if opts[:ruby]
+  puts mead.metadata.to_json if opts[:json]
+  if !opts[:ruby] and !opts[:json]
+    pp mead.metadata
+  end
+else
+  response = {}
+  response[:status] = 'Invalid'
+  response.merge!(mead.errors)
+  pp response if opts[:ruby]
+  if opts[:json]
+    response[:mead] = response[:mead].map{|error| error.message }
+    puts response.to_json
+  end
+  if !opts[:ruby] and !opts[:json]
+    pp response
+  end
+end

data/bin/ead2meads

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pp'
+require 'rubygems'
+require 'mead'
+require 'json'
+require 'mead/trollop'
+require 'trollop'
+include Mead::TrollopOptions
+
+#eadid, baseurl
+opts = Trollop::options do
+  banner <<-EOS
+This script takes an EAD XML document and returns mead identifiers and metadata
+for it. It is possible to validate whether the parsed EAD XML provides unique
+identifiers for all component parts.
+
+Usage Example:
+  ead2meads --url http://www.lib.ncsu.edu/findingaids/mc00240.xml [options]
+
+Default output is pretty printed Ruby. Multiple outputs can be specified.
+
+where options are:
+EOS
+  opt :eadid, 'Eadid of the EAD.', :type => String
+  opt :url, 'Specify the whole URL for grabbing the EAD XML.', :type => String
+  opt :file, 'File path to EAD XML.', :type => String
+  opt :ruby, 'Output as pretty printed Ruby.'
+  opt :json, 'Output as JSON'
+  opt :csv, 'Output as CSV. Default.'
+  opt :valid, 'Only outputs whether the EAD creates valid identifiers or not.'
+  opt :verbose, 'Outputs the list of invalid containers in cases where invalid.'
+  opt :meadsonly, 'Only output a list of mead identifiers.'
+end
+
+check_options(opts)
+location = get_location_options(opts)
+
+options = {}
+options[:eadid] = opts[:eadid] if opts[:eadid]
+options.merge!(location)
+
+begin
+  ead = Mead::Ead.new(options)
+rescue => e
+  puts e
+  puts e.backtrace
+  exit
+end
+
+if opts[:valid]
+  if ead.valid?
+    puts 'Valid.'
+  else
+    if opts[:verbose]
+      puts Mead::Ead.to_csv(ead.invalid) if opts[:csv]
+      pp ead.invalid           if opts[:ruby]
+      puts ead.invalid.to_json if opts[:json]
+
+      if !opts[:csv] and !opts[:ruby] and !opts[:json]
+        puts Mead::Ead.to_csv(ead.invalid)
+      end
+    else
+      if opts[:json]
+        json_output = {:dups => ead.dups.length, :invalid => ead.invalid.length, :total => ead.containers.length}.to_json
+        puts json_output
+      else
+        puts 'Invalid!'
+        puts 'Number of duplicate meads: ' + ead.dups.length.to_s
+        puts 'Effected Containers: ' + ead.invalid.length.to_s
+        puts 'Short meads:' + ead.short_meads.length.to_s
+      end
+    end
+
+
+  end
+else
+  if opts[:meadsonly]
+    puts ead.meads.join("\n")
+  else
+    puts ead.to_csv             if opts[:csv]
+    pp ead.containers           if opts[:ruby]
+    puts ead.containers.to_json if opts[:json]
+
+    if !opts[:csv] and !opts[:ruby] and !opts[:json]
+      puts ead.to_csv
+    end
+  end
+end
+

data/bin/emv

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require 'pp'
+require 'rubygems'
+require 'json'
+
+# does an Mead::Ead validity check on a directory of EADs using the ead2meads tool
+dir = ARGV[0] || (puts 'Give the path to a directory of EADs to validate!'; exit)
+
+valid = []
+invalid = []
+invalid_responses = {}
+
+files = Dir.glob(File.join(dir, '*.xml'))
+puts files.length
+files.each_with_index do |path, i|
+  begin
+    eadid = File.basename(path, '.xml')
+    cmd = File.join(File.dirname(__FILE__), 'ead2meads')
+    response = `#{cmd} --file #{path} --json --valid`.chomp
+    pp response
+    if response == 'Valid.'
+      puts i.to_s + ' ' + eadid + ': valid'
+      valid << eadid
+    elsif response.empty?
+    else
+      puts i.to_s + ' ' + eadid + ': !'
+      invalid << eadid
+      invalid_responses[eadid] = response
+    end
+  rescue => e
+    invalid_responses[eadid] = e.backtrace
+  end
+end
+
+puts 'Valid: ' + valid.length.to_s
+puts 'Invalid: ' + invalid.length.to_s
+
+puts 'Show all Invalid?'
+answer = STDIN.gets
+if answer.chomp == 'y'
+  pp invalid.sort
+end
+
+puts 'Show invalid responses?'
+answer = STDIN.gets
+if answer.chomp == 'y'
+  invalid_responses.each do |k,v|
+    puts k
+    puts v.sub("Invalid!\n", '')
+    puts
+  end
+end
+
+puts 'Show setdata?'
+answer = STDIN.gets
+if answer.chomp == 'y'
+  data = [%Q|google.load("visualization", "1", {packages:["corechart"]});
+      google.setOnLoadCallback(drawChart);
+      function drawChart() {
+        var data = new google.visualization.DataTable();","data.addColumn('string', 'eadid');|,
+        "data.addColumn('number', 'duplicates');",
+        "data.addColumn('number', 'invalid containers');"]
+  data << "data.addRows(#{invalid_responses.length});"
+  invalid_order = invalid_responses.keys.sort_by do |k|
+    invalid_response = JSON.parse(invalid_responses[k])
+    invalid_responses[k]["invalid"]
+  end
+  invalid_order.each_with_index do |key, i|
+    invalid_response = JSON.parse(invalid_responses[key])
+
+    data << "data.setValue(#{i}, 0, '#{key}');"
+    data << "data.setValue(#{i}, 1, #{invalid_response['dups']});"
+    data << "data.setValue(#{i}, 2, #{invalid_response['invalid']});"
+  end
+  puts data.join("\n")
+end
+

data/bin/mead2barcode

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pp'
+require 'rubygems'
+require 'mead'
+require 'mead/trollop'
+require 'trollop'
+include Mead::TrollopOptions
+
+opts = Trollop::options do
+  banner <<-EOS
+This script takes a mead (an identifier of a particular format), creates a 
+barcode and returns the path to the barcode. Gbarcode and RMagick gems must be
+installed for this to work.
+
+Usage Example:
+  mead2barcode --mead mc00240-001-ff0052-000-001 --baseurl http://www.lib.ncsu.edu/findingaids --ruby [options]
+
+where options are:
+EOS
+  opt :mead, "A mead-style identifier", :type => String
+  opt :meadfile, "Path to text file with one mead identifier on each line.", :type => String
+  opt :baseurl, 'Specify just the base URL for grabbing the EAD XML if it is of the format baseurl/eadid.xml.', :type => String
+  opt :url, 'Specify the whole URL for grabbing the EAD XML.', :type => String
+  opt :file, 'File path to EAD XML.', :type => String
+  opt :dir, 'Directory to save the barcodes.', :type => String
+end
+
+unless opts[:mead] or opts[:meadfile]
+  Trollop::die 'You must specify either a single mead identifier or a file of identifiers'
+end
+
+check_options(opts)
+location = get_location(opts)
+
+if opts[:mead]
+ meads = [opts[:mead]]
+else
+  Trollop::die 'meadfile must be a valid path' unless File.exists?(opts[:meadfile])
+  meads = File.open(opts[:meadfile], 'r').read.split
+end
+
+successful_paths = []
+meads.each do |mead_identifier|
+  begin
+    mead = Mead::Identifier.new(mead_identifier, location).extract
+
+    barcode = Mead::Barcode.new(mead)
+
+    if opts[:dir]
+      Trollop::die 'Directory must exist!' unless File.exists?(opts[:dir])
+    end
+    directory = opts[:dir] || Dir.pwd
+
+    label_path = barcode.output_label(directory)
+    successful_paths << label_path
+    puts label_path
+  rescue => e
+    puts mead_identifier + ' ' + e
+  end
+end
+
+#`convert #{successful_paths.join(' ')} -append -antialias output.png`
+

data/bin/meadbfv

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pp'
+require 'rubygems'
+require 'mead'
+require 'pp'
+
+
+file = ARGV[0]
+
+filenames = File.read(file).split
+
+valid = []
+invalid = []
+filenames.each do |filename|
+  mead = Mead::Identifier.new(filename)
+  if mead.valid_format?
+    valid << filename
+  else
+    invalid << filename
+  end
+end
+
+puts "Total filenames   " + filenames.length.to_s
+puts "Unique filenames  " + filenames.uniq.length.to_s
+puts "Valid filenames   " + valid.length.to_s unless valid.empty?
+puts "Invalid filenames " + invalid.length.to_s unless invalid.empty?

data/lib/mead/barcode.rb

@@ -0,0 +1,49 @@
+module Mead
+  class Barcode
+    attr_accessor :mead
+    
+    def initialize(identifier)
+      @mead = identifier
+    end
+    
+    def output_barcode(directory)
+      bc = Gbarcode.barcode_create(@mead.mead)
+      bc.scalef = 0.5
+      bc.margin = 25
+      Gbarcode.barcode_encode(bc, Gbarcode::BARCODE_128)
+      #tempfile for eps version of barcode
+      eps_path = File.join(directory, @mead.mead + '.eps')
+      png_path = File.join(directory, @mead.mead + '-barcode.png')
+      eps = File.new(eps_path, 'w')      
+      Gbarcode.barcode_print(bc, eps, Gbarcode::BARCODE_OUT_EPS)
+      eps.close      
+      `convert +antialias #{eps_path} -background white -flatten #{png_path}`
+      File.delete(eps_path)
+      png_path      
+    end
+    
+    def output_label(directory)
+      text_path = File.join(directory, @mead.mead + '-text.png')
+      label_path = File.join(directory, @mead.mead + '-label.png')
+      `convert -font fixed -pointsize 14 -background white -fill black label:"#{label_text}" #{text_path}`
+      # convert *.png -resize 75% -append output.png
+      png_path = output_barcode(directory)
+      begin
+        `convert #{png_path} #{text_path} -append #{label_path}`
+      rescue
+      end
+      File.delete(png_path)
+      File.delete(text_path)
+      label_path
+    end
+    
+    def label_text
+      text = [@mead.mead]
+      text << @mead.metadata.first[:unittitle][0,55]
+      text.last << '...' if @mead.metadata.first[:unittitle].length > 55
+      text << @mead.metadata.first[:item_location]
+      text.join('\n')
+    end
+    
+  end
+end

data/lib/mead/container.rb

@@ -0,0 +1,21 @@
+module Mead
+  class Container
+    attr_accessor :identifier, :type, :label, :text
+    
+    def initialize(options={})
+      @type = options[:type]
+      @label = options[:label]
+      @identifier = options[:identifier]
+      @text = options[:text]
+    end
+    
+    def ==(another_container)
+      self.identifier == another_container.identifier and
+      self.type == another_container.type and
+      self.label == another_container.label and
+      self.text == another_container.text
+    end
+    
+    
+  end
+end