midos 0.0.1

data/ChangeLog

@@ -0,0 +1,11 @@
+# markup: rd
+
+= Revision history for midos
+
+== 0.0.1 [2014-04-11]
+
+* First release (extracted from ruby-nuggets).
+
+== 0.0.0 [2014-04-09]
+
+* Birthday :-)

data/README

@@ -0,0 +1,42 @@
+= midos - A Ruby client for MIDOS databases
+
+== VERSION
+
+This documentation refers to midos version 0.0.1
+
+
+== DESCRIPTION
+
+Provides both read and write access for the flat file databases of MIDOS 2000
+and MIDOS 6 as well as MIDOS Thesaurus.
+
+
+== LINKS
+
+PROGRIS MIDOS:: http://progris.de/produkte.htm
+Documentation:: https://blackwinter.github.io/midos/
+Source code::   https://github.com/blackwinter/midos
+RubyGem::       https://rubygems.org/gems/midos
+
+
+== AUTHORS
+
+* Jens Wille <mailto:jens.wille@gmail.com>
+
+
+== LICENSE AND COPYRIGHT
+
+Copyright (C) 2014 Jens Wille
+
+midos is free software: you can redistribute it and/or modify it
+under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at your
+option) any later version.
+
+midos is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with midos. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,23 @@
+require File.expand_path(%q{../lib/midos/version}, __FILE__)
+
+begin
+  require 'hen'
+
+  Hen.lay! {{
+    gem: {
+      name:         %q{midos},
+      version:      Midos::VERSION,
+      summary:      %q{A Ruby client for MIDOS databases.},
+      description:  %q{Access PROGRIS MIDOS databases from Ruby.},
+      author:       %q{Jens Wille},
+      email:        %q{jens.wille@gmail.com},
+      license:      %q{AGPL-3.0},
+      homepage:     :blackwinter,
+      dependencies: %w[ruby-nuggets],
+
+      required_ruby_version: '>= 1.9.3'
+    }
+  }}
+rescue LoadError => err
+  warn "Please install the `hen' gem. (#{err})"
+end

data/lib/midos.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# midos -- A Ruby client for MIDOS databases                                  #
+#                                                                             #
+# Copyright (C) 2014 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# midos is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# midos is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with midos. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+module Midos
+
+  # Record separator
+  DEFAULT_RS = '&&&'
+
+  # Field separator
+  DEFAULT_FS = ':'
+
+  # Value separator
+  DEFAULT_VS = '|'
+
+  # Line break indicator
+  DEFAULT_NL = '^'
+
+  # Line ending
+  DEFAULT_LE = "\r\n"
+
+  # Default file encoding
+  DEFAULT_ENCODING = 'iso-8859-1'
+
+  class << self
+
+    def filter(source, target, source_options = {}, target_options = source_options)
+      writer, size = Writer.new(target_options.merge(:io => target)),  0
+
+      Reader.parse(source, source_options) { |*args|
+        writer << args and size += 1 if yield(*args)
+      }
+
+      size
+    end
+
+    def filter_file(source_file, target_file, source_options = {}, target_options = source_options, &block)
+      open_file(source_file, source_options) { |source|
+        open_file(target_file, target_options, 'w') { |target|
+          filter(source, target, source_options, target_options, &block)
+        }
+      }
+    end
+
+    def convert(*args)
+      filter(*args) { |*| true }
+    end
+
+    def convert_file(*args)
+      filter_file(*args) { |*| true }
+    end
+
+    def open_file(file, options = {}, mode = 'r', &block)
+      encoding = options[:encoding] ||= DEFAULT_ENCODING
+      File.open(file, mode, :encoding => encoding, &block)
+    end
+
+  end
+
+end
+
+require_relative 'midos/base'
+require_relative 'midos/reader'
+require_relative 'midos/writer'

data/lib/midos/base.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# midos -- A Ruby client for MIDOS databases                                  #
+#                                                                             #
+# Copyright (C) 2014 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# midos is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# midos is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with midos. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+module Midos
+
+  class Base
+
+    class << self
+
+      private
+
+      def file_method(method, mode, file, options = {}, *args, &block)
+        Midos.open_file(file, options, mode) { |io|
+          args.unshift(options.merge(:io => io))
+          method ? send(method, *args, &block) : block[new(*args)]
+        }
+      end
+
+      def extract_options!(args)
+        args.last.is_a?(Hash) ? args.pop : {}
+      end
+
+    end
+
+    def initialize(options = {}, &block)
+      self.key = options[:key]
+
+      self.rs = options[:rs] || DEFAULT_RS
+      self.fs = options[:fs] || DEFAULT_FS
+      self.vs = options[:vs] || DEFAULT_VS
+      self.nl = options[:nl] || DEFAULT_NL
+      self.le = options[:le] || DEFAULT_LE
+      self.io = options[:io] || self.class::DEFAULT_IO
+
+      @auto_id_block = options[:auto_id] || block
+      reset
+    end
+
+    attr_accessor :key, :rs, :fs, :nl, :le, :io, :auto_id
+
+    attr_reader :vs
+
+    def reset
+      @auto_id = @auto_id_block ? @auto_id_block.call : default_auto_id
+    end
+
+    private
+
+    def default_auto_id(n = 0)
+      lambda { n += 1 }
+    end
+
+  end
+
+end

data/lib/midos/reader.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# midos -- A Ruby client for MIDOS databases                                  #
+#                                                                             #
+# Copyright (C) 2014 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# midos is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# midos is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with midos. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+module Midos
+
+  class Reader < Base
+
+    DEFAULT_IO = $stdin
+
+    class << self
+
+      def parse(*args, &block)
+        reader = new(extract_options!(args)).parse(*args, &block)
+        block ? reader : reader.records
+      end
+
+      def parse_file(*args, &block)
+        file_method(:parse, 'r', *args, &block)
+      end
+
+    end
+
+    attr_reader :records
+
+    def reset
+      super
+      @records = {}
+    end
+
+    def vs=(vs)
+      @vs = vs.is_a?(Regexp) ? vs : %r{\s*#{Regexp.escape(vs)}\s*}
+    end
+
+    def parse(io = io, &block)
+      unless block
+        records, block = @records, amend_block { |id, record|
+          records[id] = record
+        }
+      end
+
+      rs, fs, vs, nl, le, key, auto_id, id, record =
+        @rs, @fs, @vs, @nl, @le, @key, @auto_id, nil, {}
+
+      io.each { |line|
+        line = line.chomp(le)
+
+        if line == rs
+          block[key ? id : auto_id.call, record]
+          id, record = nil, {}
+        else
+          k, v = line.split(fs, 2)
+
+          if k && v
+            if k == key
+              id = v
+            else
+              v.gsub!(nl, "\n")
+              v = v.split(vs) if v.index(vs)
+            end
+
+            record[k] = v
+          end
+        end
+      }
+
+      self
+    end
+
+    private
+
+    def amend_block(&block)
+      return block unless $VERBOSE && k = @key
+
+      r, i = block.binding.eval('_ = records, io')
+
+      l = i.respond_to?(:lineno)
+      s = i.respond_to?(:path) ? i.path :
+        Object.instance_method(:inspect).bind(i).call
+
+      lambda { |id, *args|
+        if (r ||= block.binding.eval('records')).key?(id)
+          warn "Duplicate record in #{s}#{":#{i.lineno}" if l}: »#{k}:#{id}«"
+        end
+
+        block[id, *args]
+      }
+    end
+
+  end
+
+end

data/lib/midos/version.rb

@@ -0,0 +1,27 @@
+module Midos
+
+  module Version
+
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+
+    class << self
+
+      # Returns array representation.
+      def to_a
+        [MAJOR, MINOR, TINY]
+      end
+
+      # Short-cut for version string.
+      def to_s
+        to_a.join('.')
+      end
+
+    end
+
+  end
+
+  VERSION = Version.to_s
+
+end

data/lib/midos/writer.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# midos -- A Ruby client for MIDOS databases                                  #
+#                                                                             #
+# Copyright (C) 2014 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# midos is free software; you can redistribute it and/or modify it under the  #
+# terms of the GNU Affero General Public License as published by the Free     #
+# Software Foundation; either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# midos is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with midos. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/hash/idmap'
+
+module Midos
+
+  class Writer < Base
+
+    DEFAULT_IO = $stdout
+
+    class << self
+
+      def write(*args, &block)
+        new(extract_options!(args), &block).write(*args)
+      end
+
+      def write_file(*args, &block)
+        file_method(:write, 'w', *args, &block)
+      end
+
+      def open(*args, &block)
+        file_method(nil, 'w', *args, &block)
+      end
+
+    end
+
+    def vs=(vs)
+      vs.is_a?(String) ? @vs = vs : raise(TypeError,
+        "wrong argument type #{vs.class} (expected String)")
+    end
+
+    def write(records, *args)
+      if records.is_a?(Hash)
+        records.each { |id, record| write_i(id, record, *args) }
+      else
+        records.each { |record| write_i(nil, record, *args) }
+      end
+
+      self
+    end
+
+    def put(record, *args)
+      if record.is_a?(Hash)
+        write_i(nil, record, *args)
+      else
+        write_i(*args.unshift(*record))
+      end
+
+      self
+    end
+
+    alias_method :<<, :put
+
+    private
+
+    def write_i(id, record, io = io)
+      return if record.empty?
+
+      if @key && !record.key?(@key)
+        record[@key] = id || @auto_id.call
+      end
+
+      record.each { |k, v|
+        if v
+          if k
+            v = v.is_a?(Array) ? v.join(@vs) : v.to_s
+            io << k << @fs << v.gsub("\n", @nl) << @le
+          else
+            Array(v).each { |w| io << w.to_s << @le }
+          end
+        end
+      }
+
+      io << @rs << @le << @le
+    end
+
+    class Thesaurus < self
+
+      PROLOGUE = {
+        :PAR => '1011111111110000000010001000000000000010',
+        :DAT => '00000000',
+        :DES => 'DE',
+        :TOP => 'TP~TP',
+        :KLA => 'CC~CC',
+        :OBR => 'BT~BT',
+        :UTR => 'NT~NT',
+        :SYN => 'UF~USE',
+        :FRU => 'PT~PT für',
+        :VER => 'RT~RT',
+        :SP1 => 'ENG~ENG für',
+        :SP2 => 'FRA~FRA für',
+        :SP3 => 'SPA~SPA für',
+        :SP4 => 'ITA~ITA für',
+        :SP5 => 'GRI~GRI für',
+        :SP6 => 'RUS~RUS für',
+        :SP7 => 'POL~POL für',
+        :SP8 => 'UNG~UNG für',
+        :SP9 => 'TSC~TSC für',
+        :SN1 => 'SN1',
+        :SN2 => 'SN2',
+        :SN3 => 'SN3',
+        :SN4 => 'SN4',
+        :SN5 => 'SN5',
+        :DA1 => 'DATE1',
+        :DA2 => 'DATE2',
+        :DA3 => 'DATE3',
+        :DA4 => 'DATE4',
+        :KLD => 'MIDOS Thesaurus',
+        :KOM => ' / ',
+        :KO1 => 'UF',
+        :KO2 => 'USE',
+        :TLE => '  32000 Zeichen',
+        :PAW => '',
+        :ART => '00000',
+        :REL => ' 17  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 18 19 20 21 22 23 24 25'
+      }
+
+      EPILOGUE = {
+        :DE => '*****NICHTDESKRIPTORRELATIONEN*****'
+      }
+
+      RESOLVE_FROM = [:OBR, :UTR, :VER]
+
+      RESOLVE_TO = :DES
+
+      NAME = :KLD
+
+      class << self
+
+        def write(*args, &block)
+          new(extract_options!(args), &block).instruct! { |mth| mth.write(*args) }
+        end
+
+        def open(*args, &block)
+          super { |mth| mth.instruct!(&block) }
+        end
+
+      end
+
+      def initialize(options = {}, prologue = {}, epilogue = {}, &block)
+        super(options, &block)
+
+        prologue[self.class::NAME] ||= options[:name]
+
+        @prologue = self.class::PROLOGUE.merge(prologue)
+        @epilogue = self.class::EPILOGUE.merge(epilogue)
+      end
+
+      attr_reader :prologue, :epilogue
+
+      def instruct!(*args)
+        put(prologue, *args)
+        yield self
+        put(epilogue, *args)
+      end
+
+      private
+
+      def merge_records(hash, records, *args)
+        args = [hash, records, *resolve_from_to(*args)]
+
+        records.each { |id, record|
+          new_record = hash[id] = {}
+          record.each { |key, value| new_record[key] = resolve(key, value, *args) }
+        }
+      end
+
+      def resolve_from_to(from = nil, to = prologue[RESOLVE_TO])
+        if from.nil? || from == true
+          from = prologue.values_at(*RESOLVE_FROM).map { |v| v.split('~').first }
+        end
+
+        [from, to]
+      end
+
+      def resolve(key, value, hash, records, from = nil, to = nil)
+        from && from.include?(key) ? value.map { |id| records[id][to] } : value
+      end
+
+    end
+
+    class ThesaurusX < Thesaurus
+
+      PROLOGUE = {
+        'MTX-PARAMETER' => '',
+        :BEZ            => 'MIDOS Thesaurus',
+        :KOM            => ' / ',
+        :TXL            => 0,
+        :REL            => '',
+        nil             => %w[
+          TT1|Topterm|TT1||||||
+          BT1|Oberbegriff|BT1||||||
+          NT1|Unterbegriff|NT1||||||
+          RT1|Verwandter\ Begriff|RT1||||||
+          SY1|Synonym1|SY1|SY1FOR|||||
+        ]
+      }
+
+      EPILOGUE = {}
+
+      NAME = :BEZ
+
+      private
+
+      def merge_records(hash, *)
+        idmap = hash[:__list__] = Hash.idmap
+
+        super
+
+        idmap.replace(nil => idmap.map { |key, id| "#{key}|DE|#{id}" })
+      end
+
+      def resolve_from_to(*)
+        # nothing to do
+      end
+
+      def resolve(key, value, hash, *)
+        value.map { |id| hash[:__list__][id] }
+      end
+
+    end
+
+  end
+
+end