libis-tools 0.9.6 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abe45e9ce73f0da4087c1cbfe554a9d8d62680c9
-  data.tar.gz: 845d2bbee0b78df26160501a4a15bb532ac62e1a
+  metadata.gz: 1e717837dc7e2b3f0549cf1b6abf6ca1240f1344
+  data.tar.gz: 8310be003731268e303dd930279638d61b6a5edf
 SHA512:
-  metadata.gz: afa5e9bfd7b2ea4c908046159b718e70868fa3160559f5ebe350c5e81bf7d601dae1f7aa168cea4f914249e561fbdb627e3d67a9db19ce4b3e3fbd6e104ab4a0
-  data.tar.gz: d1f52ac47989cc3bfe353d14b15ef581c3121826a06fb1c9e240364c03a291a5ec64c66da656c9bc1c4de0825f2593f92053cdac6bdee58e7e565a75bb8c18ca
+  metadata.gz: 8fce8638e6fc55803704fda53975fedce79a0ed127c2c8e2cf7dd8b989e6d87af001a56205d1091865764c5fa99dc864dd473dd23df637b24e305f29d49d8df0
+  data.tar.gz: 8b8f8b6b0af625240709d68fd48ea75003c7fe8dbf460cdaecd4d67d6f8a2a19a9aad07daae54ab9602237769ec118807eeb6d92107b34c64d48fcb9af15ad48

data/lib/libis/tools/config_file.rb

@@ -34,8 +34,7 @@ module Libis
       #
       # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
       def initialize(file_or_hash = nil, opt = {})
-        super({}, opt)
-        self << file_or_hash
+        super _file_to_hash(file_or_hash), opt
       end
 
       # Load configuration parameters from a YAML file or Hash.
@@ -48,7 +47,21 @@ module Libis
       #
       # @param [String,Hash] file_or_hash optional String or Hash argument to initialize the data.
       def <<(file_or_hash)
-        return self if file_or_hash.nil? || (file_or_hash.respond_to?(:empty?) && file_or_hash.empty?)
+        _file_to_hash(file_or_hash).each { |key, value| self[key] = value }
+        self
+      end
+
+      # Save configuration parameters in a YAML file.
+      #
+      # @param [String] file path of the YAML file to save the configuration to.
+      def >>(file)
+        File.open(file, 'w') { |f| f.write to_hash.to_yaml }
+      end
+
+      protected
+
+      def _file_to_hash(file_or_hash)
+        return {} if file_or_hash.nil? || (file_or_hash.respond_to?(:empty?) && file_or_hash.empty?)
         hash = case file_or_hash
                  when Hash
                    yield file_or_hash if block_given?
@@ -61,16 +74,8 @@ module Libis
                  else
                    {}
                end
-        return self unless hash.is_a? Hash
-        hash.each { |key, value| self[key] = value }
-        self
-      end
-
-      # Save configuration parameters in a YAML file.
-      #
-      # @param [String] file path of the YAML file to save the configuration to.
-      def >>(file)
-        File.open(file, 'w') { |f| f.write to_hash.to_yaml }
+        hash = {} unless hash.is_a? Hash
+        hash
       end
 
     end

data/lib/libis/tools/metadata/dublin_core_record.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'nori'
+require 'libis/tools/assert'
+
+module Libis
+  module Tools
+    module Metadata
+
+      class DublinCoreRecord < Libis::Tools::XmlDocument
+
+        DC_ELEMENTS = %w'contributor coverage creator date description format identifier language' +
+            %w'publisher relation rights source subject title type'
+        DCTERMS_ELEMENTS = %w'abstract accessRights accrualMethod accrualPeriodicity accrualPolicy alternative' +
+            %w'audience available bibliographicCitation conformsTo contributor coverage created creator date' +
+            %w'dateAccepted dateCopyrighted dateSubmitted description educationLevel extent format hasFormat' +
+            %w'hasPart hasVersion identifier instructionalMethod isFormatOf isPartOf isReferencedBy isReplacedBy' +
+            %w'isRequiredBy issued isVersionOf language license mediator medium modified provenance publisher' +
+            %w'references relation replaces requires rights rightsHolder source spatial subject tableOfContents' +
+            %w'temporal title type valid'
+
+        def initialize(doc = nil)
+          super()
+          xml_doc = case doc
+                      when ::Libis::Tools::XmlDocument
+                        doc
+                      when String
+                        # noinspection RubyResolve
+                        File.exist?(doc) ? Libis::Tools::XmlDocument.load(doc) : Libis::Tools::XmlDocument.parse(doc)
+                      when IO
+                        Libis::Tools::XmlDocument.parse(doc.read)
+                      when Hash
+                        Libis::Tools::XmlDocument.from_hash(doc)
+                      when NilClass
+                        Libis::Tools::XmlDocument.new.build do |xml|
+                          xml.record('xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+                                     'xmlns:dc' => 'http://purl.org/dc/elements/1.1/',
+                                     'xmlns:dcterms' => 'http://purl.org/dc/terms/') {
+                            yield xml
+                          }
+                        end
+                      else
+                        raise ArgumentError, "Invalid argument: #{doc.inspect}"
+                    end
+          @document = xml_doc.document if xml_doc
+        end
+
+        def all
+          @all_records ||= get_all_records
+        end
+
+        def xpath(path)
+          m = /^([\/.]*\/)?(dc(terms)?:)?(.*)/.match(path.to_s)
+          return [] unless m[4]
+          path = (m[1] || '') + ('dc:' || m[2]) + m[4]
+          raise ArgumentError, 'XML document not valid.' if self.invalid?
+          @document.xpath(path.to_s)
+        end
+
+        def add_node(name, value = nil, parent = nil, attributes = {})
+          ns, tag = get_namespace(name.to_s)
+          (attributes[:namespaces] ||= {})[:node_ns] ||= ns if ns
+          super tag, value, parent, attributes
+        end
+
+        protected
+
+        def get_nodes(tag, parent = nil)
+          parent ||= root
+          m = /^([\/\.]*\/)?(dc(?:terms)?:)?(.*)/.match(tag.to_s)
+          return [] unless m[3]
+          path = (m[1] || '') + ('dc:' || m[2]) + m[3]
+          parent.xpath(path)
+        end
+
+        def get_namespace(tag)
+          m = /^((dc)?(terms)?(?:_|:)?)?([a-zA-Z_][-_.0-9a-zA-Z]+)(.*)/.match tag
+          ns = if m[1].nil?
+                   if DC_ELEMENTS.include?(m[4])
+                     :dc
+                   else
+                     DCTERMS_ELEMENTS.include?(m[4]) ? :dcterms : nil
+                   end
+               elsif m[3].nil?
+                 :dc
+               else
+                 :dcterms
+               end
+          [ns, "#{m[4]}#{m[5]}"]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/field_spec.rb

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+module Libis
+  module Tools
+    module Metadata
+
+      class FieldSpec
+
+        attr_accessor :parts
+        attr_accessor :prefix
+        attr_accessor :join
+        attr_accessor :postfix
+
+        def initialize(*parts)
+          @parts = []
+          self[*parts]
+        end
+
+        def add_options(options = {})
+          if options[:fix]
+            if options[:fix].size == 2
+              @prefix, @postfix = options[:fix].split('')
+            else
+              @prefix, @postfix = options[:fix].split('|')
+            end
+          end
+          @join = options[:join] if options[:join]
+          @prefix = FieldSpec::from(options[:prefix]) if options[:prefix]
+          @postfix = FieldSpec::from(options[:postfix]) if options[:postfix]
+          self
+        end
+
+        def add_default_options(options = {})
+          options.delete(:prefix) if @prefix
+          options.delete(:postfix) if @postfix
+          options.delete(:fix) if @prefix or @postfix
+          options.delete(:join) if @join
+          add_options options
+        end
+
+        def [](*parts)
+          options = parts.last.is_a?(Hash) ? parts.pop : {}
+          parts.each { |x| add x }
+          x = options.delete(:parts)
+          add x if x
+          add_options options
+        end
+
+        def self.from(*h)
+          FieldSpec.new(*h)
+        end
+
+        def to_s
+          @parts.delete_if { |x|
+            x.nil? or
+                (x.is_a? String and x.empty?) or
+                (x.is_a? FieldSpec and x.to_s.empty?)
+          }
+          result = @parts.join(@join)
+          unless result.empty?
+            result = (@prefix || '').to_s + result + (@postfix || '').to_s
+          end
+          result
+        end
+
+        def add(part)
+          case part
+            when Hash
+              @parts << FieldSpec::from(part)
+            when Array
+              part.each { |x| add x }
+            else
+              @parts << part
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/fix_field.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+module Libis
+  module Tools
+    module Metadata
+
+      class FixField
+
+        attr_reader :tag
+        attr_reader :datas
+
+        def initialize(tag, datas)
+          @tag = tag
+          @datas = datas || ''
+        end
+
+        def dump
+          "#{@tag}:'#{@datas}'\n"
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/marc21_record.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require 'cgi'
+
+require_relative 'marc_record'
+
+module Libis
+  module Tools
+    module Metadata
+
+      class Marc21Record < Libis::Tools::Metadata::MarcRecord
+
+        private
+
+        def get_all_records
+
+          @all_records = Hash.new { |h, k| h[k] = [] }
+
+          @node.xpath('.//leader').each { |f|
+            @all_records['LDR'] << FixField.new('LDR', f.content)
+          }
+
+          @node.xpath('.//controlfield').each { |f|
+            tag = f['tag']
+            tag = '%03d' % tag.to_i if tag.size < 3
+            @all_records[tag] << FixField.new(tag, CGI::escapeHTML(f.content))
+          }
+
+          @node.xpath('.//datafield').each { |v|
+
+            tag = v['tag']
+            tag = '%03d' % tag.to_i if tag.size < 3
+
+            subfields = Hash.new { |h, k| h[k] = [] }
+            v.xpath('.//subfield').each { |s| subfields[s['code']] << CGI::escapeHTML(s.content) }
+
+            @all_records[tag] << VarField.new(tag, v['ind1'].to_s, v['ind2'].to_s, subfields)
+
+          }
+
+          @all_records
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/marc_record.rb

@@ -0,0 +1,209 @@
+# coding: utf-8
+
+require 'set'
+require 'cgi'
+
+require 'libis/tools/xml_document'
+require 'libis/tools/assert'
+
+require_relative 'fix_field'
+require_relative 'var_field'
+require_relative 'field_spec'
+
+module Libis
+  module Tools
+    module Metadata
+
+      # noinspection RubyTooManyMethodsInspection
+      class MarcRecord
+
+        def initialize(xml_node)
+          @node = xml_node
+        end
+
+        def to_raw
+          @node
+        end
+
+        def all
+          # noinspection RubyResolve
+          @all_records ||= get_all_records
+        end
+
+        def each
+          all.each do |k, v|
+            yield k, v
+          end
+        end
+
+        def all_tags(tag, subfields = '')
+          tag_, ind1, ind2 = tag =~ /^\d{3}/ ? [tag[0..2], tag[3], tag[4]] : [tag, nil, nil]
+          result = get_records(tag_, ind1, ind2, subfields)
+          return result unless block_given?
+          result.map { |record| yield record }
+          result.size > 0
+        end
+
+        def first_tag(t, subfields = '')
+          result = all_tags(t, subfields).first
+          return result unless block_given?
+          return false unless result
+          yield result
+          true
+        end
+
+        def each_tag(t, s = '')
+          all_tags(t, s).each do |record|
+            yield record
+          end
+        end
+
+        def all_fields(t, s)
+          r = all_tags(t, s).collect { |tag| tag.fields_array(s) }.flatten.compact
+          return r unless block_given?
+          r.map { |field| yield field }
+          r.size > 0
+        end
+
+        def first_field(t, s)
+          result = all_fields(t, s).first
+          return result unless block_given?
+          return false unless result
+          yield result
+          true
+        end
+
+
+        def each_field(t, s)
+          all_fields(t, s).each do |field|
+            yield field
+          end
+        end
+
+        def marc_dump
+          all.values.flatten.each_with_object([]) { |record, m| m << record.dump }.join
+        end
+
+        def save(filename)
+
+          doc = ::Libis::Tools::XmlDocument.new
+          doc.root = @node
+
+          return doc unless filename
+
+          doc.save filename, save_with: (::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+                               ::Nokogiri::XML::Node::SaveOptions::AS_XML |
+                               ::Nokogiri::XML::Node::SaveOptions::FORMAT
+                           )
+
+        end
+
+        def self.load(filename)
+
+          doc = ::Libis::Tools::XmlDocument.open(filename)
+          self.new(doc.root)
+
+        end
+
+        def self.read(io)
+          io = StringIO.new(io) if io.is_a? String
+          doc = ::Libis::Tools::XmlDocument.parse(io)
+          self.new(doc.root)
+
+        end
+
+        def to_aseq
+          record = ''
+          doc_number = tag('001').datas
+
+          all.select { |t| t.is_a? FixField }.each { |t| record += "#{format('%09s', doc_number)} #{t.tag}   L #{t.datas}\n" }
+          all.select { |t| t.is_a? VarField }.each { |t|
+            record += "#{format('%09s', doc_number)} #{t.tag}#{t.ind1}#{t.ind2} L "
+            t.keys.each { |k|
+              t.field_array(k).each { |f|
+                record += "$$#{k}#{CGI::unescapeHTML(f)}"
+              }
+            }
+            record += "\n"
+          }
+
+          record
+        end
+
+        protected
+
+        def element(*parts)
+          opts = options parts
+          field_spec(opts, *parts)
+        end
+
+        def list_s(*parts)
+          opts = options parts, join: ' '
+          field_spec(opts, *parts)
+        end
+
+        def list_c(*parts)
+          opts = options parts, join: ', '
+          field_spec(opts, *parts)
+        end
+
+        def list_d(*parts)
+          opts = options parts, join: ' - '
+          field_spec(opts, *parts)
+        end
+
+        def repeat(*parts)
+          opts = options parts, join: '; '
+          field_spec(opts, *parts)
+        end
+
+        def opt_r(*parts)
+          opts = options parts, fix: '()'
+          field_spec(opts, *parts)
+        end
+
+        def opt_s(*parts)
+          opts = options parts, fix: '[]'
+          field_spec(opts, *parts)
+        end
+
+        def odis_link(group, id, label)
+          "http://www.odis.be/lnk/#{group.downcase[0, 2]}_#{id}\##{label}"
+        end
+
+        private
+
+        def options(args, default = {})
+          default.merge(args.last.is_a?(::Hash) ? args.pop : {})
+        end
+
+        def field_spec(default_options, *parts)
+          FieldSpec.new(*parts).add_default_options(default_options).to_s
+        end
+
+        def get_records(tag, ind1 = '', ind2 = '', subfields = '')
+
+          ind1 ||= ''
+          ind2 ||= ''
+          subfields ||= ''
+
+          ind1.tr!('_', ' ')
+          ind1.tr!('#', '')
+
+          ind2.tr!('_', ' ')
+          ind2.tr!('#', '')
+
+          all[tag].select do |v|
+            v.is_a?(FixField) ||
+                ((ind1.empty? or v.ind1 == ind1) &&
+                    (ind2.empty? or v.ind2 == ind2) &&
+                    v.match_fieldspec?(subfields)
+                )
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/tools/metadata/var_field.rb

@@ -0,0 +1,224 @@
+# coding: utf-8
+
+require 'libis/tools/assert'
+
+module Libis
+  module Tools
+    module Metadata
+
+      class VarField
+
+        attr_reader :tag
+        attr_reader :ind1
+        attr_reader :ind2
+        attr_reader :subfield
+
+        def initialize(tag, ind1, ind2, subfield = {})
+          @tag = tag
+          @ind1 = ind1 || ' '
+          @ind2 = ind2 || ' '
+          @subfield = subfield || {}
+        end
+
+        # dump the contents
+        #
+        # @return [String] debug output to inspect the contents of the VarField
+        def dump
+          output = "#{@tag}:#{@ind1}:#{@ind2}:\n"
+          @subfield.each { |s, t| output += "\t#{s}:#{t}\n" }
+          output
+        end
+
+        # dump the contents
+        #
+        # @return [String] debug output to inspect the contents of the VarField - Single line version
+        def dump_line
+          output = "#{@tag}:#{@ind1}:#{@ind2}:"
+          @subfield.each { |s, t| output += "$#{s}#{t}" }
+          output
+        end
+
+        # list the subfield codes
+        #
+        # @return [Array] a list of all subfield codes
+        def keys
+          @subfield.keys
+        end
+
+        # get the first (or only) subfield value for the given code
+        #
+        # @return [String] the first or only entry of a subfield or nil if not present
+        # @param s [Character] the subfield code
+        def field(s)
+          field_array(s).first
+        end
+
+        # get a list of all subfield values for a given code
+        #
+        # @return [Array] all the entries of a repeatable subfield
+        # @param s [Character] the subfield code
+        def field_array(s)
+          assert(s.is_a?(String) && (s =~ /^[\da-z]$/) == 0, 'method expects a lower case alphanumerical char')
+          @subfield.has_key?(s) ? @subfield[s].dup : []
+        end
+
+        # get a list of the first subfield value for all the codes in the given string
+        #
+        # @return [Array] list of the first or only entries of all subfield codes in the input string
+        # @param s [String] subfield code specification (see match_fieldspec?)
+        #
+        # The subfield codes are cleaned and sorted first (see fieldspec_to_sorted_array)
+        def fields(s)
+          assert(s.is_a?(String), 'method expects a string')
+          return [] unless (match_array = match_fieldspec?(s))
+          fieldspec_to_array(match_array.join(' ')).collect { |i| send(:field, i) }.flatten.compact
+        end
+
+        # get a list of all the subfield values for all the codes in the given string
+        #
+        # @return [Array] list of the all the entries of all subfield codes in the input string
+        # @param s [String] subfield code specification (see match_fieldspec?)
+        #
+        # The subfield codes are cleaned and sorted first (see fieldspec_to_sorted_array)
+
+        def fields_array(s)
+          assert(s.is_a?(String), 'method expects a string')
+          return [] unless (match_array = match_fieldspec?(s))
+          fieldspec_to_array(match_array.join(' ')).collect { |i| send(:field_array, i) }.flatten.compact
+        end
+
+        # check if the current VarField matches the given field specification.
+        #
+        # @return [String] The matching part(s) of the specification or nil if no match
+        # @param fieldspec [String] field specification: sequence of alternative set of subfield codes that should-shouldn't be present
+        #
+        # The fieldspec consists of groups of characters. At least one of these groups should match for the test to succeed
+        # Within the group sets of codes may be divided by a hyphen (-). The first set of codes must all be present;
+        # the second set of codes must all <b>not</b> be present. Either set may be empty.
+        #
+        # Examples:
+        #   'ab'      matches '$a...$b...'            => ['ab']
+        #                     '$a...$b...$c...'       => ['ab']
+        #             but not '$a...'                 => nil      # ($b missing)
+        #                     '$b...'                 => nil      # ($a missing)
+        #   'a b'     matches '$a...'                 => ['a']
+        #                     '$b...'                 => ['b']
+        #                     '$a...$b...'            => ['a', 'b']
+        #                     '$a...$b...$c...'       => ['a', 'b']
+        #             but not '$c...'                 => nil      # ($a or $b must be present)
+        #   'abc-d'   matches '$a..,$b...$c...'       => ['abc-d']
+        #                     '$a..,$b...$c...$e...'  => ['abc-d']
+        #             but not '$a...$b...$e...'       => nil      # ($c missing)
+        #                     '$a...$b...$c...$d...'  => nil      # ($d should not be present)
+        #   'a-b b-a' matches '$a...'                 => ['a-b']
+        #                     '$a...$c...'            => ['a-b']
+        #                     '$b...'                 => ['b-a']
+        #                     '$b...$c...'            => ['b-a']
+        #             but not '$a...$b...'            => nil
+        #   'a-b c-d' matches '$a...'                 => ['a-b']
+        #                     '$a...$c...'            => ['a-b', 'c-d']
+        #                     '$a...$b...$c...'       => ['c-d']
+        #                     '$b...$c...'            => ['c-d']
+        #             but not '$a...$b...'            => nil
+        #                     '$c...$d...'            => nil
+        #                     '$b...$c...$d...'       => nil
+        #                     '$a...$b...$c...$d...'  => nil
+        def match_fieldspec?(fieldspec)
+          return [] if fieldspec.empty?
+          result = fieldspec.split.collect { |fs|
+            fa = fs.split '-'
+            assert(fa.size <= 2, 'more than one "-" is not allowed in a fieldspec')
+            must_match = (fa[0] || '').split ''
+            must_not_match = (fa[1] || '').split ''
+            next unless (must_match == (must_match & keys)) && (must_not_match & keys).empty?
+            fs
+          }.compact
+          return nil if result.empty?
+          result
+        end
+
+        private
+
+        # @return [Array] cleaned up version of the input string
+        # @param fieldspec [String] subfield code specification
+        # cleans the subfield code specification and splits it into an array of characters
+        # Duplicates will be removed from the array and the order will be untouched.
+        def fieldspec_to_array(fieldspec)
+
+          # note that we remove the '-xxx' part as it is only required for matching
+          fieldspec.gsub(/ |-\w*/, '').split('').uniq
+        end
+
+        def sort_helper(x)
+          # make sure that everything below 'A' is higher than 'z'
+          # note that this only works for numbers, but that is fine in our case.
+          x < 'A' ? (x.to_i + 123).chr : x
+        end
+
+        # implementation for methods for retrieving subfield values
+        #
+        # The methods start with a single character: the operation
+        # 'f' for retrieving only the first occurence of the subfield
+        # 'a' for retrieving all the subfield values for each of the given subfields
+        # if omitted, 'f' is assumed
+        #
+        # Then a '_' acts as a subdivider between the operation and the subfield(s). It must always be present, even
+        # if the operation is omitted.
+        #
+        # The last past is a sequence of subfield codes that should be used for selecting the values. The order in which the
+        # subfields are listed is respected in the resulting array of values.
+        #
+        # Examples:
+        #
+        #   t = VarField.new('100', '', '',
+        #                    { 'a' => %w'Name NickName',
+        #                      'b' => %w'LastName MaidenName',
+        #                      'c' => %w'eMail',
+        #                      '1' => %w'Age',
+        #                      '9' => %w'Score'})
+        #
+        #   # >> 100##$aName$aNickName$bLastName$bMaidenName$ceMail$1Age$9Score <<
+        #
+        #   t._1ab => ['Age', 'Name', 'LastName']
+        #   # equivalent to: t.f_1av or t.fields('1ab')
+        #
+        #   t.a_9ab => ['Score', 'Name', 'NickName', 'LastName', 'MaidenName']
+        #   # equivalent to: t.fields_array('9ab')
+        #
+        # Note that it is not possible to use a fieldspec for the sequence of subfield codes. Spaces and '-' are not allowed
+        # in method calls. If you want this, use the #field(s) and #field(s)_array methods.
+        #
+        def method_missing(name, *args)
+          operation, subfields = name.to_s.split('_')
+          assert(subfields.size > 0, 'need to specify at least one subfield')
+          operation = 'f' if operation.empty?
+          # convert subfield list to fieldspec
+          subfields = subfields.split('').join(' ')
+          case operation
+            when 'f'
+              if subfields.size > 1
+                operation = :fields
+              else
+                operation = :field
+              end
+            when 'a'
+              if subfields.size > 1
+                operation = :fields_array
+              else
+                operation = :field_array
+              end
+            else
+              throw "Unknown method invocation: '#{name}' with: #{args}"
+          end
+          send(operation, subfields)
+        end
+
+        def to_ary
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Tools
-    VERSION = '0.9.6'
+    VERSION = '0.9.7'
   end
 end

data/lib/libis/tools/xml_document.rb

@@ -280,13 +280,19 @@ module Libis
       #               </jkr:books>
       #           </patron>
       #
-      # @param [String] name tag for the new node
-      # @param [String] value optional content for new node; empty if nil
-      # @param [Node] parent optional parent node for new node; root if nil; xml document if root is not defined
-      # @param [Hash] attributes a Hash containing tag-value pairs for each attribute; the special key ':namespaces'
-      #     contains a Hash of namespace definitions as in {#add_namespaces}
+      # @param [Array] args arguments being:
+      #     - tag for the new node
+      #     - optional content for new node; empty if nil or not present
+      #     - optional parent node for new node; root if nil or not present; xml document if root is not defined
+      #     - a Hash containing tag-value pairs for each attribute; the special key ':namespaces'
+      #       contains a Hash of namespace definitions as in {#add_namespaces}
       # @return [Nokogiri::XML::Node] the new node
-      def add_node(name, value = nil, parent = nil, attributes = {})
+      def add_node(*args)
+        attributes = {}
+        attributes = args.pop if args.last.is_a? Hash
+        name, value, parent = *args
+
+        return nil if name.nil?
 
         node = Nokogiri::XML::Node.new name.to_s, @document
         node.content = value
@@ -386,7 +392,7 @@ module Libis
         end
 
         node.namespace_scopes.each do |ns|
-          node.namespace = ns if ns.prefix == node_ns
+          node.namespace = ns if ns.prefix == node_ns.to_s
         end if node_ns
 
         node.default_namespace = default_ns if default_ns
@@ -430,12 +436,24 @@ module Libis
       #       xml_doc.value('//email') # => "harry.potter@hogwarts.edu"
       #
       # @param [String] path the name or XPath term to search the node(s)
+      # @param [Node] parent parent node; document if nil
       # @return [String] content or nil if not found
-      def value(path)
-        xpath(path).first.content rescue nil
+      def value(path, parent = nil)
+        parent ||= document
+        parent.xpath(path).first.content rescue nil
       end
 
-      alias_method :[], :value
+      # Return the content of the first element found.
+      #
+      # Example:
+      #
+      #       xml_doc['email'] # => "harry.potter@hogwarts.edu"
+      #
+      # @param [String] path the name or XPath term to search the node(s)
+      # @return [String] content or nil if not found
+      def [](path)
+        xpath(path).first.content rescue nil
+      end
 
       # Return the content of all elements found.
       # Example:
@@ -548,8 +566,6 @@ module Libis
         node
       end
 
-      protected
-
       # Get the first node matching the tag. The node will be seached with XPath search term = "//#{tag}".
       #
       # @param [String] tag XML tag to look for; XPath syntax is allowed

data/lib/libis/tools.rb

@@ -4,7 +4,9 @@ module Libis
     autoload :Checksum, 'libis/tools/checksum'
     autoload :Command, 'libis/tools/command'
     autoload :Config, 'libis/tools/config'
+    autoload :ConfigFile, 'libis/tools/config_file'
     autoload :DCRecord, 'libis/tools/dc_record'
+    autoload :DeepStruct, 'libis/tools/deep_struct'
     autoload :Logger, 'libis/tools/logger'
     autoload :MetsFile, 'libis/tools/mets_file'
     autoload :Parameter, 'libis/tools/parameter'

data/spec/config_file_spec.rb

@@ -30,6 +30,45 @@ describe ::Libis::Tools::ConfigFile do
       expect(subject.to_hash).to eq hash
     end
 
+    it 'loads a hash' do
+      subject << hash
+      expect(subject.to_hash).to eq hash
+    end
+
+    it 'allows to change sub-hash' do
+      subject << hash
+      # noinspection RubyResolve
+      subject.b.v = 1
+      hash[:b]['v'] = 1
+      expect(subject.to_hash).to eq hash
+    end
+
+    it 'allows to change hash in array' do
+      subject << hash
+      # noinspection RubyResolve
+      subject.c[0][0].a[0].v = 1
+      hash[:c][0][0][:a][0]['v'] = 1
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+  context 'initialization with hash' do
+    subject { ::Libis::Tools::ConfigFile.new hash }
+
+    it 'has hash' do
+      expect(subject.to_hash).to eq hash
+    end
+
+  end
+
+  context 'initialization with file' do
+    subject { ::Libis::Tools::ConfigFile.new test_file }
+
+    it 'has hash' do
+      expect(subject.to_hash).to eq hash
+    end
+
   end
 
 end

data/spec/metadata/dublin_core_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require_relative '../spec_helper'
+require 'libis/tools/metadata/dublin_core_record'
+
+require 'rspec/matchers'
+require 'equivalent-xml'
+
+describe 'DublinCoreRecord' do
+
+  let(:header) { '<?xml version="1.0" encoding="utf-8"?>' }
+
+  subject(:dc) { Libis::Tools::Metadata::DublinCoreRecord.new(data) {} }
+
+  def dc_xml(tag, value = '', attributes = {})
+    "<dc:#{tag}#{attributes.sort.each{|k,v| " #{k}=\"#{v}\""}.join}>#{value}</dc:#{tag}>"
+  end
+
+  def dcterms_xml(tag, value = '', attributes = {})
+    "<dcterms:#{tag}#{attributes.sort.each{|k,v| " #{k}=\"#{v}\""}.join}>#{value}</dcterms:#{tag}>"
+  end
+
+  def match_xml(doc1, doc2)
+    xml1 = doc1.is_a?(::Libis::Tools::XmlDocument) ? doc1.document : ::Nokogiri::XML(doc1.to_s)
+    xml2 = doc2.is_a?(::Libis::Tools::XmlDocument) ? doc2.document : ::Nokogiri::XML(doc2.to_s)
+    # noinspection RubyResolve
+    expect(xml1).to be_equivalent_to(xml2).respecting_element_order
+  end
+
+  context 'Empty record' do
+    let(:data) { nil }
+    let(:root) { <<STR.chomp
+<record \
+xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" \
+xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/"
+STR
+    }
+    let(:record_start) { root + '>' }
+    let(:record_end) { '</record>' }
+    let(:empty_record) { header + root + '/>' }
+
+
+    it 'contains emtpy record' do
+      match_xml dc.document, empty_record
+    end
+
+    it 'add dc:title' do
+      dc.title = 'abc'
+      match_xml dc.document, header + record_start + dc_xml('title', 'abc') + record_end
+    end
+
+    it 'add dc:date' do
+      dc.date = '2001'
+      dc.dcdate = '2002'
+      dc.dc_date = '2003'
+      match_xml dc.document,
+                header +
+                    record_start +
+                    dc_xml('date', '2001') +
+                    dc_xml('date', '2002') +
+                    dc_xml('date', '2003') +
+                    record_end
+    end
+
+    it 'add dcterms:date' do
+      dc.termsdate = '2001'
+      dc.dctermsdate = '2002'
+      dc.terms_date = '2003'
+      dc.dcterms_date = '2004'
+      match_xml dc.document,
+                header +
+                    record_start +
+                    dcterms_xml('date', '2001') +
+                    dcterms_xml('date', '2002') +
+                    dcterms_xml('date', '2003') +
+                    dcterms_xml('date', '2004') +
+                    record_end
+    end
+
+  end
+
+end

data/spec/xmldocument_spec.rb

@@ -199,7 +199,7 @@ describe 'XML Document' do
 
     xml_doc.add_node :patron
     xml_doc.add_node :name, 'Harry Potter'
-    books = xml_doc.add_node :books, nil, nil, namespaces: { jkr: 'http://JKRowling.com' , node_ns: 'jkr' }
+    books = xml_doc.add_node :books, namespaces: { jkr: 'http://JKRowling.com' , node_ns: 'jkr' }
     xml_doc.add_node :book, nil, books,
                      title: 'Quidditch Through the Ages', author: 'Kennilworthy Whisp', due_date: '1992-4-23',
                      namespaces: {node_ns: 'jkr'}
@@ -362,7 +362,7 @@ describe 'XML Document' do
 
   end
 
-  it 'should work' do
+  it 'allows to parse xml string, save and reload' do
     xml_doc = ::Libis::Tools::XmlDocument.parse(<<-END.align_left)
       <patron>
         <name>Harry Potter</name>
@@ -381,6 +381,10 @@ describe 'XML Document' do
 
     match_xml xml_doc.document, @xml_template
 
+  end
+
+  it 'supports build to create XML document' do
+
     xml_doc = ::Libis::Tools::XmlDocument.build do
       # noinspection RubyResolve
       patron {
@@ -394,6 +398,10 @@ describe 'XML Document' do
 
     match_xml xml_doc.document, @xml_template
 
+  end
+
+  it 'supports different ways to create nodes' do
+
     xml_doc = ::Libis::Tools::XmlDocument.new
     xml_doc.add_node :patron
     xml_doc.name = 'Harry Potter'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-tools
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -194,10 +194,16 @@ files:
 - lib/libis/tools/extend/string.rb
 - lib/libis/tools/extend/struct.rb
 - lib/libis/tools/logger.rb
+- lib/libis/tools/metadata/dublin_core_record.rb
+- lib/libis/tools/metadata/field_spec.rb
+- lib/libis/tools/metadata/fix_field.rb
+- lib/libis/tools/metadata/marc21_record.rb
+- lib/libis/tools/metadata/marc_record.rb
+- lib/libis/tools/metadata/sharepoint_mapping.rb
+- lib/libis/tools/metadata/sharepoint_record.rb
+- lib/libis/tools/metadata/var_field.rb
 - lib/libis/tools/mets_file.rb
 - lib/libis/tools/parameter.rb
-- lib/libis/tools/sharepoint_mapping.rb
-- lib/libis/tools/sharepoint_record.rb
 - lib/libis/tools/version.rb
 - lib/libis/tools/xml_document.rb
 - libis-tools.gemspec
@@ -212,6 +218,7 @@ files:
 - spec/data/test_config.yml
 - spec/deep_struct_spec.rb
 - spec/logger_spec.rb
+- spec/metadata/dublin_core_spec.rb
 - spec/parameter_container_spec.rb
 - spec/parameter_spec.rb
 - spec/spec_helper.rb
@@ -256,6 +263,7 @@ test_files:
 - spec/data/test_config.yml
 - spec/deep_struct_spec.rb
 - spec/logger_spec.rb
+- spec/metadata/dublin_core_spec.rb
 - spec/parameter_container_spec.rb
 - spec/parameter_spec.rb
 - spec/spec_helper.rb