geb 0.1.11

data/lib/geb/site/build.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+#
+# Site building functionality, building assets and pages
+#
+# @title Geb - Site - Build Module
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class Site
+    module Build
+
+      class SiteNotLoadedError < Geb::Error
+        MESSAGE = "Site not loaded.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class SiteNotLoadedError < Geb::Error
+
+      class FailedToOutputSite < Geb::Error
+        MESSAGE = "Failed to output site.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class FailedToOutputSite < Geb::Error
+
+      # build the site
+      def build
+
+        # make sure the site is laoded, if not, raise an error
+        raise SiteNotLoadedError.new("Could not build the site.") unless @loaded
+
+        # build the assets and pages
+        # it is important to build pages first as there may be pages in the assets directory
+        build_pages()
+        build_assets()
+
+      end # def build
+
+      # build the assets for the site
+      # @raise SiteNotLoaded if the site is not loaded
+      def build_assets
+
+        # make sure the site is laoded, if not, raise an error
+        raise SiteNotLoadedError.new("Could not build assets.") unless @loaded
+
+        # get the site asset and output assets directory
+        site_assets_dir = get_site_assets_directory()
+        outout_assets_dir = File.join(get_site_output_directory(), site_assets_dir.gsub(@site_path, ""))
+
+        Geb.log "Building assets for #{site_name}\n\n"
+
+        # step through all the asset files and copy them to the output directory
+        Dir.glob("#{site_assets_dir}/**/*").each do |asset_file|
+
+          # skip directories
+          next if File.directory?(asset_file)
+
+          # get the relative path of the asset file and the destination path
+          asset_relative_path = asset_file.gsub(site_assets_dir, "")
+          asset_full_destination_path = File.join(outout_assets_dir, asset_relative_path)
+
+          # check if the destination asset file exists
+          if File.exist?(asset_full_destination_path)
+
+            Geb.log " - skipping asset: #{asset_relative_path}"
+
+          else
+
+            Geb.log " - processing asset: #{asset_relative_path}"
+
+            # create the output directory for the asset file
+            output_dir = File.join(outout_assets_dir, File.dirname(asset_relative_path))
+            FileUtils.mkdir_p(output_dir)
+
+            # copy the asset file to the output directory
+            FileUtils.cp(asset_file, output_dir)
+
+          end # if else
+
+        end # Dir.glob
+        Geb.log "\nDone building assets for #{site_name}"
+
+      end # def build_assets
+
+      # build the pages for the site
+      # @raise SiteNotLoaded if the site is not loaded
+      def build_pages
+
+        # make sure the site is laoded, if not, raise an error
+        raise SiteNotLoadedError.new("Could not build pages.") unless @loaded
+
+        # expire page template and partial caches
+        Geb::Template.expire_cache
+        Geb::Partial.expire_cache
+
+        # find all HTML files in the site path that don't start with an underscore, with extention .html and .htm
+        page_files = get_page_files(@site_path,
+                                    @site_config.page_extensions(),
+                                    @site_config.template_and_partial_identifier(),
+                                    [get_site_output_directory(), get_site_release_directory()])
+
+        Geb.log "Building #{page_files.length} pages for #{site_name}"
+
+        # create a temporary directory
+        Dir.mktmpdir do |tmp_dir|
+
+          # iterate over the HTML files and build the pages
+          page_files.each do |page_file|
+
+            # create a new page object and buid the page into the temporary directory
+            page = Geb::Page.new(self, page_file)
+            page.build(tmp_dir)
+
+          end # html_files.each
+          Geb.log "\nDone building #{page_files.length} pages for #{site_name}"
+
+          # attempt to write the site to the output directory
+          begin
+
+            # clear the output directory
+            Geb.log_start "Clearing site output folder #{get_site_output_directory()} ... "
+            clear_site_output_directory()
+            Geb.log "done."
+
+            # copy the files to the output directory
+            Geb.log_start "Outputting site to #{get_site_output_directory()} ... "
+            output_site(tmp_dir)
+            Geb.log "done."
+
+          rescue => e
+            raise FailedToOutputSite.new(e.message)
+          end # begin rescue
+
+        end # Dir.mktmpdir
+
+      end # def build_pages
+
+      # get the site output directory
+      # @return [String] the site output directory
+      def get_site_output_directory
+        return File.join(@site_path, @site_config.output_dir, Geb::Defaults::LOCAL_OUTPUT_DIR)
+      end # def get_site_output_directory
+
+      # get the page files in the specified path, with specified extentions and ignoring files that match the pattern
+      # @param path [String] the path to the files
+      # @param exts [Array] the extentions to look for, default is Geb::Defaults.PAGE_EXTENSIONS
+      # @param ignore_files_exp [Regexp] the pattern to ignore files, default is Geb::Defaults.TEMPLATE_AND_PARTIAL_IDENTIFIER
+      # @param ignore_directories [Array] the directories to ignore, default is []
+      # @return [Array] the array of matched file paths
+      # @note the ignore_files_exp and ignore_directories are used to ignore files that are not pages
+      def get_page_files(path, exts = Geb::Defaults::PAGE_EXTENSIONS, ignore_files_exp = Geb::Defaults::TEMPLATE_AND_PARTIAL_IDENTIFIER, ignore_directories = [])
+
+        # get all files in the path with the specified extentions
+        files = Dir.glob("#{path}/**/*{#{exts.join(',')}}")
+
+        # reject files that match the ignore pattern and that are within the output or release directories
+        files.reject! do |file|
+          File.basename(file) =~ ignore_files_exp ||
+          ignore_directories.any? { |dir| file.start_with?(dir) }
+        end # files.reject!
+
+        # return the array of matched file paths
+        return files
+
+      end # def get_page_files
+
+      # clear the site output directory
+      # @return [Nil]
+      def clear_site_output_directory
+        FileUtils.rm_rf(Dir.glob("#{get_site_output_directory()}/*"))
+      end # def clear_site_output_directory
+
+      # output the site from specified directory to the output directory. The specified directory is typically
+      # a temporary directory where the site has been built.
+      # @param output_dir [String] the directory to output
+      # @return [Nil]
+      def output_site(output_dir)
+        FileUtils.cp_r("#{output_dir}/.", get_site_output_directory())
+      end # def output_site
+
+      # get the site assets directory
+      # @return [String] the site assets directory
+      def get_site_assets_directory
+        return File.join(@site_path, @site_config.assets_dir)
+      end # def get_site_assets_directory
+
+    end # module Build
+  end # class Site
+end # module Geb

data/lib/geb/site/core.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+#
+# Site core functionality, loading, validation and creation
+#
+# @title Geb - Site - Core Module
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class Site
+    module Core
+
+      class DirectoryExistsError < Geb::Error
+        MESSAGE = "Site folder already exists, please choose a different name or location.\nIf you want to use the existing site folder, use the --force option.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class DirectoryExistsError < Geb::Error
+
+      class SiteAlreadyValidated < Geb::Error
+        MESSAGE = "Proposed site and template have not been validated. This is an internal error".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class SiteAlreadyValidated < Geb::Error
+
+      class InvalidTemplate < Geb::Error
+        MESSAGE = "Invalid template site. Make sure the specified path is a directory and contains a valid geb.config.yml file.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class InvalidTemplate < Geb::Error
+
+      class UnvalidatedSiteAndTemplate < Geb::Error
+        MESSAGE = "You are trying to create an unvalidated site. This is an internal error".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class UnvalidatedSiteAndTemplate < Geb::Error
+
+      class SiteNotFoundError < Geb::Error
+        MESSAGE = "Could not find geb config file.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class SiteNotFoundError < Geb::Error
+
+      # validate the site path and template path, and set the validated flag
+      # it executes the following validations:
+      #   - make sure the site is not already validated
+      #   - make sure the site path is valid, consider force option
+      #   - if template path is nil, use the default template
+      #   - if template path is a URL, validate the URL and download the template
+      #   - if template path is a directory, check if it has a geb.config.yml file
+      # @param site_path      [String]  the path to the site folder
+      # @param template_path  [String]  the path to the site template, default is nil, can be a URL, directory or a bundled template identifier
+      # @param skip_template  [Boolean] skip the template validation, default is false
+      # @param force          [Boolean] force the site creation, default is false
+      # @raise SiteAlreadyValidated if the site has already been validated
+      # @raise DirectoryExistsError if the site folder already exists and force option is not set
+      # @raise InvalidTemplate if the template path is invalid
+      # @raise InvalidTemplateURL if the template URL is invalid
+      # @return [Nil]
+      def validate(site_path, template_path = nil, skip_template = false, force = false)
+
+        # raise an error if the site has already been validated
+        raise SiteAlreadyValidated.new if @validated
+
+        Geb.log_start "Validating site path #{site_path} ... "
+        # raise error if site folder already exists and force option is not set
+        raise DirectoryExistsError.new if site_directory_exists?(site_path) && !force
+        @site_path = site_path
+        Geb.log('done.')
+
+        Geb.log("Skipping template validation as told.") if skip_template
+
+        # check if we are skipping the template
+        unless skip_template
+
+          # initialize the template directory path.
+          template_dir = nil
+
+          # if the template path is nil, use the first bundled template name
+          if template_path.nil? || template_path.empty?
+
+            Geb.log "No template specified, using default: #{Geb::Defaults::DEFAULT_TEMPLATE}."
+            template_dir = Geb::Defaults::DEFAULT_TEMPLATE_DIR
+
+          end # if
+
+          # check if the template path is a URL
+          if is_url?(template_path) && template_dir.nil?
+
+            # check if the template URL is valid and download it if it is
+            valid_template_url = validate_template_url(template_path)
+            template_dir       = download_template_from_url(valid_template_url)
+
+          end # if
+
+          # check if the template path is a bundled template
+          if template_dir.nil? && is_bundled_template?(template_path)
+
+            template_dir = File.join(Geb::Defaults::BUNDLED_TEMPLATES_DIR, template_path)
+            Geb.log "Specified template is a Geb sample: #{template_path}, using it as site template."
+
+          end # if
+
+          # set the template dir to specified template path if template dir is still nil
+          template_dir = template_path if template_dir.nil? # this is the case when the template is a local directory
+
+          # check if the template path is a directory and ontains a geb.config.yml file
+          Geb.log_start "Validating template path #{template_dir.to_s} ... "
+          raise InvalidTemplate.new if template_dir.nil?
+          raise InvalidTemplate.new unless template_directory_exists?(template_dir)
+          raise InvalidTemplate.new unless Geb::Config.site_directory_has_config?(template_dir)
+          Geb.log "done."
+
+          # set the template path
+          @template_path = template_dir
+
+        end # unless skip_template
+
+        # set the validated flag
+        @validated = true
+
+      end # def validate
+
+      # create the site. It assumes and checks that the site has been validated first.
+      # the reason we don't just call validate from here is that we want to separate
+      # the validation from the creation for CLI UI purposes.
+      # performs the following steps
+      #   - raise an error if the site has not been validated
+      #   - create the site folder, if it exists, just skip it
+      #   - copy the template files to the site folder if the template path is set
+      #   - create the output folders
+      # @raise UnvalidatedSiteAndTemplate if the site has not been validated
+      # @return [Nil]
+      def create
+
+        # raise an error if the site has not been validated
+        raise UnvalidatedSiteAndTemplate.new unless @validated
+
+        # check if the folder already exists, if we are here and it does, just skip it, validation would have considered a force option
+        Geb.log_start "Creating site folder: #{@site_path} ... "
+        if site_directory_exists?(@site_path)
+          Geb.log "skipped, folder already exists."
+        else
+          Dir.mkdir(@site_path)
+          Geb.log "done."
+        end # if
+
+        Geb.log("Skipping template creation as told.") if @template_path.nil?
+
+        # check if we are skipping the template, if not copy the template files
+        copy_template_from_path unless @template_path.nil?
+
+        # check if the site has a geb config file, if not, copy the default one
+        if Geb::Config.site_directory_has_config?(@site_path)
+          Geb.log "Config file already exists, no need to create it."
+        else
+          Geb.log_start "Creating default geb config file ... "
+          FileUtils.cp(File.join(Geb::Defaults::BUNDLED_TEMPLATES_DIR, Geb::Defaults::SITE_CONFIG_FILENAME), @site_path)
+          Geb.log "done."
+        end # if else
+
+        # load the site config
+        @site_config = Geb::Config.new(self)
+
+        # create the assets folder if it does not exist
+        if File.directory?(File.join(@site_path, @site_config.assets_dir))
+          Geb.log "Assets folder already exists, no need to create it."
+        else
+          Geb.log_start "Creating assets folder since it wasn't created by the template ... "
+          FileUtils.mkdir_p(File.join(@site_path, @site_config.assets_dir))
+          Geb.log "done."
+        end # if else
+
+        # create the output folders
+        Geb.log_start "Creating: local and release output folders ..."
+        FileUtils.mkdir_p(File.join(@site_path, @site_config.output_dir, Geb::Defaults::LOCAL_OUTPUT_DIR))
+        FileUtils.mkdir_p(File.join(@site_path, @site_config.output_dir, Geb::Defaults::RELEASE_OUTPUT_DIR))
+        Geb.log "done."
+
+      end # def create
+
+      # load a site from a site path
+      # it checks if the site path has a geb config file, if not, it goes up the chain to find it
+      # @param site_path [String] the path to the site folder
+      # @raise SiteNotFoundError if the site path is not found
+      # @return [Nil]
+      def load(site_path)
+
+        Geb.log_start "Loading site from path #{site_path} ... "
+
+        # set the site path candidate
+        site_path_candidate = site_path
+
+        # check if the site has a geb config file, if not go up the chain to find it
+        until site_path_candidate == '/'
+
+          # check if the site path has a geb config file
+          if Geb::Config.site_directory_has_config?(site_path_candidate)
+
+            # set the site path
+            @site_path = site_path_candidate
+
+            # load the site configuration
+            @site_config = Geb::Config.new(self)
+
+            # set the loaded flag and break the loop
+            @loaded = true
+            break
+
+          end # if
+
+          # go up the chain
+          site_path_candidate = File.expand_path('..', site_path_candidate)
+
+        end # until
+
+        # raise an error if the site path is not found
+        raise SiteNotFoundError.new("#{site_path} is not and is not in a geb site.") unless @loaded
+
+        Geb.log "done."
+        Geb.log "Found geb site at path #{@site_path} as #{site_name}."
+
+      end # def load
+
+      # check if the site directory exists
+      def site_directory_exists?(site_path)
+        File.directory?(site_path)
+      end # def site_directory_exists?
+
+    end
+  end
+end

data/lib/geb/site/release.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+#
+# Site release functionality, releasing the site, packaging site templates and assets
+#
+# @title Geb - Site - Release Module
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class Site
+    module Release
+
+      # release the site
+      def release
+
+        # build the site first
+        build();
+
+        # get the site local and release directory
+        site_release_directory  = get_site_release_directory()
+
+        # clear the output directory
+        Geb.log_start "Clearing site release folder #{site_release_directory} ... "
+        clear_site_release_directory()
+        Geb.log "done."
+
+        # copy the files to the output directory
+        Geb.log_start "Releasing site to #{site_release_directory} ... "
+        copy_site_to_release_directory()
+        Geb.log "done."
+
+      end # def release
+
+      # get the template archive path
+      # @return [String] the template archive path within the release directory
+      def get_template_archive_release_path
+        return File.join(@site_path, @site_config.output_dir, Geb::Defaults::RELEASE_OUTPUT_DIR, Geb::Defaults::TEMPLATE_ARCHIVE_FILENAME)
+      end # def get_template_archive_release_path
+
+      # get the site release directory
+      # @return [String] the site release directory
+      def get_site_release_directory
+        return File.join(@site_path, @site_config.output_dir, Geb::Defaults::RELEASE_OUTPUT_DIR)
+      end # def get_site_release_directory
+
+      # clear the site release directory
+      # @return [Nil]
+      def clear_site_release_directory
+        FileUtils.rm_rf(Dir.glob("#{get_site_release_directory()}/*"))
+      end # def clear_site_release_directory
+
+      # output the site from local output to release directory.
+      # @return [Nil]
+      def copy_site_to_release_directory
+        FileUtils.cp_r("#{get_site_output_directory()}/.", get_site_release_directory())
+      end # def output_site
+
+      # check if the site has been released.
+      # The site is considered released if the release directory exists and is not empty.
+      # @return [Boolean] true if the site has been released, false otherwise
+      def released?
+        return Dir.exist?(get_site_release_directory()) && !Dir.empty?(get_site_release_directory())
+      end # def released?
+
+    end # module Build
+  end # class Site
+end # module Geb

data/lib/geb/site/remote.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+#
+# Site remote functionality, things like ssh, scp, rsync, etc.
+#
+# @title Geb - Site - Remote
+# @author Edin Mustajbegovic <edin@actiontwelve.com>
+# @copyright 2024 Edin Mustajbegovic
+# @license MIT
+#
+# @see https://github.com/mainfram-work/geb for more information
+
+module Geb
+  class Site
+    module Remote
+
+      class RemoteURINotConfigured < Geb::Error
+        MESSAGE = "Remote URI not configured in geb.config.yml".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class RemoteURINotConfigured < Geb::Error
+
+      class RemotePathNotConfigured < Geb::Error
+        MESSAGE = "Remote Path is not configured in geb.config.yml".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class RemotePathNotConfigured < Geb::Error
+
+      class SiteNotReleasedError < Geb::Error
+        MESSAGE = "Site not released. Please run 'geb release' first.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end
+
+      # launch a remote session
+      # @return [Nil]
+      # @raise SiteNotLoadedError if the site is not loaded
+      # @raise RemoteURINotConfigured if the remote uri is not configured
+      def launch_remote
+
+        # raise an error if the site is not loaded
+        raise Geb::Site::SiteNotFoundError.new("Site not loaded") unless @loaded
+
+        # make sure the remote uri is configured
+        raise RemoteURINotConfigured.new unless @site_config.remote_uri
+
+        # Temporarily disable reporting exceptions in threads
+        original_thread_report_on_exception_setting = Thread.report_on_exception
+        Thread.report_on_exception = false
+
+        Geb.log "About to start an ssh session with the remote server #{@site_config.remote_uri}."
+
+        # attempt to launch a remote session
+        begin
+          Open3.capture3("ssh", @site_config.remote_uri)
+        rescue Interrupt, IOError
+          Geb.log "Remote session interrupted."
+        rescue
+          Geb.log "Remote session interrupted."
+        ensure
+          # restore the original thread report on exception setting
+          Thread.report_on_exception = original_thread_report_on_exception_setting
+        end # begin ... rescue
+
+      end # def launch_remote
+
+      # upload the site release to the remote server
+      # @return [Nil]
+      # @raise SiteNotReleasedError if the site has not been released
+      # @raise RemoteURINotConfigured if the remote uri is not configured
+      # @raise RemotePathNotConfigured if the remote path is not configured
+      def upload_release_to_remote()
+
+        # check if the release directory is empty
+        raise SiteNotReleasedError.new unless released?
+
+        # make sure the remote uri and remote path are configured
+        raise RemoteURINotConfigured.new  unless @site_config.remote_uri
+        raise RemotePathNotConfigured.new unless @site_config.remote_path
+
+        # Temporarily disable reporting exceptions in threads
+        original_thread_report_on_exception_setting = Thread.report_on_exception
+        Thread.report_on_exception = false
+
+
+        Geb.log "About to upload the site release to remote server2."
+
+        # attempt to upload the release to the remote server
+        begin
+
+          # build up the command arguments
+          command_exclude_pattern = '*.DS_Store'
+          command_source_directory  = File.join(get_site_release_directory, '/')
+          command_remote_uri        = @site_config.remote_uri + ":" + @site_config.remote_path
+
+          # build the rsync command
+          rsync_command = [
+            'rsync',
+            '-av',
+            '-e', 'ssh',
+            "--exclude=#{command_exclude_pattern}",
+            command_source_directory,
+            command_remote_uri
+          ]
+
+          Geb.log " - upload command: #{rsync_command.join(' ')}"
+
+          # execute the rsync command
+          Open3.popen3(*rsync_command) do |stdin, stdout, stderr, wait_thr|
+
+            # create threads to read the stdout
+            stdout_thread = Thread.new do
+              stdout.each_line { |line| Geb.log " - #{line}" }
+            end
+
+            # create threads to read the stderr
+            stderr_thread = Thread.new do
+              stderr.each_line { |line| Geb.log " - (error) #{line}" }
+            end
+
+            # wait for the threads to finish
+            stdout_thread.join
+            stderr_thread.join
+
+            # get the status of the command
+            status = wait_thr.value
+
+            # log the status of the command
+            { stdout: stdout, stderr: stderr, status: status }
+
+          end # Open3.popen3
+
+        rescue Interrupt, IOError
+          Geb.log "Upload interrupted."
+        rescue
+          Geb.log "Upload interrupted."
+        ensure
+          # restore the original thread report on exception setting
+          Thread.report_on_exception = original_thread_report_on_exception_setting
+        end # begin ... rescue
+
+      end # def upload_release_to_remote
+
+    end # module Remote
+  end # class Site
+end # module Geb