litbuild 1.0.1

data/lib/litbuild/logfile_namer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Litbuild
+  class LogfileNamer
+    def initialize(log_dir)
+      @log_dir = log_dir
+      @counter = 0
+    end
+
+    def path_for(blueprint, phase = nil, stage = nil)
+      count = format('%03d', @counter)
+      @counter += 1
+      file_name = build_name(count, blueprint, phase, stage)
+      File.join(@log_dir, file_name)
+    end
+
+    protected
+
+    def build_name(*elements)
+      elements.uniq.compact.join('-') + '.log'
+    end
+  end
+end

data/lib/litbuild/multi_part_visitor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'litbuild/errors'
+require 'litbuild/visitor'
+
+module Litbuild
+  ##
+  # This is a base class for Visitors that can be sent to multiple Parts
+  # and/or Appendices. It is appropriate for Visitors like
+  # AsciiDocVisitors.
+  class MultiPartVisitor < Visitor
+    def initialize(directory:)
+      super
+      @other_parts = []
+      @appendices = []
+    end
+
+    def visit_part(part)
+      @other_parts << part.name
+      part.accept(visitor: self)
+    end
+
+    # We need to call some methods on the appendix blueprint, so we
+    # store the entire appendix rather than just the name.
+    def visit_appendix(appendix)
+      @appendices << appendix
+      appendix.accept(visitor: self)
+    end
+
+    protected
+
+    attr_reader :other_parts
+    attr_reader :appendices
+  end
+end

data/lib/litbuild/narrative.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'litbuild/blueprint'
+
+module Litbuild
+  class Narrative < Blueprint
+    def self.directory_name
+      'narratives'
+    end
+
+    def accept(visitor:)
+      super
+      visitor.visit_narrative(narrative: self)
+    end
+  end
+end

data/lib/litbuild/package.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'litbuild/blueprint'
+
+module Litbuild
+  class Package < Blueprint
+    BUILD_STAGES = %w[configure compile test install].freeze
+    STAGE_DIRECTIVES = BUILD_STAGES.map { |stg| "#{stg}-commands" }.freeze
+    STAGE_DEFAULTS = { 'configure-commands' => './configure --prefix=/usr',
+                       'compile-commands' => 'make',
+                       'test-commands' => 'make check',
+                       'install-commands' => 'make install' }.freeze
+    NONE = '(none)'
+
+    def self.directory_name
+      'packages'
+    end
+
+    def initialize(text:)
+      super
+      if phases?
+        phases.each do |p|
+          synthesize_default_commands(@phase_directives[p], @phase_grafs[p])
+        end
+      else
+        synthesize_default_commands(@base_directives, @base_grafs)
+      end
+    end
+
+    def accept(visitor:)
+      super
+      visitor.visit_package(package: self)
+    end
+
+    def version
+      self['version'].first
+    end
+
+    def tar_files_needed
+      ["#{name_and_version}.tar"] + in_tree_packages
+    end
+
+    def in_tree
+      in_tree_files = self['in-tree-sources'] || []
+      in_tree_files.map(&:split)
+    end
+
+    def in_tree_packages
+      in_tree.map { |name, version, _path| "#{name}-#{version}.tar" }
+    end
+
+    def patch_files
+      patches = self['patches'] || []
+      patches.map { |basename| "#{name_and_version}-#{basename}.patch" }
+    end
+
+    def build_dir
+      value('build-dir')
+    end
+
+    def name_and_version
+      "#{name}-#{version}"
+    end
+
+    def build_commands(stage)
+      commands = directives["#{stage}-commands"]
+      return [] if commands == [NONE]
+
+      commands
+    end
+
+    def pkgusr_name
+      value('package-user')['name'].first
+    end
+
+    def header_text
+      name
+    end
+
+    ##
+    # Return the URL directive of the specified type, or `(unknown)` if
+    # there is none.
+    def url(url_type)
+      directives["#{url_type}-url"]&.first || '(unknown)'
+    end
+
+    private
+
+    # This is called from the constructor, be careful if modifying it.
+    def synthesize_default_commands(directives, grafs)
+      to_add = {}
+      STAGE_DIRECTIVES.each do |sdir|
+        unless directives.include?(sdir)
+          directives[sdir] = [STAGE_DEFAULTS[sdir]]
+          to_add[sdir] = [STAGE_DEFAULTS[sdir]]
+        end
+      end
+      add_to_narrative(grafs, to_add) unless to_add.empty?
+    end
+
+    # We have default commands to add to the narrative. Where do they
+    # go?
+    #
+    # The logic here is a little thorny (see comments embeddeed in this
+    # method for a description). For any occasion where it does not have
+    # a pleasing result, the blueprint can simply be written to have
+    # explicit directives rather than using defaults.
+    def add_to_narrative(grafs, to_add)
+      # *install* always goes at the end.
+      stages_to_consider = STAGE_DIRECTIVES.reverse
+      stg = stages_to_consider.shift
+      grafs << { stg => to_add[stg] } if to_add.key?(stg)
+
+      # For other stages...
+      until stages_to_consider.empty?
+        stg = stages_to_consider.shift
+        next unless to_add.key?(stg)
+
+        # if there is a previous stage *and* directives for that stage
+        # are present in the narrative, the default version goes right
+        # *after* the *last* of those directives;
+        previous_stage = stages_to_consider[0]
+        if previous_stage
+          last_idx = grafs.rindex do |graf|
+            graf.respond_to?(:key) && graf.key?(previous_stage)
+          end
+          if last_idx
+            grafs.insert(last_idx + 1, stg => to_add[stg])
+            next
+          end
+        end
+
+        # otherwise, the default version goes right *before* the *first
+        # directive of the next stage* (which will always be present).
+        next_stage = STAGE_DIRECTIVES[STAGE_DIRECTIVES.index(stg) + 1]
+        first_idx = grafs.index do |graf|
+          graf.respond_to?(:key) && graf.key?(next_stage)
+        end
+        grafs.insert(first_idx, stg => to_add[stg])
+      end
+    end
+  end
+end

data/lib/litbuild/section.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'litbuild/blueprint'
+require 'litbuild/errors'
+require 'litbuild/multi_part_visitor'
+
+module Litbuild
+  class Section < Blueprint
+    def self.directory_name
+      'sections'
+    end
+
+    def accept(visitor:)
+      super
+      visitor.in_subdirectory(name) do
+        components.each do |bp|
+          bp.accept(visitor: visitor)
+        end
+      end
+      visitor.visit_section(section: self)
+      return unless visitor.is_a?(MultiPartVisitor)
+
+      self['other-parts']&.each do |part|
+        part_bp = @bp_library.blueprint_for(target: part)
+        visitor.visit_part(part_bp)
+      end
+      self['appendices']&.each do |app|
+        app_bp = @bp_library.blueprint_for(target: app)
+        visitor.visit_appendix(app_bp)
+      end
+    end
+
+    def components
+      return @components if @components
+
+      blueprints = self['blueprints'].clone || []
+      if $DEBUG
+        warn("Explicit blueprints for section #{name}:" \
+             " #{blueprints.join(', ')}")
+      end
+      blueprints << automatic_inclusions
+      deduped = blueprints.flatten.uniq
+      @components = deduped.map do |bp|
+        @bp_library.blueprint_for(target: bp)
+      end
+      @components
+    end
+
+    def automatic_inclusions
+      auto_adds = []
+      @bp_library.blueprints.each_value do |bp|
+        if bp.phases.include?(name)
+          auto_adds << "#{bp.name}::#{name}"
+        elsif bp['in-section']&.include?(name)
+          auto_adds << bp.name
+        end
+      end
+      if $DEBUG
+        warn("Automatically-added blueprints for section #{name}:" \
+             " #{auto_adds.sort.join(', ')}")
+      end
+      auto_adds.sort
+    end
+
+    def success_line
+      'HUGE SUCCESS'
+    end
+
+    def failure_line
+      'DISMAL FAILURE'
+    end
+  end
+end

data/lib/litbuild/service_dir.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Litbuild
+  # Service definition directories are a bit complicated. This is just
+  # a helper class that knows how to deal with them.
+  class ServiceDir
+    def initialize(svcdef)
+      @svcdef = svcdef
+    end
+
+    def name
+      @svcdef['name'].first
+    end
+
+    def bundle
+      @svcdef['bundle']&.first
+    end
+
+    def type
+      return @svcdef['type'].first if @svcdef.key?('type')
+      return 'longrun' if @svcdef.key?('run')
+      return 'oneshot' if @svcdef.key?('up')
+
+      raise(InvalidDirective, "servicedir #{name} must specify type")
+    end
+
+    def oneline_files
+      file_contents = { 'type' => type }
+      %w[down-signal notification-fd].each do |fn|
+        file_contents[fn] = @svcdef[fn].first if @svcdef.key?(fn)
+      end
+      file_contents
+    end
+
+    def dependencies
+      @svcdef['dependencies'] || []
+    end
+
+    def multiline_files
+      file_contents = {}
+      %w[up down run].each do |fn|
+        next unless @svcdef.key?(fn)
+
+        file_contents[fn] = @svcdef[fn]
+      end
+      file_contents
+    end
+
+    def env
+      return [] unless @svcdef.key?('env')
+
+      flattened = {}
+      @svcdef['env'].first.each do |variable, value|
+        flattened[variable] = value.first
+      end
+      flattened
+    end
+  end
+end

data/lib/litbuild/source_code_manager.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'litbuild/errors'
+
+module Litbuild
+  ##
+  # Find all of the tar files and patch files, possibly compressed,
+  # present in any of the directories passed to the constructor or any
+  # direct subdirectories of those directories. Given a package
+  # blueprint, provide suitable commands to unpack tar files and in-tree
+  # source tarfiles, apply patch files, or copy those files to a package
+  # user home directory.
+  #
+  # Note, SourceCodeManager does not recurse into additional levels of
+  # subdirectories -- it turns out that makes the test suite really
+  # slow.
+  class SourceCodeManager
+    def initialize(*dirs)
+      all_pkgfiles = dirs.map do |d|
+        Dir.glob("#{d}/*.tar*") +
+          Dir.glob("#{d}/*/*.tar*") +
+          Dir.glob("#{d}/*.patch*") +
+          Dir.glob("#{d}/*/*.patch*")
+      end.flatten
+      abs_paths = all_pkgfiles.map { |f| File.expand_path(f) }
+      @available_files = abs_paths.sort.uniq
+    end
+
+    def untar_command_for(package)
+      unpack_tar(package.name_and_version)
+    end
+
+    def intree_untar_commands_for(package)
+      commands = []
+      package.in_tree.each do |basename, version, path|
+        intree = "#{basename}-#{version}"
+        commands << unpack_tar(intree)
+        if path
+          commands << "mkdir -p #{File.dirname(path)}"
+          commands << "mv #{intree} #{path}"
+        else
+          commands << "mv #{intree} #{basename}"
+        end
+      end
+      commands
+    end
+
+    def patch_commands_for(package)
+      return [] unless package.patch_files
+
+      package.patch_files.map do |patch_file|
+        full_fn = find_file(patch_file)
+        "#{decompress_command(full_fn)} < #{full_fn} | patch -p1"
+      end
+    end
+
+    ##
+    # Package Users expect to have tarfiles for the top-level package
+    # and any in-tree packages in their `src` directory, and patches in
+    # their `patches` directory. This produces commands that copy needed
+    # files from the TARFILE_DIR and PATCH_DIR to those directories, if
+    # not already present there.
+    def copy_source_files_commands(package)
+      pkgusr = pkgusr_name(package)
+      mkdir_commands = %w[src patches].map do |dir|
+        "mkdir -p ~#{pkgusr}/#{dir}"
+      end
+      copy_commands = []
+      package.tar_files_needed.each do |filename|
+        unless pkgusr_file_available?(package, filename)
+          copy_commands << "cp #{find_tarfile(filename)} ~#{pkgusr}/src"
+        end
+      end
+      package.patch_files.each do |filename|
+        unless pkgusr_file_available?(package, filename)
+          copy_commands << "cp #{find_file(filename)} ~#{pkgusr}/patches"
+        end
+      end
+      mkdir_commands + copy_commands.sort
+    end
+
+    private
+
+    def pkgusr_file_available?(package, filename)
+      pkghome = homedir(package)
+      return false unless pkghome
+
+      dir = filename.match?(/.tar$/) ? 'src' : 'patches'
+      possible_names = DECOMPRESSORS.keys.map { |ext| "#{filename}.#{ext}" }
+      possible_names << filename
+      possible_names.any? { |f| File.exist?(File.join(pkghome, dir, f)) }
+    end
+
+    def find_file(filename)
+      @available_files.detect { |f| /#{filename}/ =~ f } ||
+        raise(Litbuild::MissingSource,
+              "File #{filename} is needed but not available.")
+    end
+
+    def find_tarfile(filename)
+      filename = "#{filename}.tar" unless filename.end_with?('.tar')
+      find_file(filename)
+    end
+
+    def unpack_tar(basename)
+      tarfile = find_tarfile(basename)
+      decompress_opt = tar_decompress_opt(tarfile)
+      "tar -x #{decompress_opt} -f #{tarfile}"
+    end
+
+    DECOMPRESSORS = { 'gz' => 'gzip', 'bz2' => 'bzip2', 'lzma' => 'lzma',
+                      'lz' => 'lzip', 'xz' => 'xz' }.freeze
+
+    def decompressor_for_file(file)
+      ext = DECOMPRESSORS.keys.find { |e| file =~ /#{e}$/ }
+      ext ? DECOMPRESSORS[ext] : nil
+    end
+
+    def decompress_command(filename)
+      decompressor = decompressor_for_file(filename)
+      decompressor ? "#{decompressor} -d" : 'cat'
+    end
+
+    def tar_decompress_opt(tarfile)
+      decompressor = decompressor_for_file(tarfile)
+      decompressor ? "--use-compress-program=#{decompressor}" : ''
+    end
+
+    def pkgusr_name(package)
+      pkgusr = package['package-user'].first
+      name = pkgusr['name'].first
+      raise(InvalidDirective, 'package-user missing name') unless name
+
+      name
+    end
+
+    def homedir(package)
+      Dir.home(pkgusr_name(package))
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/litbuild/source_files_visitor.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: false
+
+require 'litbuild/visitor'
+
+module Litbuild
+  # This is a simple Visitor that just accumulates the files needed to
+  # build a set of Pacakge blueprints.
+  class SourceFilesVisitor < Visitor
+    def initialize
+      super
+      @files = []
+    end
+
+    def visit_package(package:)
+      @files << files_needed(package)
+    end
+
+    def files_needed(pkg)
+      ["#{pkg.name_and_version}.tar"] + pkg.patch_files + pkg.in_tree_packages
+    end
+
+    def files
+      @files.compact.flatten.sort.uniq
+    end
+  end
+end

data/lib/litbuild/url_visitor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: false
+
+require 'litbuild/visitor'
+
+module Litbuild
+  # This is a simple Visitor that just accumulates the best download URL
+  # for a set of Package blueprints.
+  class UrlVisitor < Visitor
+    def initialize
+      super
+      @urls = []
+    end
+
+    def visit_package(package:)
+      @urls << download_url(package)
+    end
+
+    def download_url(pkg)
+      url = pkg.directives['download-url'] ||
+            pkg.directives['project-url'] ||
+            pkg.directives['scm-url']
+      url ? url.first : "#{name}: no download URL known"
+    end
+
+    def urls
+      @urls.compact.flatten.sort.uniq
+    end
+  end
+end

data/lib/litbuild/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Litbuild
+  VERSION = '1.0.1'
+end

data/lib/litbuild/visitor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: false
+
+module Litbuild
+  ##
+  # This is the base class for Litubild Visitors; it defines a
+  # no-operation Visitor. Each Visitor subclass encapsulates one of the
+  # operations that can be performed on a Blueprint along with its
+  # dependencies and components (and along with the dependencies and
+  # components of those Blueprints and so on).
+  class Visitor
+    # The main Visitor classes (bash script, asciidoc) write files to
+    # specific directories, and need to be able to switch to
+    # subdirectories tmeporarily; so Litbuild::Visitor has some
+    # functionality to support that.
+    #
+    # The default '/' value is just to avoid nil checking for Visitors
+    # that don't need this feature.
+    def initialize(directory: '/')
+      @dir_stack = [directory]
+    end
+
+    def in_subdirectory(subdir)
+      @dir_stack.push(File.join(cwd, subdir))
+      yield
+      @dir_stack.pop
+    end
+
+    def visit_commands(commands:); end
+
+    def visit_narrative(narrative:); end
+
+    def visit_package(package:); end
+
+    def visit_section(section:); end
+
+    protected
+
+    def cwd
+      @dir_stack.last
+    end
+  end
+end

data/lib/litbuild.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'litbuild/blueprint'
+require 'litbuild/blueprint_library'
+require 'litbuild/blueprint_parser'
+require 'litbuild/commands'
+require 'litbuild/driver'
+require 'litbuild/errors'
+require 'litbuild/logfile_namer'
+require 'litbuild/narrative'
+require 'litbuild/package'
+require 'litbuild/section'
+require 'litbuild/source_files_visitor'
+require 'litbuild/url_visitor'
+require 'litbuild/version'
+require 'litbuild/visitor'