continuent-tools-core 0.1.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc877f6c4fc1d24cf76c6b6a0eb8cea7bffe14a0
-  data.tar.gz: 1b0cf2c4aeabc5d44475b7959bb5d21dc53af90f
+  metadata.gz: 256816c02fae6a3705e6ebccdff65da094570a94
+  data.tar.gz: 9ce21782909d9e01f599191e51fceb9dd9c942e5
 SHA512:
-  metadata.gz: 34001efb0e766f5258ee514a3e8db5817af9bfe3d39c14817b754718c135fd8450c62a310e25b712a13543573eec7bb9340876cabc62c2717290929bcf29a034
-  data.tar.gz: 1f85017ebab7a298b35e285750eafd04b19a4a81d67560e61cf86f5a22d0d917ce14f7acc5d3d90b2b5bcb461ff0bb79dc6fd037d6e6d996f940d540b3eeec36
+  metadata.gz: fbf0c48597aedd4672accc6b5ed353604a488978b27500902a928df6d7c3e2bd859c682daf16a74345524ff08501dfbb3692b2a6573586c8ef025ef38e116241
+  data.tar.gz: 05cd1d15c8ba0bd16d46ac0aaf0564fe5187c1031e418befed059d3ac1329b7413d86487ea049bb914cf368dedfa7fbd72c2c176329d6dad79a51626587fad95

data/lib/continuent-tools-core.rb

@@ -140,17 +140,6 @@ module TungstenScript
   
   def validate
     orig_validate()
-    
-    @option_definitions.each{
-      |option_key,definition|
-      
-      if definition[:required] == true
-        if opt(option_key).to_s() == ""
-          arg = definition[:on][0].split(" ")[0]
-          TU.error("Missing value for the #{arg} option")
-        end
-      end
-    }
   end
 end
 

data/lib/iniparse.rb

@@ -0,0 +1,66 @@
+dir = File.expand_path('iniparse', File.dirname(__FILE__))
+
+require File.join(dir, 'document')
+require File.join(dir, 'generator')
+require File.join(dir, 'line_collection')
+require File.join(dir, 'lines')
+require File.join(dir, 'parser')
+
+module IniParse
+  VERSION = '1.3.2'
+
+  # A base class for IniParse errors.
+  class IniParseError < StandardError; end
+
+  # Raised if an error occurs parsing an INI document.
+  class ParseError < IniParseError; end
+
+  # Raised when an option line is found during parsing before the first
+  # section.
+  class NoSectionError < ParseError; end
+
+  # Raised when a line is added to a collection which isn't allowed (e.g.
+  # adding a Section line into an OptionCollection).
+  class LineNotAllowed < IniParseError; end
+
+  module_function
+
+  # Parse given given INI document source +source+.
+  #
+  # See IniParse::Parser.parse
+  #
+  # ==== Parameters
+  # source<String>:: The source from the INI document.
+  #
+  # ==== Returns
+  # IniParse::Document
+  #
+  def parse(source)
+    IniParse::Parser.new(source).parse
+  end
+
+  # Opens the file at +path+, reads and parses it's contents.
+  #
+  # ==== Parameters
+  # path<String>:: The path to the INI document.
+  #
+  # ==== Returns
+  # IniParse::Document
+  #
+  def open(path)
+    document = IniParse::Parser.new(File.read(path)).parse
+    document.path = path
+    document
+  end
+
+  # Creates a new IniParse::Document using the specification you provide.
+  #
+  # See IniParse::Generator.
+  #
+  # ==== Returns
+  # IniParse::Document
+  #
+  def gen(&blk)
+    IniParse::Generator.new.gen(&blk)
+  end
+end

data/lib/iniparse/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008-2010 Anthony Williams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/iniparse/document.rb

@@ -0,0 +1,84 @@
+module IniParse
+  # Represents an INI document.
+  class Document
+    include Enumerable
+
+    attr_reader   :lines
+    attr_accessor :path
+
+    # Creates a new Document instance.
+    def initialize(path = nil)
+      @path  = path
+      @lines = IniParse::SectionCollection.new
+    end
+
+    # Enumerates through each Section in this document.
+    #
+    # 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
+
+    # Returns the section identified by +key+.
+    #
+    # Returns nil if there is no Section with the given key.
+    #
+    def [](key)
+      @lines[key.to_s]
+    end
+
+    # Deletes the section whose name matches the given +key+.
+    #
+    # Returns the document.
+    #
+    def delete(*args)
+      @lines.delete(*args)
+      self
+    end
+
+    # Returns this document as a string suitable for saving to a file.
+    def to_ini
+      string = @lines.to_a.map { |line| line.to_ini }.join($/)
+      string = "#{ string }\n" unless string[-1] == "\n"
+
+      string
+    end
+
+    alias_method :to_s, :to_ini
+
+    # A human-readable version of the document, for debugging.
+    def inspect
+      sections = @lines.select { |l| l.is_a?(IniParse::Lines::Section) }
+      "#<IniParse::Document {#{ sections.map(&:key).join(', ') }}>"
+    end
+
+    # Returns true if a section with the given +key+ exists in this document.
+    def has_section?(key)
+      @lines.has_key?(key.to_s)
+    end
+
+    # Saves a copy of this Document to disk.
+    #
+    # If a path was supplied when the Document was initialized then nothing
+    # needs to be given to Document#save. If Document was not given a file
+    # path, or you wish to save the document elsewhere, supply a path when
+    # calling Document#save.
+    #
+    # ==== Parameters
+    # path<String>:: A path to which this document will be saved.
+    #
+    # ==== Raises
+    # IniParseError:: If your document couldn't be saved.
+    #
+    def save(path = nil)
+      @path = path if path
+      raise IniParseError, 'No path given to Document#save' if @path !~ /\S/
+      File.open(@path, 'w') { |f| f.write(self.to_ini) }
+    end
+  end
+end

data/lib/iniparse/generator.rb

@@ -0,0 +1,203 @@
+module IniParse
+  # Generator provides a means for easily creating new INI documents.
+  #
+  # Rather than trying to hack together new INI documents by manually creating
+  # Document, Section and Option instances, it is preferable to use Generator
+  # which will handle it all for you.
+  #
+  # The Generator is exposed through IniParse.gen.
+  #
+  #   IniParse.gen do |doc|
+  #     doc.section("vehicle") do |vehicle|
+  #       vehicle.option("road_side", "left")
+  #       vehicle.option("realistic_acceleration", true)
+  #       vehicle.option("max_trains", 500)
+  #     end
+  #
+  #     doc.section("construction") do |construction|
+  #       construction.option("build_on_slopes", true)
+  #       construction.option("autoslope", true)
+  #     end
+  #   end
+  #
+  #   # => IniParse::Document
+  #
+  # This can be simplified further if you don't mind the small overhead
+  # which comes with +method_missing+:
+  #
+  #   IniParse.gen do |doc|
+  #     doc.vehicle do |vehicle|
+  #       vehicle.road_side = "left"
+  #       vehicle.realistic_acceleration = true
+  #       vehicle.max_trains = 500
+  #     end
+  #
+  #     doc.construction do |construction|
+  #       construction.build_on_slopes = true
+  #       construction.autoslope = true
+  #     end
+  #   end
+  #
+  #   # => IniParse::Document
+  #
+  # If you want to add slightly more complicated formatting to your document,
+  # each line type (except blanks) takes a number of optional parameters:
+  #
+  # :comment::
+  #   Adds an inline comment at the end of the line.
+  # :comment_offset::
+  #   Indent the comment. Measured in characters from _beginning_ of the line.
+  #   See String#ljust.
+  # :indent::
+  #   Adds the supplied text to the beginning of the line.
+  #
+  # If you supply +:indent+, +:comment_sep+, or +:comment_offset+ options when
+  # adding a section, the same options will be inherited by all of the options
+  # which belong to it.
+  #
+  #   IniParse.gen do |doc|
+  #     doc.section("vehicle",
+  #       :comment => "Options for vehicles", :indent  => "    "
+  #     ) do |vehicle|
+  #       vehicle.option("road_side", "left")
+  #       vehicle.option("realistic_acceleration", true)
+  #       vehicle.option("max_trains", 500, :comment => "More = slower")
+  #     end
+  #   end.to_ini
+  #
+  #       [vehicle] ; Options for vehicles
+  #       road_side = left
+  #       realistic_acceleration = true
+  #       max_trains = 500 ; More = slower
+  #
+  class Generator
+    attr_reader :context
+    attr_reader :document
+
+    def initialize(opts = {}) # :nodoc:
+      @document   = IniParse::Document.new
+      @context    = @document
+
+      @in_section = false
+      @opt_stack  = [opts]
+    end
+
+    def gen # :nodoc:
+      yield self
+      @document
+    end
+
+    # Creates a new IniParse::Document with the given sections and options.
+    #
+    # ==== Returns
+    # IniParse::Document
+    #
+    def self.gen(opts = {}, &blk)
+      new(opts).gen(&blk)
+    end
+
+    # Creates a new section with the given name and adds it to the document.
+    #
+    # You can optionally supply a block (as detailed in the documentation for
+    # Generator#gen) in order to add options to the section.
+    #
+    # ==== Parameters
+    # name<String>:: A name for the given section.
+    #
+    def section(name, opts = {})
+      if @in_section
+        # Nesting sections is bad, mmmkay?
+        raise LineNotAllowed, "You can't nest sections in INI files."
+      end
+
+      if @document.has_section?(name.to_s())
+        @context = @document[name.to_s()]
+      else
+        @context = Lines::Section.new(name, line_options(opts))
+        @document.lines << @context
+      end
+
+      if block_given?
+        begin
+          @in_section = true
+          with_options(opts) { yield self }
+          @context = @document
+          blank()
+        ensure
+          @in_section = false
+        end
+      end
+    end
+
+    # Adds a new option to the current section.
+    #
+    # Can only be called as part of a section block, or after at least one
+    # section has been added to the document.
+    #
+    # ==== Parameters
+    # key<String>:: The key (name) for this option.
+    # value::       The option's value.
+    # opts<Hash>::  Extra options for the line (formatting, etc).
+    #
+    # ==== Raises
+    # IniParse::NoSectionError::
+    #   If no section has been added to the document yet.
+    #
+    def option(key, value, opts = {})
+      @context.lines << Lines::Option.new(
+        key, value, line_options(opts)
+      )
+    rescue LineNotAllowed
+      # Tried to add an Option to a Document.
+      raise NoSectionError,
+        'Your INI document contains an option before the first section is ' \
+        'declared which is not allowed.'
+    end
+
+    # Adds a new comment line to the document.
+    #
+    # ==== Parameters
+    # comment<String>:: The text for the comment line.
+    #
+    def comment(comment, opts = {})
+      @context.lines << Lines::Comment.new(
+        line_options(opts.merge(:comment => comment))
+      )
+    end
+
+    # Adds a new blank line to the document.
+    def blank
+      @context.lines << Lines::Blank.new
+    end
+
+    # Wraps lines, setting default options for each.
+    def with_options(opts = {}) # :nodoc:
+      opts = opts.dup
+      opts.delete(:comment)
+      @opt_stack.push( @opt_stack.last.merge(opts))
+      yield self
+      @opt_stack.pop
+    end
+
+    def method_missing(name, *args, &blk) # :nodoc:
+      if m = name.to_s.match(/(.*)=$/)
+        option(m[1], *args)
+      else
+        section(name.to_s, *args, &blk)
+      end
+    end
+
+    #######
+    private
+    #######
+
+    # Returns options for a line.
+    #
+    # If the context is a section, we use the section options as a base,
+    # rather than the global defaults.
+    #
+    def line_options(given_opts) # :nodoc:
+      @opt_stack.last.empty? ? given_opts : @opt_stack.last.merge(given_opts)
+    end
+  end
+end

data/lib/iniparse/line_collection.rb

@@ -0,0 +1,170 @@
+module IniParse
+  # Represents a collection of lines in an INI document.
+  #
+  # LineCollection acts a bit like an Array/Hash hybrid, allowing arbitrary
+  # lines to be added to the collection, but also indexes the keys of Section
+  # and Option lines to enable O(1) lookup via LineCollection#[].
+  #
+  # The lines instances are stored in an array, +@lines+, while the index of
+  # each Section/Option is held in a Hash, +@indicies+, keyed with the
+  # Section/Option#key value (see LineCollection#[]=).
+  #
+  module LineCollection
+    include Enumerable
+
+    def initialize
+      @lines    = []
+      @indicies = {}
+    end
+
+    # Retrive a value identified by +key+.
+    def [](key)
+      has_key?(key) ? @lines[ @indicies[key] ] : nil
+    end
+
+    # Set a +value+ identified by +key+.
+    #
+    # If a value with the given key already exists, the value will be replaced
+    # with the new one, with the new value taking the position of the old.
+    #
+    def []=(key, value)
+      key = key.to_s
+
+      if has_key?(key)
+        @lines[ @indicies[key] ] = value
+      else
+        @lines << value
+        @indicies[key] = @lines.length - 1
+      end
+    end
+
+    # Appends a line to the collection.
+    #
+    # Note that if you pass a line with a key already represented in the
+    # collection, the old item will be replaced.
+    #
+    def <<(line)
+      line.blank? ? (@lines << line) : (self[line.key] = line) ; self
+    end
+
+    alias_method :push, :<<
+
+    # Enumerates through the collection.
+    #
+    # By default #each does not yield blank and comment lines.
+    #
+    # ==== Parameters
+    # include_blank<Boolean>:: Include blank/comment lines?
+    #
+    def each(include_blank = false)
+      @lines.each do |line|
+        if include_blank || ! (line.is_a?(Array) ? line.empty? : line.blank?)
+          yield(line)
+        end
+      end
+    end
+
+    # Removes the value identified by +key+.
+    def delete(key)
+      key = key.key if key.respond_to?(:key)
+
+      unless (idx = @indicies[key]).nil?
+        @indicies.delete(key)
+        @indicies.each { |k,v| @indicies[k] = v -= 1 if v > idx }
+        @lines.delete_at(idx)
+      end
+    end
+
+    # Returns whether +key+ is in the collection.
+    def has_key?(*args)
+      @indicies.has_key?(*args)
+    end
+
+    # Return an array containing the keys for the lines added to this
+    # collection.
+    def keys
+      map { |line| line.key }
+    end
+
+    # Returns this collection as an array. Includes blank and comment lines.
+    def to_a
+      @lines.dup
+    end
+
+    # Returns this collection as a hash. Does not contain blank and comment
+    # lines.
+    def to_hash
+      Hash[ *(map { |line| [line.key, line] }).flatten ]
+    end
+
+    alias_method :to_h, :to_hash
+  end
+
+  # A implementation of LineCollection used for storing (mostly) Option
+  # instances contained within a Section.
+  #
+  # Since it is assumed that an INI document will only represent a section
+  # once, if SectionCollection encounters a Section key already held in the
+  # collection, the existing section is merged with the new one (see
+  # IniParse::Lines::Section#merge!).
+  class SectionCollection
+    include LineCollection
+
+    def <<(line)
+      if line.kind_of?(IniParse::Lines::Option)
+        option = line
+        line   = IniParse::Lines::AnonymousSection.new
+
+        line.lines << option if option
+      end
+
+      if line.blank? || (! has_key?(line.key))
+        super # Adding a new section, comment or blank line.
+      else
+        self[line.key].merge!(line)
+      end
+
+      self
+    end
+  end
+
+  # A implementation of LineCollection used for storing (mostly) Option
+  # instances contained within a Section.
+  #
+  # Whenever OptionCollection encounters an Option key already held in the
+  # collection, it treats it as a duplicate. This means that instead of
+  # overwriting the existing value, the value is changed to an array
+  # containing the previous _and_ the new Option instances.
+  class OptionCollection
+    include LineCollection
+
+    # Appends a line to the collection.
+    #
+    # If you push an Option with a key already represented in the collection,
+    # the previous Option will not be overwritten, but treated as a duplicate.
+    #
+    # ==== Parameters
+    # line<IniParse::LineType::Line>:: The line to be added to this section.
+    #
+    def <<(line)
+      if line.kind_of?(IniParse::Lines::Section)
+        raise IniParse::LineNotAllowed,
+          "You can't add a Section to an OptionCollection."
+      end
+
+      if line.blank? || (! has_key?(line.key))
+        super # Adding a new option, comment or blank line.
+      else
+        self[line.key] = [self[line.key], line].flatten
+      end
+
+      self
+    end
+
+    # Return an array containing the keys for the lines added to this
+    # collection.
+    def keys
+      map { |line| line.kind_of?(Array) ? line.first.key : line.key }
+    end
+  end
+end