libis-metadata 0.2.0

data/lib/libis/metadata/parser/dublin_core_parser.rb

@@ -0,0 +1,35 @@
+require 'parslet'
+
+require_relative 'basic_parser'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      class DublinCoreParser < Libis::Metadata::Parser::BasicParser
+        rule(:namespace) {match('[^:]').repeat(1).as(:namespace) >> str(':')}
+        rule(:namespace?) {namespace.maybe}
+
+        rule(:attribute) {namespace? >> name_string.as(:name) >> str('=') >> str('"') >> match('[^"]').repeat(1).as(:value) >> str('"')}
+        rule(:attributes) {attribute >> (spaces >> attribute).repeat}
+        rule(:attributes?) {attributes.maybe}
+        rule(:element) {name_string.as(:element)}
+        rule(:DC) {namespace >> element >> (spaces >> attributes.as(:attributes)).maybe}
+
+        root(:DC)
+
+        def to_target(tree)
+          tree = tree[:DC]
+          return nil unless tree
+          result = "xml['#{tree[:namespace]}'].#{tree[:element]}("
+          tree[:attributes].each {|attribute| result += "'#{attribute[:name]}' => '#{attribute[:value]}'"}
+          result + ').text'
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/metadata/parser/marc21_parser.rb

@@ -0,0 +1,205 @@
+require 'parslet'
+
+require_relative 'basic_parser'
+require_relative 'marc_rules'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      class Marc21Parser < Libis::Metadata::Parser::BasicParser
+
+        root(:marc21)
+        rule(:marc21) {select.as(:select) | format.as(:format)}
+
+        # select syntax
+        rule(:select) do
+          str('MARC') >>
+              spaces? >> tag.as(:tag) >>
+              spaces? >> indicator.maybe.as(:ind1) >> indicator.maybe.as(:ind2) >>
+              spaces? >> subfield.maybe.as(:subfield) >>
+              spaces? >> condition.maybe.as(:condition)
+        end
+        rule(:condition) {grouped_anonymous(cond_format.as(:cond_format))}
+        rule(:cond_format) {cond_entry.repeat(1).maybe.as(:entry) >> postfix.maybe.as(:postfix)}
+        rule(:cond_entry) {sf_reference | method_call | cond_group}
+        rule(:cond_group) {(prefix.maybe.as(:prefix) >> grouped(cond_format)).as(:cond_group)}
+
+        # Formatting syntax
+        rule(:format) {entry.repeat(1).maybe.as(:entry) >> postfix.maybe.as(:postfix)}
+
+        rule(:entry) {sf_reference | method_call | group}
+        # noinspection RubyArgCount
+        rule(:group) {(prefix.maybe.as(:prefix) >> grouped(format)).as(:group)}
+        # noinspection RubyArgCount
+        rule(:method_call) {(prefix.maybe.as(:prefix) >> sf_indicator >> grouped_anonymous(format, lrparen)).as(:method_call)}
+
+        # pre- and postfix
+        rule(:prefix) {other.repeat(1)}
+        rule(:prefix) {text}
+        rule(:postfix) {other.repeat(1)}
+        rule(:postfix) {text}
+
+        # subfield reference
+        rule(:sf_reference) {sf_variable.as(:subfield) | sf_fixed.as(:fixfield)}
+
+        rule(:sf_variable) {prefix.maybe.as(:prefix) >> sf_indicator >> sf_repeat.maybe.as(:repeat) >> sf_name}
+        rule(:sf_repeat) {star >> any_quoted(:separator).maybe}
+
+        rule(:sf_fixed) {prefix.maybe.as(:prefix) >> sf_indicator >> lsparen >> (sf_range | sf_position | sf_star) >> rsparen}
+        rule(:sf_star) {star.as(:all)}
+        rule(:sf_position) {integer.as(:position)}
+        rule(:sf_range) {integer.as(:first) >> minus >> integer.as(:last)}
+
+        rule(:other) {paren.absent? >> dollar.absent? >> any | litteral_dollar}
+
+        # 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}
+
+        # subfield
+        rule(:sf_indicator) {dollar}
+        rule(:sf_name) {(character | number).as(:name)}
+        rule(:sf_names) {(character | number).repeat(1).as(:names)}
+        rule(:subfield) {sf_indicator >> sf_name}
+        rule(:litteral_dollar) {dollar >> dollar}
+
+        # noinspection RubyResolve
+        class Transformer < Parslet::Transform
+          rule(name: simple(:name)) {"#{name}"}
+          # select transformation rules
+          rule(cond_group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: simple(:entry),
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "#{prefix}#{lparen}#{entry}#{postfix}#{rparen}"
+          }
+          rule(cond_group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: sequence(:entry),
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "#{prefix}#{lparen}#{entry.join}#{postfix}#{rparen}"
+          }
+          rule(cond_format: {
+              entry: sequence(:entry),
+              postfix: simple(:postfix)
+          }) {", Proc.new { |f| #{entry.join}#{postfix} }"}
+          rule(select: {
+              tag: simple(:tag),
+              ind1: simple(:ind1),
+              ind2: simple(:ind2),
+              subfield: simple(:subfield),
+              condition: simple(:condition)
+          }) {"record.select_fields('#{tag}#{ind1 || '#'}#{ind2 || '#'}#{subfield}'#{condition || ''})"}
+          # format transformation rules
+          rule(format: {
+              entry: sequence(:entries),
+              postfix: simple(:postfix)
+          }) do
+            if entries.size == 1 && postfix.nil?
+              entries.first
+            else
+              "field_format(#{entries.join(',')}#{", postfix: '#{postfix}'" if postfix}).to_s"
+            end
+          end
+          rule(group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: nil,
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "#{prefix}#{lparen}#{postfix}#{rparen}"
+          }
+          rule(group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: '',
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "#{prefix}#{lparen}#{postfix}#{rparen}"
+          }
+          rule(group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: simple(:entry),
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "field_format(#{entry}#{", prefix: '#{prefix}#{lparen}'" if prefix || lparen}#{", postfix: '#{postfix}#{rparen}'" if postfix || rparen}).to_s"
+          }
+          rule(group: {
+              prefix: simple(:prefix),
+              lparen: simple(:lparen),
+              entry: sequence(:entries),
+              postfix: simple(:postfix),
+              rparen: simple(:rparen)}) {
+            "field_format(#{entries.join(',')}#{", prefix: '#{prefix}#{lparen}'" if prefix || lparen}#{", postfix: '#{postfix}#{rparen}'" if postfix || rparen}).to_s"
+          }
+          rule(fixfield: {
+              prefix: nil,
+              all: '*'
+          }) {'f[]'}
+          rule(fixfield: {
+              prefix: simple(:prefix),
+              all: '*'
+          }) {"field_format(f[], prefix: '#{prefix}').to_s"}
+          rule(fixfield: {
+              prefix: nil,
+              position: simple(:position)
+          }) {"f[#{position}]"}
+          rule(fixfield: {
+              prefix: simple(:prefix),
+              position: simple(:position)
+          }) do
+            if prefix
+              "field_format(f[#{position}], prefix: '#{prefix}').to_s"
+            else
+              "f[#{position}]"
+            end
+          end
+          rule(fixfield: {
+              prefix: nil,
+              first: simple(:from),
+              last: simple(:to)
+          }) {"f[#{from},#{to}]"}
+          rule(fixfield: {
+              prefix: simple(:prefix),
+              first: simple(:from),
+              last: simple(:to)
+          }) {"field_format(f[#{from},#{to}], prefix: '#{prefix}').to_s"}
+          rule(subfield: {
+              prefix: simple(:prefix),
+              repeat: nil,
+              name: simple(:name),
+          }) {"field_format(f.subfield('#{name}'), prefix: '#{prefix}').to_s"}
+          rule(subfield: {
+              prefix: simple(:prefix),
+              repeat: {separator: simple(:separator)},
+              name: simple(:name),
+          }) {"field_format(f.subfield_array('#{name}')#{", prefix: '#{prefix}'" if prefix}, join: '#{separator}').to_s"}
+          rule(subfield: {
+              prefix: simple(:prefix),
+              repeat: '*',
+              name: simple(:name),
+          }) {"field_format(f.subfield_array('#{name}')#{", prefix: '#{prefix}'" if prefix}, join: ';').to_s"}
+          rule(subfield: {
+              prefix: nil,
+              repeat: nil,
+              name: simple(:name),
+          }) {"f.subfield('#{name}')"}
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'parslet'
+
+require_relative 'basic_parser'
+require_relative 'marc_rules'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      class MarcFormatParser < Libis::Metadata::Parser::BasicParser
+        include Libis::Metadata::Parser::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/metadata/parser/marc_rules.rb

@@ -0,0 +1,34 @@
+require 'parslet'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      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/metadata/parser/marc_select_parser.rb

@@ -0,0 +1,24 @@
+require 'parslet'
+
+require_relative 'basic_parser'
+require_relative 'marc_rules'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      class MarcSelectParser < Libis::Metadata::Parser::BasicParser
+        include Libis::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/metadata/parser/patch.rb

@@ -0,0 +1,22 @@
+# New style parsers and converters for metadata. New, not finished and untested.
+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/metadata/parser/subfield_criteria_parser.rb

@@ -0,0 +1,70 @@
+require 'parslet'
+
+require_relative 'basic_parser'
+
+module Libis
+  module Metadata
+    module Parser
+      # noinspection RubyResolve
+
+      # New style parsers and converters for metadata. New, not finished and untested.
+      class SubfieldCriteriaParser < Libis::Metadata::Parser::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