libis-tools 0.9.65 → 1.0.0

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'parslet'
-
-require_relative 'basic_parser'
-
-module Libis
-  module Tools
-    module Metadata
-      # noinspection RubyResolve
-
-      # New style parsers and converters for metadata. New, not finished and untested.
-      class DublinCoreParser < Libis::Tools::Metadata::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/tools/metadata/parser/marc21_parser.rb

@@ -1,207 +0,0 @@
-# encoding: utf-8
-
-require 'parslet'
-
-require_relative 'basic_parser'
-require_relative 'marc_rules'
-
-module Libis
-  module Tools
-    module Metadata
-      # noinspection RubyResolve
-
-      # New style parsers and converters for metadata. New, not finished and untested.
-      class Marc21Parser < Libis::Tools::Metadata::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/tools/metadata/parser/marc_format_parser.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require 'parslet'
-
-require_relative 'basic_parser'
-require_relative 'marc_rules'
-
-module Libis
-  module Tools
-    module Metadata
-      # noinspection RubyResolve
-
-      # New style parsers and converters for metadata. New, not finished and untested.
-      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

@@ -1,36 +0,0 @@
-# encoding: utf-8
-
-require 'parslet'
-
-module Libis
-  module Tools
-    module Metadata
-      # 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/tools/metadata/parser/marc_select_parser.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'parslet'
-
-require_relative 'basic_parser'
-require_relative 'marc_rules'
-
-module Libis
-  module Tools
-    module Metadata
-      # noinspection RubyResolve
-
-      # New style parsers and converters for metadata. New, not finished and untested.
-      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

@@ -1,22 +0,0 @@
-# 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/tools/metadata/parser/subfield_criteria_parser.rb

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