beaver-build 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ace78ab68116b7ea0748f4afd8afa6fc5a7419dce452b2eac63c8f5f88a2e383
-  data.tar.gz: '09ca079efe80ff36931176d874020ef987fd2ec645136bb56c10f410f59223f1'
+  metadata.gz: aa3e53273d2fd49984ac532f522eefad45a60b53ed8ee79e8f8ca4db819f43b9
+  data.tar.gz: 37b8f8c9e771c9f265096fa9adddc935f77d2592250a15ade2daf6b19a24fe17
 SHA512:
-  metadata.gz: 0acc179794281ac8c06f63ec953ccbf08f5ae80bc248657bb20d80844dd344c6295fae2c5d6cf4ee15a4444f5932e42f004bd94f2190a406d62de8f9790e2f04
-  data.tar.gz: d01832c2d0ee507f5a716459e97c4920ac30411d92c0796366aa15f0035d5709ab8e4ad58bccde0a1caf46f0dab3c492a4f17696a9b4663ff4680832749a8484
+  metadata.gz: 6190cb42ae9716e86244ee74a0959bb6fd48b0c7b2a4e45e40585583bec89259044948ce21efe7fabefec41256cdab3b502e745fdc0ddd77b484b301a3e5e522
+  data.tar.gz: '00930de6654e5ea1db3769a59d38d6602b6d50c70cc2e6623968b35007134895f2dab9781c98fbfe880beb9b2593e077b35bfdd05963a4fde7a1ce216c18d875'

data/lib/beaver.rb

@@ -1,38 +1,61 @@
 require 'fileutils'
 
-# Export functions
-require 'file_change'
-require 'file_exists'
-require 'command'
-require 'alias'
-
 class Beaver
-  # The location where Beaver caches
+  # The location where beaver stores its info about files, etc
   attr_accessor :cache_loc
-  
-  # Initializer should not be used outside of this module
+  # whether the current terminal supports 256 color support
+  attr_accessor :term_256_color
+  attr_accessor :opts
+
+  # Initialize functon should not be used by build scripts
   def initialize
     # Contains all commands
-    # [commandName: String => command: Function]
+    # { CommandName: Symbol => command: Command }
     @commands = Hash.new
-    # Contains the main command name
+    # Name of the main command
     @mainCommand = nil
     @cache_loc = "./.beaver"
+    unless Dir.exist? @cache_loc
+      Dir.mkdir @cache_loc
+    end
+    @term_256_color = `echo $TERM`.include? "256color"
+    @opts = []
   end
-  
-  # Appends a command to the global beaver
-  def __appendCommand(name, func)
-    if @commands.size == 0
-      @mainCommand = name.to_sym
+
+  def file_cache_file
+    file_loc = File.join(@cache_loc, "files.info")
+    unless File.exist? file_loc
+      FileUtils.touch file_loc
     end
-    
-    @commands[name.to_sym] = func
+    return file_loc
   end
-  
-  def __appendCommandCB(name, &func)
-    self.__appendCommand(name, func)
+
+  # Set an option
+  # :e = exit on non-zero exit code of `sh` execution
+  def set(opt)
+    @opts << opt.to_sym
+  end
+
+  # Check if an option is present
+  def has(opt)
+    @opts.include? opt
+  end
+
+  # Remove an option
+  def rm(opt)
+    @opts.delete opt
+  end
+
+  # Append a command to the global beaver object
+  # - cmd: Command
+  def __appendCommand(cmd)
+    if @commands.size == 0
+      @mainCommand = cmd.name
+    end
+
+    @commands[cmd.name] = cmd
   end
-  
+
   # Call a command
   def call(cmd)
     _cmd = @commands[cmd.to_sym]
@@ -40,21 +63,35 @@ class Beaver
       puts "No command called #{cmd} found"
       exit 1
     end
-    
+
     _cmd.call
   end
-  
+
   # Put this at the end of a file
   def end
+    $cache = CacheManager.new # load cache file
+    
     command = ARGV[0] || @mainCommand
     self.call command
+
+    $cache.save # save cache file
   end
-  
-  # Clean beaver
+
+  # Clean cache
   def clean
     FileUtils.rm_r @cache_loc
   end
 end
 
-# Global beaver object
 $beaver = Beaver.new
+
+# Export functions
+require 'command'
+require 'file'
+require 'file_dep'
+require 'sh'
+
+# Call a command
+def call(cmd)
+  $beaver.call cmd
+end

data/lib/command.rb

@@ -1,105 +1,76 @@
-require 'pathname'
-require 'file_matches'
+require 'file.rb'
 
-# register a new beaver command
-#
-# - Possible combinations
-# Register a normal command
-#   command :name do end
-# Register a command that executes if a source file changed, or the target file does not exist (one target file per source file)
-#   command :name, src: "", target_dir: "", target_ext: "", do end
-# Register a command that executes if a source file changed, or the single target file does not exist (multiple sources into one target file)
-# The callback will receive a files variables, which is a string containing all paths, separated by spaces
-#   command :name, src: "", target: "" do end
-def command(name, src:nil, target_dir:nil, target_ext:nil, target:nil, &func)
-  if !src.nil? && !target_dir.nil? && !target_ext.nil?
-    _command_oto name, src:src, target_dir:target_dir, target_ext:target_ext do |src, trg|
-      func.call src, trg
+class Command
+  attr_accessor :name
+  attr_accessor :fn
+
+  def initialize(name, file_deps, fn)
+    @name = name
+    # When one of these files changes, the command should rerun
+    # Type: FileDep, or nil
+    @file_deps = file_deps
+    @fn = fn
+  end
+
+  # Execute the command if needed (dependency files changed)
+  def call
+    if self.should_run?
+      self.call_now()
     end
-  elsif !src.nil? && !target.nil?
-      _command_mto name, src:src, target:target do |files, target|
-        func.call files, target
+  end
+
+  # Force call the command, even if none of the files changed
+  def call_now
+    $file = nil
+    $files = nil
+    if @file_deps.type == :each
+      @file_deps.files.each do |file_obj|
+        $file = file_obj
+        @fn.call()
       end
-  else
-    _command name do ||
-      func.call
+    else
+      $files = @file_deps.files
+      @fn.call()
     end
   end
-end
 
-# Register a new beaver command
-def _command(name, &func)
-  $beaver.__appendCommand(name, func)
-end
+  # Returns wheter the command should run, meaning if any of the depency
+  # files changed
+  def should_run?
+    if changed? "__BEAVER__CONFIG__", $PROGRAM_NAME
+      # Ruby script itself changed
+      # TODO: does not account for dependencies of the script (probably uncommon though)
 
-# Defines a dependency from source file to target file
-OneWayDependency = Struct.new(:src, :target)
+      # Clear cache, because the config failed
+      reset_cache
 
-# - Example:
-# ```ruby
-# command_oto :command_name, src: "src/**/*.c", target_dir: "build", target_ext: ".o" do |source_file, target_file|
-# 
-# end
-# ```
-def _command_oto(name, src: nil, target_dir: nil, target_ext: nil, &func)
-  $beaver.__appendCommandCB name do
-    src_files = get_matches(src)
-    
-    abs_cd = File.dirname(File.expand_path($0))
-    
-    # Contains all files with (source and target)
-    files = []
-    src_files.each do |srcfile|
-      file_name = File.basename(srcfile, ".*")
-      
-      # path of the source file relative to the current directory
-      path_ext = File.dirname(
-        Pathname.new(File.expand_path(srcfile))
-          .relative_path_from(abs_cd)
-      )
+      unless @file_deps.nil?
+        @file_deps.each_file do |file|
+          $cache.files.add(@name, file)
+        end
+      end
       
-      files << OneWayDependency.new(
-        srcfile,
-        File.join(target_dir, path_ext, "#{file_name}#{target_ext}")
-      )
+      return true
     end
     
-    for file in files
-      should_execute = false
-      if file_changed?(file.src)
-        # If source file has changed, then the function should be called
-        should_execute = true
-      elsif !File.file?(file.target)
-        # If the target file does not exist, then the function should be called
-        should_execute = true
-      elsif __beaver_file_changed?
-        # If the beaver config file changed, then the function should be called
-        should_execute = true
+    if @file_deps.nil?
+      return true
+    end
+
+    changed = false
+    @file_deps.each_file do |file|
+      if !changed && (changed? @name, file)
+        changed = true
       end
-    
-      if should_execute
-        func.call file.src, file.target
-      end      
+      
+      $cache.files.add(@name, file)
     end
+
+    return changed
   end
 end
 
-
-def _command_mto(name, src:nil, target:nil, &func)
-  $beaver.__appendCommandCB name do
-    should_execute = false
-    
-    if_any_changed src do |_|
-      should_execute = true
-    end
-    
-    if !File.file?(target)
-      should_execute = true
-    end
-    
-    if should_execute
-      src_files = get_matches(src)
-      func.call src_files.join(" "), target
-    end
-  end
+def cmd(name, deps = nil, &fn)
+  cmd = Command.new name, deps, fn
+  $beaver.__appendCommand cmd
 end

data/lib/file.rb

@@ -0,0 +1,112 @@
+#########
+# Cache #
+#########
+
+require 'msgpack'
+
+FileInfo = Struct.new(:modified)
+
+# - file_info: { command => file_name => file_info }
+Files = Struct.new(:commands) do
+  # returns the modified date of the file, or nil if it is not yet known
+  def modified(cmd, file)
+    files_info = commands[cmd.to_s]
+    if files_info.nil?
+      return nil
+    end
+    fi = files_info[file]
+    if fi.nil?
+      nil
+    else
+      fi.modified
+    end
+  end
+
+  def add(cmd, path)
+    files_info = commands[cmd.to_s]
+    if files_info.nil?
+      commands[cmd.to_s] = Hash.new
+      files_info = commands[cmd.to_s]
+    end
+    files_info[path] = FileInfo.new(
+      File.mtime(path).to_i # modified date as unix time stamp
+    )
+  end
+end
+
+MessagePack::DefaultFactory.register_type(
+      0x01,
+      Files,
+      packer: ->(files, packer) {
+        packer.write(files.commands)
+      },
+      unpacker: ->(unpacker) {
+        Files.new(unpacker.read)
+      },
+      recursive: true,
+)
+
+MessagePack::DefaultFactory.register_type(
+      0x02,
+      FileInfo,
+      packer: ->(fi, packer) {
+        packer.write(fi.modified)
+      },
+      unpacker: ->(unpacker) {
+        FileInfo.new(unpacker.read)
+      },
+      recursive: true
+)
+
+# f = Files.new(Hash.new)
+# f.add("lib/beaver.rb")
+# pack = msg = MessagePack.pack(f)
+# p pack
+# p MessagePack::unpack(pack)
+
+class CacheManager
+  attr_accessor :files
+  
+  def initialize
+    begin
+      @files = MessagePack::unpack(File.read $beaver.file_cache_file)
+    rescue EOFError
+      @files = Files.new(Hash.new)
+      @files.add("__BEAVER__CONFIG__", $PROGRAM_NAME)
+    end
+  end
+
+  def save
+    packed = MessagePack.pack(@files)
+    File.binwrite($beaver.file_cache_file, packed)
+  end
+end
+
+$cache = nil # will be initialized in `$beaver.end`, so that all settings are applied first
+
+def reset_cache
+  $cache.files = Files.new(Hash.new)
+  $cache.files.add("__BEAVER__CONFIG__", $PROGRAM_NAME)
+end
+
+##############
+# File utils #
+##############
+
+# Returns wether a file has changed
+# Also returns true if no information about file changes is found
+def changed? cmd_ctx, file
+  cached_modified = $cache.files.modified cmd_ctx, file
+
+  if cached_modified.nil?
+    # probably new file
+    return true
+  end
+  
+  last_modified = File.mtime(file).to_i
+  if cached_modified < last_modified
+    return true
+  else
+    return false
+  end
+end

data/lib/file_dep.rb

@@ -0,0 +1,87 @@
+require 'file_obj'
+
+# File dependencies for commands
+class FileDep
+  attr_accessor :type
+  
+  def initialize(glob, type)
+    # Can be a string like "main.c" or "src/*.c", or an array like
+    # ["src/main.c", "src/lib/*.c"]
+    @glob = glob
+    # :each or :all
+    @type = type
+    # SingleFile, or MultiFile
+    @file_obj = nil
+  end
+
+  # Run fn for each file, passing the file name to fn
+  def each_file(&fn)
+    # Check if already a file object collected
+    if !@file_obj.nil?
+      if @type == :each
+        # @file_obj = []SingleFile
+        @file_obj.each do |file_o|
+          fn.call(file_o.path)
+        end
+      else
+        # @file_obj = MultiFiles
+        @file_obj.each do |file|
+          fn.call(file)
+        end
+      end
+
+      return
+    end
+
+    # Collect the file object
+    
+    # initialize files as an empty array. This will contain full paths to
+    # files, which well then be put into @file_obj as either a []SingleFile
+    # or MultiFiles
+    files = []
+    
+    globs = nil
+    if @glob.respond_to? :each
+      # array
+      globs = glob
+    else
+      # string
+      globs = [@glob]
+    end
+
+    globs.each do |glob|
+      Dir[glob].each do |file|
+        fn.call(file)
+        files << file
+      end
+    end
+
+    # set the @file_obj
+    if @type == :each
+      @file_obj = files.map { |file| SingleFile.new file }
+    else
+      @file_obj = MultiFiles.new files
+    end
+  end
+
+  # retuns the file/files object(s)
+  # will return either []SingleFile or MultiFiles
+  def files
+    if @file_obj.nil?
+      # Collect file_obj first
+      self.each_file { |f| }
+    end
+
+    return @file_obj
+  end
+end
+
+# Command will be called for each file
+def each(dep)
+  return FileDep.new dep, :each
+end
+
+# Command will be called for all files at once
+def all(dep)
+  return FileDep.new dep, :all
+end

data/lib/file_obj.rb

@@ -0,0 +1,89 @@
+# Global file objects $file and $files
+
+class SingleFile
+  # Full file path e.g. "src/main.c"
+  attr_accessor :path
+
+  def initialize(path)
+    @path = path
+  end
+
+  # the name of the file, without extension
+  def name
+    File.basename(@path, ".*")
+  end
+
+  # the file name and extension
+  def full_name
+    File.basename(@path)
+  end
+
+  # the file extension
+  def ext
+    File.extname(@path)
+  end
+
+  # the directory of the file e.g. if the file is "src/main.c", dir will be
+  # "src"
+  def dir
+    File.dirname(@path)
+  end
+
+  # will return path
+  def to_s
+    @path
+  end
+end
+
+class MultiFiles
+  # an array of file paths
+  attr_accessor :paths
+
+  def initialize(paths)
+    @paths = paths
+  end
+
+  # an array of all file names, without extensions
+  def names
+    @paths.map { |p| File.basename(p, ".*") }
+  end
+
+  # all file names, including their extensions
+  def full_names
+    @paths.map { |p| File.basename(p) }
+  end
+
+  # all file extensions
+  # 
+  # For a list of all unique extensions, use `$files.exts.uniq`
+  def exts
+    @paths.map { |p| File.extname(p) }
+  end
+
+  # all directories
+  #
+  # For a list of all unique directories, use `$files.dir.uniq`
+  def dir
+    @paths.map { |p| File.dirname(p) }
+  end
+
+  # loop over each file
+  def each(&f)
+    @paths.each do |p|
+      f.call(p)
+    end
+  end
+
+  # will return a space separated list of files, surrounded with quotes
+  def to_s
+    @paths.inject("") { |list, elem| list + " \"#{elem}\"" }.strip
+  end
+end
+
+$file = nil
+$files = nil
+
+# Shorthand for using `$file` or `$files`
+# def $f
+#   return $file || $files
+# end

data/lib/sh.rb

@@ -0,0 +1,43 @@
+# Shell commands
+
+# Execute shell command
+def sh(strcmd)
+  unless strcmd.is_a?(SilentCommand) || strcmd.is_a?(SilentAll) then
+    if $beaver.term_256_color
+      puts "\u001b[38;5;246m#{strcmd}\u001b[0m"
+    else
+      puts "\u001b[30;1m#{strcmd}\u001b[0m"
+    end
+  end
+
+  if strcmd.is_a? SilentAll
+    `#{strcmd}`
+  else
+    puts `#{strcmd}`
+  end
+
+  if $beaver.has(:e)
+    exit($?.exitstatus) if $?.exitstatus != 0
+  end
+end
+
+SilentCommand = Struct.new(:strcmd) do
+  def to_s
+    strcmd
+  end
+end
+SilentAll = Struct.new(:strcmd) do
+  def to_s
+    strcmd
+  end
+end
+
+# Do not print the command
+def silent(strcmd)
+  return SilentCommand.new(strcmd)
+end
+
+# Do not print the command, or the output of the command
+def full_silent(strcmd)
+  return SilentAll.new(strcmd)
+end

data/lib/util.rb

@@ -0,0 +1,2 @@
+# TODO: OS = uname
+# ARCH = uname -m

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: beaver-build
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jonas Everaert
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-16 00:00:00.000000000 Z
-dependencies: []
+date: 2023-01-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 description: |-
   Beaver is an easy to understand build tool with a lot of capabilities.
   Documentation and examples on [github](https://github.com/jomy10/beaver) (https://github.com/jomy10/beaver).
@@ -20,13 +34,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/beaver
-- lib/FileInfo.rb
-- lib/alias.rb
 - lib/beaver.rb
 - lib/command.rb
-- lib/file_change.rb
-- lib/file_exists.rb
-- lib/file_matches.rb
+- lib/file.rb
+- lib/file_dep.rb
+- lib/file_obj.rb
+- lib/sh.rb
+- lib/util.rb
 homepage: https://github.com/jomy10/beaver
 licenses:
 - MIT

data/lib/FileInfo.rb

@@ -1,51 +0,0 @@
-require 'json'
-require 'fileutils'
-
-# date: last modified
-FileInfo = Struct.new(:date)
-
-class FileInfoRW 
-  # file_loc = cache file location
-  # file_path = path of the file that represents the cache file
-  def initialize(file_loc, file_path)
-    @file_loc = file_loc
-    @file_path = file_path
-  end
-  
-  # Read the info file and write a new one if needed
-  # Report back if the file has changed
-  def file_has_changed?()
-    cache_file = File.open(@file_loc)
-    
-    file_info = JSON.parse(cache_file.read, object_class: OpenStruct)
-    last_modified = File.mtime(@file_path).to_i
-    if last_modified > file_info.date
-      json = self._json
-      File.write(@file_loc, json)
-      return true
-    else
-      return false
-    end
-  end
-  
-  # Create the cache file
-  def create_cache()
-    json = self._json
-
-    dirnames = File.dirname(@file_loc)
-    unless File.directory?(dirnames)
-      # Directories do not exist, create them
-      FileUtils.mkdir_p(dirnames)
-    end
-    
-    File.write(@file_loc, json)
-  end
-  
-  private
-  # FileInfo as json
-  def _json
-    return FileInfo.new(
-      File.mtime(@file_path).to_i
-    ).to_h.to_json
-  end
-end

data/lib/alias.rb

@@ -1,35 +0,0 @@
-# Aliases for default ruby commands for easier access by beaver users
-
-# Execute system command
-def §(cmd)
-  puts cmd
-  system cmd
-end
-
-# Execute system command
-def sys(cmd)
-  puts cmd
-  system cmd
-end
-
-String.prepend(Module.new do
-  # The directory a file resides in
-  def dirname
-    return File.dirname self
-  end
-  
-  # Basename of a file
-  def basename
-    return File.basename(self, ".*")
-  end
-  
-  # File's basename with extension
-  def basename_ext
-    return File.basenam self
-  end
-  
-  # The file's extension
-  def ext
-    return File.extname self
-  end
-end)

data/lib/file_change.rb

@@ -1,62 +0,0 @@
-require 'file_matches'
-require 'FileInfo'
-
-# Execute a function if the specified files have changed since last execution
-# Also executes the function if the config file has changed
-#
-# # Parameters
-# - files: either an array of files (or file patterns), or a file pattern as a string or regexp
-# - func: the body of the if statement
-def if_changed(files, &func)
-  matches = get_matches(files)
-  
-  # Execute for each match if either no cache exists, or
-  # if the cache indicates a older file version
-  matches.each do |file|
-    if file_changed?(file) || __beaver_file_changed?
-      func.call file
-    end
-  end
-end
-
-# Executes if any file changed
-# The callback receives a list of changed files
-def if_any_changed(files, &func)
-  changed_files = []
-  if_changed files do |file|
-      changed_files << file
-  end
-  
-  unless changed_files.empty?
-    func.call changed_files
-  end
-end
-
-# check if a single file has changed
-# returns true if it has been changed
-def file_changed?(file)
-  cache_file_loc = "#{$beaver.cache_loc}/#{file}.info"
-  info_rw = FileInfoRW.new(cache_file_loc, file)
-  if !File.file?(cache_file_loc)
-      # File does not exist, so create it and call the function
-      info_rw.create_cache()
-      
-      return true
-  else
-    # File exists, so read it
-    if info_rw.file_has_changed?
-      return true
-    else
-      return false
-    end
-  end
-end
-
-$__beaver_file = nil
-def __beaver_file_changed?
-  if $__beaver_file == nil
-    $__beaver_file = file_changed?($0)
-  end
-  
-  return $__beaver_file
-end

data/lib/file_exists.rb

@@ -1,22 +0,0 @@
-# Executes a function if a file exists, passing in the existing file
-def if_exists(files, &func)
-  files.each do |file|
-    if File.file?(file)
-      func.call file
-    end
-  end
-end
-
-# Executes a function if a file does not exists, passing in the non-existing file
-def if_not_exists(files, &func)
-  files.each do |file|
-    unless File.file?(file)
-      func.call file
-    end
-  end
-end
-
-# Executes a function if a file exists, passing in the existing file
-def unless_exists(files, &func)
-  if_not_exists(files, func)
-end

data/lib/file_matches.rb

@@ -1,26 +0,0 @@
-def get_matches(files)
-  # All file patterns to process
-  patterns_to_process = []
-  
-  # Check if array or string
-  if files.respond_to? :each
-    # is an array
-    patterns_to_process = file
-  else
-    patterns_to_process << files
-  end
-  
-  # Contains all files that match the expressions
-  matches = nil
-  
-  patterns_to_process.each do |pattern|
-    if pattern.is_a?(Regexp)
-      matches = Find.find("./").grep(pattern)
-    else
-      # is a string
-      matches = Dir.glob(pattern)
-    end
-  end
-  
-  return matches
-end