cfa 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0bc2e08acdb945ee444cd4cc4161f8486269624
+  data.tar.gz: 63f48a1e6955ed2eaf9ab2a2a7e349fbc599e181
+SHA512:
+  metadata.gz: 3d378441e8342f71da3787af6f8c4addcad952421b60928546eb9c7c455455cfb482cc9ae398f219c8d9456fefd20d1c79465d107f84676fb458c66245d1b948
+  data.tar.gz: 187f9e0e23a30f3b952aed40f028d193d759581ea7801f3b945218da964f90a4ef2f42e669507c6ebce8c4a9f015b2e07a506622869f38e7d13faf2e0eaae3bf

data/lib/config_files_api/augeas_parser.rb

@@ -0,0 +1,235 @@
+require "augeas"
+require "forwardable"
+require "config_files_api/placer"
+
+module ConfigFilesApi
+  # Represents list of same config options in augeas.
+  # For example comments are often stored in collections.
+  class AugeasCollection
+    extend Forwardable
+    def initialize(tree, name)
+      @tree = tree
+      @name = name
+      load_collection
+    end
+
+    def_delegators :@collection, :[], :empty?, :each, :map, :any?, :all?, :none?
+
+    def add(value, placer = AppendPlacer.new)
+      element = placer.new_element(@tree)
+      element[:key] = augeas_name
+      element[:value] = value
+    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
+
+      load_collection
+    end
+
+  private
+
+    def load_collection
+      entries = @tree.data.select { |d| d[:key] == augeas_name }
+      @collection = entries.map { |e| e[:value] }.freeze
+    end
+
+    def augeas_name
+      @name + "[]"
+    end
+  end
+
+  # Represent parsed augeas config tree with user friendly methods
+  class AugeasTree
+    # low level access to augeas structure
+    attr_reader :data
+
+    def initialize
+      @data = []
+    end
+
+    def collection(key)
+      AugeasCollection.new(self, key)
+    end
+
+    def delete(key)
+      @data.reject! { |entry| entry[:key] == key }
+    end
+
+    def add(key, value, placer = AppendPlacer.new)
+      element = placer.new_element(self)
+      element[:key] = key
+      element[:value] = value
+    end
+
+    def [](key)
+      entry = @data.find { |d| d[:key] == key }
+      return entry[:value] if entry
+
+      nil
+    end
+
+    def []=(key, value)
+      entry = @data.find { |d| d[:key] == key }
+      if entry
+        entry[:value] = value
+      else
+        @data << {
+          key:   key,
+          value: value
+        }
+      end
+    end
+
+    def select(matcher)
+      @data.select(&matcher)
+    end
+
+    # @note for internal usage only
+    # @private
+    def load_from_augeas(aug, prefix)
+      matches = aug.match("#{prefix}/*")
+
+      @data = matches.map do |aug_key|
+        {
+          key:   load_key(prefix, aug_key),
+          value: load_value(aug, aug_key)
+        }
+      end
+    end
+
+    # @note for internal usage only
+    # @private
+    def save_to_augeas(aug, prefix)
+      arrays = {}
+
+      @data.each do |entry|
+        aug_key = obtain_aug_key(prefix, entry, arrays)
+        if entry[:value].is_a? AugeasTree
+          entry[:value].save_to_augeas(aug, aug_key)
+        else
+          report_error(aug) unless aug.set(aug_key, entry[:value])
+        end
+      end
+    end
+
+    # @note for debugging purpose only
+    def dump_tree(prefix = "")
+      arrays = {}
+
+      @data.each_with_object("") do |entry, res|
+        aug_key = obtain_aug_key(prefix, entry, arrays)
+        if entry[:value].is_a? AugeasTree
+          res << entry[:value].dump_tree(aug_key)
+        else
+          res << aug_key << "\n"
+        end
+      end
+    end
+
+  private
+
+    def obtain_aug_key(prefix, entry, arrays)
+      key = entry[:key]
+      if key.end_with?("[]")
+        array_key = key.sub(/\[\]$/, "")
+        arrays[array_key] ||= 0
+        arrays[array_key] += 1
+        key = array_key + "[#{arrays[array_key]}]"
+      end
+
+      "#{prefix}/#{key}"
+    end
+
+    def report_error(aug)
+      error = aug.error
+      raise "Augeas error #{error[:message]}." \
+        "Details: #{error[:details]}."
+    end
+
+    def load_key(prefix, aug_key)
+      key = aug_key.sub(/^#{Regexp.escape(prefix)}\//, "")
+      key.sub(/\[\d+\]$/, "[]")
+    end
+
+    def load_value(aug, aug_key)
+      nested = !aug.match("#{aug_key}/*").empty?
+      if nested
+        subtree = AugeasTree.new
+        subtree.load_from_augeas(aug, aug_key)
+        subtree
+      else
+        aug.get(aug_key)
+      end
+    end
+  end
+
+  # @example read, print, modify and serialize again
+  #    require "config_files/augeas_parser"
+  #
+  #    parser = ConfigFilesApi::AugeasParser.new("sysconfig.lns")
+  #    data = parser.parse(File.read("/etc/default/grub"))
+  #
+  #    puts data["GRUB_DISABLE_OS_PROBER"]
+  #    data["GRUB_DISABLE_OS_PROBER"] = "true"
+  #    puts parser.serialize(data)
+  class AugeasParser
+    def initialize(lens)
+      @lens = lens
+    end
+
+    def parse(raw_string)
+      @old_content = raw_string
+
+      # 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", raw_string)
+        report_error(aug) unless aug.text_store(@lens, "/input", "/store")
+
+        tree = AugeasTree.new
+        tree.load_from_augeas(aug, "/store")
+
+        return tree
+      end
+    end
+
+    def serialize(data)
+      # 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")
+
+        res = aug.text_retrieve(@lens, "/input", "/store", "/output")
+        report_error(aug) unless res
+
+        return aug.get("/output")
+      end
+    end
+
+  private
+
+    def report_error(aug)
+      error = aug.error
+      # zero is no error, so problem in lense
+      if aug.error[:code] != 0
+        raise "Augeas error #{error[:message]}. Details: #{error[:details]}."
+      else
+        msg = aug.get("/augeas/text/store/error/message")
+        location = aug.get("/augeas/text/store/error/lens")
+        raise "Augeas parsing/serializing error: #{msg} at #{location}"
+      end
+    end
+  end
+end

data/lib/config_files_api/base_model.rb

@@ -0,0 +1,150 @@
+module ConfigFilesApi
+  # A base class for models. Represents a configuration file as an object
+  # with domain-specific attributes/methods. For persistent storage,
+  # use load and save,
+  # Non-responsibilities: actual storage and parsing (both delegated).
+  # There is no caching involved.
+  class BaseModel
+    # @param parser [.parse, .serialize] parser that can convert object to
+    #   string and vice versa. It have to provide methods
+    #   `string #serialize(object)` and `object #parse(string)`.
+    #   For example see {ConfigFilesApi::AugeasParser}
+    # @param file_path [String] expected path passed to file_handler
+    # @param file_handler [.read, .write] object, that can read/write string.
+    #   It have to provide methods `string read(string)` and
+    #   `write(string, string)`. For example see {ConfigFilesApi::MemoryFile}
+    def initialize(parser, file_path, file_handler: File)
+      @file_handler = file_handler
+      @parser = parser
+      @file_path = file_path
+      @loaded = false
+    end
+
+    def save(changes_only: false)
+      merge_changes if changes_only
+      @file_handler.write(@file_path, @parser.serialize(data))
+    end
+
+    def load
+      self.data = @parser.parse(@file_handler.read(@file_path))
+      @loaded = true
+    end
+
+    # powerfull method that sets any value in config. It try to be
+    # 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)
+    end
+
+    # powerfull method that gets unformatted any value in config.
+    # @note prefer to use specialized methods of children
+    def generic_get(key)
+      data[key]
+    end
+
+    # rubocop:disable Style/TrivialAccessors
+    # Returns if configuration was already loaded
+    def loaded?
+      @loaded
+    end
+
+  protected
+
+    # generates accessors for trivial key-value attributes
+    def self.attributes(attrs)
+      attrs.each_pair do |key, value|
+        define_method(key) do
+          generic_get(value)
+        end
+
+        define_method(:"#{key.to_s}=") do |target|
+          generic_set(value, target)
+        end
+      end
+    end
+    private_class_method :attributes
+
+    attr_accessor :data
+
+    def merge_changes
+      new_data = data.dup
+      read
+      # TODO: recursive merge
+      data.merge(new_data)
+    end
+
+    def modify(key, value)
+      # if already set, just change value
+      return false unless data[key]
+
+      data[key] = value
+      true
+    end
+
+    def uncomment(key, value)
+      # Try to find if it is commented out, so we can replace line
+      matcher = Matcher.new(
+        collection:    "#comment",
+        value_matcher: /(\s|^)#{key}\s*=/
+      )
+      return false unless  data.data.any?(&matcher)
+
+      data.add(key, value, ReplacePlacer.new(matcher))
+      true
+    end
+
+    def add_new(key, value)
+      data.add(key, value)
+    end
+  end
+
+  # Representing boolean value switcher in default grub configuration file.
+  # Allows easy switching and questioning for boolean value, even if
+  # represented by text in config file
+  class BooleanValue
+    def initialize(name, model, true_value: "true", false_value: "false")
+      @name = name
+      @model = model
+      @true_value = true_value
+      @false_value = false_value
+    end
+
+    def enable
+      @model.generic_set(@name, @true_value)
+    end
+
+    def disable
+      @model.generic_set(@name, @false_value)
+    end
+
+    def enabled?
+      return nil unless data
+
+      data == @true_value
+    end
+
+    def disabled?
+      return nil unless data
+
+      data != @true_value
+    end
+
+    def defined?
+      !data.nil?
+    end
+
+    # sets boolean value, recommend to use for generic boolean setter.
+    # for constants prefer to use enable/disable
+    def value=(value)
+      @model.generic_set(@name, value ? @true_value : @false_value)
+    end
+
+  private
+
+    def data
+      @model.generic_get(@name)
+    end
+  end
+end

data/lib/config_files_api/matcher.rb

@@ -0,0 +1,42 @@
+module ConfigFilesApi
+  # Class used to create matcher, that allows to find specific option in augeas
+  # tree or subtree
+  # TODO: examples of usage
+  class Matcher
+    def initialize(key: nil, collection: nil, value_matcher: nil)
+      @matcher = lambda do |element|
+        return false unless key_match?(element, key)
+        return false unless collection_match?(element, collection)
+        return false unless value_match?(element, value_matcher)
+        return true
+      end
+    end
+
+    def to_proc
+      @matcher
+    end
+
+    def key_match?(element, key)
+      return true unless key
+
+      element[:key] == key
+    end
+
+    def collection_match?(element, collection)
+      return true unless collection
+
+      element[:key] == (collection + "[]")
+    end
+
+    def value_match?(element, matcher)
+      case matcher
+      when nil then true
+      when Regexp
+        return false unless element[:value].is_a?(String)
+        matcher =~ element[:value]
+      else
+        matcher == element[:value]
+      end
+    end
+  end
+end

data/lib/config_files_api/memory_file.rb

@@ -0,0 +1,20 @@
+module ConfigFilesApi
+  # memory file is used when string is stored only in memory.
+  # Useful for testing. For remote read or socket read, own File class
+  # creation is recommended.
+  class MemoryFile
+    attr_accessor :content
+
+    def initialize(content = "")
+      @content = content
+    end
+
+    def read(_path)
+      @content.dup
+    end
+
+    def write(_path, content)
+      @content = content
+    end
+  end
+end

data/lib/config_files_api/placer.rb

@@ -0,0 +1,76 @@
+module ConfigFilesApi
+  # allows to place element at the end of configuration. Default one.
+  class AppendPlacer
+    def new_element(tree)
+      res = {}
+      tree.data << res
+
+      res
+    end
+  end
+
+  # Specialized placer, that allows to place config value before found one.
+  # If noone is found, then append to the end
+  # Useful, when config option should be inserted to specific location.
+  class BeforePlacer
+    def initialize(matcher)
+      @matcher = matcher
+    end
+
+    def new_element(tree)
+      index = tree.data.index(&@matcher)
+
+      res = {}
+      if index
+        tree.data.insert(index, res)
+      else
+        tree.data << res
+      end
+      res
+    end
+  end
+
+  # Specialized placer, that allows to place config value after found one.
+  # If noone is found, then append to the end
+  # Useful, when config option should be inserted to specific location.
+  class AfterPlacer
+    def initialize(matcher)
+      @matcher = matcher
+    end
+
+    def new_element(tree)
+      index = tree.data.index(&@matcher)
+
+      res = {}
+      if index
+        tree.data.insert(index + 1, res)
+      else
+        tree.data << res
+      end
+      res
+    end
+  end
+
+  # Specialized placer, that allows to place config value instead of found one.
+  # If noone is found, then append to the end
+  # Useful, when value already exists and detected by matcher. Then easy add
+  # with this placer replace it carefully to correct location.
+  class ReplacePlacer
+    def initialize(matcher)
+      @matcher = matcher
+    end
+
+    def new_element(tree)
+      index = tree.data.index(&@matcher)
+      res = {}
+
+      if index
+        tree.data[index] = res
+      else
+        tree.data << res
+      end
+
+      res
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: cfa
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josef Reidinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-augeas
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library offering separation of parsing and file access from the rest
+  of the logic for managing configuraton files. It has built-in support for parsing
+  using augeas lenses and also for working with files directly in memory.
+email:
+- jreidinger@suse.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/config_files_api/augeas_parser.rb
+- lib/config_files_api/base_model.rb
+- lib/config_files_api/matcher.rb
+- lib/config_files_api/memory_file.rb
+- lib/config_files_api/placer.rb
+homepage: http://github.com/config-files-api/config_files_api
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: CFA (Config Files API) provides easy way to create model on top of configuration
+  file
+test_files: []
+has_rdoc: