yuzu 0.2.1.pre

data/lib/yuzu/generators/paginate.rb

@@ -0,0 +1,136 @@
+require 'generators/base'
+require 'core/paginated_file'
+
+
+module Yuzu::Generators
+  class PaginateGenerator < Generator
+
+    @@generated = []
+    def self.get_generated
+      @@generated
+    end
+
+    def self.add_generator(generator)
+      @@generated.push(generator)
+    end
+
+    def self.is_generated?(generator)
+      @@generated.include?(generator)
+    end
+
+    def initialize
+      @name = "paginate"
+      @directive = "INSERTCATALOG"
+    end
+
+    def should_generate?(website_file)
+      not PaginateGenerator.is_generated?(website_file) and \
+        not website_file.raw_contents.scan(regex).flatten.empty?
+    end
+
+    def visitor_filter
+      proc {|c| c.file?}
+    end
+
+    def generate!(website_file)
+      # Attempt to ensure this website_file isn't generated twice.
+      return if website_file.is_a?(Yuzu::Core::PaginatedWebsiteFile) or \
+        PaginateGenerator.is_generated?(website_file)
+
+      CatalogPaginator.new(website_file, self).generate!
+      PaginateGenerator.add_generator(website_file)
+    end
+  end
+  Generator.register(:paginate => PaginateGenerator)
+
+
+  class CatalogPaginator
+    # Determine whether each catalog requires pagination.
+    # Produce the new WebsiteFile objects by replacing each INSERTCATALOG(...) with a new one.
+    # Add the new WebsiteFile objects to the parent.
+    def initialize(website_file, catalog_generator)
+      @website_file = website_file
+      @catalog_generator = catalog_generator
+    end
+
+    def generate!
+      catalog_args = @website_file.raw_contents.scan(@catalog_generator.regex).flatten
+      catalogs = catalogs_from_args(catalog_args)
+      generate_files_from_catalogs!(catalogs)
+    end
+
+    def generate_files_from_catalogs!(catalogs)
+      paginating_catalogs = catalogs.select {|cat| cat.should_paginate?}
+      first_paginating_catalog = paginating_catalogs.empty? ? nil : paginating_catalogs[0]
+
+      generate_files_for_paginating_catalog!(first_paginating_catalog)
+    end
+
+    # Return an Array of Catalog instances from the given user-specified catalog arguments.
+    #
+    # @param [Array] catalog_args An Array of Hashes containing the arguments gathered from the
+    #   INSERTCATALOG directives of the page.
+    # @return [Array] An Array of corresponding Catalog objects.
+    def catalogs_from_args(catalog_args)
+      catalog_args.collect {|args| Yuzu::Filters.catalog_for(@website_file, args)}
+    end
+
+    # Given a Catalog instance, check to see if it requires pagination and generate the appropriate
+    # files for the given content.
+    # 
+    # @param [Catalog] catalog The Yuzu::Generator.Catalog object that represents the contents to
+    #   insert into the page.
+    # @return nothing
+    def generate_files_for_paginating_catalog!(catalog)
+      return if catalog.nil?
+
+      num_pages = catalog.num_pages
+      return if num_pages == 1
+
+      # Don't generate the first page, it's all ready to go.
+      num_pages_to_generate = num_pages - 1
+      num_pages_to_generate.times do |page|
+        generate_page!(page + 2, catalog)
+      end
+    end
+
+    # Add a single PaginatedWebsiteFile instance and add it to the parent of the given WebsiteFile
+    # as a sibling for the specified page of the given Catalog.
+    #
+    # @param [Fixnum] page The page to generate, indexed by 1.
+    # @param [Catalog] catalog The Catalog being paginated.
+    # @return nothing
+    def generate_page!(page, catalog)
+      original_directive = catalog.original_directive
+      directive_for_page = catalog.directive_for_page(page)
+
+      new_raw_contents = @website_file.raw_contents.sub(original_directive, directive_for_page)
+
+      paginated_file = Yuzu::Core::PaginatedWebsiteFile.new(@website_file, new_raw_contents, page)
+      add_file(paginated_file)
+    end
+
+    # Takes the PaginatedWebsiteFile instance and adds it as a sibling to the root WebsiteFile being
+    # paginated.
+    #
+    # @param [PaginatedWebsiteFile] paginated_file The new page to add as a sibling.
+    # @return nothing
+    def add_file(paginated_file)
+      container = @website_file.parent
+      container.append_child(paginated_file)
+      stash_paginated_file(paginated_file)
+    end
+
+    # Registers the generated file in the seed file's stash, enabling us to generate pagination
+    # links and other niceties later.
+    # 
+    # @param [PaginatedWebsiteFile] paginated_file A file to add.
+    # @return nothing
+    def stash_paginated_file(paginated_file)
+      paginated_siblings = @website_file.stash[:paginated_siblings] || []
+      @website_file.stash(:paginated_siblings => paginated_siblings + [paginated_file])
+    end
+
+  end
+end
+

data/lib/yuzu/postprocessors/all_categories.rb

@@ -0,0 +1,48 @@
+require 'postprocessors/base'
+require 'core/visitor'
+
+module Yuzu::PostProcessors
+
+  class AllCategoriesPostProcessor < PostProcessor
+    def initialize
+      @name = :all_categories
+    end
+
+    def regex
+    end
+
+    def default_value(website_file)
+      []
+    end
+
+    def value(website_file)
+      # There should only be one set of categories no matter which WebsiteFile is asked to gather
+      # them. So we can cache the value in this singleton.
+      @value ||= get_value(website_file)
+    end
+
+    def get_value(website_file)
+      cats = []
+      found_names = []
+
+      v = Yuzu::Core::Visitor.new(proc {|c| c.file?})
+      v.traverse(website_file.root) do |f|
+        # NOTE Because of Ruby's hashing algorithm, we'll get different results calling uniq on an
+        # array with objects hashed against a simple string. The comparison doesn't produce truly
+        # unique results, and the categories.uniq call isn't accurate or consistent.
+
+        f.categories.each do |cat|
+          if not found_names.include?(cat.name) and not cat.name == "uncategorized"
+            found_names.push(cat.name)
+            cats.push(cat)
+          end
+        end
+      end
+
+      cats.sort
+    end
+  end
+  PostProcessor.register(:all_categories => AllCategoriesPostProcessor)
+
+end
+

data/lib/yuzu/postprocessors/base.rb

@@ -0,0 +1,34 @@
+
+module Yuzu::PostProcessors
+  include Yuzu::Registrar
+
+  class PostProcessor < Register
+    @@postprocessors = {}
+    def self.registry
+      :postprocessors
+    end
+    def self.postprocessors
+      @@postprocessors
+    end
+
+    attr_reader :name
+
+    def initialize
+      @name = :postprocessor
+    end
+
+    def value(website_file)
+      match(website_file.rendered_contents)
+    end
+
+    def match(contents)
+      contents.to_s.match(regex)
+    end
+
+    def regex
+      /.*/
+    end
+  end
+
+end
+

data/lib/yuzu/postprocessors/contents_without_first_paragraph.rb

@@ -0,0 +1,20 @@
+require 'postprocessors/base'
+
+module Yuzu::PostProcessors
+  class ContentsWithoutFirstParagraphPostProcessor < PostProcessor
+    def initialize
+      @name = :contents_without_first_paragraph
+      @directive = "CONTENTSWITHOUTFIRSTPARAGRAPH"
+    end
+
+    def regex
+      /<p\b[^>]*?>(.*?)<\/p>/n
+    end
+
+    def match(contents)
+      contents.sub(regex, "")
+    end
+  end
+  PostProcessor.register(:contents_without_first_paragraph => ContentsWithoutFirstParagraphPostProcessor)
+end
+

data/lib/yuzu/postprocessors/excerpt.rb

@@ -0,0 +1,23 @@
+require 'postprocessors/base'
+
+module Yuzu::PostProcessors
+  class ExcerptPostProcessor < PostProcessor
+    def initialize
+      @name = :excerpt
+      @directive = "EXCERPT"
+    end
+
+    def regex
+      # Grab the entire paragraph, with the tag.
+      /<p\b[^>]*?>.*?<\/p>/n
+    end
+
+    def match(contents)
+      num_paragraphs = 5
+      m = contents.scan(regex)
+      m.nil? ? "" : m[0...5].join
+    end
+  end
+  PostProcessor.register(:excerpt => ExcerptPostProcessor)
+end
+

data/lib/yuzu/postprocessors/first_paragraph.rb

@@ -0,0 +1,16 @@
+require 'postprocessors/base'
+
+module Yuzu::PostProcessors
+  class FirstParagraphPostProcessor < PostProcessor
+    def initialize
+      @name = :first_paragraph
+      @directive = "FIRSTPARAGRAPH"
+    end
+
+    def regex
+      /<p\b[^>]*?>(.*?)<\/p>/n
+    end
+  end
+  PostProcessor.register(:first_paragraph => FirstParagraphPostProcessor)
+end
+

data/lib/yuzu/postprocessors/pagination.rb

@@ -0,0 +1,35 @@
+require 'postprocessors/base'
+require 'html/base'
+
+module Yuzu::PostProcessors
+  class PaginationPostProcessor < PostProcessor
+    def initialize
+      @name = :pagination
+      @directive = "PAGINATION"
+    end
+
+    def value(website_file)
+      root_file = website_file.paginated? ? website_file.original_file : website_file
+      pagination_catalog = root_file.stash[:catalog]
+      return "" if pagination_catalog.nil?
+      num_pages = pagination_catalog.num_pages
+
+      pages = [root_file] + root_file.stash[:paginated_siblings]
+
+      links = pages.collect do |page|
+        page_num = pages.find_index(page) + 1
+        is_current_page = page == website_file
+        if is_current_page
+          Html::Span.new << page_num.to_s
+        else
+          Html::Link.new(:href => page.link_url) << page_num.to_s
+        end
+      end
+
+      return Html::Div.new(:class => "pagination-links") << links.join(" ")
+    end
+  end
+  PostProcessor.register(:pagination => PaginationPostProcessor)
+
+end
+

data/lib/yuzu/postprocessors/recent_posts.rb

@@ -0,0 +1,27 @@
+require 'postprocessors/base'
+
+module Yuzu::PostProcessors
+
+  class RecentPostsPostProcessor < PostProcessor
+    def initialize
+      @name = :recent_posts
+    end
+
+    def regex
+    end
+
+    def value(website_file)
+      # Only one set of recent posts per site, so we can cache this.
+      @value ||= get_value(website_file)
+    end
+
+    def get_value(website_file)
+      processable = website_file.blog_folder.all_processable_children
+      user_authored = processable.reject {|file| file.generated? or file.index?}
+      user_authored.sort {|a, b| b.modified_at <=> a.modified_at}[0...10]
+    end
+  end
+  PostProcessor.register(:recent_posts => RecentPostsPostProcessor)
+
+end
+

data/lib/yuzu/postprocessors/thumbnails.rb

@@ -0,0 +1,48 @@
+require 'postprocessors/base'
+require 'html/base'
+
+module Yuzu::PostProcessors
+  class ThumbnailsPostProcessor < PostProcessor
+    def initialize
+      @name = "thumbnails"
+    end
+
+    def value(website_file)
+      thumbnails = website_file.config.thumbnails
+      images = website_file.images
+      Thumbnails.new(images, thumbnails.keys)
+    end
+  end
+  PostProcessor.register(:thumbnails => ThumbnailsPostProcessor)
+
+
+  class Thumbnails
+    def initialize(images, thumbnail_sizes)
+      image_path = images.empty? ? nil : images[0]
+
+      (class << self; self; end).class_eval do
+        thumbnail_sizes.each do |size|
+          define_method size do
+            begin
+
+              if image_path.nil?
+                ""
+              else
+                ext = File.extname(image_path)
+                new_name = image_path.sub(ext, "-#{size}#{ext}")
+                Html::Image.new(:src => new_name).to_s
+              end
+            rescue => e
+              puts "Exception in thumbnails"
+              puts e.message
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+end
+
+

data/lib/yuzu/preprocessors/base.rb

@@ -0,0 +1,71 @@
+
+module Yuzu::PreProcessors
+  include Yuzu::Registrar
+
+  # Preprocessors differ from PostProcesors and Filters in that they are allowed to modify the
+  # raw_contents of a website_file. e.g. When contents are inserted from other files, they are done
+  # so in a manner to create the illusion that those contents were part of the original file.
+  class PreProcessor < Register
+    @@preprocessors = {}
+    def self.registry
+      :preprocessors
+    end
+    def self.preprocessors
+      @@preprocessors
+    end
+
+    attr_reader :name
+
+    def initialize
+      @name = :preprocessor
+      @directive = "PREPROCESSOR"
+    end
+
+    def value(website_file)
+      match(website_file.raw_contents)
+    end
+
+    def match(contents)
+      m = contents.to_s.match(regex)
+      m[1]
+    end
+
+    def regex
+      Regexp.new('^\s*' + @directive.to_s + '\(([\w\s\.\,\'\"\/\-:]*?)\)')
+    end
+
+    # Returns the contents to replace the directive with as written. This will modify the raw
+    # contents of the website_file.
+    #
+    # @param [WebsiteFile] website_file The page in which the directive appears
+    # @param [String, nil] new_contents The contents of the given WebsiteFile as they are
+    #   being transformed by processing.
+    # @return [String] What to replace the directive with.
+    def replacement(website_file, new_contents="")
+      website_file.raw_contents
+    end
+
+    def process(website_file, new_contents)
+      replaced = false
+
+      m = new_contents.match(regex)
+
+      while not m.nil?
+        repl = replacement(website_file, new_contents)
+
+        # Remove the next match.
+        new_contents = new_contents.sub(regex, repl.to_s)
+        replaced = true
+
+        # Find any others...
+        m = new_contents.match(regex)
+      end
+
+      if replaced
+        website_file.instance_variable_set(:@raw_contents, new_contents)
+      end
+    end
+  end
+
+end
+