rif-cs 1.0.0

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem 'nokogiri'
+
+group :development do
+  gem "rspec"
+  gem "rdoc"
+  gem "bundler", "~> 1.1.0"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.3)
+    nokogiri (1.5.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.1.0)
+  jeweler (~> 1.8.3)
+  nokogiri
+  rdoc
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Sean McCarthy
+
+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,9 @@
+= ruby_rif-cs
+
+A module to help generate {RIF-CS}[http://ands.org.au/resource/rif-cs.html]
+
+== Copyright
+
+Copyright (c) 2012 Intersect Australia Ltd. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+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 = "rif-cs"
+  gem.homepage = "http://github.com/IntersectAustralia/ruby_rif-cs"
+  gem.license = "MIT"
+  gem.summary = %Q{Instrument your class to return RIF-CS}
+  gem.description = %Q{Instrument your class to return RIF-CS}
+  gem.email = "sean@intersect.org.au"
+  gem.authors = ["Sean McCarthy"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "RIF-CS (for Ruby) #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/rif-cs.rb

@@ -0,0 +1,167 @@
+require 'rif-cs/party'
+require 'rif-cs/service'
+require 'rif-cs/collection'
+require 'rif-cs/activity'
+
+module RIFCS
+
+  def self.camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/(?:_)(.)/) { $1.upcase }
+  end
+
+  def self.list_of(list, name, xml)
+    #method_name = "#{prefix}_#{name}"
+    #return unless respond_to?(method_name.to_sym)
+#puts list.inspect
+    list.each do |attrs|
+      xml.send(camelize(name), attrs[:value], attrs.select{|k| k != :value})
+    end
+  end
+
+  def self.names(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |name|
+      xml.name_(:dateFrom => name[:date_from], :dateTo => name[:date_to], :type => name[:type], 'xml:lang' => name[:xmllang]) do
+        name[:name_parts].each do |part|
+          xml.namePart_(part[:value], :type => part[:type])
+        end
+      end
+    end
+  end
+
+  def self.locations(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |location|
+      xml.location_(:dateFrom => location[:date_from], :dateTo => location[:date_to], :type => location[:type]) do
+        addresses(location[:addresses], xml)
+        spatials(location[:spatials], xml)
+      end
+    end
+  end
+
+  def self.addresses(addr_list, xml)
+    return if addr_list.nil? or addr_list.empty?
+    xml.address_ do
+      addr_list.each do |addr|
+        electronic_addresses(addr[:electronic], xml)
+        physical_addresses(addr[:physical], xml)
+      end
+    end
+  end
+
+  def self.electronic_addresses(addr_list, xml)
+    return if addr_list.nil? or addr_list.empty?
+    addr_list.each do |addr|
+      xml.electronic_(:type => addr[:type]) do
+        xml.value_ addr[:value]
+        if addr.has_key?(:args)
+          addr[:args].each do |arg|
+            xml.arg_(arg[:value], :required => arg[:required], :type => arg[:type], :use => arg[:use])
+          end
+        end
+      end
+    end
+  end
+
+  def self.physical_addresses(addr_list, xml)
+    return if addr_list.nil? or addr_list.empty?
+    addr_list.each do |addr|
+      xml.physical_(:type => addr[:type], 'xml:lang' => addr[:xmllang]) do
+        addr[:address_parts].each do |addr_part|
+          xml.addressPart_(addr_part[:value], :type => addr_part[:type])
+        end
+      end
+    end
+  end
+
+  def self.coverage(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |coverage|
+      xml.coverage_ do
+        spatials(coverage[:spatials], xml)
+        temporals(coverage[:temporals], xml)
+      end
+    end
+  end
+
+  def self.spatials(spatial_list, xml)
+    return if spatial_list.nil? or spatial_list.empty?
+    spatial_list.each do |addr|
+      xml.spatial_(addr[:value], :type => addr[:type], 'xml:lang' => addr[:xmllang])
+    end
+  end
+
+  def self.temporals(temp_list, xml)
+    return if temp_list.nil? or temp_list.empty?
+    temp_list.each do |temp|
+      xml.temporal_ do
+        temp[:dates].each do |date_elem|
+          xml.date_(date_elem[:value], :dateFormat => date_elem[:date_format], :type => date_elem[:type])
+        end
+        temp[:text].each do |text|
+          xml.text_ text
+        end
+      end
+    end
+  end
+
+  def self.related_objects(obj, xml)
+    return if obj.nil?
+    obj.each do |rel_type, relations|
+      relations.each do |rel|
+        xml.relatedObject do
+          xml.key(rel[:key])
+          xml.relation_(:type => camelize(rel_type)) do
+            rel[:relation].each do |key, value|
+              xml.send(key, value)
+            end if rel.has_key?(:relation)
+          end
+        end
+      end
+    end
+  end
+
+  def self.related_info(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |info|
+      xml.relatedInfo_(:type => info[:type]) do
+        xml.identifier_(info[:identifier][:value], :type => info[:identifier][:type])
+        xml.title_(info[:title]) if info.has_key?(:title)
+        xml.notes(info[:notes]) if info.has_key?(:notes)
+      end
+    end 
+  end
+
+  def self.rights(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |rights|
+      xml.rights_ do
+        xml.rightsStatement_(rights[:rights_statement][:value], :rightsUri => rights[:rights_statement][:rights_uri]) if rights.has_key?(:rights_statement)
+        xml.licence_(rights[:licence][:value], :rightsUri => rights[:licence][:rights_uri]) if rights.has_key?(:licence)
+        xml.accessRights_(rights[:access_rights][:value], :rightsUri => rights[:access_rights][:rights_uri]) if rights.has_key?(:access_rights)
+      end
+    end
+  end
+
+  def self.subjects(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |subject|
+      xml.subject_(subject[:value], :termIdentifier => subject[:term_identifier], :type => subject[:type], 'xml:lang' => subject[:xmllang])
+    end
+  end
+
+  def self.existence_dates(list, xml)
+    return if list.nil? or list.empty?
+    list.each do |dates|
+      xml.existenceDates_ do
+        [:start_date, :end_date].each do |datetype|
+          date_obj = dates[datetype]
+          next if date_obj.nil?
+          xml.send(camelize(datetype), date_obj[:value], :dateFormat => date_obj[:date_format])
+        end
+      end
+    end
+  end
+
+end
+

data/lib/rif-cs/activity.rb

@@ -0,0 +1,45 @@
+module RIFCS
+  module Activity
+    include RIFCS
+    require 'nokogiri'
+
+    def to_rifcs(encoding='UTF-8')
+      Nokogiri::XML::Builder.new(:encoding => encoding) do |xml|
+        xml.registryObject_(:group => activity_group) do
+
+          xml.key_ activity_key
+          xml.originatingSource_ activity_originating_source if respond_to?(:activity_originating_source)
+
+          xml.activity_(:dateModified => activity_date_modified, :type => activity_type) do
+            RIFCS::list_of(activity_identifiers, :identifiers, xml) if respond_to?(:activity_identifiers)
+
+            RIFCS::names(activity_names, xml) if respond_to?(:activity_names)
+
+            RIFCS::locations(activity_locations, xml) if respond_to?(:activity_locations)
+
+            RIFCS::coverage(activity_coverage, xml) if respond_to?(:activity_coverage)
+
+            RIFCS::list_of(activity_descriptions, :descriptions, xml) if respond_to?(:activity_descriptions)
+
+            RIFCS::existence_dates(activity_existence_dates, xml) if respond_to?(:activity_existence_dates)
+
+            RIFCS::related_info(activity_related_info, xml) if respond_to?(:activity_related_infos)
+
+            RIFCS::related_objects(activity_related_objects, xml) if respond_to?(:activity_related_objects)
+
+            RIFCS::rights(activity_rights, xml) if respond_to?(:activity_rights)
+
+            RIFCS::subjects(activity_subjects, xml) if respond_to?(:activity_subjects)
+
+          end # activity
+        end
+      end
+    end
+
+    def activity_key
+      raise "Supply a activity_key attribute or implement a method"
+    end
+
+
+  end
+end

data/lib/rif-cs/collection.rb

@@ -0,0 +1,74 @@
+module RIFCS
+  module Collection
+    include RIFCS
+    require 'nokogiri'
+
+    def to_rifcs(encoding='UTF-8')
+      Nokogiri::XML::Builder.new(:encoding => encoding) do |xml|
+        xml.registryObject_(:group => collection_group) do
+
+          xml.key_ collection_key
+          xml.originatingSource_ collection_originating_source if respond_to?(:collection_originating_source)
+
+          xml.collection_(:dateModified => collection_date_modified, :type => collection_type, :dateAccessioned => collection_date_accessioned) do
+            RIFCS::list_of(collection_identifiers, :identifiers, xml) if respond_to?(:collection_identifiers)
+
+            RIFCS::names(collection_names, xml) if respond_to?(:collection_names)
+
+            RIFCS::locations(collection_locations, xml) if respond_to?(:collection_locations)
+
+            RIFCS::coverage(collection_coverage, xml) if respond_to?(:collection_coverage)
+
+            RIFCS::related_objects(collection_related_objects, xml) if respond_to?(:collection_related_objects)
+
+            RIFCS::subjects(collection_subjects, xml) if respond_to?(:collection_subjects)
+
+            RIFCS::list_of(collection_descriptions, :descriptions, xml) if respond_to?(:collection_descriptions)
+
+            RIFCS::rights(collection_rights, xml) if respond_to?(:collection_rights)
+
+            RIFCS::related_info(collection_related_info, xml) if respond_to?(:collection_related_infos)
+
+            citation_info(collection_citation_info, xml) if respond_to?(:collection_citation_info)
+          end # collection
+        end
+      end
+    end
+
+    def citation_info(list, xml)
+      return if list.nil? or list.empty?
+      list.each do |citation|
+        xml.fullCitation_(citation[:full_citation][:value], :style => citation[:full_citation][:style]) 
+        xml.citationMetadata_ do
+          meta_obj = citation[:citation_metadata]
+          xml.identifier(meta_obj[:identifier][:value], :type => meta_obj[:identifier][:type])
+          meta_obj[:contributor].each do |name|
+            xml.contributor_(:seq => name[:seq]) do
+              name[:name_parts].each do |part|
+                xml.namePart_(part[:value], :type => part[:type])
+              end
+            end
+          end
+          xml.title_(meta_obj[:title])
+          xml.edition_(meta_obj[:edition])
+          xml.publisher_(meta_obj[:publisher]) if meta_obj.has_key?(:publisher)
+          xml.placePublished_(meta_obj[:place_published])
+          meta_obj[:date].each do |d|
+            xml.date_(d[:value], :type => d[:type])
+          end if meta_obj.has_key?(:date)
+          xml.url_(meta_obj[:url])
+          xml.context_(meta_obj[:context])
+        end
+      end
+    end
+
+    def collection_key
+      raise "Supply a collection_key attribute or implement a method"
+    end
+
+
+    def collection_originating_source
+      raise "Supply a collection_originating_source attribute or implement a method"
+    end
+  end
+end

data/lib/rif-cs/party.rb

@@ -0,0 +1,45 @@
+module RIFCS
+  module Party
+    include RIFCS
+    require 'nokogiri'
+
+    def to_rifcs(encoding='UTF-8')
+      Nokogiri::XML::Builder.new(:encoding => encoding) do |xml|
+        xml.registryObject_(:group => party_group) do
+
+          xml.key_ party_key
+          xml.originatingSource_ party_originating_source if respond_to?(:party_originating_source)
+
+          xml.party_(:dateModified => party_date_modified, :type => party_type) do
+            RIFCS::list_of(party_identifiers, :identifiers, xml) if respond_to?(:party_identifiers)
+
+            RIFCS::names(party_names, xml) if respond_to?(:party_names)
+
+            RIFCS::locations(party_locations, xml) if respond_to?(:party_locations)
+
+            RIFCS::coverage(party_coverage, xml) if respond_to?(:party_coverage)
+
+            RIFCS::list_of(party_descriptions, :descriptions, xml) if respond_to?(:party_descriptions)
+
+            RIFCS::existence_dates(party_existence_dates, xml) if respond_to?(:party_existence_dates)
+
+            RIFCS::related_info(party_related_info, xml) if respond_to?(:party_related_infos)
+
+            RIFCS::related_objects(party_related_objects, xml) if respond_to?(:party_related_objects)
+
+            RIFCS::rights(party_rights, xml) if respond_to?(:party_rights)
+
+            RIFCS::subjects(party_subjects, xml) if respond_to?(:party_subjects)
+
+          end # party
+        end
+      end
+    end
+
+    def party_key
+      raise "Supply a party_key attribute or implement a method"
+    end
+
+
+  end
+end