plover 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c02ad2ecd60c71f6183a2db31ba64dd0f15769cbf7774273913595dfb72ccd93
-  data.tar.gz: c6fb12369964a4aa2238ffde51d4675e5b716eae056e12311193bb3570ec204e
+  metadata.gz: b2984c4ea419b9a232a29d892175645cf91d464e2eaec36d7f48e0322d3590fa
+  data.tar.gz: 4ed6849a1ac93e65a6882e4a9031f6591db54bf8cf83318446401ac9acb20396
 SHA512:
-  metadata.gz: 15a087dd706ac377d6535956b9f62bb3a94e7811ce15c09e2a1b81ee3e79a2c25b26d495eedf5dd1a561e54b495d6c3867d9342a0d28ebbefc48fed7800c48b8
-  data.tar.gz: 7c8eee52f8818b246f1a57dd01947cb1ee398f12e92d0811559e0c3425ca93e5abfba0ecc2597c0dd091f74a48cf34feb7f159d43257f263c0b1eaab27c3d30b
+  metadata.gz: e0652cc353807d85f0696d52f9f2c09537d4b941a6faf7e1cdb62a63a5c997c508c0b038f1c741c85a72e9af8bb8bc07a8a3adb5453d4d0f4efcaa71d16d94fa
+  data.tar.gz: c61d1e4c31e95ce23022ca037a02ac646771c7d21208f9422397d37674483717b835fc929439006c5dcca4e7fd4f918a90bb282ab9e3981a55311a607d7e6015

data/README.md

@@ -10,7 +10,7 @@ To help you with that, Plover provides a lightweight DSL for defining build phas
 
 #### Tiny & Embeddable 
 
-Plover consists of ~200 lines of plain Ruby, with no dependencies outside of the standard library.
+Plover consists of ~300 lines of plain Ruby, with no dependencies outside of the standard library.
 
 Because Plover is built to be embeddable, you can copy/paste `lib/plover.rb` into your project if you'd rather not use the gem. 
 
@@ -47,7 +47,7 @@ Or, add it to your project’s Gemfile:
 gem "plover"
 ```
 
-Because Plover is built to be embeddable, you can also just copy/paste `lib/plover.rb` into your project if you'd rather not use RubyGems (it's ~200 lines of plain Ruby, with no dependencies outside of the standard library).
+Because Plover is built to be embeddable, you can also just copy/paste `lib/plover.rb` into your project if you'd rather not use RubyGems (it's ~300 lines of plain Ruby, with no dependencies outside of the standard library).
 
 ## Usage
 

data/lib/plover.rb

@@ -4,7 +4,7 @@ module Plover
   require "shellwords"
   require "fileutils"
 
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 
   class PloverError < StandardError; end
 
@@ -30,6 +30,46 @@ module Plover
     end
   end
 
+  module Log
+    require "logger"
+
+    def log(severity, msg)
+      logger.add(log_severity(severity), msg) unless log_config[:level] == :none
+    end
+
+    def log_level(severity)
+      log_config[:level] = severity
+      @logger = nil
+      logger.level = log_severity(log_config[:level])
+    end
+
+    def log_severity(severity = nil)
+      Logger::Severity.coerce(severity)
+    rescue
+      Logger::Severity.coerce(:unknown)
+    end
+
+    def logger
+      sink = case log_config[:sink]
+      when String
+        f = File.open(log_config[:sink], "a")
+        f.sync = true
+        f
+      when ->(s) { s.respond_to?(:write) }
+        log_config[:sink]
+      else $stdout
+      end
+
+      @logger ||= Logger.new(sink,
+        progname: "<Plover/#{is_a?(Class) ? name : self.class.name}>",
+        level: log_severity(log_config[:level]))
+    end
+
+    def log_config
+      is_a?(Class) ? configuration[:options][:log] : @configuration[:options][:log]
+    end
+  end
+
   class Builder
     class FlagError < PloverError; end
 
@@ -39,6 +79,8 @@ module Plover
 
     module Common; end
 
+    include Log
+
     attr_reader :configuration
 
     @configuration = {
@@ -51,9 +93,13 @@ module Plover
       },
       options: {
         flags: {},
-        expected_flags: []
+        expected_flags: [],
+        common_include: :none,
+        log: {
+          level: :info,
+          sink: :stdout
+        }
       },
-      include_common: :none,
       artifacts: {
         setup: {},
         before_build: {},
@@ -64,10 +110,12 @@ module Plover
     }
 
     class << self
+      extend Log
+
       attr_reader :configuration
 
       def inherited(subclass)
-        auto_include_common
+        subclass.extend(Log)
         subclass.instance_variable_set(:@configuration, deep_copy(configuration))
       end
 
@@ -87,6 +135,14 @@ module Plover
         configuration[:options][:common_include] = :none
       end
 
+      def log_level(severity)
+        configuration[:options][:log][:level] = severity.to_sym
+      end
+
+      def log_sink(sink)
+        configuration[:options][:log][:sink] = sink
+      end
+
       def common_include(*modules)
         configuration[:options][:common_include] = [] unless configuration[:options][:common_include].is_a?(Array)
 
@@ -108,14 +164,17 @@ module Plover
       end
 
       def auto_include_common
-        return if configuration[:options][:common_include] == :none
+        return if @configuration[:options][:common_include] == :none
 
         ObjectSpace.each_object(Module).select { |m| m&.name&.start_with?("Plover::Builder::Common::") }.each do |mod|
           next if mod.name.to_s.end_with?("::ClassMethods")
 
-          next if configuration[:options][:common_include].is_a?(Array) && !configuration[:options][:common_include].any? { |m| m.end_with?("::#{mod.name}") }
+          next if @configuration[:options][:common_include].is_a?(Array) && !@configuration[:options][:common_include].any? { |m| m == mod.name.split("::").last }
 
-          mod.apply_concern(self) if mod.respond_to?(:apply_concern) && !included_modules.include?(mod)
+          if mod.respond_to?(:apply_concern) && !included_modules.include?(mod)
+            log(:debug, "Loading Common #{mod.name}")
+            mod.apply_concern(self)
+          end
         end
       end
 
@@ -131,15 +190,22 @@ module Plover
       end
     end
 
-    def initialize(flags = {})
-      self.class.auto_include_common
+    def initialize(flags = {}, use_env_flags: true)
       @configuration = self.class.configuration
-      @configuration[:options][:flags] = @configuration[:options][:flags].merge(flags).merge(self.class.env_flags)
 
-      return unless @configuration[:options][:expected_flags].any?
+      @configuration[:options][:log][:level] = flags[:log_level] || ENV["PLOVER_LOG_LEVEL"]&.to_sym || @configuration[:options][:log][:level] || :info
+      @configuration[:options][:log][:sink] = flags[:log_sink] || ENV["PLOVER_LOG_SINK"] || @configuration[:options][:log][:sink] || :stdout
 
-      missing_flags = @configuration[:options][:expected_flags].reject { |sym| @configuration[:options][:flags].key?(sym) }
-      raise BuildError.new("Missing required flags: #{missing_flags.join(", ")}") if missing_flags.any?
+      @configuration[:options][:flags] = @configuration[:options][:flags].merge(flags).merge(use_env_flags ? self.class.env_flags : {})
+
+      self.class.auto_include_common
+
+      if @configuration[:options][:expected_flags].any?
+        missing_flags = @configuration[:options][:expected_flags].reject { |sym| @configuration[:options][:flags].key?(sym) }
+        fail_build("Missing required flags: #{missing_flags.join(", ")}") if missing_flags.any?
+      end
+
+      log :debug, "Initialized, options=#{@configuration[:options]}"
     end
 
     def prepend_phase(phase, &block)
@@ -167,11 +233,15 @@ module Plover
     end
 
     def raise_unless_flag(name, message)
-      raise FlagError.new(message) unless flag(name)
+      unless flag(name)
+        log :fatal, "Missing flag '#{name}': #{message}"
+        raise FlagError.new(message)
+      end
     end
 
     def push_artifact(name, value)
       return unless @current_phase
+      log :debug, "Pushed artifact name='#{name}' value='#{value}'"
       @configuration[:artifacts][@current_phase][name] = value
     end
 
@@ -189,17 +259,23 @@ module Plover
     end
 
     def raise_unless_artifact(phase, name, message)
-      raise ArtifactError.new(message) unless artifact(phase, name)
+      unless artifact(phase, name)
+        log :fatal, "Missing artifact '#{name}': #{message}"
+        raise ArtifactError.new(message)
+      end
     end
 
     def fail_build(message)
+      log :fatal, "Build failure: #{message}"
       raise BuildError.new(message)
     end
 
     def run_phase(phase)
+      log :debug, "\\/ #{phase.to_s.capitalize} Phase Starting \\/"
       @current_phase = phase
       @configuration[:steps][phase].each { |block| instance_exec(&block) }
       @current_phase = nil
+      log :debug, "/\\ #{phase.to_s.capitalize} Phase Finished /\\"
     end
 
     def run
@@ -210,6 +286,7 @@ module Plover
         run_phase(:after_build)
       end
       run_phase(:teardown)
+      logger.close
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: plover
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Charlton Trezevant
 bindir: exe
 cert_chain: []
-date: 2025-03-17 00:00:00.000000000 Z
+date: 2025-03-18 00:00:00.000000000 Z
 dependencies: []
 description: Plover is a tiny, embeddable Ruby build system.
 email: