geb 0.1.11 → 0.1.12

data/lib/geb/server.rb

@@ -22,11 +22,13 @@ module Geb
     # @param site [Geb::Site] the site instance to serve
     # @param port [Integer] the port to run the server on
     # @param auto_build [Boolean] whether to start the file watcher
-    def initialize(site, port, auto_build)
+    # @param debug [Boolean] whether to enable full output during site rebuild
+    def initialize(site, port, auto_build, debug)
 
       # set the site and port
       @site = site
       @port = port
+      @debug = debug
 
       # get the http server instance and file watcher if auto_build is set
       @http_server  = get_http_server()
@@ -73,7 +75,7 @@ module Geb
       # Create a new WEBrick server
       server = WEBrick::HTTPServer.new(
         Port: @port,
-        DocumentRoot: @site.get_site_output_directory()
+        DocumentRoot: @site.get_site_local_output_directory()
       ) # WEBrick::HTTPServer.new
 
       Geb.log "Server running on http://localhost:#{server.config[:Port]}/"
@@ -104,8 +106,12 @@ module Geb
           # attempt to rebuild the site, log any errors but do not stop watching
           begin
 
-            # rebuild the site, suppress log output
-            Geb.no_log { @site.build() }
+            # rebuild the site, suppress log output if deubg is not set
+            if @debug
+              @site.build()
+            else
+              Geb.no_log { @site.build() }
+            end # if else
 
           rescue Geb::Error => e
             Geb.log "\nError rebuilding site: #{e.message}"
@@ -118,8 +124,8 @@ module Geb
       end # Listen.to(site.site_path) do |modified, added, removed|
 
       # set ignore the output and release directories, cleanup the paths and make them relative to the site path
-      ignore_output_dir   = @site.get_site_output_directory().gsub(@site.site_path, '').gsub(/\A\W+/, '')
-      ignore_release_dir  = @site.get_site_release_directory().gsub(@site.site_path, '').gsub(/\A\W+/, '')
+      ignore_output_dir   = @site.get_site_local_output_directory().gsub(@site.site_path, '').gsub(/\A\W+/, '')
+      ignore_release_dir  = @site.get_site_release_output_directory().gsub(@site.site_path, '').gsub(/\A\W+/, '')
 
       Geb.log  "Watching for changes in [#{@site.site_path}]"
       Geb.log  "Ignoring [#{ignore_output_dir}]"

data/lib/geb/site/build.rb

@@ -24,6 +24,7 @@ module Geb
       end # class FailedToOutputSite < Geb::Error
 
       # build the site
+      # @raise SiteNotLoaded if the site is not loaded
       def build
 
         # make sure the site is laoded, if not, raise an error
@@ -36,52 +37,6 @@ module Geb
 
       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
@@ -93,13 +48,13 @@ module Geb
         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
+        # find all pages to build
         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()])
+                                    [get_site_local_output_directory(), get_site_release_output_directory()])
 
-        Geb.log "Building #{page_files.length} pages for #{site_name}"
+        Geb.log "Building #{page_files.length} #{site_name} pages #{@releasing ? 'for release' : 'locally'}"
 
         # create a temporary directory
         Dir.mktmpdir do |tmp_dir|
@@ -117,14 +72,17 @@ module Geb
           # attempt to write the site to the output directory
           begin
 
+            # get the destination directory for the site output, depending on the release flag
+            destination_directory = @releasing ? get_site_release_output_directory() : get_site_local_output_directory()
+
             # clear the output directory
-            Geb.log_start "Clearing site output folder #{get_site_output_directory()} ... "
-            clear_site_output_directory()
+            Geb.log_start "Clearing site output folder #{destination_directory} ... "
+            clear_site_output_directory(destination_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_start "Outputting site to #{destination_directory} ... "
+            output_site(tmp_dir, destination_directory)
             Geb.log "done."
 
           rescue => e
@@ -135,11 +93,60 @@ module Geb
 
       end # def build_pages
 
-      # get the site output directory
+      # 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 destination directory for the site output, depending on the release flag
+        destination_directory = @releasing ? get_site_release_output_directory() : get_site_local_output_directory()
+
+        # get the site asset and output assets directory
+        site_assets_dir = get_site_assets_directory()
+        output_assets_dir = File.join(destination_directory, site_assets_dir.gsub(@site_path, ""))
+
+        Geb.log "Building #{site_name} assets #{@releasing ? 'for release' : 'locally'}\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(output_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(output_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
+
+      # get the site local output directory
       # @return [String] the site output directory
-      def get_site_output_directory
+      def get_site_local_output_directory
         return File.join(@site_path, @site_config.output_dir, Geb::Defaults::LOCAL_OUTPUT_DIR)
-      end # def get_site_output_directory
+      end # def get_site_local_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
@@ -150,6 +157,9 @@ module Geb
       # @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 = [])
 
+        # make sure every page extention specified starts with a dot
+        exts.map! { |ext| ext.start_with?('.') ? ext : ".#{ext}" }
+
         # get all files in the path with the specified extentions
         files = Dir.glob("#{path}/**/*{#{exts.join(',')}}")
 
@@ -165,17 +175,19 @@ module Geb
       end # def get_page_files
 
       # clear the site output directory
+      # @param output_directory [String] the output directory to clear
       # @return [Nil]
-      def clear_site_output_directory
-        FileUtils.rm_rf(Dir.glob("#{get_site_output_directory()}/*"))
+      def clear_site_output_directory(output_directory)
+        FileUtils.rm_rf(Dir.glob("#{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
+      # @param source_dir [String] the source directory
+      # @param output_dir [String] the output directory
       # @return [Nil]
-      def output_site(output_dir)
-        FileUtils.cp_r("#{output_dir}/.", get_site_output_directory())
+      def output_site(source_dir, output_dir)
+        FileUtils.cp_r("#{source_dir}/.", output_dir)
       end # def output_site
 
       # get the site assets directory

data/lib/geb/site/release.rb

@@ -13,24 +13,31 @@ module Geb
   class Site
     module Release
 
+      class SiteReleasingError < Geb::Error
+        MESSAGE = "Site is already releasing.".freeze
+        def initialize(e = ""); super(e, MESSAGE); end
+      end # class SiteReleasingError < Geb::Error
+
       # release the site
+      # @raise SiteNotLoadedError if the site is not loaded
       def release
 
-        # build the site first
-        build();
+        # make sure the site is laoded, if not, raise an error
+        raise Geb::Site::SiteNotLoadedError.new("Could not release the site.") unless @loaded
 
-        # get the site local and release directory
-        site_release_directory  = get_site_release_directory()
+        # make sure the site is not already releasing, to prevent recursive releases
+        raise Geb::Site::SiteReleasingError.new if @releasing
 
-        # clear the output directory
-        Geb.log_start "Clearing site release folder #{site_release_directory} ... "
-        clear_site_release_directory()
-        Geb.log "done."
+        # set the site to releasing
+        @releasing = true
+
+        # build the site
+        build();
 
-        # copy the files to the output directory
-        Geb.log_start "Releasing site to #{site_release_directory} ... "
-        copy_site_to_release_directory()
-        Geb.log "done."
+      ensure
+
+        # set the site to not releasing
+        @releasing = false
 
       end # def release
 
@@ -40,29 +47,17 @@ module Geb
         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
+      # get the site release output directory
       # @return [String] the site release directory
-      def get_site_release_directory
+      def get_site_release_output_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
+      end # def get_site_release_output_directory
 
       # 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())
+        return Dir.exist?(get_site_release_output_directory()) && !Dir.empty?(get_site_release_output_directory())
       end # def released?
 
     end # module Build

data/lib/geb/site/remote.rb

@@ -86,7 +86,7 @@ module Geb
 
           # build up the command arguments
           command_exclude_pattern = '*.DS_Store'
-          command_source_directory  = File.join(get_site_release_directory, '/')
+          command_source_directory  = File.join(get_site_release_output_directory(), '/')
           command_remote_uri        = @site_config.remote_uri + ":" + @site_config.remote_path
 
           # build the rsync command

data/lib/geb/site/template.rb

@@ -68,6 +68,7 @@ module Geb
       # @raise InvalidTemplateSpecification if the template paths are not specified
       # @raise InvalidTemplateSpecification if the resolved template paths are empty
       # @raise InvalidTemplateSpecification if the template archive cannot be created
+      # @note template will be bundled with the geb.config.yml file, so the site can be re-created from the template
       def bundle_template
 
         # raise an error if the site is not loaded
@@ -91,6 +92,11 @@ module Geb
         Geb.copy_paths_to_directory(@site_path, resolved_template_paths, tmp_archive_directory)
         Geb.log "Done copying directories and files to the template archive directory."
 
+        # create a geb config file in the temporary directory
+        Geb.log_start "Generating geb.config.yml in the template archive directory ... "
+        @site_config.generate_config_file(tmp_archive_directory)
+        Geb.log "done."
+
         # create a template archive with files from the temporary directory into the release directory
         output_archive_filename = File.join(@site_path, @site_config.output_dir, Geb::Defaults::RELEASE_OUTPUT_DIR, Geb::Defaults::TEMPLATE_ARCHIVE_FILENAME)
         Geb.log_start "Creating template archive in [#{output_archive_filename}] ... "

data/lib/geb/site.rb

@@ -53,6 +53,12 @@ module Geb
     # @return [Boolean] true if the site is loaded
     attr_reader :loaded
 
+    # @!attribute [r] releasing
+    # @return [Boolean] true if the site is releasing
+    # @note this is used to prevent recursive releases and to ensure site variables are correct
+    # @note this is set to true when the site is being released and reset to false when the release is done
+    attr_reader :releasing
+
     # @!attribute [r] pages
     # @return [Hash] the site pages to process
     attr_reader :pages
@@ -63,6 +69,7 @@ module Geb
 
       @validated = false
       @loaded = false
+      @releasing = false
       @site_path = nil
       @template_path = nil
       @pages = {}

data/lib/geb/template.rb

@@ -18,6 +18,7 @@ require 'fileutils'
 module Geb
   class Template
 
+    # template, section and insert tag match patterns
     TEMPLATE_PATTERN  = /<% template: (.*?) %>/
     SECTION_PATTERN   = /<% start: (.*?) %>(.*?)<% end: \1 %>/m
     INSERT_PATTERN    = /<%= insert: (.*?) %>/

data/lib/geb/utilities.rb

@@ -87,7 +87,7 @@ module Geb
       destination_file_path = File.join(destination_path, relative_template_path)
 
       # ensure the destination directory exists
-      FileUtils.mkdir_p(File.dirname(destination_path))
+      FileUtils.mkdir_p(File.dirname(destination_file_path))
 
       # copy the resolved template path to the destination path
       if File.directory?(path)

data/lib/geb.rb

@@ -14,7 +14,7 @@
 module Geb
 
   # define the version of the gem
-  VERSION = "0.1.11"
+  VERSION = "0.1.12"
 
 end # module Geb
 

data/test/api tests/test_cli.rb

@@ -131,7 +131,7 @@ class TestCli < Minitest::Test
     refute_nil    Geb::CLI::Commands::Server.method_defined?(:options)
     refute_empty  Geb::CLI::Commands::Server.options, "Server command should have options."
 
-    assert_cli_option Geb::CLI::Commands::Server, :port,       :int,     0
+    assert_cli_option Geb::CLI::Commands::Server, :port,       :int,     nil
     assert_cli_option Geb::CLI::Commands::Server, :skip_build, :boolean, false
 
   end # test "that geb has a server command"

data/test/api tests/test_config.rb

@@ -327,4 +327,136 @@ class TestConfig < Minitest::Test
 
   end # test "that the template paths are returned as config value if set"
 
+  test "that generate config file creates a new config file" do
+
+    site = Geb::Site.new
+    site_path = File.join(File.dirname(__FILE__), "..", "files", "test-site")
+
+    site.instance_variable_set :@site_path, site_path
+
+    config = Geb::Config.new(site)
+
+    refute_empty config.instance_variable_get(:@config)
+
+    Dir.mktmpdir do |tmp_dir|
+
+      config.generate_config_file(tmp_dir)
+
+      assert File.exist?(File.join(tmp_dir, Geb::Defaults::SITE_CONFIG_FILENAME))
+
+      new_generated_config = YAML.load_file(File.join(tmp_dir, Geb::Defaults::SITE_CONFIG_FILENAME))
+
+      refute_empty new_generated_config
+
+      assert_nil new_generated_config['site_name']
+      assert_nil new_generated_config['remote_uri']
+      assert_nil new_generated_config['remote_path']
+
+    end # Dir.mktmpdir
+
+  end # test "that generate config file creates a new config file"
+
+  test "that generate config file raises an error if the destination directory doesn't exist" do
+
+    site = Geb::Site.new
+    site_path = File.join(File.dirname(__FILE__), "..", "files", "test-site")
+
+    site.instance_variable_set :@site_path, site_path
+
+    config = Geb::Config.new(site)
+
+    refute_empty config.instance_variable_get(:@config)
+
+    error = assert_raises(Geb::Config::DestinationDirMissing) do
+      config.generate_config_file("fake_dir")
+    end
+
+    assert_includes error.message, "Specified directory [fake_dir] missing."
+
+  end # test "that generate config file raises an error if the destination directory doesn't exist"
+
+  test "that generate config file raises an error if the config file already exists" do
+
+    site = Geb::Site.new
+    site_path = File.join(File.dirname(__FILE__), "..", "files", "test-site")
+
+    site.instance_variable_set :@site_path, site_path
+
+    config = Geb::Config.new(site)
+
+    refute_empty config.instance_variable_get(:@config)
+
+    Dir.mktmpdir do |tmp_dir|
+
+      File.open(File.join(tmp_dir, Geb::Defaults::SITE_CONFIG_FILENAME), 'w') { |f| f.write("test") }
+
+      error = assert_raises(Geb::Config::ConfigAlreadyExists) do
+        config.generate_config_file(tmp_dir)
+      end
+
+      assert_includes error.message, "Specified directory [#{tmp_dir}] already has geb config."
+
+    end # Dir.mktmpdir
+
+  end # test "that generate config file raises an error if the config file already exists"
+
+  test "that generate config sucessfully generates all configuration fields" do
+
+    site = Geb::Site.new
+    site_path = File.join(File.dirname(__FILE__), "..", "files", "test-site")
+
+    site.instance_variable_set :@site_path, site_path
+
+    config = Geb::Config.new(site)
+
+    refute_empty config.instance_variable_get(:@config)
+
+    test_config = {}
+    test_config['site_name']                        = "test-site"
+    test_config['remote_uri']                       = "https://primjer.hr"
+    test_config['remote_path']                      = "/var/www/html"
+    test_config['local_port']                       = 737373
+    test_config['output_dir']                       = "publicni"
+    test_config['assets_dir']                       = "assetsni"
+    test_config['page_extensions']                  = [".erb", ".htm", ".php"]
+    test_config['template_paths']                   = ["templates", "partials"]
+    test_config['template_and_partial_identifier']  = "erb"
+    test_config['site_variables']                   = {
+      'local'   => {'site_name' => 'test-site', 'site_url' => 'http://localhost:737373',  'site_path' => '/var/www/html' },
+      'release' => {'site_name' => 'test-site', 'site_url' => 'https://primjer.hr',       'site_path' => '/var/www/html' }
+    }
+
+    config.instance_variable_set :@config, test_config
+
+    Dir.mktmpdir do |tmp_dir|
+
+      config.generate_config_file(tmp_dir)
+
+      assert File.exist?(File.join(tmp_dir, Geb::Defaults::SITE_CONFIG_FILENAME))
+
+      new_generated_config = YAML.load_file(File.join(tmp_dir, Geb::Defaults::SITE_CONFIG_FILENAME))
+
+      refute_empty new_generated_config
+
+      assert_nil new_generated_config['site_name']
+      assert_nil new_generated_config['remote_uri']
+      assert_nil new_generated_config['remote_path']
+
+      assert_equal test_config['local_port'],                       new_generated_config['local_port']
+      assert_equal test_config['output_dir'],                       new_generated_config['output_dir']
+      assert_equal test_config['assets_dir'],                       new_generated_config['assets_dir']
+      assert_equal test_config['page_extensions'],                  new_generated_config['page_extensions']
+      assert_equal test_config['template_paths'],                   new_generated_config['template_paths']
+      assert_equal test_config['template_and_partial_identifier'],  new_generated_config['template_and_partial_identifier']
+      assert_equal test_config['site_variables']['local'],          new_generated_config['site_variables']['local']
+      refute_equal test_config['site_variables']['release'],        new_generated_config['site_variables']['release']
+
+      assert_empty new_generated_config['site_variables']['release']['site_name']
+      assert_empty new_generated_config['site_variables']['release']['site_url']
+      assert_empty new_generated_config['site_variables']['release']['site_path']
+
+    end # Dir.mktmpdir
+
+  end # test "that generate config sucessfully generates all configuration fields"
+
 end # class TestConfig < Minitest::Test

data/test/api tests/test_page.rb

@@ -76,17 +76,17 @@ class PageTest < Geb::ApiTest
     site = mock('site')
     site.stubs(:site_path).returns(Dir.pwd)
 
+    parse_sequence = sequence('parse_sequence')
     Geb::Page.any_instance.stubs(:page_file_exists?).returns(true)
-    Geb::Page.any_instance.stubs(:parse_for_templates).returns(parsed_page_content)
-    Geb::Page.any_instance.stubs(:parse_for_partials).returns(parsed_page_content)
+    Geb::Page.any_instance.stubs(:parse_for_templates).returns(parsed_page_content).once.in_sequence(parse_sequence)
+    Geb::Page.any_instance.stubs(:parse_for_partials).returns(parsed_page_content).once.in_sequence(parse_sequence)
+    Geb::Page.any_instance.stubs(:parse_for_site_variables).returns(parsed_page_content).once.in_sequence(parse_sequence)
     File.stubs(:read).returns(page_content)
 
     page = Geb::Page.new(site, page_path)
 
     assert_respond_to page, :parse
 
-    page.parse
-
     assert_respond_to page, :parsed_content
     assert_equal page.parsed_content, parsed_page_content
     refute_equal page.parsed_content, page.content
@@ -204,6 +204,90 @@ class PageTest < Geb::ApiTest
 
   end # test "that page parse_for_partials method works"
 
+  test "that the parse_for_site_variables method works" do
+
+    page_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+    site_name = "Some cool site"
+    page_title = "This is some ultra cool page title"
+    page_content = <<-PAGE
+      _{variable_1}_ _{variable_2}_ _{variable_3}_
+      <title>#{page_title}</title>
+      Find the _{page_title}_ here
+      _{page_relative_path}_
+      _{site_name}_
+      Geb version _{geb_version}_
+    PAGE
+
+    site_variables = { "variable_1" => "value_1", "variable_2" => "value_2" }
+
+    config = mock('config')
+    config.stubs(:get_site_variables).returns(site_variables)
+    config.stubs(:site_name).returns(site_name)
+
+    site = mock('site')
+    site.stubs(:site_path).returns(Dir.pwd)
+    site.stubs(:site_config).returns(config)
+
+    File.stubs(:read).returns(page_content)
+    Geb::Page.any_instance.stubs(:page_file_exists?).returns(true)
+    Geb::Page.any_instance.stubs(:parse_for_templates).returns(page_content)
+    Geb::Page.any_instance.stubs(:parse_for_partials).returns(page_content)
+
+    page = Geb::Page.new(site, page_path)
+
+    output_content = page.parse_for_site_variables(page_content)
+
+    assert_includes output_content, "value_1"
+    assert_includes output_content, "value_2"
+    assert_includes output_content, "_{variable_3}_"
+    assert_includes output_content, site_name
+    assert_includes output_content, "Find the #{page_title} here"
+    assert_includes output_content, "Geb version #{Geb::VERSION}"
+    assert_includes output_content, page_path.gsub(Dir.pwd, "")
+
+  end # test "that the parse_for_site_variables method works"
+
+  test "that the parse_for_site_variables method works if site variables are not set" do
+
+    page_path = File.join(Dir.pwd, "test", "fixtures", "template.html")
+    site_name = "Some cool site"
+    page_title = "This is some ultra cool page title"
+    page_content = <<-PAGE
+      _{variable_1}_ _{variable_2}_ _{variable_3}_
+      <title>#{page_title}</title>
+      _{site_name}_
+      _{page_relative_path}_
+      _{site_name}_
+    PAGE
+
+    site_variables = nil
+
+    config = mock('config')
+    config.stubs(:get_site_variables).returns(site_variables)
+    config.stubs(:site_name).returns(site_name)
+
+    site = mock('site')
+    site.stubs(:site_path).returns(Dir.pwd)
+    site.stubs(:site_config).returns(config)
+
+    File.stubs(:read).returns(page_content)
+    Geb::Page.any_instance.stubs(:page_file_exists?).returns(true)
+    Geb::Page.any_instance.stubs(:parse_for_templates).returns(page_content)
+    Geb::Page.any_instance.stubs(:parse_for_partials).returns(page_content)
+
+    page = Geb::Page.new(site, page_path)
+
+    output_content = page.parse_for_site_variables(page_content)
+
+    assert_includes output_content, "_{variable_1}_"
+    assert_includes output_content, "_{variable_2}_"
+    assert_includes output_content, "_{variable_3}_"
+    assert_includes output_content, site_name
+    assert_includes output_content, " <title>#{page_title}</title>"
+    assert_includes output_content, page_path.gsub(Dir.pwd, "")
+
+  end # test "that the parse_for_site_variables method works if site variables are not set"
+
   test "that page build method works" do
 
     site_path = Dir.pwd