bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/utils/ansi.rb

@@ -0,0 +1,57 @@
+# Frozen-string-literal: true
+
+module Bridgetown
+  module Utils
+    module Ansi
+      extend self
+
+      ESCAPE = format("%c", 27)
+      MATCH = %r!#{ESCAPE}\[(?:\d+)(?:;\d+)*(j|k|m|s|u|A|B|G)|\e\(B\e\[m!ix.freeze
+      COLORS = {
+        :red     => 31,
+        :green   => 32,
+        :black   => 30,
+        :magenta => 35,
+        :yellow  => 33,
+        :white   => 37,
+        :blue    => 34,
+        :cyan    => 36,
+      }.freeze
+
+      # Strip ANSI from the current string.  It also strips cursor stuff,
+      # well some of it, and it also strips some other stuff that a lot of
+      # the other ANSI strippers don't.
+
+      def strip(str)
+        str.gsub MATCH, ""
+      end
+
+      #
+
+      def has?(str)
+        !!(str =~ MATCH)
+      end
+
+      # Reset the color back to the default color so that you do not leak any
+      # colors when you move onto the next line. This is probably normally
+      # used as part of a wrapper so that we don't leak colors.
+
+      def reset(str = "")
+        @ansi_reset ||= format("%c[0m", 27)
+        "#{@ansi_reset}#{str}"
+      end
+
+      # SEE: `self::COLORS` for a list of methods.  They are mostly
+      # standard base colors supported by pretty much any xterm-color, we do
+      # not need more than the base colors so we do not include them.
+      # Actually... if I'm honest we don't even need most of the
+      # base colors.
+
+      COLORS.each do |color, num|
+        define_method color do |str|
+          "#{format("%c", 27)}[#{num}m#{str}#{reset}"
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/exec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Bridgetown
+  module Utils
+    module Exec
+      extend self
+
+      # Runs a program in a sub-shell.
+      #
+      # *args - a list of strings containing the program name and arguments
+      #
+      # Returns a Process::Status and a String of output in an array in
+      # that order.
+      def run(*args)
+        stdin, stdout, stderr, process = Open3.popen3(*args)
+        out = stdout.read.strip
+        err = stderr.read.strip
+
+        [stdin, stdout, stderr].each(&:close)
+        [process.value, out + err]
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/internet.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module Internet
+      # Public: Determine whether the present device has a connection to
+      # the Internet. This allows plugin writers which require the outside
+      # world to have a neat fallback mechanism for offline building.
+      #
+      # Example:
+      #   if Internet.connected?
+      #     Typhoeus.get("https://pages.github.com/versions.json")
+      #   else
+      #     Bridgetown.logger.warn "Warning:", "Version check has been disabled."
+      #     Bridgetown.logger.warn "", "Connect to the Internet to enable it."
+      #     nil
+      #   end
+      #
+      # Returns true if a DNS call can successfully be made, or false if not.
+
+      module_function
+
+      def connected?
+        !dns("example.com").nil?
+      end
+
+      def dns(domain)
+        require "resolv"
+        Resolv::DNS.open do |resolver|
+          resolver.getaddress(domain)
+        end
+      rescue Resolv::ResolvError, Resolv::ResolvTimeout
+        nil
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/platforms.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module Platforms
+      extend self
+
+      # TODO: jruby is NOT supported by Bridgetown. This should probably
+      # get removed.
+      { :jruby? => "jruby", :mri? => "ruby" }.each do |k, v|
+        define_method k do
+          ::RUBY_ENGINE == v
+        end
+      end
+
+      # --
+      # Allows you to detect "real" Windows, or what we would consider
+      # "real" Windows.  That is, that we can pass the basic test and the
+      # /proc/version returns nothing to us.
+      # --
+
+      def vanilla_windows?
+        RbConfig::CONFIG["host_os"] =~ %r!mswin|mingw|cygwin!i && \
+          !proc_version
+      end
+
+      # --
+      # XXX: Remove in 4.0
+      # --
+
+      alias_method :really_windows?, \
+                   :vanilla_windows?
+
+      #
+
+      def bash_on_windows?
+        RbConfig::CONFIG["host_os"] =~ %r!linux! && \
+          proc_version =~ %r!microsoft!i
+      end
+
+      #
+
+      def windows?
+        vanilla_windows? || bash_on_windows?
+      end
+
+      #
+
+      def linux?
+        RbConfig::CONFIG["host_os"] =~ %r!linux! && \
+          proc_version !~ %r!microsoft!i
+      end
+
+      # Provides windows?, linux?, osx?, unix? so that we can detect
+      # platforms. This is mostly useful for `bridgetown doctor` and for testing
+      # where we kick off certain tests based on the platform.
+
+      { :osx? => %r!darwin|mac os!, :unix? => %r!solaris|bsd! }.each do |k, v|
+        define_method k do
+          !!(
+            RbConfig::CONFIG["host_os"] =~ v
+          )
+        end
+      end
+
+      #
+
+      private
+
+      def proc_version
+        @proc_version ||=
+          begin
+            File.read("/proc/version")
+          rescue Errno::ENOENT, Errno::EACCES
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/thread_event.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    # Based on the pattern and code from
+    # https://emptysqua.re/blog/an-event-synchronization-primitive-for-ruby/
+    class ThreadEvent
+      attr_reader :flag
+
+      def initialize
+        @lock = Mutex.new
+        @cond = ConditionVariable.new
+        @flag = false
+      end
+
+      def set
+        @lock.synchronize do
+          yield if block_given?
+          @flag = true
+          @cond.broadcast
+        end
+      end
+
+      def wait
+        @lock.synchronize do
+          @cond.wait(@lock) unless @flag
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/utils/win_tz.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Utils
+    module WinTZ
+      extend self
+
+      # Public: Calculate the Timezone for Windows when the config file has a defined
+      #         'timezone' key.
+      #
+      # timezone - the IANA Time Zone specified in "_config.yml"
+      #
+      # Returns a string that ultimately re-defines ENV["TZ"] in Windows
+      def calculate(timezone)
+        External.require_with_graceful_fail("tzinfo") unless defined?(TZInfo)
+        tz = TZInfo::Timezone.get(timezone)
+        difference = Time.now.to_i - tz.now.to_i
+        #
+        # POSIX style definition reverses the offset sign.
+        #   e.g. Eastern Standard Time (EST) that is 5Hrs. to the 'west' of Prime Meridian
+        #   is denoted as:
+        #     EST+5 (or) EST+05:00
+        # Reference: http://www.gnu.org/software/libc/manual/html_node/TZ-Variable.html
+        sign = difference.negative? ? "-" : "+"
+        offset = sign == "-" ? "+" : "-" unless difference.zero?
+        #
+        # convert the difference (in seconds) to hours, as a rational number, and perform
+        # a modulo operation on it.
+        modulo = modulo_of(rational_hour(difference))
+        #
+        # Format the hour as a two-digit number.
+        # Establish the minutes based on modulo expression.
+        hh = format("%<hour>02d", :hour => absolute_hour(difference).ceil)
+        mm = modulo.zero? ? "00" : "30"
+
+        Bridgetown.logger.debug "Timezone:", "#{timezone} #{offset}#{hh}:#{mm}"
+        #
+        # Note: The 3-letter-word below doesn't have a particular significance.
+        "WTZ#{sign}#{hh}:#{mm}"
+      end
+
+      private
+
+      # Private: Convert given seconds to an hour as a rational number.
+      #
+      # seconds - supplied as an integer, it is converted to a rational number.
+      # 3600 - no. of seconds in an hour.
+      #
+      # Returns a rational number.
+      def rational_hour(seconds)
+        seconds.to_r / 3600
+      end
+
+      # Private: Convert given seconds to an hour as an absolute number.
+      #
+      # seconds - supplied as an integer, it is converted to its absolute.
+      # 3600 - no. of seconds in an hour.
+      #
+      # Returns an integer.
+      def absolute_hour(seconds)
+        seconds.abs / 3600
+      end
+
+      # Private: Perform a modulo operation on a given fraction.
+      #
+      # fraction - supplied as a rational number, its numerator is divided
+      #            by its denominator and the remainder returned.
+      #
+      # Returns an integer.
+      def modulo_of(fraction)
+        fraction.numerator % fraction.denominator
+      end
+    end
+  end
+end

data/lib/bridgetown-core/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  VERSION = "0.7.1"
+end

data/lib/bridgetown-core/watcher.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "listen"
+
+module Bridgetown
+  module Watcher
+    extend self
+
+    # Public: Continuously watch for file changes and rebuild the site
+    # whenever a change is detected.
+    #
+    # If the optional site argument is populated, that site instance will be
+    # reused and the options Hash ignored. Otherwise, a new site instance will
+    # be instantiated from the options Hash and used.
+    #
+    # options - A Hash containing the site configuration
+    # site    - The current site instance (populated starting with Bridgetown 3.2)
+    #           (optional, default: nil)
+    #
+    # Returns nothing.
+    def watch(options, site = nil)
+      ENV["LISTEN_GEM_DEBUGGING"] ||= "1" if options["verbose"]
+
+      site ||= Bridgetown::Site.new(options)
+      listener = build_listener(site, options)
+      listener.start
+
+      Bridgetown.logger.info "Auto-regeneration:", "enabled for '#{options["source"]}'"
+
+      unless options["serving"]
+        trap("INT") do
+          listener.stop
+          Bridgetown.logger.info "", "Halting auto-regeneration."
+          exit 0
+        end
+
+        sleep_forever
+      end
+    rescue ThreadError
+      # You pressed Ctrl-C, oh my!
+    end
+
+    private
+
+    def build_listener(site, options)
+      Listen.to(
+        options["source"],
+        :ignore        => listen_ignore_paths(options),
+        :force_polling => options["force_polling"],
+        &listen_handler(site)
+      )
+    end
+
+    def listen_handler(site)
+      proc do |modified, added, removed|
+        t = Time.now
+        c = modified + added + removed
+        n = c.length
+
+        Bridgetown.logger.info "Regenerating…"
+        Bridgetown.logger.info "", "#{n} file(s) changed at #{t.strftime("%Y-%m-%d %H:%M:%S")}"
+
+        c.each { |path| Bridgetown.logger.info "", path["#{site.source}/".length..-1] }
+        process(site, t)
+      end
+    end
+
+    def normalize_encoding(obj, desired_encoding)
+      case obj
+      when Array
+        obj.map { |entry| entry.encode!(desired_encoding, entry.encoding) }
+      when String
+        obj.encode!(desired_encoding, obj.encoding)
+      end
+    end
+
+    def custom_excludes(options)
+      Array(options["exclude"]).map { |e| Bridgetown.sanitized_path(options["source"], e) }
+    end
+
+    def config_files(options)
+      %w(yml yaml toml).map do |ext|
+        Bridgetown.sanitized_path(options["source"], "_config.#{ext}")
+      end
+    end
+
+    def to_exclude(options)
+      [
+        config_files(options),
+        options["destination"],
+        custom_excludes(options),
+      ].flatten
+    end
+
+    # Paths to ignore for the watch option
+    #
+    # options - A Hash of options passed to the command
+    #
+    # Returns a list of relative paths from source that should be ignored
+    # rubocop: disable Metrics/AbcSize
+    def listen_ignore_paths(options)
+      source = Pathname.new(options["source"]).expand_path
+      paths  = to_exclude(options)
+
+      paths.map do |p|
+        absolute_path = Pathname.new(normalize_encoding(p, options["source"].encoding)).expand_path
+        next unless absolute_path.exist?
+
+        begin
+          relative_path = absolute_path.relative_path_from(source).to_s
+          relative_path = File.join(relative_path, "") if absolute_path.directory?
+          unless relative_path.start_with?("../")
+            path_to_ignore = %r!^#{Regexp.escape(relative_path)}!
+            Bridgetown.logger.debug "Watcher:", "Ignoring #{path_to_ignore}"
+            path_to_ignore
+          end
+        rescue ArgumentError
+          # Could not find a relative path
+        end
+      end.compact + [%r!^\.bridgetown\-metadata!]
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def sleep_forever
+      loop { sleep 1000 }
+    end
+
+    def process(site, time)
+      begin
+        site.process
+        Bridgetown.logger.info "Done! 🎉", "Completed in #{(Time.now - time).round(3)} seconds."
+      rescue StandardError => e
+        Bridgetown.logger.warn "Error:", e.message
+        Bridgetown.logger.warn "Error:", "Run bridgetown build --trace for more information."
+      end
+      Bridgetown.logger.info ""
+    end
+  end
+end