nub 0.0.75 → 0.0.76

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5999fb1317e9737b0f1635fabedbf445f5c721fba5b3bbe3840e4877cce3014
-  data.tar.gz: 77d77b46e2b950b39d9de2b21fee171e90a5e980080dc7d835a062657e8368c5
+  metadata.gz: fa43f1a038ebba265bc6b032dcb802cd5870e9b1cc703fe46fb5a96f6240d71a
+  data.tar.gz: 5f6201fb958875f52935cb9b0257831671d3dd3db21f2ccbcb49356fdd1cf8d8
 SHA512:
-  metadata.gz: 2e14f4967da9531fbd776dae27ac96371941706bbdfff3f6c7705d31f5cc5a4be3515c8367678bcaf86f5372d19dd0bbf59535ee039309c35679a929c84e21ee
-  data.tar.gz: 4277a647369fd8911c48bc22cf8b77cfdfbd496cd5d0d9e3b1e1f9d9be03e751fe9ff98d5158b19e2c0e70d294ca763299522583c7bd50709fd4d2608aeb8f58
+  metadata.gz: da19249c6af9fac56ac2d8c7ec4c6a525792bbca53fe1b63b8dc5e47c0439e525b5e918ddfdc82fb820579e708dc4ed12602722491638f4be3681701e9d75019
+  data.tar.gz: 902fbbaae0773ca9cd7a36b6d3575d9fba4b602ea85e3ae6789c9a599d4fc30cc5fb273bd18d7f7f71b9503027315a037199be38f0b60fc4700dd749f019c64f

data/lib/nub/core.rb

@@ -20,6 +20,7 @@
 #SOFTWARE.
 
 require 'erb'
+require 'ostruct'
 
 ColorPair = Struct.new(:str, :color_code, :color_name)
 ColorMap = {
@@ -77,6 +78,27 @@ class ERBResolve
 
     return data
   end
+
+  # Resolve variables for the given data type, changes are done inplace
+  # @data [string/array/hash] data to replace vars
+  def resolve!(data)
+
+    # Recurse
+    if data.is_a?(Array)
+      for i in 0...data.size
+        resolve!(data[i])
+      end
+    elsif data.is_a?(Hash)
+      data.each{|k,v| data[k] = resolve!(v)}
+    end
+
+    # Base case
+    if data.is_a?(String)
+      data.gsub!(data, ERB.new(data).result(@context))
+    end
+
+    return data
+  end
 end
 
 # Hash extensions
@@ -94,6 +116,12 @@ class Hash
   def erb(vars = {})
     ERBResolve.new(vars).resolve(self)
   end
+
+  # Easily inject ERB variables into hash values
+  # +vars+:: hash of variables to inject into the string
+  def erb!(vars = {})
+    ERBResolve.new(vars).resolve!(self)
+  end
 end
 
 # Array extensions
@@ -109,6 +137,12 @@ class Array
   def erb(vars = {})
     ERBResolve.new(vars).resolve(self)
   end
+
+  # Easily inject ERB variables into Array values
+  # +vars+:: hash of variables to inject into the string
+  def erb!(vars = {})
+    ERBResolve.new(vars).resolve!(self)
+  end
 end
 
 # Monkey patch string with some useful methods
@@ -120,6 +154,12 @@ class String
     ERBResolve.new(vars).resolve(self)
   end
 
+  # Easily inject ERB variables into a string
+  # @param vars [Hash] of variables to inject into the string
+  def erb!(vars = {})
+    ERBResolve.new(vars).resolve!(self)
+  end
+
   # Convert the string to ascii, stripping out or converting all non-ascii characters
   def to_ascii
     options = {
@@ -175,8 +215,6 @@ class String
 
     return tokens
   end
-
-
 end
 
 # vim: ft=ruby:ts=2:sw=2:sts=2

data/lib/nub/fileutils.rb

@@ -19,11 +19,45 @@
 #OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #SOFTWARE.
 
+require 'digest'
 require 'fileutils'
+require 'yaml'
+
+require_relative 'core'
 
 # Monkey patch FileUtils with some useful methods
 module FileUtils
 
+  # Check if any digests have changed based on the given files
+  # @param key [yaml] yalm section heading to give digests
+  # @param digestfile [string] digest file to check against
+  # @param files [array] files to get digests for
+  # @returns (newfiles, modifiedfiles, deletedfiles)
+  def self.digests_changed?(key, digestfile, files)
+    files = [files] if files.is_a?(String)
+    newfiles, modifiedfiles, deletedfiles = [], [], []
+
+    # Since layers are stacked and the digest file may be from a lower
+    # layer this should be ignored unless the layer matches
+    if (digests = File.exist?(digestfile) ? YAML.load_file(digestfile)[key] : nil)
+
+      # New files: in files but not yaml
+      newfiles = files.select{|x| not digests[x]}
+
+      # Delete files: in yaml but not files
+      deletedfiles = digests.map{|k,v| k}.select{|x| not files.include?(x)}
+
+      # Modified files: in both but digest is different
+      modifiedfiles = files.select{|x| digests[x] and
+        Digest::MD5.hexdigest(File.binread(x)) != digests[x]}
+    else
+      newfiles = files
+    end
+
+    return newfiles, modifiedfiles, deletedfiles
+  end
+
+
   # Check PATH for executable
   # @param name [String] name of executable to find
   # @param path [Array] path to search
@@ -48,9 +82,10 @@ module FileUtils
   # @return new version
   def self.inc_version(path, regex, major:false, minor:false, rev:true, override:nil)
     version = nil
-    self.update(path){|line|
+    self.update(path){|data|
 
       # Increment version
+      line = data.split("\n").find{|x| x[regex, 1]}
       if ver = line[regex, 1]
         new_ver = nil
         if not override
@@ -65,15 +100,92 @@ module FileUtils
 
         # Modify the original line
         version = new_ver
-        line.gsub!(ver, new_ver)
+        newline = line.gsub(ver, new_ver)
+        data.gsub!(line, newline)
       end
     }
 
     return version
   end
 
+  # Insert into a file
+  # Location of insert is determined by the given regex and offset.
+  # Append is used if no regex is given.
+  # @param file [string] path of file to modify
+  # @param values [array] string or list of string values to insert
+  # @param regex [string] regular expression for location, not used if offset is nil
+  # @param offset [int] offset insert location by this amount for regexs
+  # @returns true if a change was made to the file
+  def self.insert(file, values, regex:nil, offset:1)
+    return false if not values or values.empty?
+
+    changed = false
+    values = [values] if values.is_a?(String)
+    FileUtils.touch(file) if not File.exist?(file)
+
+    begin
+      data = nil
+      File.open(file, 'r+') do |f|
+        data = f.read
+        lines = data.split("\n")
+
+        # Match regex for insert location
+        regex = Regexp.new(regex) if regex.is_a?(String)
+        i = regex ? lines.index{|x| x =~ regex} : lines.size
+        return false if not i
+        i += offset if regex and offset
+
+        # Insert at offset
+        values.each{|x|
+          lines.insert(i, x) and i += 1
+          changed = true
+        }
+
+        # Truncate then write out new content
+        f.seek(0)
+        f.truncate(0)
+        f.puts(lines)
+      end
+    rescue
+      # Revert back to the original incase of failure
+      File.open(file, 'w'){|f| f << data} if data
+      raise
+    end
+
+    return changed
+  end
+
+
+  # Replace in file
+  # @param file [string] file to modify
+  # @param regex [string] regular expression match on
+  # @param value [string] regular expression string replacement
+  # @returns true on change
+  def self.replace(file, regex, value)
+    changed = self.update(file){|data|
+      lines = data.split("\n")
+
+      # Search replace
+      regex = Regexp.new(regex) if regex.is_a?(String)
+      lines.each{|x| x.gsub!(regex, value)}
+
+      # Change data inline
+      data.gsub!(data, lines * "\n")
+    }
+
+    return changed
+  end
+
+  # Resolve template
+  # @param file [string] file to resolve templates for
+  # @param vars [hash/ostruct] templating variables to use while resolving
+  # @returns true on change
+  def self.resolve(file, vars)
+    return self.update(file){|data| data.erb!(vars)}
+  end
+
   # Update the file using a block, revert on failure.
-  # Use this for simple line edits. Block is passed in each line of the file
+  # Use this for file edits. Block is passed in the file data
   # @param filename [String] name of the file to change
   # @return true on change
   def self.update(filename)
@@ -81,23 +193,25 @@ module FileUtils
     block = Proc.new # Most efficient way to get block
 
     begin
-      lines = nil
+      data = nil
       File.open(filename, 'r+'){|f|
-        lines = f.readlines
-        lines.each{|line|
-          line_copy = line.dup
-          block.call(line)
-          changed |= line_copy != line
-        }
+        data = f.read
+        data_orig = data.dup
+
+        # Call block
+        block.call(data)
+        changed |= data_orig != data
 
         # Save the changes back to the file
-        f.seek(0)
-        f.truncate(0)
-        f.puts(lines)
+        if changed
+          f.seek(0)
+          f.truncate(0)
+          f << data
+        end
       }
-    rescue
+    rescue Exception => e
       # Revert back to the original incase of failure
-      File.open(filename, 'w'){|f| f.puts(lines)} if lines
+      File.open(filename, 'w'){|f| f << data} if data
       raise
     end
 
@@ -112,21 +226,41 @@ module FileUtils
   def self.update_copyright(path, copyright, year:Time.now.year)
     set_copyright = false
 
-    changed = self.update(path){|line|
+    changed = self.update(path){|data|
+      line = data.split("\n").find{|x| x[/#{Regexp.quote(copyright)}/]}
       if !set_copyright && line =~ /#{Regexp.quote(copyright)}/
         set_copyright = true
         _year = line[/#{Regexp.quote(copyright)}\s+((\d{4}\s)|(\d{4}-\d{4})).*/, 1].strip
         if _year.include?("-")
           years = _year.split("-")
-          line.gsub!(_year, "#{years.first}-#{year}") if years.last != year
+          if years.last != year
+            newline = line.gsub(_year, "#{years.first}-#{year}")
+            data.gsub!(line, newline)
+          end
         elsif prev_year = _year != year.to_s ? year.to_i - 1 : nil
-          line.gsub!(_year.to_s, "#{prev_year}-#{year}")
+          newline = line.gsub(_year.to_s, "#{prev_year}-#{year}")
+          data.gsub!(line, newline)
         end
       end
     }
     return changed
   end
 
+  # Generate digests for array of files given and save them
+  # @param key [yaml] yalm section heading to give digests
+  # @param digestfile [string] digest file to update
+  # @param files [array] files to get digests for
+  def self.update_digests(key, digestfile, files)
+    files = [files] if files.is_a?(String)
+
+    # Build up digests structure
+    digests = {}
+    files.each{|x| digests[x] = Digest::MD5.hexdigest(File.binread(x)) if File.exist?(x)}
+
+    # Write out digests structure as yaml with named header
+    File.open(digestfile, 'w'){|f| f.puts({key => digests}.to_yaml)}
+  end
+
   # Get SemVer formatted versions
   # @param path [String] file to increment version for
   # @param regex [Regex] capture pattern for version match

data/lib/nub/pacman.rb

@@ -0,0 +1,94 @@
+#MIT License
+#Copyright (c) 2018 phR0ze
+#
+#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.
+
+require 'fileutils'
+require_relative 'log'
+require_relative 'sys'
+require_relative 'module'
+
+# Wrapper around system Arch Linux pacman
+module Pacman
+  extend self
+  mattr_accessor(:path, :config, :sysroot)
+
+  # Configure pacman for the given root
+  # @param path [String] path where all pacman artifacts will be (i.e. logs, cache etc...)
+  # @param config [String] config file path to use, note gets copied in
+  # @param sysroot [String] path to the system root to use
+  def init(path, config, sysroot)
+    self.path = path
+    self.sysroot = sysroot
+    self.config = File.join(path, File.basename(config))
+
+    # Validate incoming params
+    Log.die("pacman path '#{path}' doesn't exist") unless Dir.exist?(path)
+    Log.die("pacman sysroot '#{sysroot}' doesn't exist") unless Dir.exist?(sysroot)
+    Log.die("pacman config file '#{config}' doesn't exist") unless File.exist?(config)
+
+    # Update the given pacman config file to use the given path
+    FileUtils.rm_rf(File.join(path, '.'))
+    FileUtils.cp(config, path, preserve: true)
+    
+    Sys.exec("cp -a #{@pacman_src_mirrors} #{@pacman_path}")
+    Fedit.replace(@pacman_conf, /(Architecture = ).*/, "\\1#{@vars.arch}")
+    # Leave DBPath set as /var/lib/pacman and copy out sync
+    Fedit.replace(@pacman_conf, /#(CacheDir\s+= ).*/, "\\1#{File.join(@pacman_path, 'cache')}")
+    Fedit.replace(@pacman_conf, /#(LogFile\s+= ).*/, "\\1#{File.join(@pacman_path, 'pacman.log')}")
+    Fedit.replace(@pacman_conf, /#(GPGDir\s+= ).*/, "\\1#{File.join(@pacman_path, 'gnupg')}")
+    Fedit.replace(@pacman_conf, /#(HookDir\s+= ).*/, "\\1#{File.join(@pacman_path, 'hooks')}")
+    Fedit.replace(@pacman_conf, /.*(\/.*mirrorlist).*/, "Include = #{@pacman_path}\\1")
+
+    repos = Dir[File.join(@pacman_path, "*.mirrorlist")].map{|x| File.basename(x, '.mirrorlist')}
+    Sys.exec("pacman-key --config #{@pacman_conf} --init")
+    Sys.exec("pacman-key --config #{@pacman_conf} --populate #{repos * ' '}")
+
+    # Initialize pacman keyring
+    #Sys.exec("pacman-key --config #{self.config} --init")
+    #Sys.exec("pacman-key --config #{self.config} --populate #{repos * ' '}")
+  end
+
+  # Update the pacman database
+  def update
+    success = false
+    while not success
+      begin
+        cmd = "pacman -Sy"
+        cmd += " --sysroot #{self.sysroot}" if self.sysroot
+        Sys.exec(cmd)
+        success = true
+      rescue Exception => e
+        puts(e.message)
+      end
+    end
+  end
+
+  # Install the given packages
+  # @param pkgs [Array] List of packages to install
+  def install()
+    puts("Pacstrap package installs for '#{deployment}'...".colorize(:cyan))
+    cmd = ['pacstrap', '-GMc', deployment_work, '--config', @pacman_conf, '--needed', *apps[:reg]]
+    cmd += ['--ignore', apps[:ignore] * ','] if apps[:ignore].any?
+    !puts("Error: Failed to install packages correctly".colorize(:red)) and
+      exit unless Sys.exec(cmd, env:@proxyenv)
+  end
+end
+
+# vim: ft=ruby:ts=2:sw=2:sts=2

data/lib/nub/sys.rb

@@ -107,19 +107,6 @@ module Sys
     return pass
   end
 
-  # Update pacman database
-  def pacman_update
-    success = false
-    while not success
-      begin
-        Sys.exec("pacman -Sy")
-        success = true
-      rescue Exception => e
-        puts(e.message)
-      end
-    end
-  end
-
   # Remove given dir or file
   # Params:
   # +path+:: path to delete

data/lib/nub.rb

@@ -30,6 +30,7 @@ module Nub
   require 'nub/log'
   require 'nub/module'
   require 'nub/net'
+  require 'nub/pacman'
   require 'nub/thread_comm'
   require 'nub/user'
   require 'nub/sys'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nub
 version: !ruby/object:Gem::Version
-  version: 0.0.75
+  version: 0.0.76
 platform: ruby
 authors:
 - Patrick Crummett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-11 00:00:00.000000000 Z
+date: 2018-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -97,6 +97,7 @@ files:
 - lib/nub/log.rb
 - lib/nub/module.rb
 - lib/nub/net.rb
+- lib/nub/pacman.rb
 - lib/nub/sys.rb
 - lib/nub/thread_comm.rb
 - lib/nub/user.rb