log2mail 0.0.1.pre3 → 0.0.1.pre4

data/lib/log2mail/config/config_file_snippet.rb

@@ -0,0 +1,17 @@
+module Log2mail
+  module Config
+
+    class ConfigFileSnippet
+      attr_reader :snippet, :filename
+      def initialize( snippet, filename )
+        @snippet  = snippet
+        @filename = filename
+      end
+
+      def to_s
+        @snippet
+      end
+    end
+
+  end
+end

data/lib/log2mail/config/old_config_file_handler.rb

@@ -0,0 +1,220 @@
+require_relative 'attribute'
+require_relative 'section'
+
+module Log2mail
+  module Config
+    class ConfigFileHandler
+
+      class <<self
+        def parse_config(config_path)
+          new(config_path)
+          # pp config.config
+          # config.files.each do |f|
+          #   puts "File: #{f}"
+          #   config.patterns_for_file(f).each do |pattern|
+          #     puts "  Pattern: #{pattern}; mailto: " + config.mailtos_for_pattern( f, pattern ).join(', ')
+          #   end
+          # end
+        end
+      end
+
+      attr_reader :raw
+
+      def initialize(config_paths)
+        $logger.debug "Reading configuration from #{config_paths}"
+        @config_paths = Array(config_paths)
+        expand_paths
+        @raw = read_configuration
+        validate_configuration
+      end
+
+      # returns all the paths of all files needed to be watched
+      def files
+        @config.keys - [:defaults]
+      end
+
+      def file_patterns
+        h = {}
+        files.each do |file|
+          h[file] = patterns_for_file(file)
+        end
+        h
+      end
+
+      def patterns_for_file( file )
+        Hash(@config[file][:patterns]).keys + \
+        Hash(defaults[:patterns]).keys
+      end
+
+      def mailtos_for_pattern( file, pattern )
+        m = []
+        m.concat Hash( config_file_pattern(file, pattern)[:mailtos] ).keys
+        m.concat Hash(Hash(Hash(defaults[:patterns])[pattern])[:mailtos]).keys
+        m.concat Array(defaults[:mailtos]) if m.empty?
+        m.uniq
+      end
+
+      def settings_for_mailto( file, pattern, mailto )
+        h = defaults.reject {|k,v| k==:mailtos}
+        h.merge config_file_mailto(file, pattern, mailto)
+      end
+
+      def defaults
+        Hash(@config[:defaults])
+      end
+
+      def formatted( show_effective )
+        Terminal::Table.new do |t|
+          settings_header = show_effective ? 'Effective Settings' : 'Settings'
+          t << ['File', 'Pattern', 'Recipient', settings_header]
+          t << :separator
+          files.each do |file|
+            patterns_for_file(file).each do |pattern|
+              mailtos_for_pattern(file, pattern).each do |mailto|
+                settings = []
+                if show_effective
+                  settings_for_mailto(file, pattern, mailto).each_pair \
+                    { |k,v| settings << '%s=%s' % [k,v] }
+                else
+                  config_file_mailto(file, pattern, mailto).each_pair \
+                    { |k,v| settings << '%s=%s' % [k,v] }
+                end
+                t.add_row [file, pattern, mailto, settings.join($/)]
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def config_file(file)
+        Hash(@config[file])
+      end
+
+      def config_file_pattern(file, pattern)
+        Hash( Hash( config_file(file)[:patterns] )[pattern] )
+      end
+
+      def config_file_mailtos(file, pattern)
+        Hash( config_file_pattern(file, pattern)[:mailtos] )
+      end
+
+      def config_file_mailto(file, pattern, mailto)
+        Hash( config_file_mailtos(file, pattern)[mailto] )
+      end
+
+      def expand_paths
+        expanded_paths = []
+        @config_paths.each do |path|
+          if ::File.directory?(path)
+            expanded_paths.concat Dir.glob( ::File.join( path, '*[^~#]' ) )
+          else
+            expanded_paths << path
+          end
+        end
+        @config_paths = expanded_paths
+      end
+
+      # tries to follow original code at https://github.com/lordlamer/log2mail/blob/master/config.cc#L192
+      def read_configuration
+        @config = {}
+        @config_paths.map do |file|
+          @section = nil; @pattern = nil; @mailto = nil
+          # section, pattern, mailto are reset for every file (but not when included by 'include')
+          parse_file( file )
+        end.join($/)
+      end
+
+      def parse_file( filename )
+        raw = ""
+        IO.readlines(filename).each_with_index do |line, lineno|
+          raw << line
+          parse(filename, line, lineno + 1)
+        end
+        raw
+      rescue Errno::ENOENT
+        fail Error, "Configuration file or directory not found (or not readable): #{filename}"
+      end
+
+      def parse(file, line, lineno)
+        line.strip!
+        return if line =~ /^#/
+        return if line =~ /^$/
+        line =~ /^(\S+)\s*=?\s*"?(.*?)"?(\s*#.*)?$/  # drop double quotes on right hand side; drop comments
+        key, value = $1.to_sym, $2.strip
+        if key == :include # include shall work everywhere
+          parse_file( ::File.join(Pathname(file).parent, value) )
+          return
+        end
+        if key == :defaults and value.empty?  # section: specifies top level; must be 'defaults' or 'file'
+          @section = key
+          @pattern = nil; @mailto = nil
+          fail Error, "Invalid section. Section 'defaults' already specified." if @config[@section]
+          @config[@section] = {}
+        elsif key == :file
+          @section = value
+          @pattern = nil; @mailto = nil
+          @config[@section] ||= {}
+        elsif key == :pattern # must come inside 'file' (or 'defaults')
+          # fail "Invalid section. All statements must appear after 'defaults' or 'file=...'" unless @section
+          @pattern = value; @mailto = nil
+          @config[@section][:patterns] ||= {}
+          warning { "Redefining pattern section '#{value}' which has been defined already for '#{@section}'." } \
+            if @config[@section][:patterns][value]
+          @config[@section][:patterns][value] = {}
+        elsif key == :mailto and @section != :defaults # must come inside 'pattern' (or 'defaults')
+          fail Error, "'mailto' statements only allowed inside 'pattern' or 'defaults'." unless @pattern
+          @mailto = value
+          @config[@section][:patterns][@pattern][:mailtos] ||= {}
+          warning { "Redefining mailto section '#{value}' which has been defined already for '#{@section}'." } \
+            if @config[@section][:patterns][@pattern][:mailtos][value]
+          @config[@section][:patterns][@pattern][:mailtos][value] = {}
+        else # everything else must come inside 'defaults' or 'mailto'
+          fail Error, "'#{key}' must be set within 'defaults' or 'mailto'." unless @section == :defaults or @mailto
+          if INT_OPTIONS.include?(key)
+            value = value.to_i
+          elsif STR_OPTIONS.include?(key)
+          elsif PATH_OPTIONS.include?(key)
+            value = ::File.expand_path( value, Pathname(file).parent ) unless Pathname(value).absolute?
+          elsif key == :mailto # special handling for 'mailto' in 'defaults' section
+            @config[:defaults][:mailtos] ||= []
+            @config[:defaults][:mailtos] << value
+            return # skip the 'mailto' entry itself
+          else
+            fail Error, "'#{key}' is an unknown configuration statement."
+          end
+          if @section == :defaults and !@pattern and !@mailto
+            warning { "Redefining value for '#{key}'." } if @config[@section][key]
+            @config[@section][key] = value
+          else
+            warning { "Redefining value for '#{key}'." } \
+              if @config[@section][:patterns][@pattern][:mailtos][@mailto][key]
+            @config[@section][:patterns][@pattern][:mailtos][@mailto][key] = value
+          end
+        end
+      rescue
+        fail Error, "#{file} (line #{lineno}): #{$!.message}#$/[#{$!.class} at #{$!.backtrace.first}]"
+      end
+
+      def validate_configuration
+        files.each do |file|
+          patterns_for_file(file).each do |pattern|
+            mailtos = mailtos_for_pattern(file, pattern)
+            $logger.warn "Pattern #{file}:#{pattern} has no recipients." if mailtos.empty?
+          end
+        end
+        # FIXME: empty configuration should cause FATAL error
+        # TODO: illegal regexp pattern should cause ERROR
+      end
+
+      def warning(&block)
+        file = block.binding.eval('file')
+        lineno = block.binding.eval('lineno')
+        message = block.call
+        $logger.warn "#{file} (line #{lineno}): #{message}#$/[at #{caller.first}]"
+      end
+
+    end
+  end
+end

data/lib/log2mail/config/parser.rb

@@ -0,0 +1,144 @@
+require 'parslet'
+
+module Log2mail
+  module Config
+
+    class ParseError < Log2mail::Error
+      def initialize( opts )
+        @opts = opts
+      end
+      def original
+        @opts[:exception]
+      end
+      def to_s
+        'File \'' + @opts[:filename] + '\': ' + ($verbose ? original.cause.ascii_tree : original.to_s)
+      end
+    end
+
+    class Transform < Parslet::Transform
+
+      rule(:quoted_string   => simple(:value)) { value.to_s.gsub('\\"', '"') }
+      rule(:unquoted_string => simple(:value)) { value.to_s.strip }
+      rule(:integer         => simple(:value)) { value.to_i }
+
+      rule(:attribute_name => simple(:key), :attribute_value => simple(:value)) do
+        Attribute.new( key, value )
+      end
+
+      rule(:section_name => simple(:key), :section_value => simple(:value)) do
+        Section.new( key, value )
+      end
+      rule(:section_name => simple(:key)) do
+        Section.new( key )
+      end
+
+      rule(:section => sequence(:values)) { |dict| merge_values( dict[:values] ) }
+
+      def self.merge_values( values )
+        values.reduce do |v1, v2|
+          fail "v1 must be a Section" unless v1.instance_of?(Section)
+          case v2
+          when Attribute
+            v1.attrs << v2
+            v1
+          when Section
+            v1.attrs << v2
+            v1
+          else
+            fail "Unsupported value class: #{v1.class}: #{v1.inspect}"
+          end
+        end
+        values.first
+      end
+
+      rule(:section => simple(:section)) do
+        fail "Unsupported section class: #{section.class}" unless section.instance_of?(Section)
+        section
+      end
+
+      rule(:config => sequence(:sections)) do
+        Config.new(sections)
+      end
+
+      rule(:config => simple(:comment)) { Config.new }
+
+    end
+
+    class Parser < Parslet::Parser
+
+      rule(:config)           { block.repeat.as(:config) }
+      root(:config)
+
+      rule(:block)            { (defaults_section | file_section).as(:section) | eol }
+
+      rule(:defaults_section) { defaults_section_head >> defaults_section_content }
+      rule(:file_section)     { file_section_head >> file_section_content }
+      rule(:defaults_section_content) { ( mailto_section.as(:section) | pattern_section.as(:section) | attribute | eol ).repeat }
+      rule(:file_section_content)     { ( pattern_section.as(:section) | attribute | eol ).repeat }
+
+      rule(:pattern_section)          { pattern_section_head >> pattern_section_content }
+      rule(:pattern_section_content)  { ( mailto_section.as(:section) | attribute | eol ).repeat }
+
+      rule(:mailto_section)           { mailto_section_head >> mailto_section_content }
+      rule(:mailto_section_content)   { attributes }
+
+      def line_expression( expr )
+        space? >> expr >> eol
+      end
+
+      def equation( name, value )
+        line_expression( name >> space? >> str('=') >> space? >> value )
+      end
+
+      rule(:defaults_section_head) { line_expression( str('defaults').as(:section_name) ) }
+      rule(:file_section_head)     { equation( str('file').as(:section_name), value.as(:section_value)) }
+      rule(:mailto_section_head)   { equation( str('mailto').as(:section_name), value.as(:section_value)) }
+      rule(:pattern_section_head)  { equation( str('pattern').as(:section_name), value.as(:section_value)) }
+
+      rule(:attribute)         { equation( valid_attr_name.as(:attribute_name), value.as(:attribute_value) ) }
+      # rule(:mailto_attribute)  { equation( str('mailto').as(:attribute_name), value.as(:attribute_value)) }
+      # rule(:pattern_attribute) { equation( str('pattern').as(:attribute_name), value.as(:attribute_value)) }
+
+      rule(:attributes)       { attribute.repeat }
+      rule(:valid_attr_name)  { ATTRIBUTES.map{|a| str(a.to_s)}.reduce(&:|) }
+
+      rule(:value)            { quoted_string | integer | string_value }
+      rule(:string_value)     { (newline.absent? >> comment.absent? >> any).repeat.as(:unquoted_string) }
+      rule(:integer)          { match['0-9'].repeat(1).as(:integer) }
+
+      rule(:escaped_quote)    { str('\\"') }
+      rule(:quoted_string)    { quote >> ( escaped_quote | quote.absent? >> any ).repeat.as(:quoted_string) >> quote }
+
+      rule(:comment)          { str('#') >> ( newline.absent? >> any ).repeat }
+      rule(:newline)          { str("\n") >> str("\r").maybe }
+      rule(:quote)            { str('"') | str('\'') }
+      rule(:space)            { match(' ').repeat(1) }
+      rule(:space?)           { space.maybe }
+
+      rule(:eol)              { space? >> comment.maybe >> newline }
+
+      def parse_snippets( snippets )
+        fail(ArgumentError, "Need ConfigFileSnippets") unless snippets.instance_of?(Array) and snippets.all? {|s| s.instance_of?(ConfigFileSnippet)}
+        parsed_tree = {}
+        snippets.each do |snippet|
+          begin
+            parsed_tree.merge! parse(snippet.to_s) do |key, oldval, newval|
+              Array(oldval) + Array(newval)
+            end
+          rescue Parslet::ParseFailed
+            fail ParseError.new( filename: snippet.filename, exception: $! )
+          end
+        end
+        Transform.new.apply( parsed_tree )
+      end
+
+      def parse_and_transform( text )
+        Transform.new.apply parse(text)
+      rescue Parslet::ParseFailed
+        raise
+      end
+
+    end
+
+  end
+end

data/lib/log2mail/config/section.rb

@@ -0,0 +1,70 @@
+module Log2mail
+  module Config
+    class Section
+      attr_reader :name, :value
+      attr_accessor :attrs
+      def initialize( name, value = nil, attrs = [] )
+        @name  = name.to_sym
+        @value = value
+        @attrs = attrs
+      end
+      def ==(other)
+        return false unless other.instance_of?(self.class)
+        self.name == other.name and self.value == other.value and self.attrs == other.attrs
+      end
+      def inspect
+        'Section %s = %s---%s' % [@name.inspect, @value.inspect, @attrs.inspect]
+      end
+      def tree
+        h = {}
+        @attrs.inject(h) do |h, a|
+          if a.instance_of?(Section)
+            name = a.name.pluralize.to_sym
+            unless a.attrs.empty?
+              apdx = {a.value => a.tree}
+            else
+              apdx = a.value
+            end
+            case apdx
+            when Hash
+              apdx.each_pair{ |k,v| ( h[name] ||= {} )[k] = v }
+            when Array
+              fail "do not know what to do"
+            else
+              ( h[name] ||= {} )[apdx] = {}
+            end
+          else
+            name = a.name
+            h[name] = a.value
+          end
+          h
+        end
+        if @name==:file
+          return {self.value => h}
+          # unless @attrs.empty?
+          #   return {self.value => h}
+          # else
+          #   return self.value
+          # end
+        end
+        h
+      end
+
+      # merges sections by prefering other's attributes
+      # FIXME: needs specing
+      def +(other)
+        fail "Unmergable sections:\n1) #{self.inspect}\n2) #{other.inspect}\nReason: values must differ." unless self.value == other.value
+        @attrs.each do |a|
+          case a
+          when Attribute
+            other.attrs << a unless other.attrs.map(&:name).include?(a.name)
+          when Section
+            other.attrs << a
+          end
+        end
+        other
+      end
+
+    end
+  end
+end