yuzu 0.2.1.pre

data/lib/yuzu/core/website_base.rb

@@ -0,0 +1,150 @@
+require 'helpers/path'
+
+module Yuzu::Core
+  class WebsiteBase
+    include Helpers
+
+    attr_reader :path, :parent, :kind
+
+    def initialize(path, parent)
+      raise "WebsiteBase not initialized with a Path object." if not path.is_a?(Path)
+
+      @path = path
+      raise "@path is nil for #{self}" if @path.nil?
+      @parent = parent
+      @kind = nil
+      @stash = {}
+    end
+
+    def == (other)
+      return false if not other.is_a?(WebsiteBase)
+      return @path == other.path
+    end
+
+    def name
+      @path.basename
+    end
+
+    def root
+      @root ||= (@parent.nil? ? self : @parent.root)
+    end
+
+    def root?
+      root == self
+    end
+
+    def blog_folder
+      @@blog ||= root.find_file_by_path(Path.new(config.blog_dir))
+    end
+
+    def in_blog?
+      blog_folder.nil? ? false : blog_folder.is_child?(self)
+    end
+
+    def is_blog?
+      self == blog_folder or (index? and self.path.dirname == blog_folder.path.dirname)
+    end
+
+    def index?
+      false
+    end
+
+    def config
+      @parent.config
+    end
+
+    def file?
+      @kind == :file
+    end
+
+    def folder?
+      @kind == :folder
+    end
+
+    def children
+      nil
+    end
+
+    def processable?
+      @processable ||= is_processable?
+    end
+
+    def is_processable?
+      return false if folder?
+      config_says = config.processable?(@path)
+      translators_say = Yuzu::Translators::Translator.can_translate?(self)
+      config_says and translators_say
+    end
+
+    def resource?
+      return false if folder?
+      config.resource?(@path)
+    end
+
+    def image?
+      return false if folder?
+      config.image?(@path)
+    end
+
+    def asset?
+      return false if folder?
+      config.asset?(@path)
+    end
+
+    def hidden?
+      return false if root?
+      @parent.hidden? or @path.rootname[0].chr == "_"
+    end
+
+    def config
+      @parent.config
+    end
+
+    def link_to_self(attr={})
+      Html::Link.new({:href => link_url}.merge(attr)) << name
+    end
+
+    def link_url
+      @link_url ||= get_link_url
+    end
+
+    def get_link_url
+      folder? ? currentpath.full : (currentpath + output_filename).full
+    end
+
+    def remote_path
+      @remote_path ||= get_remote_path
+    end
+
+    def get_remote_path
+      if processable?
+        tr = file? ? @path.with_extension(extension) : @path
+        if tr == @path
+          raise "Remote path and source path are the same! Got #{tr} and #{@path}."
+        end
+        tr
+      else
+        @path
+      end
+    end
+
+    def default_stash
+      {
+        :generated_siblings => [],
+        :catalog => nil
+      }
+    end
+
+    # Enables other processes to add imbue this node with information.
+    def stash(kwds={})
+      @stash = default_stash if @stash.nil?
+      kwds.empty? ? @stash : @stash.update(kwds)
+    end
+
+    def generated?
+      false
+    end
+
+  end
+end
+

data/lib/yuzu/core/website_file.rb

@@ -0,0 +1,270 @@
+require 'html/base'
+require 'core/website_base'
+require 'core/layout'
+
+require 'filters/base'
+require 'renderers/base'
+require 'preprocessors/base'
+require 'postprocessors/base'
+require 'translators/base'
+
+%w(filters renderers preprocessors postprocessors translators).each do |folder|
+  Dir["#{File.dirname(__FILE__)}/../#{folder}/*"].each { |c| require c if not c.include?("base.rb")}
+end
+
+module Yuzu::Core
+  class WebsiteFile < WebsiteBase
+    include Yuzu::Filters
+    include Yuzu::Renderers
+    include Yuzu::PreProcessors
+    include Yuzu::PostProcessors
+    include Yuzu::Translators
+
+    def self.translators
+      Translator.translators
+    end
+
+    def self.processors
+      tr = Filter.filters.merge(Renderer.renderers)
+    end
+
+    # Create an accessor method for each filter, renderer, postprocessor.
+    self.processors.each_pair do |name, object|
+      execution_method = object.kind_of?(Renderer) ? :render : :value
+
+      instance_variable = "@#{name}".to_sym
+
+      define_method(name) do
+        val = self.instance_variable_get(instance_variable)
+
+        if val.nil?
+          self.instance_variable_set(
+            instance_variable,
+            object.send(execution_method, self)
+          )
+        end
+
+        self.instance_variable_get(instance_variable)
+      end
+    end
+
+    # Adds all the postprocessors to this object as methods.
+    PostProcessor.postprocessors.each_pair do |name, processor|
+
+      define_method name do
+        # This routine caches the result in an instance variable.
+        instance_variable = "@postprocessor_#{name}".to_sym
+        begin
+          if instance_variable_get(instance_variable).nil?
+            result = processor.value(self)
+            instance_variable_set(instance_variable, result)
+          end
+          instance_variable_get(instance_variable)
+        rescue => e
+          puts "\033[91mEXCEPTION IN #{name}\033[0m"
+          #puts e.message
+          #puts e.backtrace
+        end
+      end
+
+    end
+
+    attr_reader :page, :parent, :path
+
+    def initialize(path, parent, page=1)
+      @path = path
+      raise "@path is nil for #{self}" if @path.nil?
+
+      @parent = parent
+      @page = page
+
+      @kind = :file
+    end
+
+    # Returns a Hash of the properties of this file, like the name, etc.
+    def properties
+      @properties ||= FileProperties.new(self)
+    end
+
+    def to_s
+      "WebsiteFile(#{@path.relative})"
+    end
+
+    def name
+      post_title
+    end
+
+    def author
+      config.author
+    end
+
+    def home?
+      parent.root? and index?
+    end
+
+    def index?
+      basename == "index" or basename.include?("index_")
+    end
+
+    def filename
+      @path.filename
+    end
+
+    def basename
+      @path.basename
+    end
+
+    def output_filename
+      processable? ? @path.with_extension(extension).filename : filename
+    end
+
+    def markdown?
+      @path.markdown?
+    end
+
+    def plaintext?
+      @path.plaintext?
+    end
+
+    # Alias
+    def link_root
+      linkroot
+    end
+
+    def paginated?
+      false
+    end
+
+    def raw_contents
+      if @raw_contents.nil?
+        @raw_contents = get_raw_contents
+        preprocess!
+      end
+      @raw_contents
+    end
+
+    def get_raw_contents
+      f = File.open(@path.absolute, "r")
+      contents = f.read
+      f.close
+      contents
+    end
+
+    def created_at
+      @created_at ||= @path.pathname.ctime
+    end
+
+    def modified_at
+      @modified_at ||= @path.pathname.mtime
+    end
+
+    def preprocess!
+      PreProcessor.preprocessors.each do |name, preprocessor|
+        preprocessor.process(self, @raw_contents)
+      end
+    end
+
+    def prefiltered_contents
+      @prefiltered_contents ||= get_prefiltered_contents
+    end
+
+    def get_prefiltered_contents
+      tr = raw_contents
+      prefilters.each do |filter|
+        tr = filter.process(self, tr)
+      end
+      tr
+    end
+
+    # Returns the contents passed through the filters.
+    #
+    # @return [String] the processed contents
+    def processed_contents
+      @processed_contents ||= get_processed_contents
+    end
+
+    def get_processed_contents
+      tr = prefiltered_contents
+      (mainfilters + postfilters).each do |filter|
+        tr = filter.process(self, tr)
+      end
+      tr
+    end
+
+    # Return the results of running the processed_contents through the textual processors, e.g.
+    # markdown.
+    #
+    # @return [String] the file's html-rendered contents
+    def rendered_contents
+      @rendered_contents ||= Translator.translate(processed_contents, @path.extension)
+    end
+
+    def layout
+      @layout ||= Yuzu::Core::Layout.new(template)
+    end
+
+    # Presents the rendered_contents placed into its layout. The postprocessors act on this to
+    # produce the values needed for html_contents.
+    def layout_contents
+      layout.render(self)
+    end
+
+
+    # The user-facing entry for post.contents in the Haml templates.
+    def contents
+      rendered_contents
+    end
+
+    # Renders the full, rendered HTML to write to disk.
+    def html_contents
+      layout_contents
+    end
+
+    def filters
+      Filter.filters
+    end
+
+    def prefilters
+      @prefilters ||= filters.values.select {|filt| filt.filter_type.include?(:prefilter)}
+    end
+
+    def mainfilters
+      @mainfilters ||= filters.values.select {|filt| filt.filter_type.include?(:filter)}
+    end
+
+    def postfilters
+      @postfilters ||= filters.values.select {|filt| filt.filter_type.include?(:postfilter)}
+    end
+
+  end
+
+
+  # FileProperties objects are passed into renderers when they need to pass information
+  # to a Haml template or other user-facing mechanism. e.g. This makes "breadcrumb" available in
+  # Haml templates and layouts by using post.breadcrumb.
+  class FileProperties
+    # instance.methods == public instance methods
+    def initialize(website_file)
+
+      @website_file = website_file
+      unique_methods = (website_file.methods - Object.instance_methods).sort
+
+      (class << self; self; end).class_eval do
+
+        unique_methods.each do |method_name|
+
+          define_method(method_name) do
+            website_file.send(method_name)
+          end
+
+        end
+      end # class_eval
+
+    end # initialize
+
+    def to_s
+      "Properties(#{@website_file.path.relative})"
+    end
+  end
+
+end

data/lib/yuzu/core/website_folder.rb

@@ -0,0 +1,176 @@
+require 'core/website_file'
+
+module Yuzu::Core
+  class WebsiteFolder < WebsiteBase
+    def initialize(path, parent)
+      raise "Not a Path object." if not path.is_a?(Path)
+      @path = path
+      raise "@path is nil for #{self}" if @path.nil?
+      @parent = parent
+      @kind = :folder
+    end
+
+    def to_s
+      "WebsiteFolder(#{@path})"
+    end
+
+    # -------------------------------------------------------------------------------------------
+    # TODO Find a way for folders to know what all the categories are, or better yet, remove this
+    # interface and have another way of files, folders, and processors to ask information about the
+    # entire site.
+    #def all_categories
+    #end
+
+    def breadcrumb
+      Yuzu::Renderers::BreadcrumbRenderer.new.render(self)
+    end
+
+    def currentpath
+      Yuzu::Filters::CurrentpathFilter.new.value(self)
+    end
+    # -------------------------------------------------------------------------------------------
+
+    def name
+      @path.rootname.titlecase
+    end
+
+    def files
+      @files ||= children.select {|child| child.file?}
+    end
+
+    def folders
+      @folders ||= children.select {|child| child.folder?}
+    end
+
+    def all_files
+      @all_files ||= get_all_files
+    end
+
+    def get_all_files
+      v = Visitor.new(proc {|c| c.file?})
+      tr = []
+      v.traverse(self) do |website_file|
+        tr.push(website_file)
+      end
+      tr
+    end
+
+    def processable_children
+      children.select {|child| child.processable?}
+    end
+
+    # Returns all the descendants of this folder, as deep as the tree goes, that are "processable"
+    # as specified by the config.
+    #
+    # @return [Array] Of WebsiteFiles representing content that can be translated into HTML or other
+    #   publishable form.
+    def all_processable_children
+      all_files.select {|child| child.processable? and not child.hidden?}
+    end
+
+    # Returns an array of immediate children, files and folders.
+    def children
+      @children ||= get_children
+    end
+
+    # Add a new child object to the @children. Used by generators to add new files to the existing
+    # file-system-gathered pages. This method should only be called in a generator, since their
+    # execution is managed in such a way that new children are added at the right stage of
+    # processing.
+    #
+    # @param [WebsiteFile, WebsiteFolder] new_child The new generated object to add a child.
+    # @return nothing
+    def append_child(new_child)
+      # Ensure we get the children from disk first.
+      children
+      @children.push(new_child)
+    end
+
+    def get_children
+      tr = folder_contents.collect { |child_path| get_object_for_path(child_path) }
+      tr.reject {|c| c.nil?}
+    end
+
+    # Returns a WebsiteFile or WebsiteFolder for the given path.
+    #
+    # @param [Path] path The Path object representing the on-disk file or folder.
+    # @return [WebsiteFile, WebsiteFolder, nil] The child of this folder.
+    def get_object_for_path(path)
+      # TODO Add different file types: processable, resource, etc.
+
+      if path.file?
+        WebsiteFile.new(path, self)
+
+      elsif path.folder?
+        WebsiteFolder.new(path, self)
+
+      else
+        # ignore
+        nil
+      end
+    end
+
+    def folder_contents
+      @path.children
+    end
+
+    def get_child_by_path(path)
+      children.each do |child|
+        return child if child.path == path
+      end
+      nil
+    end
+
+    def get_child_by_rootname(rootname)
+      children.each do |child|
+        return child if child.path.rootname == rootname
+      end
+      nil
+    end
+
+    def get_child_by_basename(basename)
+      children.each do |child|
+        return child if child.path.basename == basename
+      end
+      nil
+    end
+
+    def get_child_by_filename(filename)
+      children.each do |child|
+        return child if child.path.filename == filename
+      end
+      nil
+    end
+
+    def is_immediate_child?(web_obj)
+      children.include?(web_obj)
+    end
+
+    def is_child?(web_obj)
+      folders_only = proc {|c| c.folder?}
+      tr = self.is_immediate_child?(web_obj)
+      return true if tr
+
+      v = Visitor.new(folders_only)
+      v.traverse(self) do |website_folder|
+        tr ||= website_folder.is_immediate_child?(web_obj)
+      end
+      tr
+    end
+
+    def has_index?
+      @has_index ||= get_has_index
+    end
+
+    def get_has_index
+      child_names = files.collect do |file|
+        filename = file.filename
+        ext = File.extname(filename)
+        filename.sub(ext, "")
+      end
+      child_names.include?("index")
+    end
+  end
+
+end
+