plover 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c02ad2ecd60c71f6183a2db31ba64dd0f15769cbf7774273913595dfb72ccd93
-  data.tar.gz: c6fb12369964a4aa2238ffde51d4675e5b716eae056e12311193bb3570ec204e
+  metadata.gz: e379809ddbf68dfdeea5b28c0f12494b0afc748fdeda52b41c9dbcc132db45d8
+  data.tar.gz: 61134a172618ef8651d10e550d11d4eb09cd132d4a5c1b0e996c38ba485f63b2
 SHA512:
-  metadata.gz: 15a087dd706ac377d6535956b9f62bb3a94e7811ce15c09e2a1b81ee3e79a2c25b26d495eedf5dd1a561e54b495d6c3867d9342a0d28ebbefc48fed7800c48b8
-  data.tar.gz: 7c8eee52f8818b246f1a57dd01947cb1ee398f12e92d0811559e0c3425ca93e5abfba0ecc2597c0dd091f74a48cf34feb7f159d43257f263c0b1eaab27c3d30b
+  metadata.gz: 8f5f26be169f24153958ef159e8798e397555fcb75d4f3e5dc4cbec31681e04e2f2b319ca5528aac99c1811881208952edf8f63c816c6eba2bad6ccdd2902960
+  data.tar.gz: 974db73e8b87acb54d8c278fbfe74ac169bfb5dca68296fe7c0fa935616f4e1b615976a58d2a9faf6c5231edb53e9efeb17fdacecee93966feedea7798e1cd20

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.1"
 
   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,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: plover
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Charlton Trezevant
 bindir: exe
 cert_chain: []
-date: 2025-03-17 00:00:00.000000000 Z
-dependencies: []
+date: 2025-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger
+  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: Plover is a tiny, embeddable Ruby build system.
 email:
 - ct@ctis.me