ruby-nuggets 0.9.1 → 0.9.2

data/lib/nuggets/midos.rb

@@ -0,0 +1,130 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2013 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 Parser
+
+      # Record separator
+      DEFAULT_RS = '&&&'
+
+      # Field separator
+      DEFAULT_FS = ':'
+
+      # Value separator
+      DEFAULT_VS = ' | '
+
+      # Line break indicator
+      DEFAULT_NL = '^'
+
+      def self.parse(input, *args, &block)
+        parser = new(*args).parse(input, &block)
+        block_given? ? parser : parser.records
+      end
+
+      def initialize(options = {})
+        @key = options[:key]
+
+        @rs = options[:rs] || DEFAULT_RS
+        @fs = options[:fs] || DEFAULT_FS
+        @vs = options[:vs] || DEFAULT_VS
+        @vs = /\s*#{Regexp.escape(@vs)}\s*/ unless @vs.is_a?(Regexp)
+        @nl = options[:nl] || DEFAULT_NL
+
+        reset
+      end
+
+      attr_reader :rs, :fs, :vs, :key, :records
+
+      def reset
+        @records = {}
+        @auto_id = auto_id
+      end
+
+      def parse(input, &block)
+        unless block
+          records, block = @records, amend_block { |id, record|
+            records[id] = record
+          }
+        end
+
+        rs, fs, vs, nl, key, auto_id, id, record =
+          @rs, @fs, @vs, @nl, @key, @auto_id, nil, {}
+
+        input.each { |line|
+          line = line.chomp
+
+          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 auto_id(n = 0)
+        lambda { n += 1 }
+      end
+
+      def amend_block(&block)
+        return block unless $VERBOSE && k = @key
+
+        r, i = block.binding.eval('_ = records, input')
+
+        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
+
+  end
+end

data/lib/nuggets/mysql.rb

@@ -0,0 +1,209 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2013 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 'strscan'
+
+module Nuggets
+  module MySQL
+
+    class Parser
+
+      DEFAULT_NAME  = '__DEFAULT__'
+      DEFAULT_TABLE = '__DEFAULT__'
+
+      USE_RE           = /\AUSE\s+`(.+?)`/i
+      CREATE_TABLE_RE  = /\ACREATE\s+TABLE\s+`(.+?)`/i
+      TABLE_COLUMN_RE  = /\A\s+`(.+?)`/
+      FINISH_TABLE_RE  = /\A\).*;\Z/
+      INSERT_VALUES_RE = /\AINSERT\s+INTO\s+`(.+?)`\s+(?:\((.+?)\)\s+)?VALUES\s*(.*);\Z/i
+      CLEAN_COLUMNS_RE = /[\s`]+/
+
+      def self.parse(input, &block)
+        parser = new.parse(input, &block)
+        block_given? ? parser : parser.tables
+      end
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @name         = DEFAULT_NAME
+        @table        = DEFAULT_TABLE
+        @tables       = {}
+        @columns      = Hash.new { |h, k| h[k] = [] }
+        @value_parser = ValueParser.new
+      end
+
+      attr_reader :tables
+
+      def parse(input, &block)
+        unless block
+          tables, block = @tables, lambda { |_, name, table, columns, values|
+            ((tables[name] ||= {})[table] ||= []) << fields = {}
+
+            values.each_with_index { |value, index|
+              if column = columns[index]
+                fields[column] = value
+              end
+            }
+          }
+        end
+
+        name, table, columns, value_parser, block_given =
+          @name, @table, @columns, @value_parser, block_given?
+
+        input.each { |line|
+          case line
+            when USE_RE
+              name = $1
+              yield :use, name if block_given
+            when CREATE_TABLE_RE
+              table = $1
+            when TABLE_COLUMN_RE
+              columns[table] << $1 if table
+            when FINISH_TABLE_RE
+              yield :table, name, table, columns[table] if block_given
+              table = nil
+            when INSERT_VALUES_RE
+              _table, _columns, _values = $1, $2, $3
+
+              _columns = _columns.nil? ? columns[_table] :
+                _columns.gsub(CLEAN_COLUMNS_RE, '').split(',')
+
+              value_parser.parse(_values) { |values|
+                block[:insert, name, _table, _columns, values]
+              } unless _columns.empty?
+          end
+        }
+
+        @name, @table = name, table
+
+        self
+      end
+
+    end
+
+    class ValueParser
+
+      AST = Struct.new(:value)
+
+      def self.parse(input)
+        new.parse(input)
+      end
+
+      def parse(input)
+        @input = StringScanner.new(input)
+
+        rows, block_given = [], block_given?
+
+        while result = parse_row
+          row = result.value
+          block_given ? yield(row) : rows << row
+          break unless @input.scan(/,\s*/)
+        end
+
+        @input.scan(/;/)  # optional
+
+        error('Unexpected data') unless @input.eos?
+
+        rows unless block_given
+      end
+
+      def parse_row
+        return unless @input.scan(/\(/)
+
+        row = []
+
+        while result = parse_value
+          row << result.value
+          break unless @input.scan(/,\s*/)
+        end
+
+        error('Unclosed row') unless @input.scan(/\)/)
+
+        AST.new(row)
+      end
+
+      def parse_value
+        parse_string ||
+        parse_number ||
+        parse_keyword
+      end
+
+      def parse_string
+        return unless @input.scan(/'/)
+
+        string = ''
+
+        while contents = parse_string_content || parse_string_escape
+          string << contents.value
+        end
+
+        error('Unclosed string') unless @input.scan(/'/)
+
+        AST.new(string)
+      end
+
+      def parse_string_content
+        if @input.scan(/[^\\']+/)
+          AST.new(@input.matched)
+        end
+      end
+
+      def parse_string_escape
+        if @input.scan(/\\[abtnvfr]/)
+          AST.new(eval(%Q{"#{@input.matched}"}))
+        elsif @input.scan(/\\.|''/)
+          AST.new(@input.matched[-1, 1])
+        end
+      end
+
+      def parse_number
+        if @input.scan(/-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)
+          AST.new(eval(@input.matched))
+        end
+      end
+
+      def parse_keyword
+        if @input.scan(/null/i)
+          AST.new(nil)
+        end
+      end
+
+      def error(message)
+        if @input.eos?
+          raise "Unexpected end of input (#{message})."
+        else
+          raise "#{message} at #{$.}:#{@input.pos}: #{@input.peek(16).inspect}"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/nuggets/pluggable.rb

@@ -0,0 +1,92 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of ruby-nuggets, some extensions to the Ruby programming        #
+# language.                                                                   #
+#                                                                             #
+# Copyright (C) 2007-2011 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 'set'
+
+module Nuggets
+  module Pluggable
+
+    def self.load_plugins_for(*klasses)
+      klasses.map { |klass| klass.extend(self).load_plugins }
+    end
+
+    def load_plugins(name = plugin_filename)
+      load_path_plugins(name)
+      load_gem_plugins(name)
+      load_env_plugins(name)
+
+      loaded_plugins.to_a
+    end
+
+    def loaded_plugins
+      @loaded_plugins ||= Set.new
+    end
+
+    def plugin_filename
+      @plugin_filename ||= "#{name.
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/,     '\1_\2').
+        gsub(/::/, '/').tr('-', '_').downcase}_plugin.rb"
+    end
+
+    attr_writer :plugin_filename
+
+    private
+
+    def load_path_plugins(name)
+      $LOAD_PATH.dup.each { |path|
+        plugin = ::File.expand_path(name, path)
+        load_plugin_file(plugin) if ::File.file?(plugin)
+      }
+    end
+
+    def load_gem_plugins(name)
+      ::Gem::Specification.latest_specs.each { |spec|
+        load_plugin_files(spec.matches_for_glob(name))
+      } if ::Object.const_defined?(:Gem)
+    end
+
+    def load_env_plugins(name)
+      path = ::ENV["#{name.chomp(ext = ::File.extname(name)).upcase}_PATH"]
+      path.split(::File::PATH_SEPARATOR).each { |dir|
+        load_plugin_files(::Dir["#{dir}/*#{ext}"])
+      } if path
+    end
+
+    def load_plugin_file(plugin)
+      load plugin if loaded_plugins.add?(plugin)
+    rescue ::Exception => err
+      raise unless loaded_plugins.delete?(plugin)
+      warn "Error loading #{name} plugin: #{plugin}: #{err} (#{err.class})"
+    end
+
+    def load_plugin_files(plugins)
+      plugins.each { |plugin| load_plugin_file(::File.expand_path(plugin)) }
+    end
+
+  end
+end