yuzu 0.2.1.pre

data/lib/yuzu/filters/base.rb

@@ -0,0 +1,86 @@
+require 'core/registrar'
+
+module Yuzu::Filters
+  include Yuzu::Registrar
+
+  # Filters are the primary means to derive information from a given source file and place new
+  # contents into it before it is placed in a layout.
+  # 
+  # There are 3 stages of filtering that happen to each file.
+  #
+  # 1. prefilter -- replacing LINKROOT and CURRENTPATH, so the next phase has the proper paths
+  # 2. filter -- transforming contents
+  # 3. postfilter -- replacing LINKROOT and CURRENTPATH again
+  class Filter < Register
+    @@filters = {}
+    def self.registry
+      :filters
+    end
+    def self.filters
+      @@filters
+    end
+
+    attr_reader :name, :directive
+
+    def initialize
+      @name = :directive
+      @directive = "DIRECTIVE"
+    end
+
+    def filter_type
+      [:filter]
+    end
+
+    def default(website_file=nil)
+      nil
+    end
+
+    def value(website_file)
+      get_value(website_file) || default(website_file)
+    end
+
+    def get_value(website_file)
+      match(website_file.raw_contents)
+    end
+
+    def match(contents)
+      get_match(contents)
+    end
+
+    def get_match(contents)
+      m = contents.match(regex)
+      m.nil? ? nil : m[1]
+    end
+
+    # Returns the contents to replace the directive with as written.
+    #
+    # @param [WebsiteFile] website_file The page in which the directive appears
+    # @param [String, nil] processing_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, processing_contents=nil)
+      ""
+    end
+
+    def regex
+      Regexp.new('^\s*' + @directive.to_s + '\(([\w\s\.\,\'\"\/\-:]*?)\)')
+    end
+
+    def process(website_file, processing_contents)
+      m = processing_contents.match(regex)
+
+      while not m.nil?
+        repl = replacement(website_file, processing_contents)
+
+        # Remove the next match.
+        processing_contents = processing_contents.sub(regex, repl.to_s)
+
+        # Find any others...
+        m = processing_contents.match(regex)
+      end
+
+      processing_contents
+    end
+  end
+end
+

data/lib/yuzu/filters/catalog.rb

@@ -0,0 +1,248 @@
+require 'filters/base'
+require 'core/template'
+require 'helpers/path'
+require 'html/base'
+
+
+module Yuzu::Filters
+  include Yuzu::Core
+
+  class CatalogFilter < Filter
+    def initialize
+      @name = :catalog
+      @directive = "INSERTCATALOG"
+    end
+
+    def value(website_file)
+      nil
+    end
+
+    def replacement(website_file, processing_contents=nil)
+      catalog = Yuzu::Filters.catalog_for(website_file, match(processing_contents))
+
+      if catalog.should_paginate? and catalog.num_pages > 1
+        website_file.stash(:catalog => catalog)
+      end
+
+      return catalog.render
+    end
+  end
+  Filter.register(:catalog => CatalogFilter)
+
+
+  # Create a Catalog instance for a given match
+  #
+  # @param [WebsiteFile] website_file The file in which the catalog is being rendered.
+  # @param [String] match_string The match given by the filter, e.g. "page:1, per_row:3, ..."
+  # @return [Catalog] The catalog object responsible for rendering the pages specified.
+  def catalog_for(website_file, match_string)
+    kwds = Yuzu::Filters.get_kwds(match_string)
+    Catalog.new(kwds, website_file, match_string)
+  end
+  module_function :catalog_for
+
+  # Returns a Hash of the keyword arguments contained in the inner match string of the tag:
+  #
+  #     INSERTCATALOG(page: 1, count:10)
+  #
+  # yields
+  #
+  #     {:page => 1, :count => 10}
+  #
+  # @param [String] match_string The text inside the tag match.
+  # @return [Hash] The key to value pairs.
+  def get_kwds(match_string)
+    pairs = match_string.split(",").collect {|pair| pair.strip}
+
+    kwds = {}
+    pairs.each do |pair|
+      key, val = pair.split(":").collect {|el| el.strip}
+      kwds[key.to_sym] = val
+    end
+
+    kwds
+  end
+  module_function :get_kwds
+
+
+  # Catalogs render one page of collected contents and have no knowledge of pagination. The
+  # auto-pagination happens earlier as part of the generation process.
+  class Catalog
+    include Helpers
+    attr_reader :website_file
+
+    def initialize(kwds, website_file, original_match_string)
+      @kwds = kwds
+      @website_file = website_file
+      @original_match_string = original_match_string
+
+      @siteroot = website_file.root
+    end
+
+    # Define accessors for each of the given keyword arguments.
+    @@kwd_defaults = {
+      :template => '_block.haml',
+      :total => 1000,
+      :per_page => 10,
+      :per_row => 1,
+      :page => 1,
+      :offset => 0,
+      :category => nil
+    }
+    @@kwd_defaults.each_pair do |key, default_value|
+      define_method key do
+        if @kwds.has_key?(key)
+          # The user's arguments always come in as a String, so this converts the argument into its
+          # appropriate type as specified by the defaults Hash.
+          convert_method = get_default_type_method(key)
+          convert_method.nil? ? @kwds[key] : @kwds[key].send(convert_method)
+        else
+          default_value
+        end
+      end
+    end
+
+    def get_default_type_method(key)
+      klass = get_default_type(key)
+      if klass == String
+        :to_s
+      elsif klass == Fixnum
+        :to_i
+      elsif klass == Float
+        :to_f
+      else
+        nil
+      end
+    end
+
+    def get_default_type(key)
+      @@kwd_defaults.has_key?(key) ? @@kwd_defaults[key].class : nil
+    end
+
+    def should_paginate?
+      num_total_files > number_of_files_to_show
+    end
+
+    def num_total_files
+      [target_files.length, total].min
+    end
+
+    def num_pages
+      return 1 if not should_paginate?
+      (num_total_files.to_f / per_page.to_f).ceil
+    end
+
+    def original_directive
+      # TODO build a regex forgiving of whitespace
+      "INSERTCATALOG(#{@original_match_string})"
+    end
+
+    def directive_for_page(page)
+      with_page = @kwds.merge({:page => page})
+      args = with_page.collect {|key, val| "#{key}:#{val}"}.join(", ")
+      "INSERTCATALOG(#{args})"
+    end
+
+    def formatted_directive
+      args = @kwds.collect {|key, val| "#{key}:#{val}"}.join(", ")
+      "INSERTCATALOG(#{args})"
+    end
+
+    def render
+      if well_formed?
+        rows = []
+        num_rows_this_page.times do |row|
+          rows.push(render_nth_row(row))
+        end
+        rows.join("\n")
+      else
+        Html::Comment.new << "Error in processing the catalog. Got #{formatted_directive}"
+      end
+    end
+
+    def render_nth_row(row)
+      start = row * per_row
+      stop = (row + 1) * per_row
+      files_this_row = files_to_render_this_page[start...stop]
+      if files_this_row.empty?
+        Html::Div.new(:class => 'row') << Html::Comment.new << "No files in this row."
+      else
+        render_row(files_this_row)
+      end
+    end
+
+    def render_row(files)
+      rendered_files = files.collect {|file| render_post(file)}.join("\n")
+      Html::Div.new(:class => 'row') << rendered_files
+    end
+
+    def render_post(file)
+      partial.render(file, {:klass => css_class})
+    end
+
+    def css_class
+      num_columns_12 = (12.0 / per_row).floor
+      "span#{num_columns_12}"
+    end
+
+    def partial
+      Yuzu::Core::HamlTemplate.new(template)
+    end
+
+    def well_formed?
+      @kwds.has_key?(:path)
+    end
+
+    def target_folder
+      case
+      when (not well_formed?)
+        nil
+      when @kwds[:path] == ""
+        @siteroot
+      else
+        search_path = Path.new(@kwds[:path])
+        @siteroot.find_file_by_path(search_path)
+      end
+    end
+
+    def target_files
+      @target_files ||= get_target_files
+    end
+
+    def get_target_files
+      return [] if target_folder.nil?
+      unsorted = target_folder.all_processable_children.reject {|node| node.index?}
+      if not category.nil?
+        unsorted = unsorted.select {|file| file_has_category?(file)}
+      end
+      unsorted.sort {|a, b| b.post_date <=> a.post_date}
+    end
+
+    def file_has_category?(file)
+      file.categories.each do |cat|
+        if cat.name == category.downcase.dasherize
+          return true
+        end
+      end
+      return false
+    end
+
+    # Returns an array of WebsiteFile objects that are the contents of the catalog on this page.
+    def files_to_render_this_page
+      start = (page - 1) * per_page + offset
+      stop = page * per_page + offset
+      target_files[start...stop]
+    end
+
+    def num_rows_this_page
+      (number_of_files_to_show.to_f / per_row.to_f).ceil
+    end
+
+    def number_of_files_to_show
+      [total, per_page, target_files.length, page * per_page].min
+    end
+
+  end
+end
+
+

data/lib/yuzu/filters/categories.rb

@@ -0,0 +1,58 @@
+require 'filters/base'
+require 'helpers/url'
+require 'helpers/path'
+
+module Yuzu::Filters
+  class CategoriesFilter < Filter
+    def initialize
+      @name = :categories
+      @directive = "CATEGORIES"
+    end
+
+    def default(website_file)
+      [Category.new("uncategorized", website_file)]
+    end
+
+    def get_value(website_file)
+      m = match(website_file.raw_contents)
+      return default(website_file) if m.nil?
+
+      category_list = m.split(",")
+      category_list.collect! {|cat| cat.strip.downcase}
+      category_list.reject! {|cat| cat.empty?}
+      category_list.collect {|cat| Category.new(cat, website_file)}
+    end
+  end
+  Filter.register(:categories => CategoriesFilter)
+
+
+  class Category
+    attr_reader :name
+
+    def initialize(name, website_file)
+      @name = name.dasherize.downcase
+      @website_file = website_file
+    end
+
+    def link
+      Html::Link.new(:href => url) << @name.titlecase
+    end
+
+    def url
+      blog_folder.link_url + "/" + @name
+    end
+
+    def path
+      Helpers::Path.new(blog_folder.path.name, @name)
+    end
+
+    def blog_folder
+      @website_file.blog_folder
+    end
+
+    def <=>(other)
+      @name <=> other.name
+    end
+  end
+end
+

data/lib/yuzu/filters/currentpath.rb

@@ -0,0 +1,35 @@
+require 'filters/base'
+require 'helpers/url'
+
+module Yuzu::Filters
+  class CurrentpathFilter < Filter
+    include Helpers
+
+    def initialize
+      @name = :currentpath
+      @directive = "CURRENTPATH"
+    end
+
+    def filter_type
+      # Filter the LINKROOT in IMAGES and other path-dependent tags first, so they have the proper
+      # paths to search for. Then process LINKROOT afterwards.
+      [:prefilter, :postfilter]
+    end
+
+    def regex
+      /CURRENTPATH/
+    end
+
+    def get_value(website_file)
+      linkroot = website_file.config.linkroot
+      pathname = website_file.path.dirname
+      Url.new(pathname, prefix=linkroot)
+    end
+
+    def replacement(website_file, processing_contents=nil)
+      get_value(website_file)
+    end
+  end
+  Filter.register(:currentpath => CurrentpathFilter)
+end
+

data/lib/yuzu/filters/description.rb

@@ -0,0 +1,16 @@
+require 'filters/base'
+
+module Yuzu::Filters
+  class DescriptionFilter < Filter
+    def initialize
+      @name = :description
+      @directive = "DESCRIPTION"
+    end
+
+    def default(website_file=nil)
+      ""
+    end
+  end
+  Filter.register(:description => DescriptionFilter)
+end
+