yuzu 0.2.1.pre

data/lib/yuzu/core/paginated_file.rb

@@ -0,0 +1,69 @@
+require 'core/website_file'
+
+module Yuzu::Core
+  class PaginatedWebsiteFile < WebsiteFile
+    attr_reader :original_file
+
+    # Initialize a new generated file from an existing WebsiteFile
+    # 
+    # @param [WebsiteFile] original_file The root file representing page 1.
+    # @param [String] new_raw_contents The new contents with the INSERTCATALOG directives updated to
+    #   include the page:N argument.
+    # @param [Fixnum] page The page that this generated file represents.
+    def initialize(original_file, new_raw_contents, page)
+      @raw_contents = new_raw_contents
+      @page = page
+
+      @path = Yuzu::Core.get_paginated_path(original_file.path, page)
+      raise "@path is nil in #{self}" if @path.nil?
+
+      @original_file = original_file
+      @parent = original_file.parent
+      @kind = :file
+    end
+
+    def to_s
+      "PaginatedWebsiteFile(#{@path.relative})"
+    end
+
+    def get_raw_contents
+      @raw_contents
+    end
+
+    def modified_at
+      @original_file.modified_at
+    end
+
+    def created_at
+      @original_file.created_at
+    end
+
+    def load_file_info!
+      # No need to do anything here. All dependent methods are overridden.
+    end
+
+    def generated?
+      true
+    end
+
+    def paginated?
+      true
+    end
+  end
+
+  # Calculate the page of this file, assuming it's a file produced from pagination.
+  #
+  # @param [Path] original_path The path of the original seed file being paginated.
+  # @param [Fixnum] page The page of the new file.
+  # @return [Path] The new path in the format path/to/file_N.ext where N is the page number.
+  def get_paginated_path(original_path, page)
+    new_path = original_path.dup
+    new_path.make_file!
+    tr = new_path.add_suffix(page)
+    raise "New path is nil!" if tr.nil?
+    tr.make_file!
+    tr
+  end
+  module_function :get_paginated_path
+
+end

data/lib/yuzu/core/registrar.rb

@@ -0,0 +1,32 @@
+
+module Yuzu::Registrar
+
+  # Class Register includes routines for storing singletons of objects with a common base class that
+  # can be executed as a set.
+  class Register
+    # Subclasses should redefine `registry` with a unique identifier equal to the name of the class
+    # variable that will contain the singletons.
+    @@registered = {}
+    def self.registry
+      :registered
+    end
+    def self.registered
+      @@registered
+    end
+
+    # Subclasses of the Register should call this method after their definitions to register them 
+    # into the registry.
+    def self.register(name_to_class={})
+      class_var = "@@#{self.registry}".to_sym
+      register = class_variable_get(class_var)
+      if register.nil?
+        class_variable_set(class_var, {})
+        register = {}
+      end
+      name_to_instance = Hash[name_to_class.collect {|name, klass| [name, klass.new]}]
+      class_variable_set(class_var, register.merge(name_to_instance))
+    end
+  end
+
+end
+

data/lib/yuzu/core/siteroot.rb

@@ -0,0 +1,57 @@
+require 'core/website_folder'
+
+Dir["#{File.dirname(__FILE__)}/../generators/*"].each { |c| require c }
+
+module Yuzu::Core
+  class SiteRoot < WebsiteFolder
+    include Yuzu::Generators
+
+    attr_reader :config
+    def initialize(yuzu_config)
+      @config = yuzu_config
+      @path = @config.pwd
+      @parent = nil
+      @kind = :folder
+
+      generate!
+    end
+
+    def name
+      @config.site_name
+    end
+
+    # Given a Path, return the WebsiteFile or WebsiteFolder corresponding to the Path.
+    def find_file_by_path(path)
+      path_elements = path.relative.split(File::SEPARATOR)
+
+      parent = self
+      path_elements.each do |element|
+        child = parent.get_child_by_rootname(element)
+        return nil if child.nil?
+        parent = child
+      end
+
+      return parent
+    end
+
+    def generators
+      Generator.generators
+    end
+
+    # Process all the generators to make all the new files required from things like pagination of
+    # catalogs and new index files.
+    def generate!
+      generators.each_pair do |name, generator|
+        v = Visitor.new(generator.visitor_filter)
+
+        v.traverse(self) do |node|
+          if generator.should_generate?(node)
+            generator.generate!(node)
+          end
+        end
+      end
+    end
+  end
+
+end
+

data/lib/yuzu/core/template.rb

@@ -0,0 +1,158 @@
+require 'haml'
+require 'helpers/path'
+
+module Yuzu::Core
+  class Template
+    include Helpers
+
+    # TODO Make this part of a module-level config.
+    @@template_dir = Path.new("_templates")
+
+    # template_name -- String. The filename of the template, e.g. _gallery.haml
+    def initialize(template_name)
+      @template_name = template_name
+    end
+
+    def path
+      @@template_dir + @template_name
+    end
+
+    def exists?
+      path.exists?
+    end
+
+    def fallback_path
+      # TODO Configure fallbacks in a more general way.
+      if @template_name[0].chr == "_"
+        @@template_dir + "_block.haml"
+      else
+        @@template_dir + "generic.haml"
+      end
+    end
+
+    def fallback_exists?
+      fallback_path.exists?
+    end
+
+    def contents
+      @contents ||= get_contents
+    end
+
+    def get_contents
+      tr = get_template_contents(path)
+      tr.nil? ? get_template_contents(fallback_path) : tr
+    end
+
+    def get_template_contents(file_path)
+      if file_path.exists?
+        f = File.open(file_path.absolute, 'r')
+        contents = f.read
+        f.close
+        contents
+      else
+        $stderr.puts "WARNING: Couldn't find template #{file_path}"
+        nil
+      end
+    end
+
+    def render(website_file, data={})
+      ""
+    end
+  end
+
+
+  class HamlTemplate < Template
+    def options
+      {:format => :html5}
+    end
+
+    def engine
+      @engine ||= Haml::Engine.new(contents, options)
+    end
+
+    def locals(website_file)
+      {
+        :post => website_file.properties,
+        :config => website_file.config
+      }
+    end
+
+    def render(website_file, data={})
+      engine.render(
+        TemplateMethods.new(website_file.root),
+        locals(website_file).merge(data)
+      )
+    end
+  end
+
+
+  # The root object that contains functions that can be called from inside the Haml template.
+  class TemplateMethods
+    def initialize(siteroot)
+      @siteroot = siteroot
+    end
+
+    def insert_raw_file(filename)
+      insert_contents(filename, :raw_contents)
+    end
+
+    def insert_rendered_contents(filename)
+      insert_contents(filename, :rendered_contents)
+    end
+
+    def insert_contents(filename, method=:raw_contents)
+      path = Helpers::Path.new(filename)
+      return (Html::Comment.new << "File #{filename} not found.") if not path.exists?
+
+      website_file = @siteroot.find_file_by_path(path)
+
+      if not website_file.nil?
+        website_file.send(method)
+
+      else
+
+        f = File.open(filename, "r")
+        contents = f.read
+        f.close
+
+        return contents if method == :raw_contents
+        Yuzu::Translators::Translator.translate(contents, path.extension)
+
+      end
+    end
+
+    def format_date(raw_date)
+      if not raw_date.is_a?(String) and not raw_date.is_a?(Time)
+        return raw_date
+      end
+
+      if raw_date.is_a?(String)
+        raw_date = Time.parse(raw_date)
+      end
+
+      date = raw_date.strftime("%Y-%m-%d")
+
+      months = {
+        "01" => "January",
+        "02" => "February",
+        "03" => "March",
+        "04" => "April", 
+        "05" => "May",
+        "06" => "June",
+        "07" => "July",
+        "08" => "August", 
+        "09" => "September",
+        "10" => "October",
+        "11" => "November",
+        "12" => "December"
+      }
+
+      year, month, day = date.split("-")[0..2]
+      month = months[month]
+
+      "#{year} #{month} #{day}"
+    end
+
+  end
+end
+

data/lib/yuzu/core/updater.rb

@@ -0,0 +1,123 @@
+require 'core/visitor'
+require 'helpers/path'
+require 'core/siteroot'
+
+
+
+module Yuzu::Core
+  BOLD = "\033[1m"
+  WHITE = "\033[37m"
+  ENDC = "\033[0m"
+
+  # Updater is the primary mechanism to update a website and filter for the files that need
+  # updating.
+  class Updater
+
+    def initialize(uploader, config)
+      @uploader = uploader
+      @config = config
+
+      @siteroot = SiteRoot.new(@config)
+
+      $stderr.puts "Updater initialized..." if @config.verbose?
+    end
+
+    def update_all
+      $stderr.puts "Updating all..." if @config.verbose?
+
+      filter = proc {|c| (c.processable? or c.resource? or c.image? or c.asset?) and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def update_text
+      $stderr.puts "Updating text files..." if @config.verbose?
+
+      filter = proc {|c| c.processable? and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def upload_new_images(known_images=[])
+      filter = proc {|c| c.image? and not c.hidden? and not known_images.include?(c)}
+      update_by_filter(filter)
+    end
+
+    def upload_all_images
+      filter = proc {|c| c.image? and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def upload_all_assets
+      filter = proc {|c| c.asset? and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def upload_all_resources
+      filter = proc {|c| c.resource? and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def upload_all_css
+      filter = proc {|c| c.path.extension == ".css" and not c.hidden?}
+      update_by_filter(filter)
+    end
+
+    def update_by_filter(proc_filter)
+      updated = []
+      visit = Visitor.new(proc_filter)
+
+      visit.traverse(@siteroot) do |file|
+        update_file(file)
+        updated.push(file)
+      end
+
+      updated
+    end
+
+    # Update a single WebsiteFile. This effectively initiates the uploader to publish the file to
+    # the destination specified by the currently selected service.
+    def update_file(website_file)
+      $stderr.puts "#{BOLD}#{WHITE}Updating #{website_file}#{ENDC}#{ENDC}" if @config.verbose?
+
+      if website_file.processable?
+        @uploader.upload(website_file.remote_path, website_file.html_contents)
+
+      elsif website_file.resource? or website_file.image? or website_file.asset?
+        f = File.open(website_file.path.absolute, "r")
+        @uploader.upload(website_file.remote_path, f)
+        f.close
+
+      else
+        $stderr.puts "Can't update #{website_file}." if @config.verbose?
+
+      end
+    end
+
+    # Update a particular list of files. This is relatively expensive as it requires searching
+    # through the file tree, but it should work well for a few files.
+    #
+    # @param [Array] files_to_update An Array of Strings holding absolute file paths or paths
+    #   relative to the project folder.
+    def update_these(files_to_update=[])
+      if files_to_update.empty?
+        update_all
+        return
+      end
+
+      $stderr.puts "Updating files..." if @config.verbose?
+
+      files_to_update.each do |relative_path|
+        p = Helpers::Path.new(relative_path)
+        website_file = @siteroot.find_file_by_path(p)
+        if not website_file.nil?
+          update_file(website_file)
+        else
+          $stderr.puts "Couldn't find a WebsiteFile for #{p}" if @config.verbose?
+        end
+      end
+    end  
+
+    def done
+      @uploader.close! unless @uploader.nil?
+    end
+  end
+end

data/lib/yuzu/core/visitor.rb

@@ -0,0 +1,44 @@
+
+module Yuzu::Core
+
+  # Visitor is a convenience mechanism for traversing a tree structure. To be traversable, objects
+  # in the data structure must have the following interface defined:
+  #
+  #     def children
+  #       return an array of nodes or nil
+  #     end
+  #
+  # WebsiteBase and Path have this interface, so are traversable. Given a Proc that returns a
+  # boolean, we can limit the operation performed by the visitor to a subset of available nodes.
+  #
+  # Usage:
+  #
+  #     filter_for_files_only = proc {|c| c.file?}
+  #     v = Visitor.new(filter_for_files_only)
+  #     v.traverse(root) do |child|
+  #       # Do something with child.
+  #     end
+  #
+  # Each node passing the `filter_for_files_only` filter will be executed in the given block.
+  class Visitor
+
+    # Create a visitor
+    #
+    # @param [Proc] filter A proc that returns true/false given the child object in question
+    def initialize(filter=nil)
+      #raise "Visitor must be given a Proc." if not filter.is_a?(Proc)
+      @filter = filter.nil? ? proc {|c| true} : filter
+    end
+
+    def traverse(container, &block)
+      return if container.children.nil?
+
+      container.children.each do |child|
+        block.call(child) if @filter.call(child)
+        self.traverse(child, &block) if not child.children.nil?
+      end
+    end
+  end
+
+end
+