bunto 1.0.0

data/lib/bunto/related_posts.rb

@@ -0,0 +1,56 @@
+module Bunto
+  class RelatedPosts
+    class << self
+      attr_accessor :lsi
+    end
+
+    attr_reader :post, :site
+
+    def initialize(post)
+      @post = post
+      @site = post.site
+      Bunto::External.require_with_graceful_fail('classifier-reborn') if site.lsi
+    end
+
+    def build
+      return [] unless site.posts.docs.size > 1
+
+      if site.lsi
+        build_index
+        lsi_related_posts
+      else
+        most_recent_posts
+      end
+    end
+
+    def build_index
+      self.class.lsi ||= begin
+        lsi = ClassifierReborn::LSI.new(:auto_rebuild => false)
+        display("Populating LSI...")
+
+        site.posts.docs.each do |x|
+          lsi.add_item(x)
+        end
+
+        display("Rebuilding index...")
+        lsi.build_index
+        display("")
+        lsi
+      end
+    end
+
+    def lsi_related_posts
+      self.class.lsi.find_related(post, 11)
+    end
+
+    def most_recent_posts
+      @most_recent_posts ||= (site.posts.docs.reverse - [post]).first(10)
+    end
+
+    def display(output)
+      $stdout.print("\n")
+      $stdout.print(Bunto.logger.formatted_topic(output))
+      $stdout.flush
+    end
+  end
+end

data/lib/bunto/renderer.rb

@@ -0,0 +1,191 @@
+# encoding: UTF-8
+
+module Bunto
+  class Renderer
+    attr_reader :document, :site, :payload
+
+    def initialize(site, document, site_payload = nil)
+      @site     = site
+      @document = document
+      @payload  = site_payload || site.site_payload
+    end
+
+    # Determine which converters to use based on this document's
+    # extension.
+    #
+    # Returns an array of Converter instances.
+    def converters
+      @converters ||= site.converters.select { |c| c.matches(document.extname) }
+    end
+
+    # Determine the extname the outputted file should have
+    #
+    # Returns the output extname including the leading period.
+    def output_ext
+      @output_ext ||= (permalink_ext || converter_output_ext)
+    end
+
+    ######################
+    ## DAT RENDER THO
+    ######################
+
+    def run
+      Bunto.logger.debug "Rendering:", document.relative_path
+
+      payload["page"] = document.to_liquid
+
+      if document.respond_to? :pager
+        payload["paginator"] = document.pager.to_liquid
+      end
+
+      if document.is_a?(Document) && document.collection.label == 'posts'
+        payload['site']['related_posts'] = document.related_posts
+      end
+
+      # render and transform content (this becomes the final content of the object)
+      payload['highlighter_prefix'] = converters.first.highlighter_prefix
+      payload['highlighter_suffix'] = converters.first.highlighter_suffix
+
+      Bunto.logger.debug "Pre-Render Hooks:", document.relative_path
+      document.trigger_hooks(:pre_render, payload)
+
+      info = {
+        :filters   => [Bunto::Filters],
+        :registers => { :site => site, :page => payload['page'] }
+      }
+
+      output = document.content
+
+      if document.render_with_liquid?
+        Bunto.logger.debug "Rendering Liquid:", document.relative_path
+        output = render_liquid(output, payload, info, document.path)
+      end
+
+      Bunto.logger.debug "Rendering Markup:", document.relative_path
+      output = convert(output)
+      document.content = output
+
+      if document.place_in_layout?
+        Bunto.logger.debug "Rendering Layout:", document.relative_path
+        place_in_layouts(
+          output,
+          payload,
+          info
+        )
+      else
+        output
+      end
+    end
+
+    # Convert the given content using the converters which match this renderer's document.
+    #
+    # content - the raw, unconverted content
+    #
+    # Returns the converted content.
+    def convert(content)
+      converters.reduce(content) do |output, converter|
+        begin
+          converter.convert output
+        rescue => e
+          Bunto.logger.error "Conversion error:", "#{converter.class} encountered an error while converting '#{document.relative_path}':"
+          Bunto.logger.error("", e.to_s)
+          raise e
+        end
+      end
+    end
+
+    # Render the given content with the payload and info
+    #
+    # content -
+    # payload -
+    # info    -
+    # path    - (optional) the path to the file, for use in ex
+    #
+    # Returns the content, rendered by Liquid.
+    def render_liquid(content, payload, info, path = nil)
+      site.liquid_renderer.file(path).parse(content).render!(payload, info)
+    rescue Tags::IncludeTagError => e
+      Bunto.logger.error "Liquid Exception:", "#{e.message} in #{e.path}, included in #{path || document.relative_path}"
+      raise e
+    rescue Exception => e
+      Bunto.logger.error "Liquid Exception:", "#{e.message} in #{path || document.relative_path}"
+      raise e
+    end
+
+    # Checks if the layout specified in the document actually exists
+    #
+    # layout - the layout to check
+    #
+    # Returns true if the layout is invalid, false if otherwise
+    def invalid_layout?(layout)
+      !document.data["layout"].nil? && layout.nil?
+    end
+
+    # Render layouts and place given content inside.
+    #
+    # content - the content to be placed in the layout
+    #
+    #
+    # Returns the content placed in the Liquid-rendered layouts
+    def place_in_layouts(content, payload, info)
+      output = content.dup
+      layout = site.layouts[document.data["layout"]]
+
+      Bunto.logger.warn("Build Warning:", "Layout '#{document.data["layout"]}' requested in #{document.relative_path} does not exist.") if invalid_layout? layout
+
+      used   = Set.new([layout])
+
+      while layout
+        payload['content'] = output
+        payload['page']    = document.to_liquid
+        payload['layout']  = Utils.deep_merge_hashes(payload['layout'] || {}, layout.data)
+
+        output = render_liquid(
+          layout.content,
+          payload,
+          info,
+          File.join(site.config['layouts_dir'], layout.name)
+        )
+
+        # Add layout to dependency tree
+        site.regenerator.add_dependency(
+          site.in_source_dir(document.path),
+          site.in_source_dir(layout.path)
+        ) if document.write?
+
+        if layout = site.layouts[layout.data["layout"]]
+          if used.include?(layout)
+            layout = nil # avoid recursive chain
+          else
+            used << layout
+          end
+        end
+      end
+
+      output
+    end
+
+    private
+
+    def permalink_ext
+      if document.permalink && !document.permalink.end_with?("/")
+        permalink_ext = File.extname(document.permalink)
+        permalink_ext unless permalink_ext.empty?
+      end
+    end
+
+    def converter_output_ext
+      if output_exts.size == 1
+        output_exts.last
+      else
+        output_exts[-2]
+      end
+    end
+
+    def output_exts
+      @output_exts ||= converters.map do |c|
+        c.output_ext(document.extname)
+      end.compact
+    end
+  end
+end

data/lib/bunto/site.rb

@@ -0,0 +1,391 @@
+# encoding: UTF-8
+require 'csv'
+
+module Bunto
+  class Site
+    attr_reader   :source, :dest, :config
+    attr_accessor :layouts, :pages, :static_files, :drafts,
+                  :exclude, :include, :lsi, :highlighter, :permalink_style,
+                  :time, :future, :unpublished, :safe, :plugins, :limit_posts,
+                  :show_drafts, :keep_files, :baseurl, :data, :file_read_opts,
+                  :gems, :plugin_manager
+
+    attr_accessor :converters, :generators, :reader
+    attr_reader   :regenerator, :liquid_renderer
+
+    # Public: Initialize a new Site.
+    #
+    # config - A Hash containing site configuration details.
+    def initialize(config)
+      @config = config.clone
+
+      %w(safe lsi highlighter baseurl exclude include future unpublished
+        show_drafts limit_posts keep_files gems).each do |opt|
+        self.send("#{opt}=", config[opt])
+      end
+
+      # Source and destination may not be changed after the site has been created.
+      @source              = File.expand_path(config['source']).freeze
+      @dest                = File.expand_path(config['destination']).freeze
+
+      @reader = Bunto::Reader.new(self)
+
+      # Initialize incremental regenerator
+      @regenerator = Regenerator.new(self)
+
+      @liquid_renderer = LiquidRenderer.new(self)
+
+      self.plugin_manager = Bunto::PluginManager.new(self)
+      self.plugins        = plugin_manager.plugins_path
+
+      self.file_read_opts = {}
+      self.file_read_opts[:encoding] = config['encoding'] if config['encoding']
+
+      self.permalink_style = config['permalink'].to_sym
+
+      Bunto.sites << self
+
+      reset
+      setup
+    end
+
+    # Public: Read, process, and write this Site to output.
+    #
+    # Returns nothing.
+    def process
+      reset
+      read
+      generate
+      render
+      cleanup
+      write
+      print_stats
+    end
+
+    def print_stats
+      if @config['profile']
+        puts @liquid_renderer.stats_table
+      end
+    end
+
+    # Reset Site details.
+    #
+    # Returns nothing
+    def reset
+      self.time = (config['time'] ? Utils.parse_date(config['time'].to_s, "Invalid time in _config.yml.") : Time.now)
+      self.layouts = {}
+      self.pages = []
+      self.static_files = []
+      self.data = {}
+      @collections = nil
+      @regenerator.clear_cache
+      @liquid_renderer.reset
+
+      if limit_posts < 0
+        raise ArgumentError, "limit_posts must be a non-negative number"
+      end
+
+      Bunto::Hooks.trigger :site, :after_reset, self
+    end
+
+    # Load necessary libraries, plugins, converters, and generators.
+    #
+    # Returns nothing.
+    def setup
+      ensure_not_in_dest
+
+      plugin_manager.conscientious_require
+
+      self.converters = instantiate_subclasses(Bunto::Converter)
+      self.generators = instantiate_subclasses(Bunto::Generator)
+    end
+
+    # Check that the destination dir isn't the source dir or a directory
+    # parent to the source dir.
+    def ensure_not_in_dest
+      dest_pathname = Pathname.new(dest)
+      Pathname.new(source).ascend do |path|
+        if path == dest_pathname
+          raise Errors::FatalException.new "Destination directory cannot be or contain the Source directory."
+        end
+      end
+    end
+
+    # The list of collections and their corresponding Bunto::Collection instances.
+    # If config['collections'] is set, a new instance is created for each item in the collection.
+    # If config['collections'] is not set, a new hash is returned.
+    #
+    # Returns a Hash containing collection name-to-instance pairs.
+    def collections
+      @collections ||= Hash[collection_names.map { |coll| [coll, Bunto::Collection.new(self, coll)] } ]
+    end
+
+    # The list of collection names.
+    #
+    # Returns an array of collection names from the configuration,
+    #   or an empty array if the `collections` key is not set.
+    def collection_names
+      case config['collections']
+      when Hash
+        config['collections'].keys
+      when Array
+        config['collections']
+      when nil
+        []
+      else
+        raise ArgumentError, "Your `collections` key must be a hash or an array."
+      end
+    end
+
+    # Read Site data from disk and load it into internal data structures.
+    #
+    # Returns nothing.
+    def read
+      reader.read
+      limit_posts!
+      Bunto::Hooks.trigger :site, :post_read, self
+    end
+
+    # Run each of the Generators.
+    #
+    # Returns nothing.
+    def generate
+      generators.each do |generator|
+        generator.generate(self)
+      end
+    end
+
+    # Render the site to the destination.
+    #
+    # Returns nothing.
+    def render
+      relative_permalinks_are_deprecated
+
+      payload = site_payload
+
+      Bunto::Hooks.trigger :site, :pre_render, self, payload
+
+      collections.each do |_, collection|
+        collection.docs.each do |document|
+          if regenerator.regenerate?(document)
+            document.output = Bunto::Renderer.new(self, document, payload).run
+            document.trigger_hooks(:post_render)
+          end
+        end
+      end
+
+      pages.flatten.each do |page|
+        if regenerator.regenerate?(page)
+          page.output = Bunto::Renderer.new(self, page, payload).run
+          page.trigger_hooks(:post_render)
+        end
+      end
+
+      Bunto::Hooks.trigger :site, :post_render, self, payload
+    rescue Errno::ENOENT
+      # ignore missing layout dir
+    end
+
+    # Remove orphaned files and empty directories in destination.
+    #
+    # Returns nothing.
+    def cleanup
+      site_cleaner.cleanup!
+    end
+
+    # Write static files, pages, and posts.
+    #
+    # Returns nothing.
+    def write
+      each_site_file do |item|
+        item.write(dest) if regenerator.regenerate?(item)
+      end
+      regenerator.write_metadata
+      Bunto::Hooks.trigger :site, :post_write, self
+    end
+
+    def posts
+      collections['posts'] ||= Collection.new(self, 'posts')
+    end
+
+    # Construct a Hash of Posts indexed by the specified Post attribute.
+    #
+    # post_attr - The String name of the Post attribute.
+    #
+    # Examples
+    #
+    #   post_attr_hash('categories')
+    #   # => { 'tech' => [<Post A>, <Post B>],
+    #   #      'ruby' => [<Post B>] }
+    #
+    # Returns the Hash: { attr => posts } where
+    #   attr  - One of the values for the requested attribute.
+    #   posts - The Array of Posts with the given attr value.
+    def post_attr_hash(post_attr)
+      # Build a hash map based on the specified post attribute ( post attr =>
+      # array of posts ) then sort each array in reverse order.
+      hash = Hash.new { |h, key| h[key] = [] }
+      posts.docs.each { |p| p.data[post_attr].each { |t| hash[t] << p } if p.data[post_attr] }
+      hash.values.each { |posts| posts.sort!.reverse! }
+      hash
+    end
+
+    def tags
+      post_attr_hash('tags')
+    end
+
+    def categories
+      post_attr_hash('categories')
+    end
+
+    # Prepare site data for site payload. The method maintains backward compatibility
+    # if the key 'data' is already used in _config.yml.
+    #
+    # Returns the Hash to be hooked to site.data.
+    def site_data
+      config['data'] || data
+    end
+
+    # The Hash payload containing site-wide data.
+    #
+    # Returns the Hash: { "site" => data } where data is a Hash with keys:
+    #   "time"       - The Time as specified in the configuration or the
+    #                  current time if none was specified.
+    #   "posts"      - The Array of Posts, sorted chronologically by post date
+    #                  and then title.
+    #   "pages"      - The Array of all Pages.
+    #   "html_pages" - The Array of HTML Pages.
+    #   "categories" - The Hash of category values and Posts.
+    #                  See Site#post_attr_hash for type info.
+    #   "tags"       - The Hash of tag values and Posts.
+    #                  See Site#post_attr_hash for type info.
+    def site_payload
+      Drops::UnifiedPayloadDrop.new self
+    end
+
+    # Get the implementation class for the given Converter.
+    # Returns the Converter instance implementing the given Converter.
+    # klass - The Class of the Converter to fetch.
+
+    def find_converter_instance(klass)
+      converters.find { |klass_| klass_.instance_of?(klass) } || \
+        raise("No Converters found for #{klass}")
+    end
+
+    # klass - class or module containing the subclasses.
+    # Returns array of instances of subclasses of parameter.
+    # Create array of instances of the subclasses of the class or module
+    # passed in as argument.
+
+    def instantiate_subclasses(klass)
+      klass.descendants.select { |c| !safe || c.safe }.sort.map do |c|
+        c.new(config)
+      end
+    end
+
+    # Warns the user if permanent links are relative to the parent
+    # directory. As this is a deprecated function of Bunto.
+    #
+    # Returns
+    def relative_permalinks_are_deprecated
+      if config['relative_permalinks']
+        Bunto.logger.abort_with "Since v3.0, permalinks for pages" \
+                                " in subfolders must be relative to the" \
+                                " site source directory, not the parent" \
+                                " directory. Check http://bunto.github.io/docs/upgrading/"\
+                                " for more info."
+      end
+    end
+
+    # Get the to be written documents
+    #
+    # Returns an Array of Documents which should be written
+    def docs_to_write
+      documents.select(&:write?)
+    end
+
+    # Get all the documents
+    #
+    # Returns an Array of all Documents
+    def documents
+      collections.reduce(Set.new) do |docs, (_, collection)|
+        docs + collection.docs + collection.files
+      end.to_a
+    end
+
+    def each_site_file
+      %w(pages static_files docs_to_write).each do |type|
+        send(type).each do |item|
+          yield item
+        end
+      end
+    end
+
+    # Returns the FrontmatterDefaults or creates a new FrontmatterDefaults
+    # if it doesn't already exist.
+    #
+    # Returns The FrontmatterDefaults
+    def frontmatter_defaults
+      @frontmatter_defaults ||= FrontmatterDefaults.new(self)
+    end
+
+    # Whether to perform a full rebuild without incremental regeneration
+    #
+    # Returns a Boolean: true for a full rebuild, false for normal build
+    def incremental?(override = {})
+      override['incremental'] || config['incremental']
+    end
+
+    # Returns the publisher or creates a new publisher if it doesn't
+    # already exist.
+    #
+    # Returns The Publisher
+    def publisher
+      @publisher ||= Publisher.new(self)
+    end
+
+    # Public: Prefix a given path with the source directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         source directory
+    #
+    # Returns a path which is prefixed with the source directory.
+    def in_source_dir(*paths)
+      paths.reduce(source) do |base, path|
+        Bunto.sanitized_path(base, path)
+      end
+    end
+
+    # Public: Prefix a given path with the destination directory.
+    #
+    # paths - (optional) path elements to a file or directory within the
+    #         destination directory
+    #
+    # Returns a path which is prefixed with the destination directory.
+    def in_dest_dir(*paths)
+      paths.reduce(dest) do |base, path|
+        Bunto.sanitized_path(base, path)
+      end
+    end
+
+    private
+
+    # Limits the current posts; removes the posts which exceed the limit_posts
+    #
+    # Returns nothing
+    def limit_posts!
+      if limit_posts > 0
+        limit = posts.docs.length < limit_posts ? posts.docs.length : limit_posts
+        self.posts.docs = posts.docs[-limit, limit]
+      end
+    end
+
+    # Returns the Cleaner or creates a new Cleaner if it doesn't
+    # already exist.
+    #
+    # Returns The Cleaner
+    def site_cleaner
+      @site_cleaner ||= Cleaner.new(self)
+    end
+  end
+end