continuent-tools-core 0.1.6 → 0.5.0

data/lib/iniparse/lines.rb

@@ -0,0 +1,327 @@
+module IniParse
+  module Lines
+    # A base class from which other line types should inherit.
+    module Line
+      # ==== Parameters
+      # opts<Hash>:: Extra options for the line.
+      #
+      def initialize(opts = {})
+        @comment        = opts.fetch(:comment, nil)
+        @comment_sep    = opts.fetch(:comment_sep, ';')
+        @comment_prefix = opts.fetch(:comment_prefix, ' ')
+        @comment_offset = opts.fetch(:comment_offset, 0)
+        @indent         = opts.fetch(:indent, '')
+      end
+
+      # Returns if this line has an inline comment.
+      def has_comment?
+        not @comment.nil?
+      end
+
+      # Returns this line as a string as it would be represented in an INI
+      # document.
+      def to_ini
+        ini = line_contents
+        ini = @indent + ini if @indent
+
+        if has_comment?
+          ini += ' ' if ini =~ /\S/ # not blank
+          ini  = ini.ljust(@comment_offset)
+          ini += comment
+        end
+
+        ini
+      end
+
+      # Returns the contents for this line.
+      def line_contents
+        ''
+      end
+
+      # Returns the inline comment for this line. Includes the comment
+      # separator at the beginning of the string.
+      def comment
+        "#{ @comment_sep }#{ @comment_prefix }#{ @comment }"
+      end
+
+      # Returns whether this is a line which has no data.
+      def blank?
+        false
+      end
+    end
+
+    # Represents a section header in an INI document. Section headers consist
+    # of a string of characters wrapped in square brackets.
+    #
+    #   [section]
+    #   key=value
+    #   etc
+    #   ...
+    #
+    class Section
+      include Line
+
+      @regex = /^\[        # Opening bracket
+                 ([^\]]+)  # Section name
+                 \]$       # Closing bracket
+               /x
+
+      attr_accessor :key
+      attr_reader   :lines
+
+      include Enumerable
+
+      # ==== Parameters
+      # key<String>:: The section name.
+      # opts<Hash>::  Extra options for the line.
+      #
+      def initialize(key, opts = {})
+        super(opts)
+        @key   = key.to_s
+        @lines = IniParse::OptionCollection.new
+      end
+
+      def self.parse(line, opts)
+        if m = @regex.match(line)
+          [:section, m[1], opts]
+        end
+      end
+
+      # Returns this line as a string as it would be represented in an INI
+      # document. Includes options, comments and blanks.
+      def to_ini
+        coll = lines.to_a
+
+        if coll.any?
+          super + $/ + coll.to_a.map do |line|
+            if line.kind_of?(Array)
+              line.map { |dup_line| dup_line.to_ini }.join($/)
+            else
+              line.to_ini
+            end
+          end.join($/)
+        else
+          super
+        end
+      end
+
+      # Enumerates through each Option in this section.
+      #
+      # Does not yield blank and comment lines by default; if you want _all_
+      # lines to be yielded, pass true.
+      #
+      # ==== Parameters
+      # include_blank<Boolean>:: Include blank/comment lines?
+      #
+      def each(*args, &blk)
+        @lines.each(*args, &blk)
+      end
+
+      # Adds a new option to this section, or updates an existing one.
+      #
+      # Note that +[]=+ has no knowledge of duplicate options and will happily
+      # overwrite duplicate options with your new value.
+      #
+      #   section['an_option']
+      #     # => ['duplicate one', 'duplicate two', ...]
+      #   section['an_option'] = 'new value'
+      #   section['an_option]
+      #     # => 'new value'
+      #
+      # If you do not wish to overwrite duplicates, but wish instead for your
+      # new option to be considered a duplicate, use +add_option+ instead.
+      #
+      def []=(key, value)
+        @lines[key.to_s] = IniParse::Lines::Option.new(key.to_s, value)
+      end
+
+      # Returns the value of an option identified by +key+.
+      #
+      # Returns nil if there is no corresponding option. If the key provided
+      # matches a set of duplicate options, an array will be returned containing
+      # the value of each option.
+      #
+      def [](key)
+        key = key.to_s
+
+        if @lines.has_key?(key)
+          if (match = @lines[key]).kind_of?(Array)
+            match.map { |line| line.value }
+          else
+            match.value
+          end
+        end
+      end
+
+      # Deletes the option identified by +key+.
+      #
+      # Returns the section.
+      #
+      def delete(*args)
+        @lines.delete(*args)
+        self
+      end
+
+      # Like [], except instead of returning just the option value, it returns
+      # the matching line instance.
+      #
+      # Will return an array of lines if the key matches a set of duplicates.
+      #
+      def option(key)
+        @lines[key.to_s]
+      end
+
+      # Returns true if an option with the given +key+ exists in this section.
+      def has_option?(key)
+        @lines.has_key?(key.to_s)
+      end
+
+      # Merges section +other+ into this one. If the section being merged into
+      # this one contains options with the same key, they will be handled as
+      # duplicates.
+      #
+      # ==== Parameters
+      # other<IniParse::Section>:: The section to merge into this one.
+      #
+      def merge!(other)
+        other.lines.each(true) do |line|
+          if line.kind_of?(Array)
+            line.each { |duplicate| @lines << duplicate }
+          else
+            @lines << line
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def line_contents
+        '[%s]' % key
+      end
+    end
+
+    # Stores options which appear at the beginning of a file, without a
+    # preceding section.
+    class AnonymousSection < Section
+      def initialize
+        super('__anonymous__')
+      end
+
+      def to_ini
+        # Remove the leading space which is added by joining the blank line
+        # content with the options.
+        super.gsub(/\A\n/, '')
+      end
+
+      #######
+      private
+      #######
+
+      def line_contents
+        ''
+      end
+    end
+
+    # Represents probably the most common type of line in an INI document:
+    # an option. Consists of a key and value, usually separated with an =.
+    #
+    #   key = value
+    #
+    class Option
+      include Line
+
+      @regex = /^\s*([^=]+)  # Option
+                 =
+                 (.*?)$      # Value
+               /x
+
+      attr_accessor :key, :value
+
+      # ==== Parameters
+      # key<String>::   The option key.
+      # value<String>:: The value for this option.
+      # opts<Hash>::    Extra options for the line.
+      #
+      def initialize(key, value, opts = {})
+        super(opts)
+        @key, @value = key.to_s, value
+      end
+
+      def self.parse(line, opts)
+        if m = @regex.match(line)
+          [:option, m[1].strip, typecast(m[2].strip), opts]
+        end
+      end
+
+      # Attempts to typecast values.
+      def self.typecast(value)
+        case value
+          when /^\s*$/                                        then nil
+          when /^-?(?:\d|[1-9]\d+)$/                          then Integer(value)
+          when /^-?(?:\d|[1-9]\d+)(?:\.\d+)?(?:e[+-]?\d+)?$/i then Float(value)
+          when /true/i                                        then true
+          when /false/i                                       then false
+          else                                                     value
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def line_contents
+        '%s = %s' % [key, value]
+      end
+    end
+
+    # Represents a blank line. Used so that we can preserve blank lines when
+    # writing back to the file.
+    class Blank
+      include Line
+
+      def blank?
+        true
+      end
+
+      def self.parse(line, opts)
+        if line !~ /\S/ # blank
+          if opts[:comment].nil?
+            [:blank]
+          else
+            [:comment, opts[:comment], opts]
+          end
+        end
+      end
+    end
+
+    # Represents a comment. Comment lines begin with a semi-colon or hash.
+    #
+    #   ; this is a comment
+    #   # also a comment
+    #
+    class Comment < Blank
+      # Returns if this line has an inline comment.
+      #
+      # Being a Comment this will always return true, even if the comment
+      # is nil. This would be the case if the line starts with a comment
+      # seperator, but has no comment text. See spec/fixtures/smb.ini for a
+      # real-world example.
+      #
+      def has_comment?
+        true
+      end
+
+      # Returns the inline comment for this line. Includes the comment
+      # separator at the beginning of the string.
+      #
+      # In rare cases where a comment seperator appeared in the original file,
+      # but without a comment, just the seperator will be returned.
+      #
+      def comment
+        @comment !~ /\S/ ? @comment_sep : super
+      end
+    end
+  end # Lines
+end # IniParse

data/lib/iniparse/parser.rb

@@ -0,0 +1,110 @@
+module IniParse
+  class Parser
+
+    # Returns the line types.
+    #
+    # ==== Returns
+    # Array
+    #
+    def self.parse_types
+      @@parse_types ||= []
+    end
+
+    # Sets the line types. Handy if you want to add your own custom Line
+    # classes.
+    #
+    # ==== Parameters
+    # types<Array[IniParse::Lines::Line]>:: An array containing Line classes.
+    #
+    def self.parse_types=(types)
+      parse_types.replace(types)
+    end
+
+    self.parse_types = [ IniParse::Lines::Section,
+      IniParse::Lines::Option, IniParse::Lines::Blank ]
+
+    # Creates a new Parser instance for parsing string +source+.
+    #
+    # ==== Parameters
+    # source<String>:: The source string.
+    #
+    def initialize(source)
+      @source = source.dup
+    end
+
+    # Parses the source string and returns the resulting data structure.
+    #
+    # ==== Returns
+    # IniParse::Document
+    #
+    def parse
+      IniParse::Generator.gen do |generator|
+        @source.split("\n", -1).each do |line|
+          generator.send(*Parser.parse_line(line))
+        end
+      end
+    end
+
+    class << self
+      # Takes a raw line from an INI document, striping out any inline
+      # comment, and indent, then returns the appropriate tuple so that the
+      # Generator instance can add the line to the Document.
+      #
+      # ==== Raises
+      # IniParse::ParseError: If the line could not be parsed.
+      #
+      def parse_line(line)
+        sanitized, opts = strip_indent(*strip_comment(line, {}))
+
+        parsed = nil
+        @@parse_types.each do |type|
+          break if (parsed = type.parse(sanitized, opts))
+        end
+
+        if parsed.nil?
+          raise IniParse::ParseError,
+            "A line of your INI document could not be parsed to a " \
+            "LineType: '#{line}'."
+        end
+
+        parsed
+      end
+
+      #######
+      private
+      #######
+
+      # Strips in inline comment from a line (or value), removes trailing
+      # whitespace and sets the comment options as applicable.
+      def strip_comment(line, opts)
+        if m = /^(^)(?:(;|\#)(\s*)(.*))$$/.match(line) ||
+           m = /^(.*?)(?:\s+(;|\#)(\s*)(.*))$/.match(line) # Comment lines.
+          opts[:comment] = m[4].rstrip
+          opts[:comment_prefix] = m[3]
+          opts[:comment_sep] = m[2]
+          # Remove the line content (since an option value may contain a
+          # semi-colon) _then_ get the index of the comment separator.
+          opts[:comment_offset] =
+            line[(m[1].length..-1)].index(m[2]) + m[1].length
+
+          line = m[1]
+        else
+          line.rstrip!
+        end
+
+        [line, opts]
+      end
+
+      # Removes any leading whitespace from a line, and adds it to the options
+      # hash.
+      def strip_indent(line, opts)
+        if m = /^(\s+).*$/.match(line)
+          line.lstrip!
+          opts[:indent] = m[1]
+        end
+
+        [line, opts]
+      end
+    end
+  end # Parser
+end # IniParse

data/lib/tungsten/api.rb

@@ -7,7 +7,7 @@ require 'net/http'
 
 #      SAMPLE USAGE:
 #      api_server='localhost:8090'
-#      service=chicago
+#      service="chicago"
 #
 #      cctrl = TungstenDataserviceManager.new(api_server)
 #      cctrl.list(:text)
@@ -21,10 +21,10 @@ require 'net/http'
 # 
 #      begin
 #        APICall.set_return_on_call_fail(:raise)
-#        json_obj = cctrl.post(service}/host1', 'promote')
+#        json_obj = cctrl.post("#{service}/host1", 'promote')
 #        pp json_obj["message"]
 #      rescue Exception => e
-#        puts e   # failure message will coem here
+#        puts e   # failure message will come here
 #      end