ruby-avm-library 0.0.1

data/lib/avm/image_quality.rb

@@ -0,0 +1,10 @@
+require 'avm/controlled_vocabulary'
+
+module AVM
+  module ImageQuality
+    TERMS = %w{Good Moderate Poor}
+
+    include AVM::ControlledVocabulary
+  end
+end
+

data/lib/avm/image_type.rb

@@ -0,0 +1,10 @@
+require 'avm/controlled_vocabulary'
+
+module AVM
+  module ImageType
+    TERMS = %w{Observation Artwork Photographic Planetary Simulation Chart Collage}
+
+    include ControlledVocabulary
+  end
+end
+

data/lib/avm/node.rb

@@ -0,0 +1,28 @@
+require 'delegate'
+
+module AVM
+  # Delegate of Nokogiri::XML::Node which fixes XPath queries to use the correct namespace prefixes
+  class Node < DelegateClass(Nokogiri::XML::Node)
+    def initialize(xmp, node)
+      @xmp, @node = xmp, node
+      super(@node)
+    end
+
+    def at_xpath(path)
+      if node = @node.at_xpath(path, @xmp.namespaces)
+        self.class.new(@xmp, node)
+      else
+        nil
+      end
+    end
+
+    def search(path)
+      self.class.from_nodeset(@xmp, @node.search(path, @xmp.namespaces))
+    end
+
+    def self.from_nodeset(xmp, nodeset)
+      nodeset.collect { |node| new(xmp, node) }
+    end
+  end
+end
+

data/lib/avm/observation.rb

@@ -0,0 +1,76 @@
+module AVM
+  # An individual observation by a single instrument w/ specific settings.
+  # Astronomical images are made of one or more Observations.
+  class Observation
+    AVM_SINGLE_FIELDS = %w{Facility Instrument Spectral.ColorAssignment Spectral.Band Spectral.Bandpass Spectral.CentralWavelength Temporal.StartTime Temporal.IntegrationTime DatasetID}
+    AVM_SINGLE_METHODS = [ :facility, :instrument, :color_assignment, :band, :bandpass, :wavelength, :string_start_time, :integration_time, :dataset_id ]
+    AVM_SINGLES = AVM_SINGLE_FIELDS.zip(AVM_SINGLE_METHODS)
+
+    attr_reader :image, :options
+
+    def initialize(image, options = {})
+      @image, @options = image, options
+      @options[:start_time] = @options[:string_start_time] || @options[:start_time]
+    end
+  
+    def method_missing(method)
+      @options[method]
+    end
+
+    def wavelength
+      (wavelength = @options[:wavelength]) ? wavelength.to_f : nil
+    end
+
+    def start_time
+      (Time.parse(@options[:start_time]) rescue nil)
+    end
+
+    def string_start_time
+      start_time ? start_time.strftime('%Y-%m-%dT%H:%M') : nil
+    end
+
+    def to_h
+      Hash[@options.keys.reject { |key| key == :string_start_time }.collect { |key| [ key, send(key) ] }]
+    end
+
+    def self.from_xml(image, document)
+      observation_parts = {}
+
+      document.get_refs do |refs|
+        AVM_SINGLES.each do |name, method|
+          if node = refs[:avm].at_xpath(".//avm:#{name}")
+            observation_parts[method] = node.text.split(';').collect(&:strip)
+          end
+        end
+      end
+
+      begin
+        observation = {}
+
+        observation_parts.each do |method, parts|
+          if part = parts.shift
+            observation[method] = part if part != '-'
+          end
+        end
+
+        image.create_observation(observation) if !observation.empty?
+      end while !observation.empty?
+    end
+
+    def self.add_to_document(document, observations)
+      field_values = {}
+      AVM_SINGLES.each do |name, method|
+        observations.each do |observation|
+          field_values[name] ||= []
+          field_values[name] << (observation.send(method) || '-')
+        end
+      end
+
+      document.get_refs do |refs|
+        field_values.each do |name, value|
+          refs[:avm].add_child(%{<avm:#{name}>#{value.join(',')}</avm:#{name}>})
+        end
+      end
+    end
+  end
+end

data/lib/avm/spatial_quality.rb

@@ -0,0 +1,10 @@
+require 'avm/controlled_vocabulary'
+
+module AVM
+  module SpatialQuality
+    TERMS = %w{Full Position}
+
+    include AVM::ControlledVocabulary
+  end
+end
+

data/lib/avm/xmp.rb

@@ -0,0 +1,157 @@
+require 'nokogiri'
+require 'avm/node'
+
+module AVM
+  # An XMP document wrapper, providing namespace handling and document reference assistance.
+  class XMP
+    PREFIXES = {
+      'dc' => 'Dublin Core',
+      'Iptc4xmpCore' => 'IPTC',
+      'photoshop' => 'Photoshop',
+      'avm' => 'AVM'
+    }
+
+    REQUIRED_NAMESPACES = {
+      :x => "adobe:ns:meta/",
+      :rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+      :dc => "http://purl.org/dc/elements/1.1/",
+      :photoshop => "http://ns.adobe.com/photoshop/1.0/",
+      :avm => "http://www.communicatingastronomy.org/avm/1.0/",
+      :Iptc4xmpCore => "http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/"
+    }
+
+    attr_reader :doc
+
+    def initialize(doc = nil)
+      @doc = doc || empty_xml_doc
+
+      raise StandardError.new('not a Nokogiri node') if !@doc.kind_of?(::Nokogiri::XML::Node)
+
+      ensure_namespaces!
+      ensure_descriptions_findable!
+    end
+
+    def get_refs
+      yield Hash[[ :dublin_core, :iptc, :photoshop, :avm ].collect { |key| [ key, send(key) ] }]
+    end
+
+    def self.from_string(string)
+      new(Nokogiri::XML(string))
+    end
+
+    def ensure_xmlns(string)
+      string.gsub(%r{([</@])(\w+):}) { |all, matches| $1 + (prefix_map[$2] || $2) + ':' }
+    end
+
+    alias :% :ensure_xmlns
+
+    def ensure_xpath(path)
+      [ ensure_xmlns(path), namespaces ]
+    end
+
+    def search(path, node = doc)
+      node.search(*ensure_xpath(path))
+    end
+
+    def at_xpath(path, node = doc)
+      node.at_xpath(*ensure_xpath(path))
+    end
+
+    def namespaces
+      @namespaces ||= doc.document.collect_namespaces
+    end
+
+    private
+      def current_namespaces
+        doc.document.collect_namespaces
+      end
+
+      def prefix_map
+        @prefix_map ||= Hash[current_namespaces.collect { |prefix, namespace| 
+          self.class.get_required_namespace(namespace, prefix.gsub('xmlns:', '')) 
+        }.compact]
+      end
+      
+      def self.get_required_namespace(namespace, prefix)
+        result = nil
+        REQUIRED_NAMESPACES.each do |original_prefix, target_namespace|
+          result = [ original_prefix.to_s, prefix ] if namespace == target_namespace
+        end
+        result
+      end
+
+      def ensure_namespaces!
+        existing = current_namespaces
+
+        REQUIRED_NAMESPACES.each do |namespace, url|
+          doc.root.add_namespace_definition(namespace.to_s, url) if !existing.values.include?(url)
+        end
+      end
+
+      def ensure_descriptions_findable!
+        added = []
+
+        search('//rdf:Description').each do |description|
+          if first_child = description.first_element_child
+            if namespace = first_child.namespace
+              prefix = namespace.prefix
+
+              if prefix_description = PREFIXES[prefix_map.index(prefix)]
+                description[self % 'rdf:about'] = prefix_description
+                added << prefix
+              end
+            end
+          end
+        end
+
+        ensure_rdf!
+        ensure_missing_descriptions!(added)
+      end
+
+      def ensure_rdf!
+        doc.first_element_child.add_child(self % '<rdf:RDF />') if !at_xpath('//rdf:RDF')
+      end
+
+      def ensure_missing_descriptions!(already_added)
+        PREFIXES.each do |prefix, about|
+          if !already_added.include?(prefix)
+            at_xpath('//rdf:RDF').add_child(self % %{<rdf:Description rdf:about="#{about}" />})
+          end
+        end
+      end
+
+      def dublin_core
+        at_rdf_description "Dublin Core"
+      end
+
+      def iptc
+        at_rdf_description "IPTC"
+      end
+
+      def avm
+        at_rdf_description "AVM"
+      end
+
+      def photoshop
+        at_rdf_description "Photoshop"
+      end
+
+      def at_rdf_description(about)
+        AVM::Node.new(self, at_xpath(%{//rdf:Description[@rdf:about="#{about}"]}))
+      end
+
+      def empty_xml_doc
+        Nokogiri::XML(<<-XML)
+<x:xmpmeta xmlns:x="adobe:ns:meta/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+  <rdf:RDF>
+    <rdf:Description rdf:about="Dublin Core" />
+    <rdf:Description rdf:about="IPTC" />
+    <rdf:Description rdf:about="Photoshop" />
+    <rdf:Description rdf:about="AVM" />
+  </rdf:RDF>
+</x:xmpmeta>
+        XML
+      end
+  end
+end
+

data/lib/ruby-avm-library.rb

@@ -0,0 +1,7 @@
+module Ruby
+  module Avm
+    module Library
+      # Your code goes here...
+    end
+  end
+end

data/lib/ruby-avm-library/version.rb

@@ -0,0 +1,7 @@
+module Ruby
+  module Avm
+    module Library
+      VERSION = "0.0.1"
+    end
+  end
+end

data/reek.watchr

@@ -0,0 +1,12 @@
+watch('lib/(.*)\.rb') { |file| reek(file[0]) }
+watch('spec/(.*)_spec\.rb') { |file| reek("lib/#{file[1]}.rb") }
+
+def reek(file = nil)
+  file ||= Dir['lib/**/*.rb'].join(' ')
+  spec_file = file.gsub('lib/', 'spec/').gsub('.rb', '_spec.rb')
+
+  system %{bundle exec rspec -c #{spec_file}}
+  system %{reek #{file}}
+end
+
+reek

data/ruby-avm-library.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby-avm-library/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ruby-avm-library"
+  s.version     = Ruby::Avm::Library::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Bintz"]
+  s.email       = ["bintz@stsci.edu"]
+  s.homepage    = ""
+  s.summary     = %q{Library for reading and writing AVM XMP metadata}
+  s.description = %q{This library makes working with Astronomy Visualization Metadata (AVM) tags within XMP easier. Reading existing XMP files and generating new ones is made simple through a fully object oriented interface.}
+
+  s.rubyforge_project = "ruby-avm-library"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mocha'
+
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'thor'
+end

data/spec/avm/contact_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'avm/contact'
+
+describe AVM::Contact do
+  let(:contact) { AVM::Contact.new(contact_info) }
+
+  subject { contact }
+
+  let(:contact_info) { {
+    :name => name,
+    :email => email,
+    :telephone => telephone,
+    :address => address,
+    :city => city,
+    :state => state,
+    :postal_code => postal_code,
+    :country => country
+  } }
+
+  let(:name) { 'John Bintz' }
+  let(:email) { 'bintz@stsci.edu' }
+  let(:telephone) { '800-555-1234' }
+  let(:address) { '3700 San Martin Drive' }
+  let(:city) { 'Baltimore' }
+  let(:state) { 'Maryland' }
+  let(:postal_code) { '21218' }
+  let(:country) { 'USA' }
+
+  its(:name) { should == name }
+  its(:email) { should == email }
+  its(:telephone) { should == telephone }
+  its(:address) { should == address }
+  its(:city) { should == city }
+  its(:state) { should == state }
+  its(:province) { should == state }
+  its(:postal_code) { should == postal_code }
+  its(:zip) { should == postal_code }
+  its(:country) { should == country }
+
+  its(:to_h) { should == {
+    :name => name,
+    :email => email,
+    :telephone => telephone,
+    :address => address,
+    :city => city,
+    :state => state,
+    :postal_code => postal_code,
+    :country => country
+  } }
+
+  its(:to_creator_list_element) { should == "<rdf:li>John Bintz</rdf:li>" }
+
+  describe 'mappings' do
+    AVM::Contact::FIELD_MAP.each do |key, value|
+      context "#{key} => #{value}" do
+        let(:contact_info) { { key => "test" } }
+
+        its(value) { should == "test" }
+      end
+    end
+  end
+
+  context '#<=>' do
+    let(:second_contact) { AVM::Contact.new(second_contact_info) }
+    let(:contacts) { [ contact, second_contact ] }
+
+    let(:second_name) { 'Aohn Bintz' }
+
+    let(:second_contact_info) { {
+      :name => second_name,
+      :email => email,
+      :telephone => telephone,
+      :address => address,
+      :city => city,
+      :state => state,
+      :postal_code => postal_code,
+      :country => country
+    } }
+
+    subject { contacts.sort }
+
+    context 'primary not set' do
+      it { should == [ second_contact, contact ] }
+    end
+
+    context 'primary set' do
+      before { contact.primary = true }
+
+      it { should == [ contact, second_contact ] }
+    end
+  end
+end
+