libis-tools 0.9.9 → 0.9.10

data/lib/libis/tools/metadata/parser/marc_format_parser.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'parslet'
+
+require_relative 'basic_parser'
+require_relative 'marc_rules'
+
+module Libis
+  module Tools
+    module Metadata
+
+      # noinspection RubyResolve
+      class MarcFormatParser < Libis::Tools::Metadata::BasicParser
+        include Libis::Tools::Metadata::MarcRules
+
+        root(:mapping)
+
+        rule(:mapping) { entry.repeat(1).as(:entry) >> postfix?.as(:postfix) }
+
+        rule(:entry) { group.as(:group) | sf_reference }
+        rule(:group) { prefix?.as(:prefix) >> grouped(mapping) }
+
+        # pre- and postfix
+        rule(:prefix) { other.repeat(1) }
+        rule(:prefix) { text }
+        rule(:prefix?) { prefix.maybe }
+        rule(:postfix) { other.repeat(1) }
+        rule(:postfix) { text }
+        rule(:postfix?) { postfix.maybe }
+
+        # subfield reference
+        rule(:sf_reference) { sf_variable.as(:subfield) | sf_fixed.as(:fixfield) }
+
+        rule(:sf_variable) { prefix?.as(:prefix) >> sf_indicator >> sf_repeat?.as(:repeat) >> sf_name }
+        rule(:sf_repeat) { star >>
+            (dquote >> not_dquote.repeat.as(:separator) >> dquote |
+                squote >> not_squote.repeat.as(:separator) >> squote
+            ).maybe
+        }
+        rule(:sf_repeat?) { sf_repeat.maybe }
+
+        rule(:sf_fixed) { prefix?.as(:prefix) >> sf_indicator >> str('@') >> (sf_position | sf_range | sf_star) }
+        rule(:sf_position) { lsparen >> integer.as(:position) >> rsparen }
+        rule(:sf_range) { lsparen >> integer.as(:first) >> minus >> integer.as(:last) >> rsparen }
+        rule(:sf_star) { star.as(:all) }
+
+        rule(:other) { paren.absent? >> dollar.absent? >> any | str('$$') }
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/parser/marc_rules.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'parslet'
+
+module Libis
+  module Tools
+    module Metadata
+
+      # noinspection RubyResolve
+      module MarcRules
+        include Parslet
+
+        # tag
+        rule(:tag) { tag_numeric | tag_alpha }
+        rule(:tag_numeric) { number.repeat(3, 3) }
+        rule(:tag_alpha) { character.repeat(3, 3) }
+
+        # indicator
+        rule(:indicator) { hashtag | underscore | number | character }
+        rule(:indicator?) { indicator.maybe }
+        rule(:indicators) { indicator?.as(:ind1) >> indicator?.as(:ind2) }
+
+        # subfield
+        rule(:sf_indicator) { dollar }
+        rule(:sf_name) { (character | number).as(:name) }
+        rule(:sf_name?) { sf_name.maybe }
+        rule(:sf_names) { (character | number).repeat(1).as(:names) }
+        rule(:sf_names?) { sf_names.maybe }
+        rule(:subfield) { sf_indicator >> sf_name }
+
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/parser/marc_select_parser.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'parslet'
+
+require_relative 'basic_parser'
+require_relative 'marc_rules'
+
+module Libis
+  module Tools
+    module Metadata
+
+      # noinspection RubyResolve
+      class MarcSelectParser < Libis::Tools::Metadata::BasicParser
+        include Libis::Tools::Metadata::MarcRules
+        root(:MARC)
+        rule(:MARC) { str('MARC') >> spaces? >> tag.as(:tag) >> spaces? >> indicators >> spaces? >> subfield.maybe.as(:subfield) }
+
+        # subfield
+        # rule(:sf_condition) { sf_indicator >> sf_names >> (space >> sf_names).repeat }
+        # rule(:sf_names) { sf_name.repeat(1) }
+      end
+
+    end
+  end
+end

data/lib/libis/tools/metadata/parser/patch.rb

@@ -0,0 +1,21 @@
+class Parslet::Pattern
+
+  def element_match_hash(tree, exp, bindings)
+    return false if exp.size < tree.size
+    exp.each do |expected_key, expected_value|
+      if expected_key.to_s =~ /^(.*)\?$/
+        expected_key = expected_key.is_a?(Symbol) ? $1.to_sym : $1
+        return true unless tree.has_key? expected_key
+      end
+
+      return false unless tree.has_key? expected_key
+
+      # Recurse into the value and stop early on failure
+      value = tree[expected_key]
+      return false unless element_match(value, expected_value, bindings)
+    end
+
+    true
+  end
+
+end

data/lib/libis/tools/metadata/parser/subfield_criteria_parser.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'parslet'
+
+require_relative 'basic_parser'
+
+module Libis
+  module Tools
+    module Metadata
+
+      # noinspection RubyResolve
+      class SubfieldCriteriaParser < Libis::Tools::Metadata::BasicParser
+
+        root(:criteria)
+
+        rule(:criteria) { selection >> (spaces >> selection).repeat }
+
+        rule(:selection) { must >> must_not.maybe }
+
+        rule(:must) { names.as(:must).maybe >> (one_of | only_one_of).maybe }
+        rule(:must_not) { minus >> must.as(:not) }
+
+        rule(:one_of) { lrparen >> names.as(:one_of) >> rrparen }
+        rule(:only_one_of) { lcparen >> names.as(:only_one_of) >> rcparen }
+
+        rule(:names) { (character | number).repeat(1) }
+
+        def criteria_to_s(criteria)
+          case criteria
+            when Array
+              # leave as is
+            when Hash
+              criteria = [criteria]
+            else
+              return criteria
+          end
+          criteria.map { |selection| selection_to_s(selection) }.join(' ')
+        end
+
+        def selection_to_s(selection)
+          return selection unless selection.is_a? Hash
+          result = "#{selection[:must]}"
+          result += "(#{selection[:one_of]})" if selection[:one_of]
+          result += "{#{selection[:only_one_of]}}" if selection[:only_one_of]
+          result += "-#{selection_to_s(selection[:not])}" if selection[:not]
+          result
+        end
+
+        def match_criteria(criteria, data)
+          tree = self.new.parse(criteria)
+          return true if tree.is_a? String
+          tree = [tree] unless tree.is_a? Array
+          tree.map { |selection| match_selection(selection, data) }.any?
+        end
+
+        def match_selection(selection, data)
+          must_match = selection[:must].to_s.split('')
+          return false unless must_match == (must_match & data)
+          one_of = selection[:one_of].to_s.split('')
+          return false unless one_of.empty? || (one_of & data).any?
+          only_one_of = selection[:only_one_of].to_s.split('')
+          return false unless only_one_of.empty? || (only_one_of & data).size != 1
+          return false if match_selection(selection[:not], data) if selection[:not]
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Libis
+  module Tools
+    module Metadata
+
+      autoload :BasicParser, 'libis/tools/metadata/parser/basic_parser'
+      autoload :DublinCoreParser, 'libis/tools/metadata/parser/dublin_core_parser'
+      autoload :Marc21Parser, 'libis/tools/metadata/parser/marc21_parser'
+      autoload :SubfieldCriteriaParser, 'libis/tools/metadata/parser/subfield_criteria_parser'
+
+    end
+  end
+end

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

@@ -2,6 +2,8 @@
 
 require 'libis/tools/assert'
 
+require_relative 'parser/subfield_criteria_parser'
+
 module Libis
   module Tools
     module Metadata
@@ -11,13 +13,17 @@ module Libis
         attr_reader :tag
         attr_reader :ind1
         attr_reader :ind2
-        attr_reader :subfield
+        attr_reader :subfield_data
 
-        def initialize(tag, ind1, ind2, subfield = {})
+        def initialize(tag, ind1, ind2)
           @tag = tag
-          @ind1 = ind1 || ' '
-          @ind2 = ind2 || ' '
-          @subfield = subfield || {}
+          @ind1 = ind1 || ''
+          @ind2 = ind2 || ''
+          @subfield_data = Hash.new { |h, k| h[k] = Array.new   }
+        end
+
+        def add_subfield(name, value)
+          @subfield_data[name] << value
         end
 
         # dump the contents
@@ -25,7 +31,7 @@ module Libis
         # @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" }
+          @subfield_data.each { |s, t| output += "\t#{s}:#{t}\n" }
           output
         end
 
@@ -34,7 +40,7 @@ module Libis
         # @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}" }
+          @subfield_data.each { |s, t| output += "$#{s}#{t}" }
           output
         end
 
@@ -42,57 +48,57 @@ module Libis
         #
         # @return [Array] a list of all subfield codes
         def keys
-          @subfield.keys
+          @subfield_data.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
+        def subfield(s)
+          subfield_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)
+        def subfield_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 : []
+          @subfield_data.has_key?(s) ? @subfield_data[s].dup : []
         end
 
-        # get a list of the first subfield value for all the codes in the given string
+        # get a list of the first subfield values 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?)
+        # @param s [String] subfield code specification (see match)
         #
-        # The subfield codes are cleaned and sorted first (see fieldspec_to_sorted_array)
-        def fields(s)
+        # The subfield codes are cleaned (see criteria_to_array)
+        def subfields(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
+          return [] unless (match_array = match(s))
+          criteria_to_array(match_array.join(' ')).collect { |i| send(:subfield, 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?)
+        # @param s [String] subfield code criteria (see match)
         #
-        # The subfield codes are cleaned and sorted first (see fieldspec_to_sorted_array)
+        # The subfield codes are cleaned (see criteria_to_array)
 
-        def fields_array(s)
+        def subfields_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
+          return [] unless (match_array = match(s))
+          criteria_to_array(match_array.join(' ')).collect { |i| send(:subfield_array, i) }.flatten.compact
         end
 
-        # check if the current VarField matches the given field specification.
+        # check if the current VarField matches the given subfield criteria.
         #
-        # @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
+        # @return [String] The matching part(s) of the criteria or nil if no match
+        # @param criteria [String] subfield criteria: 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
+        # The subfield criteria 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.
         #
@@ -123,30 +129,34 @@ module Libis
         #                     '$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
+        def match(criteria)
+          begin
+            parser = Libis::Tools::Metadata::SubfieldCriteriaParser.new
+            tree = parser.parse(criteria)
+            return [] if tree.is_a? String
+            tree = [tree] unless tree.is_a? Array
+            result = tree.map do |selection|
+              next unless parser.match_selection(selection, keys)
+              parser.selection_to_s(selection)
+            end.compact
+            return nil if result.empty?
+            result
+          rescue Parslet::ParseFailed => failure
+            failure.cause.set_label(criteria)
+            raise failure
+          end
         end
 
         private
 
         # @return [Array] cleaned up version of the input string
-        # @param fieldspec [String] subfield code specification
+        # @param subfields [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)
+        def criteria_to_array(subfields)
 
           # note that we remove the '-xxx' part as it is only required for matching
-          fieldspec.gsub(/ |-\w*/, '').split('').uniq
+          subfields.gsub(/ |-\w*/, '').split('').uniq
         end
 
         def sort_helper(x)
@@ -186,7 +196,7 @@ module Libis
         #   # 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.
+        # in method calls. If you want this, use the #subfield(s) and #subfield(s)_array methods.
         #
         def method_missing(name, *args)
           operation, subfields = name.to_s.split('_')
@@ -197,15 +207,15 @@ module Libis
           case operation
             when 'f'
               if subfields.size > 1
-                operation = :fields
+                operation = :subfields
               else
-                operation = :field
+                operation = :subfield
               end
             when 'a'
               if subfields.size > 1
-                operation = :fields_array
+                operation = :subfields_array
               else
-                operation = :field_array
+                operation = :subfield_array
               end
             else
               throw "Unknown method invocation: '#{name}' with: #{args}"

data/lib/libis/tools/parameter.rb

@@ -73,6 +73,10 @@ module Libis
             'float'
           when DateTime, Date, Time
             'datetime'
+          when Array
+            'array'
+          when Hash
+            'hash'
           else
             send(:default).class.name.downcase
         end
@@ -95,9 +99,17 @@ module Libis
           when 'datetime'
             return v.to_datetime if v.respond_to? :to_datetime
             return DateTime.parse(v)
+          when 'array'
+            return v if v.is_a?(Array)
+            return v.split(/[,;|\s]+/) if v.is_a?(String)
+            return v.to_a if v.respond_to?(:to_a)
+          when 'hash'
+            return v when v.is_a?(Hash)
+            return Hash[(0...v.size).zip(v)] when v.is_a?(Array)
           else
             raise RuntimeError, "Datatype not supported: '#{dtype}'"
         end
+        nil
       end
 
       def check_constraint(v, constraint = nil)
@@ -145,8 +157,6 @@ module Libis
           end
         end
 
-        protected
-
         def parameters
           @parameters ||= Hash.new
         end