cfa 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c2df2919e42fdffa14bccfe6f20ef8dd8a31bb4
-  data.tar.gz: b3c552d45c3c3cb132de98f3ae194d8bd88ce76f
+  metadata.gz: a4abe1cefacc4777f6016b432b3a306f16b1b7ac
+  data.tar.gz: 359c1f958762e205c5313e0027dda5a09a10bc5c
 SHA512:
-  metadata.gz: 6305de07946201013df560ddae63102d35702f164594ea5ce4dc340624dc26aadbc382f8e43380e5062b7f72288e42099fad2a8ce4f21d7a83d284c5bca7f7ad
-  data.tar.gz: ec2a91cbabd1acccb1ff0bbc371f7ecbde7c641503f32d0c5e4e2e9ff815c63d927347d4a3fe378efad72cfc7ca618c59e92092807900bc0cdda02bb7e747525
+  metadata.gz: c8bdb5a5aa8391dfb8c46448b760868e257b71e195daa38cc7d272f1729e52d7c20be9acd6fa2632b63ec4bfb736c7bba41a3293b6e7d3e12d319d0a786fd885
+  data.tar.gz: 69296e9dbd626125d6e0612f580cbbd12266e004794231c9b61c980bd66114ee90f84cafd22393fc6b1000ce4b42d92f6ff724b2ce34c6ff96d77feba2c604cb

data/lib/cfa/augeas_parser.rb

@@ -2,6 +2,7 @@ require "augeas"
 require "forwardable"
 require "cfa/placer"
 
+# CFA: Configuration Files API
 module CFA
   # A building block for {AugeasTree}.
   #
@@ -16,6 +17,17 @@ module CFA
   # A `:value` is either a String, or an {AugeasTree},
   # or an {AugeasTreeValue} (which combines both).
   #
+  # An `:operation` is an internal variable holding modification of Augeas
+  # structure. It is used for minimizing modifications of source files. Its
+  # possible values are
+  # - `:keep` when the value is untouched
+  # - `:modify` when the `:value` changed but the `:key` is the same
+  # - `:remove` when it is going to be removed, and
+  # - `:add` when a new element is added.
+  #
+  # An `:orig_key` is an internal variable used to hold the original key
+  # including its index.
+  #
   # @return [Hash{Symbol => String, AugeasTree}]
   #
   # @todo Unify naming: entry, element
@@ -38,19 +50,16 @@ module CFA
       element = placer.new_element(@tree)
       element[:key] = augeas_name
       element[:value] = value
+      element[:operation] = :add
       # FIXME: load_collection missing here
     end
 
     def delete(value)
-      key = augeas_name
-      @tree.data.reject! do |entry|
-        entry[:key] == key &&
-          if value.is_a?(Regexp)
-            value =~ entry[:value]
-          else
-            value == entry[:value]
-          end
-      end
+      to_delete, to_mark = to_remove(value)
+                           .partition { |e| e[:operation] == :add }
+      @tree.all_data.delete_if { |e| to_delete.include?(e) }
+
+      to_mark.each { |e| e[:operation] = :remove }
 
       load_collection
     end
@@ -58,26 +67,45 @@ module CFA
   private
 
     def load_collection
-      entries = @tree.data.select { |d| d[:key] == augeas_name }
+      entries = @tree.data.select do |entry|
+        entry[:key] == augeas_name && entry[:operation] != :remove
+      end
       @collection = entries.map { |e| e[:value] }.freeze
     end
 
     def augeas_name
       @name + "[]"
     end
+
+    def to_remove(value)
+      key = augeas_name
+
+      @tree.data.select do |entry|
+        entry[:key] == key && value_match?(entry[:value], value)
+      end
+    end
+
+    def value_match?(value, match)
+      if match.is_a?(Regexp)
+        value =~ match
+      else
+        value == match
+      end
+    end
   end
 
   # Represents a node that contains both a value and a subtree below it.
   # For easier traversal it forwards `#[]` to the subtree.
   class AugeasTreeValue
     # @return [String] the value in the node
-    attr_accessor :value
+    attr_reader :value
     # @return [AugeasTree] the subtree below the node
     attr_accessor :tree
 
     def initialize(tree, value)
       @tree = tree
       @value = value
+      @modified = false
     end
 
     # (see AugeasTree#[])
@@ -85,12 +113,22 @@ module CFA
       tree[key]
     end
 
+    def value=(value)
+      @value = value
+      @modified = true
+    end
+
     def ==(other)
       [:class, :value, :tree].all? do |a|
         public_send(a) == other.public_send(a)
       end
     end
 
+    # @return true if the value has been modified
+    def modified?
+      @modified
+    end
+
     # For objects of class Object, eql? is synonymous with ==:
     # http://ruby-doc.org/core-2.3.3/Object.html#method-i-eql-3F
     alias_method :eql?, :==
@@ -100,13 +138,21 @@ module CFA
   class AugeasTree
     # Low level access to Augeas structure
     #
-    # An ordered mapping, represented by an Array of Hashes
-    # with the keys :key and :value.
+    # An ordered mapping, represented by an Array of AugeasElement, but without
+    # any removed elements.
     #
     # @see AugeasElement
     #
-    # @return [Array<Hash{Symbol => String, AugeasTree}>]
-    attr_reader :data
+    # @return [Array<Hash{Symbol => Object}>] a frozen array as it is
+    #    just a copy of the real data
+    def data
+      @data.select { |e| e[:operation] != :remove }.freeze
+    end
+
+    # low level access to all AugeasElement including ones marked for removal
+    def all_data
+      @data
+    end
 
     def initialize
       @data = []
@@ -117,13 +163,17 @@ module CFA
       AugeasCollection.new(self, key)
     end
 
-    # @param [String, Matcher]
+    # @param [String, Matcher] matcher
     def delete(matcher)
       return if matcher.nil?
       unless matcher.is_a?(CFA::Matcher)
         matcher = CFA::Matcher.new(key: matcher)
       end
-      @data.reject!(&matcher)
+      to_remove = @data.select(&matcher)
+
+      to_delete, to_mark = to_remove.partition { |e| e[:operation] == :add }
+      @data -= to_delete
+      to_mark.each { |e| e[:operation] = :remove }
     end
 
     # Adds the given *value* for *key* in the tree.
@@ -139,6 +189,7 @@ module CFA
       element = placer.new_element(self)
       element[:key] = key
       element[:value] = value
+      element[:operation] = :add
     end
 
     # Finds given *key* in tree.
@@ -146,7 +197,7 @@ module CFA
     # @return [String,AugeasTree,AugeasTreeValue,nil] the first value for *key*,
     #   or `nil` if not found
     def [](key)
-      entry = @data.find { |d| d[:key] == key }
+      entry = @data.find { |d| d[:key] == key && d[:operation] != :remove }
       return entry[:value] if entry
 
       nil
@@ -154,18 +205,13 @@ module CFA
 
     # Replace the first value for *key* with *value*.
     # Append a new element if *key* did not exist.
+    # If *key* was previously removed, then put it back to its old position.
     # @param key [String]
     # @param value [String, AugeasTree, AugeasTreeValue]
     def []=(key, value)
-      entry = @data.find { |d| d[:key] == key }
-      if entry
-        entry[:value] = value
-      else
-        @data << {
-          key:   key,
-          value: value
-        }
-      end
+      new_entry = entry_to_modify(key, value)
+      new_entry[:key] = key
+      new_entry[:value] = value
     end
 
     # @param matcher [Matcher]
@@ -174,41 +220,15 @@ module CFA
       @data.select(&matcher)
     end
 
-    # @note for internal usage only
-    # @api private
-    #
-    # Initializes {#data} from *prefix* in *aug*.
-    # @param aug [::Augeas]
-    # @param prefix [String] Augeas path prefix
-    # @param keys_cache [AugeasKeysCache]
-    # @return [void]
-    def load_from_augeas(aug, prefix, keys_cache)
-      @data = keys_cache.keys_for_prefix(prefix).map do |key|
-        aug_key = prefix + "/" + key
-        {
-          key:   load_key(prefix, aug_key),
-          value: load_value(aug, aug_key, keys_cache)
-        }
-      end
-    end
-
-    # @note for internal usage only
-    # @api private
-    #
-    # Saves {#data} to *prefix* in *aug*.
-    # @param aug [::Augeas]
-    # @param prefix [String] Augeas path prefix
-    # @return [void]
-    def save_to_augeas(aug, prefix)
-      arrays = {}
-
-      @data.each do |entry|
-        save_entry(entry[:key], entry[:value], arrays, aug, prefix)
+    def ==(other)
+      return false if self.class != other.class
+      other_data = other.data # do not compute again
+      data.each_with_index do |entry, index|
+        return false if entry[:key] != other_data[index][:key]
+        return false if entry[:value] != other_data[index][:value]
       end
-    end
 
-    def ==(other)
-      [:class, :data].all? { |a| public_send(a) == other.public_send(a) }
+      true
     end
 
     # For objects of class Object, eql? is synonymous with ==:
@@ -217,54 +237,44 @@ module CFA
 
   private
 
-    def save_entry(key, value, arrays, aug, prefix)
-      aug_key = obtain_aug_key(prefix, key, arrays)
-      case value
-      when AugeasTree then value.save_to_augeas(aug, aug_key)
-      when AugeasTreeValue
-        report_error(aug) unless aug.set(aug_key, value.value)
-        value.tree.save_to_augeas(aug, aug_key)
+    def replace_entry(old_entry)
+      index = @data.index(old_entry)
+      new_entry = { operation: :add }
+      # insert the replacement to the same location
+      @data.insert(index, new_entry)
+      # the entry is not yet in the tree
+      if old_entry[:operation] == :add
+        @data.delete_if { |d| d[:key] == key }
       else
-        report_error(aug) unless aug.set(aug_key, value)
-      end
-    end
-
-    def obtain_aug_key(prefix, key, arrays)
-      if key.end_with?("[]")
-        array_key = key[0..-3] # remove trailing []
-        arrays[array_key] ||= 0
-        arrays[array_key] += 1
-        key = array_key + "[#{arrays[array_key]}]"
+        old_entry[:operation] = :remove
       end
 
-      "#{prefix}/#{key}"
+      new_entry
     end
 
-    def report_error(aug)
-      error = aug.error
-      raise "Augeas error #{error[:message]}." \
-        "Details: #{error[:details]}."
+    def mark_new_entry(new_entry, old_entry)
+      # if an entry already exists then just modify it,
+      # but only if we previously did not add it
+      new_entry[:operation] = if old_entry && old_entry[:operation] != :add
+                                :modify
+                              else
+                                :add
+                              end
     end
 
-    def load_key(prefix, aug_key)
-      # clean from key prefix and for collection remove number inside []
-      # +1 for size due to ending '/' not part of prefix
-      key = aug_key[(prefix.size + 1)..-1]
-      key.end_with?("]") ? key.sub(/\[\d+\]$/, "[]") : key
-    end
+    def entry_to_modify(key, value)
+      entry = @data.find { |d| d[:key] == key }
+      # we are switching from tree to value or treevalue to value only
+      # like change from key=value to key=value#comment
+      if entry && entry[:value].class != value.class
+        entry = replace_entry(entry)
+      end
+      new_entry = entry || {}
+      mark_new_entry(new_entry, entry)
 
-    def load_value(aug, aug_key, keys_cache)
-      subkeys = keys_cache.keys_for_prefix(aug_key)
+      @data << new_entry unless entry
 
-      nested = !subkeys.empty?
-      value = aug.get(aug_key)
-      if nested
-        subtree = AugeasTree.new
-        subtree.load_from_augeas(aug, aug_key, keys_cache)
-        value ? AugeasTreeValue.new(subtree, value) : subtree
-      else
-        value
-      end
+      new_entry
     end
   end
 
@@ -286,6 +296,7 @@ module CFA
     # @param raw_string [String] a string to be parsed
     # @return [AugeasTree] the parsed data
     def parse(raw_string)
+      require "cfa/augeas_parser/reader"
       @old_content = raw_string
 
       # open augeas without any autoloading and it should not touch disk and
@@ -295,24 +306,21 @@ module CFA
         aug.set("/input", raw_string)
         report_error(aug) unless aug.text_store(@lens, "/input", "/store")
 
-        keys_cache = AugeasKeysCache.new(aug)
-
-        tree = AugeasTree.new
-        tree.load_from_augeas(aug, "/store", keys_cache)
-
-        return tree
+        return AugeasReader.read(aug, "/store")
       end
     end
 
     # @param data [AugeasTree] the data to be serialized
     # @return [String] a string to be written
     def serialize(data)
+      require "cfa/augeas_parser/writer"
       # open augeas without any autoloading and it should not touch disk and
       # load lenses as needed only
       root = load_path = nil
       Augeas.open(root, load_path, Augeas::NO_MODL_AUTOLOAD) do |aug|
         aug.set("/input", @old_content || "")
-        data.save_to_augeas(aug, "/store")
+        aug.text_store(@lens, "/input", "/store") if @old_content
+        AugeasWriter.new(aug).write("/store", data)
 
         res = aug.text_retrieve(@lens, "/input", "/store", "/output")
         report_error(aug) unless res
@@ -342,44 +350,4 @@ module CFA
       raise "Augeas parsing/serializing error: #{msg} at #{location}"
     end
   end
-
-  # Cache that holds all avaiable keys in augeas tree. It is used to
-  # prevent too many aug.match calls which are expensive.
-  class AugeasKeysCache
-    STORE_PREFIX = "/store".freeze
-
-    # initialize cache from passed augeas object
-    def initialize(aug)
-      fill_cache(aug)
-    end
-
-    # returns list of keys available on given prefix
-    def keys_for_prefix(prefix)
-      @cache[prefix] || []
-    end
-
-  private
-
-    def fill_cache(aug)
-      @cache = {}
-      search_path = "#{STORE_PREFIX}/*"
-      loop do
-        matches = aug.match(search_path)
-        break if matches.empty?
-        assign_matches(matches, @cache)
-
-        search_path += "/*"
-      end
-    end
-
-    def assign_matches(matches, cache)
-      matches.each do |match|
-        split_index = match.rindex("/")
-        prefix = match[0..(split_index - 1)]
-        key = match[(split_index + 1)..-1]
-        cache[prefix] ||= []
-        cache[prefix] << key
-      end
-    end
-  end
 end

data/lib/cfa/augeas_parser/keys_cache.rb

@@ -0,0 +1,41 @@
+module CFA
+  # A cache that holds all avaiable keys in an Augeas tree. It is used to
+  # prevent too many `aug.match` calls which are expensive.
+  class AugeasKeysCache
+    # initialize cache from passed Augeas object
+    # @param aug [::Augeas]
+    # @param prefix [String] Augeas path for which cache should be created
+    def initialize(aug, prefix)
+      fill_cache(aug, prefix)
+    end
+
+    # @return list of keys available on given prefix
+    def keys_for_prefix(prefix)
+      @cache[prefix] || []
+    end
+
+  private
+
+    def fill_cache(aug, prefix)
+      @cache = {}
+      search_path = "#{prefix}/*"
+      loop do
+        matches = aug.match(search_path)
+        break if matches.empty?
+        assign_matches(matches, @cache)
+
+        search_path += "/*"
+      end
+    end
+
+    def assign_matches(matches, cache)
+      matches.each do |match|
+        split_index = match.rindex("/")
+        prefix = match[0..(split_index - 1)]
+        key = match[(split_index + 1)..-1]
+        cache[prefix] ||= []
+        cache[prefix] << key
+      end
+    end
+  end
+end

data/lib/cfa/augeas_parser/reader.rb

@@ -0,0 +1,67 @@
+require "cfa/augeas_parser/keys_cache"
+require "cfa/augeas_parser"
+
+module CFA
+  # A class responsible for reading {AugeasTree} from Augeas
+  class AugeasReader
+    class << self
+      # Creates *tree* from *prefix* in *aug*.
+      # @param aug [::Augeas]
+      # @param prefix [String] Augeas path prefix
+      # @return [AugeasTree]
+      def read(aug, prefix)
+        keys_cache = AugeasKeysCache.new(aug, prefix)
+
+        tree = AugeasTree.new
+        load_tree(aug, prefix, tree, keys_cache)
+
+        tree
+      end
+
+    private
+
+      # fills *tree* with data
+      def load_tree(aug, prefix, tree, keys_cache)
+        data = keys_cache.keys_for_prefix(prefix).map do |key|
+          aug_key = prefix + "/" + key
+          {
+            key:       load_key(prefix, aug_key),
+            value:     load_value(aug, aug_key, keys_cache),
+            orig_key:  stripped_path(prefix, aug_key),
+            operation: :keep
+          }
+        end
+
+        tree.all_data.concat(data)
+      end
+
+      # loads a key in a format that AugeasTree expects
+      def load_key(prefix, aug_key)
+        # clean from key prefix and for collection remove number inside []
+        key = stripped_path(prefix, aug_key)
+        key.end_with?("]") ? key.sub(/\[\d+\]$/, "[]") : key
+      end
+
+      # path without prefix we are not interested in
+      def stripped_path(prefix, aug_key)
+        # +1 for size due to ending '/' not part of prefix
+        aug_key[(prefix.size + 1)..-1]
+      end
+
+      # loads value from auges. If value have tree under, it will also read it
+      def load_value(aug, aug_key, keys_cache)
+        subkeys = keys_cache.keys_for_prefix(aug_key)
+
+        nested = !subkeys.empty?
+        value = aug.get(aug_key)
+        if nested
+          subtree = AugeasTree.new
+          load_tree(aug, aug_key, subtree, keys_cache)
+          value ? AugeasTreeValue.new(subtree, value) : subtree
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/cfa/augeas_parser/writer.rb

@@ -0,0 +1,324 @@
+module CFA
+  # The goal of this class is to write the data stored in {AugeasTree}
+  # back to Augeas.
+  #
+  # It tries to make only the needed changes, as internally Augeas keeps
+  # a flag whether data has been modified,
+  # and keeps the unmodified parts of the file untouched.
+  #
+  # @note internal only, unstable API
+  # @api private
+  class AugeasWriter
+    # @param aug result of Augeas.create
+    def initialize(aug)
+      @aug = aug
+    end
+
+    # Writes the data in *tree* to a given *prefix* in Augeas
+    # @param prefix [String] where to write *tree* in Augeas
+    # @param tree [CFA::AugeasTree] tree to write
+    def write(prefix, tree, top_level: true)
+      @lazy_operations = LazyOperations.new(aug) if top_level
+      tree.all_data.each do |entry|
+        located_entry = LocatedEntry.new(tree, entry, prefix)
+        process_operation(located_entry)
+      end
+      @lazy_operations.run if top_level
+    end
+
+  private
+
+    # {AugeasElement} together with information about its location and a few
+    # helper methods to detect siblings.
+    #
+    # @example data for an already existing comment living under /main
+    #   entry.orig_key # => "#comment[15]"
+    #   entry.path # => "/main/#comment[15]"
+    #   entry.key # => "#comment"
+    #   entry.entry_tree # => AugeasTree.new
+    #   entry.entry_value # => "old boring comment"
+    #
+    # @example data for a new comment under /main
+    #   entry.orig_key # => nil
+    #   entry.path # => nil
+    #   entry.key # => "#comment"
+    #   entry.entry_tree # => AugeasTree.new
+    #   entry.entry_value # => "new boring comment"
+    #
+    # @example data for new tree placed at /main
+    #   entry.orig_key # => "main"
+    #   entry.path # => "/main"
+    #   entry.key # => "main"
+    #   entry.entry_tree # => entry[:value]
+    #   entry.entry_value # => nil
+    #
+    class LocatedEntry
+      attr_reader :prefix
+      attr_reader :entry
+      attr_reader :tree
+
+      def initialize(tree, entry, prefix)
+        @tree = tree
+        @entry = entry
+        @prefix = prefix
+        detect_tree_value_modification
+      end
+
+      def orig_key
+        entry[:orig_key]
+      end
+
+      def path
+        return @path if @path
+        return nil unless orig_key
+
+        @path = @prefix + "/" + orig_key
+      end
+
+      def key
+        return @key if @key
+
+        @key = @entry[:key]
+        @key = @key[0..-3] if @key.end_with?("[]")
+        @key
+      end
+
+      # @return [LocatedEntry, nil]
+      #   a preceding entry that already exists in the Augeas tree
+      #   or nil if it does not exist.
+      def preceding_existing
+        preceding_entry = preceding_entries.reverse_each.find do |entry|
+          entry[:operation] != :add
+        end
+
+        return nil unless preceding_entry
+
+        LocatedEntry.new(tree, preceding_entry, prefix)
+      end
+
+      # @return [true, false] returns true if there is any following entry
+      #    in the Augeas tree
+      def any_following?
+        following_entries.any? { |e| e[:operation] != :remove }
+      end
+
+      # @return [AugeasTree] the Augeas tree nested under this entry.
+      #   If there is no such tree, it creates an empty one.
+      def entry_tree
+        value = entry[:value]
+        case value
+        when AugeasTree then value
+        when AugeasTreeValue then value.tree
+        else AugeasTree.new
+        end
+      end
+
+      # @return [String, nil] the Augeas value of this entry. Can be nil.
+      # If the value is an {AugeasTree} then return nil.
+      def entry_value
+        value = entry[:value]
+        case value
+        when AugeasTree then nil
+        when AugeasTreeValue then value.value
+        else value
+        end
+      end
+
+    private
+
+      # For {AugeasTreeValue} we have a problem with detection of
+      # value modification as it is enclosed in a diferent object.
+      # So propagate it to this entry here.
+      def detect_tree_value_modification
+        return unless entry[:value].is_a?(AugeasTreeValue)
+        return if entry[:operation] != :keep
+
+        entry[:operation] = entry[:value].modified? ? :modify : :keep
+      end
+
+      # the entries preceding this entry
+      def preceding_entries
+        return [] if index.zero? # first entry
+        tree.all_data[0..(index - 1)]
+      end
+
+      # the entries following this entry
+      def following_entries
+        tree.all_data[(index + 1)..-1]
+      end
+
+      # the index of this entry in its tree
+      def index
+        @index ||= tree.all_data.index(entry)
+      end
+    end
+
+    # Represents an operation that needs to be done after all modifications.
+    #
+    # The reason to have this class is that Augeas renumbers its arrays after
+    # some operations like `rm` or `insert` so previous paths are no longer
+    # valid. For this reason these sensitive operations that change paths need
+    # to be done at the end and with careful order.
+    # See https://www.redhat.com/archives/augeas-devel/2017-March/msg00002.html
+    #
+    # @note This class depends on ordered operations. So adding and removing
+    # entries has to be done in order how they are placed in tree.
+    class LazyOperations
+      # @param aug result of Augeas.create
+      def initialize(aug)
+        @aug = aug
+        @operations = []
+      end
+
+      def add(located_entry)
+        @operations << { type: :add, located_entry: located_entry }
+      end
+
+      def remove(located_entry)
+        @operations << { type: :remove, path: located_entry.path }
+      end
+
+      # starts all previously inserted operations
+      def run
+        # the reverse order is needed because if there are two operations
+        # one after another then the latter cannot affect the former
+        @operations.reverse_each do |operation|
+          case operation[:type]
+          when :remove then aug.rm(operation[:path])
+          when :add
+            located_entry = operation[:located_entry]
+            add_entry(located_entry)
+          else
+            raise "Invalid lazy operation #{operation.inspect}"
+          end
+        end
+      end
+
+    private
+
+      attr_reader :aug
+
+      # Adds entry to tree. At first it finds where to add it to be in correct
+      # place and then sets its value. Recursive if needed. In recursive case
+      # it is already known that whole sub-tree is also new and just added.
+      def add_entry(located_entry)
+        path = insert_entry(located_entry)
+        set_new_value(path, located_entry)
+      end
+
+      # Sets new value to given path. It is used for values that are not yet in
+      # Augeas tree. If needed it does recursive adding.
+      # @param path [String] path which can contain Augeas path expression for
+      #   key of new value
+      # @param located_entry [LocatedEntry] entry to write
+      # @see https://github.com/hercules-team/augeas/wiki/Path-expressions
+      def set_new_value(path, located_entry)
+        aug.set(path, located_entry.entry_value)
+        prefix = path[/(^.*)\/[^\/]+/, 1]
+        # we need to get new path as set can look like [last() + 1]
+        # which creates new entry and we do not want to add subtree to new
+        # entries
+        new_path = aug.match(prefix + "/*[last()]").first
+        add_subtree(located_entry.entry_tree, new_path)
+      end
+
+      # Adds new subtree. Simplified version of common write as it is known
+      # that all entries will be just added.
+      # @param tree [CFA::AugeasTree] to add
+      # @param prefix [String] prefix where to place *tree*
+      def add_subtree(tree, prefix)
+        tree.all_data.each do |entry|
+          located_entry = LocatedEntry.new(tree, entry, prefix)
+          # universal path that handles also new elements for arrays
+          path = "#{prefix}/#{located_entry.key}[last()+1]"
+          set_new_value(path, located_entry)
+        end
+      end
+
+      # It inserts a key at given position without setting its value.
+      # Its logic is to set it after the last valid entry. If it is not defined
+      # then tries to place it before the first valid entry in tree. If there is
+      # no entry in tree, then does not insert a position, which means that
+      # subsequent setting of value appends it to the end.
+      #
+      # @param located_entry [LocatedEntry] entry to insert
+      # @return [String] where value should be written. Can
+      #   contain path expressions.
+      #   See https://github.com/hercules-team/augeas/wiki/Path-expressions
+      def insert_entry(located_entry)
+        # entries with add not exist yet
+        preceding = located_entry.preceding_existing
+        prefix = located_entry.prefix
+        if preceding
+          insert_after(preceding, located_entry)
+        # entries with remove is already removed, otherwise find previously
+        elsif located_entry.any_following?
+          aug.insert(prefix + "/*[1]", located_entry.key, true)
+          aug.match(prefix + "/*[1]").first
+        else
+          "#{prefix}/#{located_entry.key}"
+        end
+      end
+
+      # Insert key after preceding.
+      # @see insert_entry
+      # @param preceding [LocatedEntry] entry after which the new one goes
+      # @param located_entry [LocatedEntry] entry to insert
+      # @return [String] where value should be written.
+      def insert_after(preceding, located_entry)
+        aug.insert(preceding.path, located_entry.key, false)
+        paths = aug.match(located_entry.prefix + "/*")
+        paths_index = paths.index(preceding.path) + 1
+        paths[paths_index]
+      end
+    end
+
+    attr_reader :aug
+
+    # Does modification according to the operation defined in {AugeasElement}
+    # @param located_entry [LocatedEntry] entry to process
+    def process_operation(located_entry)
+      case located_entry.entry[:operation]
+      when :add, nil then @lazy_operations.add(located_entry)
+      when :remove then @lazy_operations.remove(located_entry)
+      when :modify then modify_entry(located_entry)
+      when :keep then recurse_write(located_entry)
+      else raise "invalid :operation in #{located_entry.inspect}"
+      end
+    end
+
+    # Writes value of entry to path and if it has a sub-tree
+    # then it calls {#write} on it
+    # @param located_entry [LocatedEntry] entry to modify
+    def modify_entry(located_entry)
+      value = located_entry.entry_value
+      aug.set(located_entry.path, value)
+      report_error { aug.set(located_entry.path, value) }
+      recurse_write(located_entry)
+    end
+
+    # calls write on entry if entry have sub-tree
+    # @param located_entry [LocatedEntry] entry to recursive write
+    def recurse_write(located_entry)
+      write(located_entry.path, located_entry.entry_tree, top_level: false)
+    end
+
+    # Calls block and if it failed, raise exception with details from augeas
+    # why it failed
+    # @yield call to aug that is secured
+    # @raise [RuntimeError]
+    def report_error
+      return if yield
+
+      error = aug.error
+      # zero is no error, so problem in lense
+      if aug.error[:code].nonzero?
+        raise "Augeas error #{error[:message]}. Details: #{error[:details]}."
+      end
+
+      msg = aug.get("/augeas/text/store/error/message")
+      location = aug.get("/augeas/text/store/error/lens")
+      raise "Augeas serializing error: #{msg} at #{location}"
+    end
+  end
+end

data/lib/cfa/base_model.rb

@@ -53,14 +53,15 @@ module CFA
     # smart to at first modify existing value, then replace commented out code
     # and if even that doesn't work, then append it at the end
     # @note prefer to use specialized methods of children
-    def generic_set(key, value)
-      modify(key, value) || uncomment(key, value) || add_new(key, value)
+    def generic_set(key, value, tree = data)
+      modify(key, value, tree) || uncomment(key, value, tree) ||
+        add_new(key, value, tree)
     end
 
     # powerfull method that gets unformatted any value in config.
     # @note prefer to use specialized methods of children
-    def generic_get(key)
-      data[key]
+    def generic_get(key, tree = data)
+      tree[key]
     end
 
     # rubocop:disable Style/TrivialAccessors
@@ -120,18 +121,18 @@ module CFA
     # Modify an **existing** entry and return `true`,
     # or do nothing and return `false`.
     # @return [Boolean]
-    def modify(key, value)
+    def modify(key, value, tree)
       # if already set, just change value
-      return false unless data[key]
+      return false unless tree[key]
 
-      data[key] = value
+      tree[key] = value
       true
     end
 
     # Replace a commented out entry and return `true`,
     # or do nothing and return `false`.
     # @return [Boolean]
-    def uncomment(key, value)
+    def uncomment(key, value, tree)
       # Try to find if it is commented out, so we can replace line
       matcher = Matcher.new(
         collection:    "#comment",
@@ -139,15 +140,15 @@ module CFA
         # FIXME: this will match also "# If you set FOO=bar then..."
         value_matcher: /(\s|^)#{key}\s*=/
       )
-      return false unless  data.data.any?(&matcher)
+      return false unless tree.data.any?(&matcher)
 
       # FIXME: this assumes that *data* is an AugeasTree
-      data.add(key, value, ReplacePlacer.new(matcher))
+      tree.add(key, value, ReplacePlacer.new(matcher))
       true
     end
 
-    def add_new(key, value)
-      data.add(key, value)
+    def add_new(key, value, tree)
+      tree.add(key, value)
     end
   end
 

data/lib/cfa/placer.rb

@@ -11,14 +11,20 @@ module CFA
       raise NotImplementedError,
         "Subclasses of #{Module.nesting.first} must override #{__method__}"
     end
+
+  protected
+
+    def create_element
+      { operation: :add }
+    end
   end
 
   # Places the new element at the end of the tree.
   class AppendPlacer < Placer
     # (see Placer#new_element)
     def new_element(tree)
-      res = {}
-      tree.data << res
+      res = create_element
+      tree.all_data << res
 
       res
     end
@@ -37,14 +43,15 @@ module CFA
 
     # (see Placer#new_element)
     def new_element(tree)
-      index = tree.data.index(&@matcher)
+      index = tree.all_data.index(&@matcher)
 
-      res = {}
+      res = create_element
       if index
-        tree.data.insert(index, res)
+        tree.all_data.insert(index, res)
       else
-        tree.data << res
+        tree.all_data << res
       end
+
       res
     end
   end
@@ -61,14 +68,15 @@ module CFA
 
     # (see Placer#new_element)
     def new_element(tree)
-      index = tree.data.index(&@matcher)
+      index = tree.all_data.index(&@matcher)
 
-      res = {}
+      res = create_element
       if index
-        tree.data.insert(index + 1, res)
+        tree.all_data.insert(index + 1, res)
       else
-        tree.data << res
+        tree.all_data << res
       end
+
       res
     end
   end
@@ -86,13 +94,16 @@ module CFA
 
     # (see Placer#new_element)
     def new_element(tree)
-      index = tree.data.index(&@matcher)
-      res = {}
+      index = tree.all_data.index(&@matcher)
+      res = create_element
 
       if index
-        tree.data[index] = res
+        # remove old one and add new one, as it can have different key
+        # which cause problem to simple modify
+        tree.all_data[index][:operation] = :remove
+        tree.all_data.insert(index + 1, res)
       else
-        tree.data << res
+        tree.all_data << res
       end
 
       res

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cfa
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Josef Reidinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-03 00:00:00.000000000 Z
+date: 2017-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-augeas
@@ -34,6 +34,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cfa/augeas_parser.rb
+- lib/cfa/augeas_parser/keys_cache.rb
+- lib/cfa/augeas_parser/reader.rb
+- lib/cfa/augeas_parser/writer.rb
 - lib/cfa/base_model.rb
 - lib/cfa/matcher.rb
 - lib/cfa/memory_file.rb
@@ -58,9 +61,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: CFA (Config Files API) provides an easy way to create models on top of configuration
   files
 test_files: []
+has_rdoc: