nagios_config 0.0.1 → 0.0.2

data/lib/nagios_config/formater.rb

@@ -47,8 +47,8 @@ module NagiosConfig
     
     def format_Define(define)
       buffer << "define "
-      name_width = define.variables.map(&:name).map(&:value).map(&:length).max || 0
-      value_width = define.variables.map(&:val).map(&:value).map(&:length).max || 0
+      name_width = define.variables.map {|e| e.name}.map {|e| e.value}.map {|e| e.length}.max || 0
+      value_width = define.variables.map {|e| e.val}.map {|e| e.value}.map {|e| e.length}.max || 0
       variable_width = define_indent + define_name_width + name_width + value_width
       
       self.define_name_width += name_width

data/lib/nagios_config/main.rb

@@ -0,0 +1,72 @@
+module NagiosConfig
+  class Main
+    attr_accessor :variables, :objects
+    
+    def initialize(variables={}, objects=[])
+      self.variables = Hash[variables.map {|k,v| [k.to_sym,v]}]
+      self.objects = objects
+    end
+    
+    def self.from_node(node)
+      instance = new
+      object_store = instance.objects
+      node.nodes.each do |node|
+        if node.is_a?(NagiosConfig::Variable)
+          name = node.name.value
+          value = node.val.value
+          case instance[name]
+          when nil
+            instance[name] = value
+          when Array
+            instance[name].push(value)
+          else
+            instance[name] = [instance[name], value]
+          end
+        elsif node.is_a?(NagiosConfig::Define)
+          NagiosConfig::Object.from_node(node, object_store)
+        end
+      end
+      instance
+    end
+    
+    def self.parse(io, include_comments=false)
+      from_node(NagiosConfig::Parser.new(!include_comments).parse(io))
+    end
+    
+    def [](name)
+      variables[name.to_sym]
+    end
+    
+    def []=(name, value)
+      variables[name.to_sym] = value
+    end
+    
+    def objects(of_type=nil)
+      return @objects unless of_type
+      of_type = of_type.to_sym
+      objects.select {|obj| obj.type == of_type}
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && other.variables == variables &&
+        other.objects == objects
+    end
+    
+    def inspect
+      "#<#{self.class.name}:#{object_id} @variables=#{variables.inspect}, " <<
+      "@objects=#{objects.class.name}:#{objects.object_id}" <<
+      "(#{objects.length} items)>"
+    end
+    
+    def method_missing(name, *args)
+      if name.to_s !~ /=$/ && args.empty?
+        self[name.to_sym]
+      elsif name.to_s =~ /=$/ && args.length == 1
+        self[name.to_s.chomp("=").to_sym] = args.first
+      else
+        super
+      end
+    end
+    
+  end
+end

data/lib/nagios_config/parser.rb

@@ -5,46 +5,50 @@ require 'events'
 
 module NagiosConfig
   class Parser
-    attr_accessor :scanner, :state, :in_define, :value_buffer
+    attr_accessor :scanner, :state
     include Events::Emitter
     
-    def initialize
+    NEWLINE = "\n".freeze
+    EQUALS = "=".freeze
+    OPEN_BRACE = "{".freeze
+    
+    def initialize(ignore_comments=false)
       @state = :body
-      self.scanner = StringScanner.new("")
-      self.value_buffer = ""
+      @scanner = StringScanner.new("")
+      @value_buffer = ""
+      @ignore_comments = ignore_comments
     end
     
     def parse(io)
       root = NagiosConfig::Config.new
-      current_define = nil
+      current = root
       current_variable = nil
       on(:comment) do |comment|
-        (current_define || root).add_node(NagiosConfig::Comment.new(comment))
-      end
+        current.add_node(NagiosConfig::Comment.new(comment))
+      end unless @ignore_comments
       on(:whitespace) do |whitespace|
-        (current_define || root).add_node(NagiosConfig::Whitespace.new(whitespace))
-      end
+        current.add_node(NagiosConfig::Whitespace.new(whitespace))
+      end unless @ignore_comments
       on(:trailing_comment) do |comment|
-        (current_define || root).nodes.last.add_node(NagiosConfig::TrailingComment.new(comment))
-      end
+        current.nodes.last.add_node(NagiosConfig::TrailingComment.new(comment))
+      end unless @ignore_comments
       on(:name) do |name|
         current_variable = NagiosConfig::Variable.new
         current_variable.add_node(NagiosConfig::Name.new(name))
-        (current_define || root).add_node(current_variable)
+        current.add_node(current_variable)
       end
       on(:value) do |value|
         current_variable.add_node(NagiosConfig::Value.new(value))
-        current_variable = nil
       end
       on(:begin_define) do
-        current_define = NagiosConfig::Define.new
-        root.add_node(current_define)
+        current = NagiosConfig::Define.new
+        root.add_node(current)
       end
       on(:type) do |type|
-        current_define.add_node(NagiosConfig::Type.new(type))
+        current.add_node(NagiosConfig::Type.new(type))
       end
       on(:finish_define) do
-        current_define = nil
+        current = root
       end
       stream_parse(io)
       root
@@ -58,10 +62,8 @@ module NagiosConfig
     end
     
     def <<(string)
-      scanner.string.replace(scanner.rest)
-      scanner.reset
-      scanner << string
-      self.state = send(state)
+      @scanner << string
+      @state = send(@state)
     end
     
     private
@@ -71,59 +73,61 @@ module NagiosConfig
     alias start body
     
     def empty_line
-      whitespace = scanner.scan(/[ \t]*\n/)
+      whitespace = @scanner.scan(/[ \t]*\n/)
       if whitespace
-        emit(:whitespace, whitespace)
-        in_define ? definition_body : body
-      elsif in_define && whitespace = scanner.scan(/[ \t]*(?=;)/) && trailing_comment
-        emit(:whitespace, whitespace)
+        emit(:whitespace, whitespace) unless @ignore_comments
+        @in_define ? definition_body : body
+      elsif @in_define && whitespace = @scanner.scan(/[ \t]*(?=;)/) && trailing_comment
+        emit(:whitespace, whitespace) unless @ignore_comments
         definition_body
       end
     end
     
     def leading_whitespace
-      if scanner.scan(/[ \t]+[^\s]/)
+      if @scanner.skip(/[ \t]+[^\s]/)
         raise ParseError.new("leading whitespace not allowed")
       end
     end
     
     def comment
-      comment = scanner.scan(/[ \t]*#.*(\n)/)
+      comment = @scanner.scan(/[ \t]*#[^\n]*\n/)
       if comment
-        comment.lstrip!
-        comment.slice!(0)
-        comment.chomp!("\n")
-        emit(:comment, comment)
-        in_define ? definition_body : body
-      elsif scanner.check(/#/)
+        if !@ignore_comments
+          comment.lstrip!
+          comment.slice!(0)
+          comment.chomp!(NEWLINE)
+          emit(:comment, comment)
+        end
+        @in_define ? definition_body : body
+      elsif @scanner.check(/#/)
         :comment
       end
     end
     
     def name
-      name = scanner.scan(/[^\s=]+=/)
+      name = @scanner.scan(/[^\s=]+=/)
       if name
-        name.chomp!("=")
+        name.chomp!(EQUALS)
         emit(:name, name)
         value
-      elsif scanner.scan(/.+\n/)
+      elsif @scanner.skip(/[^\n]+\n/)
         raise ParseError.new("expected variable definition")
-      elsif scanner.check(/[^\s]+/) && !scanner.check(/d(e(f(i(n(e?))?)?)?)?\Z/)
+      elsif @scanner.check(/[^\s]+/) && !@scanner.check(/d(e(f(i(n(e?))?)?)?)?\Z/)
         :name
       end
     end
     
     def value
-      value = scanner.scan(/.*\n/)
+      value = @scanner.scan(/[^\n]*\n/)
       if value
-        value = value_buffer + value
-        value.chomp!("\n")
+        value = @value_buffer + value
+        value.chomp!(NEWLINE)
         raise ParseError.new("value expected") if value.empty?
         emit(:value, value)
-        self.value_buffer = ""
+        @value_buffer = ""
         body
-      elsif value = scanner.scan(/.+/)
-        value_buffer << value
+      elsif value = @scanner.scan(/.+/)
+        @value_buffer << value
         :value
       else
         :value
@@ -131,22 +135,22 @@ module NagiosConfig
     end
     
     def definition
-      if scanner.skip(/define[ \t]/)
+      if @scanner.skip(/define[ \t]/)
         emit(:begin_define)
-        self.in_define = true
+        @in_define = true
         type
       end
     end
     
     def type
-      type = scanner.scan(/[^;{]+[ \t]*\{[ \t]*\n/)
+      type = @scanner.scan(/[^;{]+[ \t]*\{[ \t]*\n/)
       if type
         type.strip!
-        type.chomp!("{")
+        type.chomp!(OPEN_BRACE)
         type.strip!
         emit(:type, type)
         definition_body
-      elsif scanner.check(/([^;{]+[ \t]*(\{[ \t]*)?)?\Z/)
+      elsif @scanner.check(/([^;{]+[ \t]*(\{[ \t]*)?)?\Z/)
         :type
       else
         raise ParseError.new("type expected")
@@ -158,29 +162,29 @@ module NagiosConfig
     end
     
     def definition_name
-      name = scanner.scan(/[ \t]*[^\s;#]+[ \t]+/)
+      name = @scanner.scan(/[ \t]*[^\s;#]+[ \t]+/)
       if name
         name.strip!
         emit(:name, name)
         definition_value
-      elsif scanner.check(/[ \t]*[^\s#;}]+\Z/)
+      elsif @scanner.check(/[ \t]*[^\s#;}]+\Z/)
         :definition_name
-      elsif scanner.scan(/[ \t]*[^\s#;]+\n/)
+      elsif @scanner.skip(/[ \t]*[^\s#;]+\n/)
         raise ParseError.new("value expected")
       end
     end
     
     def definition_value
-      value = scanner.scan(/[^\n;#]*(?=(\n|;))/)
+      value = @scanner.scan(/[^\n;#]*(?=(\n|;))/)
       if value
-        value = value_buffer + value
+        value = @value_buffer + value
         value.strip!
         raise ParseError.new("value expected") if value.empty?
         emit(:value, value)
-        self.value_buffer = ""
+        @value_buffer = ""
         after_value
-      elsif value = scanner.scan(/[^\n;#]+/)
-        value_buffer << value
+      elsif value = @scanner.scan(/[^\n;#]+/)
+        @value_buffer << value
         :definition_value
       else
         :definition_value
@@ -188,7 +192,7 @@ module NagiosConfig
     end
     
     def after_value
-      if scanner.skip(/[ \t]*\n/) || trailing_comment
+      if @scanner.skip(/[ \t]*\n/) || trailing_comment
         definition_body
       else
         :after_value
@@ -196,18 +200,18 @@ module NagiosConfig
     end
     
     def finish_definition
-      if scanner.scan(/[ \t]*\}[ \t]*\n/)
+      if @scanner.skip(/[ \t]*\}[ \t]*\n/)
         emit(:finish_define)
-        self.in_define = false
+        @in_define = false
         body
       end
     end
     
     def trailing_comment
-      trailing_comment = scanner.scan(/[ \t]*;.*\n/)
-      if trailing_comment
+      trailing_comment = @scanner.scan(/[ \t]*;[^\n]*\n/)
+      if trailing_comment && !@ignore_comments
         trailing_comment.strip!
-        trailing_comment.chomp!("\n")
+        trailing_comment.chomp!(NEWLINE)
         trailing_comment.slice!(0)
         emit(:trailing_comment, trailing_comment)
       end

data/lib/nagios_config.rb

@@ -4,4 +4,5 @@ require File.dirname(__FILE__) + "/nagios_config/ast"
 require File.dirname(__FILE__) + "/nagios_config/parser"
 require File.dirname(__FILE__) + "/nagios_config/formater"
 require File.dirname(__FILE__) + "/nagios_config/builder"
-require File.dirname(__FILE__) + "/nagios_config/object"
+require File.dirname(__FILE__) + "/nagios_config/object"
+require File.dirname(__FILE__) + "/nagios_config/main"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nagios_config
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Matthew Sadler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-31 00:00:00 +00:00
+date: 2011-03-31 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,6 +47,7 @@ files:
 - lib/nagios_config/builder.rb
 - lib/nagios_config/errors.rb
 - lib/nagios_config/formater.rb
+- lib/nagios_config/main.rb
 - lib/nagios_config/node.rb
 - lib/nagios_config/object.rb
 - lib/nagios_config/parser.rb