ruby-nuggets 0.9.6 → 0.9.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c79a1a77d2228f3f9df348d2e8cba583886460e
-  data.tar.gz: f8c3d91368c878220707d74f5d4706b0f4e15555
+  metadata.gz: 0085d350ab71ac8d9eb89f589930da057d40769e
+  data.tar.gz: 14ad33894ecf8bfde16551bd44ec760a5f37bf64
 SHA512:
-  metadata.gz: 735ce39fe3ee94b23ba088a914af65ca93b26758cec4bad78e812a21b152049ad9e788c130879d11bd3821d80d14a364c49c36e3f88d28512e12cbc37931bf9b
-  data.tar.gz: 36b4cebd589355673234b92198642602d9b8b36b329a1cfe4ed9b1ac63d1b3547732048b5a1e920b3e2fb02610540793979f98e2cc5b49f951a98714d81dad68
+  metadata.gz: e1075bd40b0f1e876d6363833bddcb9dc928d7171544ea674d1c1dca21f73ec4160c7e923b5d5cfbe057d402a84c9b395e5755f9858cd4a58eda3b69c089fff0
+  data.tar.gz: 472db2f820fa47e20ba1b9fcfc9518df4ea73f7d080182d0ec084205236b8353cd17fe82041320e4d9d04c5a726d959eef5d1471730fdbc8d43e5f24da819b2b

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to ruby-nuggets version 0.9.6
+This documentation refers to ruby-nuggets version 0.9.7
 
 
 == DESCRIPTION
@@ -46,7 +46,7 @@ RubyGem::       http://rubygems.org/gems/ruby-nuggets
 
 == LICENSE AND COPYRIGHT
 
-Copyright (C) 2007-2013 Jens Wille
+Copyright (C) 2007-2014 Jens Wille
 
 ruby-nuggets 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

data/lib/nuggets/array/hashify.rb

@@ -0,0 +1,5 @@
+require 'nuggets/array/hashify_mixin'
+
+class Array
+  include Nuggets::Array::HashifyMixin
+end

data/lib/nuggets/array/hashify_mixin.rb

@@ -0,0 +1,48 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+module Nuggets
+  class Array
+    module HashifyMixin
+
+      def hashify(value = nil, &block)
+        block ||= lambda { |key| [key, key] }
+
+        hash = case value
+          when ::Hash then value
+          when ::Proc then ::Hash.new(&value)
+          else             ::Hash.new(value)
+        end
+
+        each { |key| hash.store(*block[key]) }
+
+        hash
+      end
+
+    end
+  end
+end

data/lib/nuggets/array/histogram_mixin.rb

@@ -141,7 +141,7 @@ module Nuggets
   #
   # See HistogramItem for further details on the individual arguments.
   def formatted_histogram(format = :default, indicator = '=')
-    format = FORMATS[format] if FORMATS.has_key?(format)
+    format = FORMATS[format] if FORMATS.key?(format)
     raise ::TypeError, "String expected, got #{format.class}" unless format.is_a?(::String)
 
     include_percentage = format.include?('%%')

data/lib/nuggets/cli.rb

@@ -104,6 +104,10 @@ module Nuggets
       }
     end
 
+    def run(arguments)
+      raise ::NotImplementedError, 'must be implemented by subclass'
+    end
+
     def reset(stdin = ::STDIN, stdout = ::STDOUT, stderr = ::STDERR)
       @stdin, @stdout, @stderr = stdin, stdout, stderr
       @options, @config = {}, {}
@@ -177,7 +181,7 @@ module Nuggets
 
     def merge_config(args = [config, defaults])
       args.each { |hash| hash && hash.each { |key, value|
-        options[key] = value unless options.has_key?(key)
+        options[key] = value unless options.key?(key)
       } }
     end
 

data/lib/nuggets/hash/unroll_mixin.rb

@@ -59,9 +59,9 @@ module Nuggets
     args = value_keys.dup
     options = value_keys.last.is_a?(::Hash) ? value_keys.pop : {}
 
-    sort_proc = if options.has_key?(:sort_by)
+    sort_proc = if options.key?(:sort_by)
       lambda { sort_by(&options[:sort_by]) }
-    elsif options.has_key?(:sort)
+    elsif options.key?(:sort)
       options[:sort] == true ? lambda { sort } : lambda { sort(&options[:sort]) }
     end
 

data/lib/nuggets/midos.rb

@@ -6,7 +6,7 @@
 # A component of ruby-nuggets, some extensions to the Ruby programming        #
 # language.                                                                   #
 #                                                                             #
-# Copyright (C) 2007-2013 Jens Wille                                          #
+# Copyright (C) 2007-2014 Jens Wille                                          #
 #                                                                             #
 # Authors:                                                                    #
 #     Jens Wille <jens.wille@gmail.com>                                       #
@@ -27,6 +27,10 @@
 ###############################################################################
 #++
 
+require 'nuggets/midos/base'
+require 'nuggets/midos/reader'
+require 'nuggets/midos/writer'
+
 module Nuggets
   module Midos
 
@@ -51,23 +55,18 @@ module Nuggets
     class << self
 
       def filter(source, target, source_options = {}, target_options = source_options)
-        records = {}
+        writer, size = Writer.new(target_options.merge(:io => target)),  0
 
-        Parser.parse(source, source_options) { |id, record|
-          records[id] = record if yield(id, record)
+        Reader.parse(source, source_options) { |*args|
+          writer << args and size += 1 if yield(*args)
         }
 
-        Writer.write(target, records, target_options)
-
-        records
+        size
       end
 
       def filter_file(source_file, target_file, source_options = {}, target_options = source_options, &block)
-        source_options[:encoding] ||= DEFAULT_ENCODING
-        target_options[:encoding] ||= DEFAULT_ENCODING
-
-        ::File.open(source_file, :encoding => source_options[:encoding]) { |source|
-          ::File.open(target_file, 'w', :encoding => target_options[:encoding]) { |target|
+        open_file(source_file, source_options) { |source|
+          open_file(target_file, target_options, 'w') { |target|
             filter(source, target, source_options, target_options, &block)
           }
         }
@@ -81,161 +80,9 @@ module Nuggets
         filter_file(*args) { |*| true }
       end
 
-    end
-
-    class Base
-
-      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
-
-        @auto_id_block = block
-        reset
-      end
-
-      attr_accessor :key, :rs, :fs, :nl, :le, :auto_id
-
-      attr_reader :vs, :records
-
-      def vs=(vs)
-        @vs = vs.is_a?(::Regexp) ? vs : %r{\s*#{::Regexp.escape(vs)}\s*}
-      end
-
-      def reset
-        @records = {}
-        @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
-
-    class Parser < Base
-
-      class << self
-
-        def parse(source, options = {}, &block)
-          parser = new(options).parse(source, &block)
-          block_given? ? parser : parser.records
-        end
-
-        def parse_file(file, options = {}, &block)
-          ::File.open(file, :encoding => options[:encoding] ||= DEFAULT_ENCODING) { |source|
-            parse(source, options, &block)
-          }
-        end
-
-      end
-
-      def initialize(options = {})
-        super
-        @vs = /\s*#{::Regexp.escape(@vs)}\s*/ unless @vs.is_a?(::Regexp)
-      end
-
-      def parse(source, &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, {}
-
-        source.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, source')
-
-        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')).has_key?(id)
-            warn "Duplicate record in #{s}#{":#{i.lineno}" if l}: »#{k}:#{id}«"
-          end
-
-          block[id, *args]
-        }
-      end
-
-    end
-
-    class Writer < Base
-
-      class << self
-
-        def write(target, records, options = {})
-          new(options).write(target, records)
-        end
-
-        def write_file(file, records, options = {})
-          ::File.open(file, 'w', :encoding => options[:encoding] ||= DEFAULT_ENCODING) { |target|
-            write(target, records, options)
-          }
-        end
-
-      end
-
-      def write(target, records = {})
-        rs, fs, vs, nl, le, key, auto_id =
-          @rs, @fs, @vs, @nl, @le, @key, @auto_id
-
-        @records.update(records).each { |id, record|
-          record, id = id, nil unless record
-
-          if key && !record.has_key?(key)
-            record[key] = id || auto_id.call
-          end
-
-          record.each { |k, v|
-            if v
-              v = v.is_a?(::Array) ? v.join(vs) : v.to_s
-              target << k << fs << v.gsub("\n", nl) << le
-            end
-          }
-
-          target << rs << le << le
-        }
-
-        self
+      def open_file(file, options = {}, mode = 'r', &block)
+        encoding = options[:encoding] ||= DEFAULT_ENCODING
+        ::File.open(file, mode, :encoding => encoding, &block)
       end
 
     end

data/lib/nuggets/midos/base.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+module Nuggets
+  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
+end

data/lib/nuggets/midos/reader.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+module Nuggets
+  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
+end

data/lib/nuggets/midos/writer.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/hash/idmap'
+
+module Nuggets
+  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
+end

data/lib/nuggets/rdf/compression.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'rdf/util'
+
+begin
+  require 'zlib'
+rescue LoadError => err
+  warn err if $VERBOSE
+end
+
+begin
+  require 'rbzip2'
+
+  class RBzip2::Decompressor
+
+    def eof?
+      @current_state == EOF
+    end
+
+    def gets(sep = $/)
+      r = ''
+
+      loop {
+        b = read0
+        break if b < 0
+
+        count(1)
+        r << b
+
+        break if r.end_with?(sep)
+      }
+
+      r
+    end
+
+  end
+rescue LoadError => err
+  warn err if $VERBOSE
+end
+
+class << RDF::Util::File
+
+  alias_method :_nuggets_original_open_file, :open_file
+
+  def open_file(filename_or_url, options = {}, &block)
+    klass = begin
+      case File.extname(filename_or_url).downcase.sub(/\A\./, '')
+        when /\Abz(?:ip)?2?\z/ then RBzip2::Decompressor
+        when /\Agz(?:ip)?\z/   then Zlib::GzipReader
+      end
+    rescue NameError => err
+      err.message.sub!('Module::', '')
+      raise
+    end
+
+    if klass
+      original_block, block = block, lambda { |file|
+        original_block[file.is_a?(IO) ? klass.new(file) : file]
+      }
+    end
+
+    _nuggets_original_open_file(filename_or_url, options, &block)
+  end
+
+end

data/lib/nuggets/rdf/prefix.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'rdf'
+
+def RDF.__prefix__; :rdf; end

data/lib/nuggets/rdf/turtle.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'nuggets/rdf/turtle/reader'
+require 'nuggets/rdf/compression'
+require 'nuggets/rdf/prefix'
+require 'nuggets/rdf/uri'
+
+module Nuggets
+  module RDF
+    class Turtle
+
+  include ::Enumerable
+
+  NS_SEPARATOR = ':'.freeze
+
+  NS = ::RDF::Vocabulary.inject({}) { |h, v| h[v.__prefix__] = v; h }
+
+  class << self
+
+    def open(file, *args)
+      ::RDF::Reader.open(file, :format => :ttl) { |reader|
+        turtle = new(reader, *args)
+        turtle.file = ::File.expand_path(file)
+
+        return block_given? ? yield(turtle) : turtle
+      }
+    end
+
+    def foreach(file, *args, &block)
+      open(file, *args) { |turtle| turtle.each(&block) }
+    end
+
+  end
+
+  def initialize(reader, map = true)
+    @reader, @base, @prefixes = reader, *reader.parse_prologue
+    self.map = map
+  end
+
+  attr_reader :reader, :map, :base, :prefixes
+
+  attr_accessor :file
+
+  def map=(map)
+    unless map.is_a?(::Hash)
+      @map = ::Hash.new(map)
+    else
+      @map = {}
+
+      map.each { |k, v|
+        if k.is_a?(::String)
+          n, s = k.split(NS_SEPARATOR, 2)
+          k = NS.key?(n = n.to_sym) ? NS[n][s] : prefixes[n] / s
+        end
+
+        @map[k] = v
+      }
+    end
+  end
+
+  def statements
+    each_statement.to_a
+  end
+
+  def each_statement(&block)
+    return enum_for(:each_statement) unless block_given?
+    reader.parse_statements(&block)
+    self
+  end
+
+  def each
+    return enum_for(:each) unless block_given?
+
+    uri, map, base = ::RDF::URI, self.map, self.base
+
+    each_statement { |t|
+      s, p, o = *t
+
+      if s.is_a?(uri) and k = map[p] and s.start_with?(base)
+        yield s, o, k
+      end
+    }
+  end
+
+  def closed?
+    reader.closed?
+  end
+
+  def inspect
+    '#<%s:0x%x @file=%p, @base=%p%s>' % [
+      self.class, object_id, file, base, closed? ? ' (closed)' : ''
+    ]
+  end
+
+    end
+  end
+end

data/lib/nuggets/rdf/turtle/reader.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'rdf/turtle'
+
+module RDF
+  class Turtle::Reader
+
+    PARSE_OPTIONS = {
+      :branch         => BRANCH,
+      :first          => FIRST,
+      :follow         => FOLLOW,
+      :reset_on_start => true
+    }
+
+    def closed?
+      @input.closed?
+    end
+
+    def parse_prologue
+      parse_internal { break }
+      rewind
+      [base_uri, prefixes]
+    end
+
+    def parse_statements
+      parse_internal { |context, _, *data|
+        if context == :statement
+          data[3] = { :context => data[3] }
+          yield Statement.new(*data)
+        end
+      }
+    end
+
+    private
+
+    def parse_internal(&block)
+      parse(@input, START, @options.merge(PARSE_OPTIONS), &block)
+    rescue => err
+      err.message << " (line #{lineno})"
+      raise
+    end
+
+  end
+end

data/lib/nuggets/rdf/uri.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2014 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@gmail.com>                                       #
+#                                                                             #
+# ruby-nuggets 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.                                                  #
+#                                                                             #
+# ruby-nuggets 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 ruby-nuggets. If not, see <http://www.gnu.org/licenses/>.        #
+#                                                                             #
+###############################################################################
+#++
+
+require 'rdf'
+
+class RDF::URI
+
+  def basename
+    File.basename(path).sub(/;[^\/]*$/, '')
+  end
+
+end

data/lib/nuggets/version.rb

@@ -4,7 +4,7 @@ module Nuggets
 
     MAJOR = 0
     MINOR = 9
-    TINY  = 6
+    TINY  = 7
 
     class << self
 

data/spec/nuggets/array/hashify_spec.rb

@@ -0,0 +1,43 @@
+require 'nuggets/array/hashify'
+
+describe Array, 'when extended by', Nuggets::Array::HashifyMixin do
+
+  it { Array.ancestors.should include(Nuggets::Array::HashifyMixin) }
+
+  example do
+    hash = [1, 2, 3, 4].hashify
+    hash.should == { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+    hash[42].should be_nil
+  end
+
+  example do
+    [1, 2, 3, 4].hashify { |i| [i, i ** 2] }.should == { 1 => 1, 2 => 4, 3 => 9, 4 => 16 }
+  end
+
+  example do
+    [1, 2, 3, 4].hashify { |i| [i ** 2, i] }.should == { 1 => 1, 4 => 2, 9 => 3, 16 => 4 }
+  end
+
+  example do
+    lambda { [1, 2, 3, 4].hashify { |i| i } }.should raise_error(ArgumentError)
+  end
+
+  example do
+    hash = [1, 2, 3, 4].hashify(0)
+    hash.should == { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+    hash[42].should == 0
+  end
+
+  example do
+    hash = [1, 2, 3, 4].hashify(lambda { |h, k| h[k] = [] })
+    hash.should == { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+    hash[42].should == []
+  end
+
+  example do
+    hash = [1, 2, 3, 4].hashify(4 => -1, 23 => 42)
+    hash.should == { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 23 => 42 }
+    hash[42].should be_nil
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-nuggets
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.9.7
 platform: ruby
 authors:
 - Jens Wille
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-19 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Some extensions to the Ruby programming language.
 email: jens.wille@gmail.com
@@ -19,6 +19,11 @@ extra_rdoc_files:
 - COPYING
 - ChangeLog
 files:
+- ".rspec"
+- COPYING
+- ChangeLog
+- README
+- Rakefile
 - lib/nuggets.rb
 - lib/nuggets/all.rb
 - lib/nuggets/all_mixins.rb
@@ -34,6 +39,8 @@ files:
 - lib/nuggets/array/flush.rb
 - lib/nuggets/array/flush_mixin.rb
 - lib/nuggets/array/format.rb
+- lib/nuggets/array/hashify.rb
+- lib/nuggets/array/hashify_mixin.rb
 - lib/nuggets/array/histogram.rb
 - lib/nuggets/array/histogram_mixin.rb
 - lib/nuggets/array/in_order.rb
@@ -113,6 +120,9 @@ files:
 - lib/nuggets/log_parser/rails.rb
 - lib/nuggets/lsi.rb
 - lib/nuggets/midos.rb
+- lib/nuggets/midos/base.rb
+- lib/nuggets/midos/reader.rb
+- lib/nuggets/midos/writer.rb
 - lib/nuggets/mysql.rb
 - lib/nuggets/net/success.rb
 - lib/nuggets/numeric/between.rb
@@ -140,6 +150,11 @@ files:
 - lib/nuggets/proc/bind_mixin.rb
 - lib/nuggets/range/quantile.rb
 - lib/nuggets/range/quantile_mixin.rb
+- lib/nuggets/rdf/compression.rb
+- lib/nuggets/rdf/prefix.rb
+- lib/nuggets/rdf/turtle.rb
+- lib/nuggets/rdf/turtle/reader.rb
+- lib/nuggets/rdf/uri.rb
 - lib/nuggets/ruby.rb
 - lib/nuggets/statistics.rb
 - lib/nuggets/statistics_mixins.rb
@@ -178,13 +193,10 @@ files:
 - lib/nuggets/util/pluggable.rb
 - lib/nuggets/util/ruby.rb
 - lib/nuggets/version.rb
-- COPYING
-- ChangeLog
-- README
-- Rakefile
 - spec/nuggets/array/boost_spec.rb
 - spec/nuggets/array/correlation_spec.rb
 - spec/nuggets/array/flush_spec.rb
+- spec/nuggets/array/hashify_spec.rb
 - spec/nuggets/array/histogram_spec.rb
 - spec/nuggets/array/limit_spec.rb
 - spec/nuggets/array/mean_spec.rb
@@ -221,7 +233,6 @@ files:
 - spec/nuggets/uri/content_type_spec.rb
 - spec/nuggets/uri/exist_spec.rb
 - spec/spec_helper.rb
-- ".rspec"
 homepage: http://github.com/blackwinter/ruby-nuggets
 licenses:
 - AGPL-3.0
@@ -229,7 +240,7 @@ metadata: {}
 post_install_message: 
 rdoc_options:
 - "--title"
-- ruby-nuggets Application documentation (v0.9.6)
+- ruby-nuggets Application documentation (v0.9.7)
 - "--charset"
 - UTF-8
 - "--line-numbers"
@@ -250,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Some extensions to the Ruby programming language.