yuzu 0.2.1.pre

data/lib/yuzu/commands/watch.rb

@@ -0,0 +1,70 @@
+#require 'fssm'
+
+#def rebuild_site(base, relative_path, config)
+#  $stderr.puts ">>> Change Detected to: #{relative_path} <<<"
+
+#  if File.directory?(relative_path)
+#    if relative_path.includes_one_of?(config.folder_blacklist)
+#      $stderr.puts ">>> Blacklisted folder found. No update."
+#      return
+#    elsif relative_path.include?(config.template_dir)
+#      $stderr.puts ">>> Change in a template found. No update (yet)."
+#      return
+#    end
+#  else
+#    file_ext = File.extname(relative_path)
+#    #if relative_path.includes_one_of?(config.folder_blacklist)
+#    #  puts ">>> Blacklisted folder found. No update."
+#    #  return
+#    #els
+#    if file_ext.includes_one_of?(config.extension_blacklist)
+#      $stderr.puts ">>> Blacklisted extension found. No update."
+#      return
+#    elsif relative_path.include?(config.template_dir)
+#      $stderr.puts ">>> Change in a template found. No update (yet)."
+#      return
+#    end
+#  end
+
+#  IO.popen("yuzu preview #{relative_path}") do |io|
+#    $stderr.print( io.readpartial(512) ) until io.eof?
+#  end
+
+#  $stderr.puts '>>> Update Complete <<<'
+#end
+
+
+module Yuzu::Command
+
+  class Watch < Base
+    # Method to start the watcher.
+    def index
+      $stder.puts "The watcher has been temporarily disabled. Please use yuzu preview."
+
+      #$stderr.puts ">>> Yuzu is watching for changes <<<"
+
+      ## The block below doesn't have the current Watch object in its scope,
+      ## so we can't pass in @config directly. Pass it into the *args parameter
+      ## and the hash becomes part of the @options instance variable in the
+      ## FSSM implementation. Then unpack it and pass the YuzuConfig(@config)
+      ## to the rebuild_site method.
+      #FSSM.monitor("#{Dir.pwd}", '**/*', :config => @config) do
+      #  update {|base, relative| rebuild_site(base, relative, @options[:config])}
+      #  delete {|base, relative| rebuild_site(base, relative, @options[:config])}
+      #  create {|base, relative| rebuild_site(base, relative, @options[:config])}
+      #end
+
+    end
+
+    def self.help method
+      case method
+      when :index
+        "Watches the current directory for changes and automatically updates the preview of changed files."
+      else
+
+      end
+    end
+  end
+
+end
+

data/lib/yuzu/content/blog_post.rb

@@ -0,0 +1,45 @@
+
+module Yuzu::Content
+  class BlogPost
+    def initialize(postname, config)
+      @postname = postname
+      @filename = postname.dasherize.downcase
+      @config = config
+    end
+
+    def deliver!
+      date = Time.now.strftime("%Y-%m-%d")
+      full_filename = "#{date}-#{@filename}.md"
+
+      file_path = File.join(@config.blog_dir, full_filename)
+
+      if File.exists?(file_path)
+        $stderr.puts "Warning: File #{@filename} already exists!"
+
+      else
+        $stderr.puts "Creating file: #{@filename}"
+
+        File.open(file_path, "w+") do |f|
+          f.puts(contents)
+        end
+
+      end
+    end
+
+    def contents
+      return %Q{# #{@postname}
+
+The title of this post is #{@postname}.
+
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, 
+sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim 
+ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip 
+ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate 
+velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat 
+cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id 
+est laborum.
+}
+    end
+  end
+
+end

data/lib/yuzu/content/sample_project.rb

@@ -0,0 +1,130 @@
+require 'yaml'
+require 'etc'
+
+module Yuzu::Content
+  class ProjectNotFound < Exception; end
+  class ThemeNotFound < Exception; end
+  class SampleContentNotFound < Exception; end
+  class ConfigNotFound < Exception; end
+
+  class SampleProject
+    def self.registered_projects
+      @@registry ||= YAML.load_file(registry_file)
+    end
+
+    def self.registry_file
+      File.join(resources_folder, "sample_projects.yml")
+    end
+
+    def initialize(sample_project_name)
+      @name = sample_project_name
+
+      if SampleProject.registered_projects.has_key?(@name)
+        @project_info = SampleProject.registered_projects[@name]
+      else
+        raise ProjectNotFound, "#{@name} is not a known sample project."
+      end
+    end
+
+    def deliver!
+      copy_theme!
+      copy_content!
+      copy_config!
+    end
+
+    def theme_name
+      @project_info['theme']
+    end
+
+    def sample_content_name
+      @project_info['content']
+    end
+
+    def copy_theme!
+      theme_folder = File.join(SampleProject.theme_folder, theme_name)
+      if File.exists?(theme_folder)
+        copy_folder_contents!(theme_folder)
+      else
+        throw ThemeNotFound, "#{theme_name} is not a known theme."
+      end
+    end
+
+    def copy_content!
+      content_folder = File.join(SampleProject.sample_content_folder, sample_content_name)
+      if File.exists?(content_folder)
+        copy_folder_contents!(content_folder)
+      else
+        throw SampleContentNotFound, "#{sample_content_name} is not a known set of sample content."
+      end
+    end
+
+    def copy_config!
+      config_folder = File.join(SampleProject.resources_folder, "config")
+      copy_folder!(config_folder)
+      post_process_config!
+    end
+
+    def copy_folder!(folder_name)
+      FileUtils.cp_r(folder_name, SampleProject.destination_folder)
+    end
+
+    def copy_folder_contents!(folder)
+      source = File.join(folder, "*")
+      FileUtils.cp_r(Dir[source], SampleProject.destination_folder)
+    end
+
+    def post_process_config!
+      destination_config = File.join(SampleProject.destination_folder, "config", "yuzu.yml")
+      if File.exists?(destination_config)
+        user_home_folder = File.expand_path("~")
+        username = Etc.getlogin
+
+        config_contents = File.read(destination_config)
+
+        config_contents.gsub!("HOME", user_home_folder)
+        config_contents.gsub!("USERNAME", username)
+
+        File.open(destination_config, "w") do |config|
+          config.puts(config_contents)
+        end
+
+        load_new_config!(destination_config)
+      else
+        raise ConfigNotFound, "The yuzu.yml file wasn't found in the expected place: #{destination_config}."
+      end
+    end
+
+    def load_new_config!(destination_config_path)
+      @new_config ||= YAML.load_file(destination_config_path)
+    end
+
+    def new_config
+      if @new_config.nil?
+        raise ConfigNotFound, "New config file not found."
+      else
+        @new_config
+      end
+    end
+
+    def self.theme_folder
+      File.join(resources_folder, "themes")
+    end
+
+    def self.sample_content_folder
+      File.join(resources_folder, "sample_content")
+    end
+
+    def self.resources_folder
+      File.join(File.dirname(__FILE__), "..", "..", "..", "resources")
+    end
+
+    def self.destination_folder
+      Dir.pwd
+    end
+
+    def self.exists?(sample_project_name)
+      registered_projects.has_key?(sample_project_name)
+    end
+  end # SampleProject
+
+end

data/lib/yuzu/core/config.rb

@@ -0,0 +1,154 @@
+require 'pathname'
+require 'helpers/path'
+require 'helpers/string'
+require 'helpers/system_checks'
+
+module Yuzu::Core
+  class Config
+    include Helpers
+
+    attr_reader :config_hash, :service
+
+    def initialize(config_hash, service_override=nil, parsed_options=[])
+      @config_hash = config_hash
+      @service = service_override || config_hash['connection']
+      @options = parsed_options
+
+      # Create a method for every top-level key in the configuration dictionary.
+      (class << self; self; end).class_eval do
+        config_hash.each_pair do |key, value|
+          instance_variable = "@#{key}".to_sym
+
+          define_method key do
+            if instance_variable_get(instance_variable).nil?
+              instance_variable_set(instance_variable, value)
+            end
+            instance_variable_get(instance_variable)
+          end
+
+          define_method "set_#{key}" do |other|
+            instance_variable_set(instance_variable, other)
+          end
+
+        end
+      end
+
+      check_for_gems
+    end
+
+    OPTIONAL_GEMS = ['compass']
+
+    # Provides information about installed gems for optional features, like Compass integration, git
+    # integration, 
+    def check_for_gems
+
+      OPTIONAL_GEMS.each do |gem_name|
+        method_name = "has_#{gem_name.underline}?".to_sym
+
+        (class << self; self; end).class_eval do
+          instance_variable_name = "@has_#{gem_name.underline}".to_sym
+
+          define_method method_name do
+            if instance_variable_get(instance_variable_name).nil?
+              gem_installed = SystemChecks.gem_available?(gem_name)
+              instance_variable_set(instance_variable_name, gem_installed)
+            end
+            instance_variable_get(instance_variable_name)
+          end # define_method
+
+        end # class_eval
+
+      end # OPTIONAL_GEMS
+    end
+
+    def verbose?
+      @options.output == :verbose
+    end
+
+    def pwd
+      Path.new
+    end
+
+    def processable?(path)
+      check_extension(path.extension, processable_extensions)
+    end
+
+    def resource?(path)
+      check_extension(path.extension, resource_extensions)
+    end
+
+    def image?(path)
+      check_extension(path.extension, image_extensions)
+    end
+
+    def asset?(path)
+      check_extension(path.extension, asset_extensions)
+    end
+
+    def check_extension(extension, extensions)
+      return false if extension_blacklist.include?(extension)
+      return extensions.include?(extension)
+    end
+
+    def can_index_folder?(path)
+      absolute_no_index_paths = (no_index_folders + folder_blacklist + system_folders).collect {|p| Path.new(p)}
+
+      tr = false
+      absolute_no_index_paths.each do |folder|
+        tr ||= folder.contains?(path)
+      end
+      not tr
+    end
+
+    def system_folders
+      ["config", ".git"]
+    end
+
+    def link_root_for_service(service)
+      @config_hash['services'][service]['link_root'].to_s
+    end
+
+    def link_root
+      link_root_for_service(@service)
+    end
+
+    def linkroot
+      link_root
+    end
+
+    def domain
+      domain_for_service @service
+    end
+
+    def domain_for_service service
+      @config_hash[service]['domain'].to_s
+    end
+
+    def possible_indices
+      @processable_indices ||= processable_extensions.collect {|e| "index#{e}"}
+    end
+
+    def preview?
+      @service == 'preview'
+    end
+
+    def stage?
+      @service == 'stage'
+    end
+
+    # Checks to see whether file should be considered hidden. By default, all
+    # filenames and folders starting with an underscore are hidden.
+    def is_hidden?(path)
+      parts = path.split(File::SEPARATOR)
+      hidden = parts.collect do |f|
+        f[0].chr == "_"
+      end
+      hidden.any?
+    end
+
+    def is_blacklisted?(path)
+      path.includes_one_of?(folder_blacklist)
+    end
+  end
+
+end

data/lib/yuzu/core/layout.rb

@@ -0,0 +1,85 @@
+require 'core/template'
+
+module Yuzu::Core
+  # A Layout is a Template that lays out an entire page. It consists of a collection of partial
+  # templates, namely for the HTML <head>, but also for a page header, footer, and navigation menu.
+  # In the future, this will be generalized.
+  class Layout < Yuzu::Core::HamlTemplate
+    # The standard page partials.
+    #def self.partial_names
+    #  #%w(head header footer menu)
+    #end
+
+    # A hash of partial name to filename.
+    #
+    # @return [Hash]
+    def self.partial_filenames
+      relative_paths = Dir[(@@template_dir + "*").to_s]
+      files = relative_paths.collect {|p| File.basename(p)}
+      files.select {|filename| filename[0].chr == "_"}
+    end
+
+    # A hash of partial name to the corresponding HamlTemplate object for that partial.
+    #
+    # @return [Hash] of String => HamlTemplate
+    def self.partials
+      @@partials ||= get_partials
+    end
+
+    # Calculates the Hash for self.partials.
+    def self.get_partials
+      tr = {}
+      partial_filenames.each do |filename|
+        partial_name = filename[1...-5]
+        tr[partial_name] = HamlTemplate.new(filename)
+      end
+      tr
+    end
+
+    # A Hash of all the local variables passed into the Haml engine when the layout is rendered.
+    #
+    # @param [WebsiteFile] website_file The website file being rendered.
+    # @return [Hash] of local variables available in the template.
+    def layout_locals(website_file)
+      {:layout => PageLayout.new(website_file, Layout.partials)}
+    end
+
+    # Actually renders the layout for the given file.
+    #
+    # @param [WebsiteFile] website_file The website_file being rendered in the layout.
+    # @return [String] A string containing the HTML rendered contents of the file as a webpage.
+    def render(website_file)
+      # Contains the standard local variables `post` and `config`.
+      local_variables = locals(website_file)
+
+      # Add `layout` to the mix.
+      layout_local_variables = layout_locals(website_file)
+
+      engine.render(
+        Yuzu::Core::TemplateMethods.new(website_file.root),
+        local_variables.merge(layout_local_variables)
+      )
+    end
+  end
+
+
+  # A class that encapsulates the variables in the `layout` namespace in the Haml layout. This means
+  # that the user can access variables passed into the `kwds` hash with dot notation on `layout`.
+  # For example:
+  #
+  #     layout.head - Refers to the rendered contents of _head.haml
+  #
+  class PageLayout
+    def initialize(website_file, kwds={})
+      kwds.each_pair do |method_name, template_obj|
+        (class << self; self; end).class_eval do
+          define_method method_name.to_sym do
+            template_obj.render(website_file)
+          end
+        end
+      end
+    end
+  end
+
+end
+