pekky 0.4 → 0.4.1

data/CHANGES

@@ -0,0 +1,24 @@
+VERSION 0.4
+Change to the configuration syntax. The generate option is now gone. Instead
+there are the #page and #pages methods. 
+
+Now, instead of saying:
+
+  page '/', 'home'
+
+You would specify:
+
+  page :index, '/', 'home'
+
+The only change in this case is that you _must_ now name all the pages in your
+config.
+
+The replacement for #generate is the #pages method. Similar signature to #page
+but it slurps up a directory and generates multiple pages from each yaml file 
+contained within it. Here is an example of generating weblog posts.
+
+  pages :post, '/posts/:slug', 'posts', :view => 'post'
+
+VERSION 0.3
+No external changes. Mainly just some reorganisation of the code.
+

data/lib/pekky.rb

@@ -26,8 +26,8 @@ require 'yaml'
 # serves as a container and shortcut.
 module Pekky
   # The third release, dedicated to stunt-men everywhere.
-  VERSION = '0.3'
-  VERSION_NAME = "Shit-scared"
+  VERSION = '0.4.1'
+  VERSION_NAME = "Still Shit-scared"
   
   # A base class for all the errors in Pekky. We’re using custom errors so that
   # we can filter out errors concerning configuration in one place, while still

data/lib/pekky/content.rb

@@ -0,0 +1,142 @@
+module Pekky
+  # The content class is used to wrap around the YAML files loaded from disk. 
+  # It provides coercions and some nice syntax for accessing the fields.
+  class Content
+    # This error will be raised if a content YAML file cannot be found in the 
+    # content directory -- stored in Config[:content_dir]
+    class ContentMissingError < PekkyError
+      def initialize(path)
+        @message = "The content file '#{path}.yml' could not be found."
+      end
+    end
+    
+    # Raised if the user tries to access a field that doesn't exist.
+    class FieldMissingError < PekkyError
+      def initialize(field)
+        @message = "The field '#{field}' doesn't exist."
+      end
+    end
+    
+    # A class ivar for storing content instances.
+    @cache = {}
+    
+    # Returns a content instance populated with data from the file at the 
+    # specified path. Errors if the file missing.
+    def self.[](path)
+      @cache[path] ||= load_file(path)
+    end
+
+    def self.get(path)
+      @cache[path] ||= begin
+        full_path = File.join(Config[:content_dir], path)
+        if File.directory?(full_path)
+          contents = []
+          Dir.foreach(full_path) do |filename|
+            unless File.directory?(filename)
+              contents << new("#{path}/#{filename}")
+            end
+          end
+          contents
+        else
+          new(path)
+        end
+      end
+    end
+    
+    # Clears out any cached content instances.
+    def self.flush!
+      @cache.clear
+    end
+    
+    # On initialization, the content class creates an instance of the Fields
+    # class. This instance encapsulates most of the logic for accessing values.
+    def initialize(path)
+      @path = path
+      load_file
+    end
+    
+    # A simple accessor for grabbing an attribute without having to use 
+    # #method_missing fall-back.
+    def [](name)
+      @fields[name]
+    end
+    
+    # Returns the fields instance. Allows users to do things like:
+    #
+    #     content.fields.each {|name, value| puts value}
+    #
+    def fields
+      @fields
+    end
+
+    def reload 
+      load_file
+    end
+    
+    # Method missing is being used to allow us to access fields on the content
+    # instance as if they were declared as readers. Yes, it's slower than 
+    # using #class_eval, but it's simple and the speed doesn't matter frankly.
+    def method_missing(name)
+      if match = name.to_s.match(/^(\S+)\?$/)
+        @fields.has?(name)
+      else
+        @fields.has?(name) ? @fields[name] : super
+      end
+    end
+    
+    private
+    
+    # Loads the content file from disk and creates a new Content instance. If 
+    # the content file is missing, it has a little cry and raises an error.
+    def load_file
+      filename = @path.include?('.yml') ? @path : "#{@path}.yml"
+      full_path = File.join(Config[:content_dir], filename)
+      if File.exists?(full_path)
+        @fields = Fields.new(YAML.load_file(full_path))
+      else
+        raise ContentMissingError.new(@path)
+      end
+    end
+    
+    # The fields class provides an interface for iterating over a record's 
+    # fields, checking to see if a field exists and other sundry tasks.
+    class Fields
+      
+      # The proxy is essentially a collection, we want it to behave like an
+      # enumerable.
+      include Enumerable
+      
+      # The fields proxy is initialized with the raw values pulled from the
+      # content YAML files.
+      def initialize(fields)
+        @fields = fields
+      end
+      
+      # Allows the proxy to be used by a hash, but under the hood it will 
+      # actually coerce values and push them into the cache. This is the 
+      # entirety of the lazy-coercion. Very simple.
+      def [](name)
+        name_ = name.to_sym
+        if @fields.has_key?(name)
+          @fields[name]
+        elsif @fields.has_key?(name_)
+          @fields[name_]
+        else
+          raise FieldMissingError.new(name)
+        end
+      end
+      
+      # Checks to see if the specified field exists, returning true or false.
+      def has?(name)
+        !!@fields.has_key?(name)
+      end
+      
+      # The each method, which is required by the Enumerable module. We iterate
+      # over the raw values, since they may not be in the cache. We then access
+      # them via #[] to ensure that they are coerced and cached.
+      def each
+        @fields.each {|k, v| yield k, v }
+      end
+    end # AttributesProxy
+  end # Conent
+end # Pekky

data/lib/pekky/format.rb

@@ -0,0 +1,247 @@
+module Pekky
+  # The Format module acts as a container for the renderers and filters. 
+  # Renderers take markup of some kind and output HTML. Filters accept HTML
+  # and modify it in some way. It also contains sundry utility methods for
+  # HTML manipulation.
+  module Format
+    # A custom error class for encapsulating load errors, so we can add a custom
+    # error message when a renderer can't find the library it needs. This is
+    # to prevent users being presented with a potentially confusing message.
+    class LibaryMissingError < PekkyError
+      def initialize(klass, error)
+        @message = "While trying to use the #{klass.to_s} transformer, we got this error:\n #{error.message}"
+      end
+    end
+    
+    # The wrapper class acts as a container for a set of renderers or filters.
+    # It's most essential job is to allow syntax like this:
+    #
+    #     Format::Formatters.textile("h1. blah")
+    #
+    # This class should never be instanced, or accessed directly. Instead, we
+    # use the Renderers and Filters subclasses.
+    class Wrapper
+      # Ahh, the good old class instance attribute accessors. This is a bit of
+      # voodoo which is better explained by more patient people.
+      class << self
+        attr_accessor :klasses, :call_with
+      end
+      
+      # Adds a transformer to the existing collection.
+      def self.add(name, klass)
+        (self.klasses ||= {})[name] = klass
+      end
+      
+      # Shortcut for accessing a transformer class by name.
+      def self.[](name)
+        self.klasses[name]
+      end
+      
+      # Returns all the names of the transformers.
+      def self.keys
+        self.klasses.keys
+      end
+      
+      # Returns the actual transformers themselves.
+      def self.values
+        self.klasses.values
+      end
+      
+      # An iterator for looping over the transformer. The block will recieve 
+      # the name and the actual class.
+      def self.each
+        self.klasses.each { |k, v| yield k, v }
+      end
+      
+      # Method missing is used here to provide nice syntax for accessing 
+      # transformer as methods.
+      def self.method_missing(name, *args)
+        if self.klasses[name]
+          self.klasses[name].send(self.call_with, *args)
+        else
+          super
+        end
+      end
+    end
+    
+    # The formatter wrapper. Adds a few additional methods for defaults etc.
+    class Formatters < Wrapper
+      self.call_with = :_format
+      
+      # Returns the default text formatter -- textile
+      def self.defaults
+        Config[:text_formatter]
+      end
+      
+      # This is the default formatter. It'll use the setting set in the site
+      # config, or the built in default -- textile.
+      def self.text(text, opts = {})
+        self.klasses[defaults]._format(text, opts)
+      end
+      
+      # Call the renderer by name rather than having the code drop down to
+      # method missing. This will mainly be used internally in Pekky.
+      def self.format(name, text, opts = {})
+        self.klasses[name]._format(text, opts)
+      end
+    end
+    
+    # The filters class just wraps the filters. Nothing special. Poor thing.
+    class Filters < Wrapper
+      self.call_with = :_filter
+      
+      # Returns the array of filters defined in site config, or all of the 
+      # filters.
+      def self.defaults
+        @defaults ||= Config[:text_filters] ? Config[:text_filters] << :links : [:links]
+      end
+    end
+    
+    # Transformer class for the formatters and filters. A subclass can actually
+    # be both a formatter -- takes text and makes HTML -- or a filter -- takes 
+    # HTML and modifies it in some way. The reason for this is that the logic 
+    # for doing both is often shared. For example in the code formatting, we 
+    # sometimes want to render code directly from text, or we want to modify 
+    # existing markup -- like some embedded in textile output.
+    class Transformer
+      # Class attribute reader bo!
+      class << self
+        attr_reader :loaded
+      end
+      
+      # The loaded variable is used to keep track if the dependencies of the 
+      # renderer has been loaded. The loading is handled by the 
+      # #check_for_requirements method.
+      @loaded = false
+    
+      # This hook is being used to see if the subclasses define either the 
+      # #format or #filter methods and thus need to be added to the relevant 
+      # wrappers.
+      def self.singleton_method_added(method_name)
+        case method_name
+          when :format then Formatters.add(name, self)
+          when :filter then Filters.add(name, self)
+        end
+      end
+      
+      # Returns the snake case version of this class name.
+      def self.name 
+        @name ||= self.to_s.match(/::(\w+)$/)[1].downcase.to_sym
+      end
+      
+      # This method wraps the actual #format method defined by the subclass. 
+      # This is so we can make sure the dependencies are loaded and then run
+      # any of the specified filters -- or the defaults.
+      def self._format(text, opts = {})
+        check_for_requirements
+        
+        output = if method(:format).arity > 1
+          format(text, opts)
+        else
+          format(text)
+        end
+        
+        filters = opts.delete(:filters) || Filters.defaults
+        
+        if filters.empty?
+          output
+        else
+          doc = Nokogiri::HTML.fragment(output)
+          filters.each do |name|
+            Filters[name].filter(doc, output)
+          end
+          doc.to_html
+        end
+      end
+      
+      # Wraps around the #filter method defined in the subclasses. It does some
+      # preflight stuff like loading requirements and setting up the Nokogiri
+      # document.
+      def self._filter(text)
+        check_for_requirements
+        doc = Nokogiri::HTML.fragment(text)
+        filter(doc, text)
+        doc.to_html
+      end
+      
+      private
+      
+      # Checks to see if the Renderer has any requirements, or if they have
+      # been run previously. It also catches errors and re-raises them as a
+      # PekkyError so we can present the user with a nicer error message.
+      def self.check_for_requirements
+        if !@loaded and respond_to?(:requirements)
+          requirements
+          @loaded = true
+        end
+      rescue LoadError => error
+        raise LibraryMissingError.new(self, error)
+      end
+    end
+    
+    # Formats textile markup into HTML.
+    class Textile < Transformer      
+      def self.format(text)
+        Tilt::RedClothTemplate.new {text}.render
+      end
+    end
+    
+    # Formats markdown into HTML.
+    class Markdown < Transformer
+      def self.format(text)
+        Tilt::RDiscountTemplate.new {text}.render
+      end
+    end
+    
+    # Ahhh, the venerable ERB templates.
+    class Erb < Transformer
+      def self.format(text)
+        Tilt::ERBTemplate.new {text}.render
+      end
+    end
+    
+    # HAML! I really like Haml. Best template language ever.
+    class Haml < Transformer
+      def self.format(text)
+        Tilt::HamlTemplate.new {text}.render
+      end
+    end
+    
+    # Would you really want to render RDoc? Maybe. I dunno.
+    class Rdoc < Transformer
+      def self.format(text)
+        Tilt::RDocTemplate.new {text}.render
+      end
+    end
+    
+    # Utility transformer which filters a nokogiri document fragment and 
+    # replaces all instances of an anchor using the pekky:// protocol with the
+    # actual path to the page. This allows users to link to pages by name, 
+    # without having to remember the path.
+    class Links < Transformer
+      def self.filter(doc, text)
+        doc.css("a[href^=pekky]").each do |a|
+          a.attributes["href"].value = Util.look_up_page(a.attributes["href"].value)
+        end
+      end
+    end
+    
+    # Util contains helper methods that don't fit anywhere else.
+    module Util
+      # Looks up a page based on a pekky URL.
+      def self.look_up_page(url)
+        match = url.match(/^pekky:\/\/(\S+)/)
+        qualify_path(Pekky.tree[match[1].to_sym].path)
+      end
+      
+      # Qualify path adds a prefix to URLs on export.
+      def self.qualify_path(path)
+        if !path.match(/^http/) and Pekky.exporting? and Config[:path_prefix]
+          File.join(Config[:path_prefix], path)
+        else
+          path
+        end
+      end
+    end # Util
+  end # Format
+end # Pekky

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pekky
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-23 00:00:00.000000000Z
+date: 2011-11-23 00:00:00.000000000 +10:30
+default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tilt
-  requirement: &70364329519300 !ruby/object:Gem::Requirement
+  requirement: &70172670560860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +22,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70364329519300
+  version_requirements: *70172670560860
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70364329518840 !ruby/object:Gem::Requirement
+  requirement: &70172670560400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +33,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70364329518840
+  version_requirements: *70172670560400
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &70364329518420 !ruby/object:Gem::Requirement
+  requirement: &70172670559980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +44,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70364329518420
+  version_requirements: *70172670559980
 description: A friendly static site builder
 email: me@lukematthewsutton.com
 executables:
@@ -53,17 +54,21 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README
+- CHANGES
 - bin/pekky
 - lib/pekky.rb
 - lib/pekky/builder.rb
 - lib/pekky/console.rb
 - lib/pekky/context.rb
+- lib/pekky/content.rb
+- lib/pekky/format.rb
 - lib/pekky/pages.rb
 - lib/pekky/server.rb
 - lib/pekky/config.rb
 - lib/pekky/tree.rb
 - lib/pekky/templates/site.rb
 - lib/pekky/templates/helpers.rb
+has_rdoc: true
 homepage: http://lukematthewsutton.com/pekky
 licenses: []
 post_install_message: 
@@ -84,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 2
 summary: Pekky’s main strengths come from the fact that it chooses explicitness over