pekky 0.2 → 0.4

data/README

@@ -35,17 +35,14 @@
   
   TODO
   * Get specs up to speed
-  * Add the option of naming pages
-  * Support shared content
-  * Add helpers for slurping up a collection of shared content i.e. news feed
-  * Support alternate formats correctly
   * Compile stylesheets with less or sass
   * Compile javascripts with Coffee
   
   
   CAVEATS
   * Not actually finished soz
-  * No Windows support. If someone wants to build it that’s cool, but I’m lazy.
+  * Windows support with cygwin only. If someone wants to fix this, that’s cool, 
+    but I’m lazy.
   * Limited Mustache support. It won’t play with arbitrary contexts.
   * May potentially be slow
   

data/lib/pekky/builder.rb

@@ -1,20 +1,13 @@
 module Pekky
   module Builder
     def self.build
-      Context.flush!
       check_for_output_dir
       copy_static_assets
-
-      @pages = []
-      # This has to be done in three loops so we can collect the meta data and
-      # content for each page first, assemble them into a tree, then render.
-      #
-      # This ensures that every page will have complete access to the entire
-      # site and it's content as it is being rendered, calling helpers etc.
-      pages = SiteConfig.page_configs.collect {|p| p.prepare}
-      pages.flatten!
-      Tree.add(pages)
-      pages.each {|p| p.render}
+      
+      Pekky::Content.flush!
+      
+      Tree.add(Config.page_configs)
+      Config.page_configs.each {|p| p.render}
     end
 
     def self.build!
@@ -23,17 +16,17 @@ module Pekky
     end
     
     def self.clear_output_dir
-      system("rm -rf '#{SiteConfig[:output_dir]}/*'") if File.exists?(SiteConfig[:output_dir])
+      system("rm -rf '#{Config[:output_dir]}/*'") if File.exists?(Config[:output_dir])
     end
     
-    def self.check_for_output_dir
-      FileUtils.mkdir(SiteConfig[:output_dir]) unless File.exists?(SiteConfig[:output_dir])
+    def self.check_for_output_dir      
+      FileUtils.mkdir(Config[:output_dir]) unless File.exists?(Config[:output_dir])
     end
     
     def self.directory(path)
-      unless File.directory?(File.join(SiteConfig[:output_dir], path))
+      unless File.directory?(File.join(Config[:output_dir], path))
         parts = path.split("/")
-        fragment = SiteConfig[:output_dir].clone
+        fragment = Config[:output_dir].clone
         while parts.length > 0
           fragment = File.join(fragment, parts.shift)
           FileUtils.mkdir(fragment) unless File.directory?(fragment)
@@ -42,13 +35,13 @@ module Pekky
     end
     
     def self.copy_static_assets
-      system("cp -fR '#{SiteConfig[:public_dir]}/.' '#{SiteConfig[:output_dir]}/.'")
+      system("cp -fR '#{Config[:public_dir]}/.' '#{Config[:output_dir]}/.'")
     end
     
     def self.generate(destination)
       destination ||= Dir.pwd
       FileUtils.mkdir(destination) unless File.exists?(destination)
-      dirs = %w(content views public public/stylesheets public/javascripts public/images)
+      dirs = %w(content views views/layouts views/partials public public/stylesheets public/javascripts public/images)
       dirs.each do |d|
         FileUtils.mkdir(File.join(destination, d))
       end

data/lib/pekky/config.rb

@@ -0,0 +1,84 @@
+module Pekky
+  module Config
+    @default_config = {
+      :content_dir      => '/content',
+      :view_dir         => '/views',
+      :layouts_dir      => '/views/layouts',
+      :partials_dir     => '/views/partials',
+      :public_dir       => '/public',
+      :output_dir       => '/output',
+      :javascripts_path => '/javascripts',
+      :stylesheets_path => '/stylesheets',
+      :images_path      => '/images',
+      :templating       => 'haml',
+      :css_processor    => 'sass'
+    }
+    
+    @config = {}
+    @loaded = false
+    
+    def self.load(p)
+      unless @loaded
+        @config = @default_config.merge(@config)
+        @config[:root] = p
+        @config.each do |k, v|
+          @config[k] = File.join(p, v) if k.to_s.match(/_dir$/)
+        end
+        @loaded = true
+      end
+    end
+    
+    @page_configs = []
+    @routes = {}
+    
+    def self.page_configs
+      @page_configs
+    end
+    
+    def self.[](name)
+      @config[name]
+    end
+    
+    def self.[]=(option, val)
+      set(option, val)
+    end
+  
+    private
+  
+    def self.set(option, val)
+      if option.to_s.match(/_dir$/)
+        @config[option] = File.join(self[:root], val)
+      else
+        @config[option] = val
+      end
+    end
+    
+    def self.page(name, path, content = nil, opts = {})
+      @page_configs << if content.is_a? Hash
+        Page.new(name, path, content, opts)
+      else
+        Page.new(name, path, Content.get(content), opts)
+      end
+    end
+
+    def self.route(name, path)
+      placeholders = path.scan(/:(\S+)/).flatten!
+      @routes[name.to_sym] = {:path => path, :placeholders => placeholders}
+    end
+
+    def self.pages(name, path, contents, opts = {})
+      route(name, path)
+      placeholders = path.scan(/:(\S+)/).flatten!
+      Content.get(contents).each do |c|
+        page_path = path.dup
+        page_name = name.to_s
+        placeholders.each do |p| 
+          page_path.sub!(':' + p, c[p])
+          page_name += ('_' + c[p])
+        end
+
+        @page_configs << Page.new(page_name, page_path, c, opts.dup)
+      end
+    end
+  end
+end

data/lib/pekky/context.rb

@@ -1,72 +1,70 @@
 module Pekky
+  # For every page instance in the site there is a corresponding context 
+  # instance. The context is used when rendering the layout and views, 
+  # encapsulating the page content and providing the built-in helpers.
+  #
+  # It also hosts any helpers provided in the helpers.rb file.  
   class Context
+    # Some attribute writers for storing information in contexts attached to 
+    # layouts. This is because the layout needs to have access to the rendered
+    # view in order to inject it into itself.
     attr_writer :view_output, :is_layout
     
-    @shared = {}
-    
-    def self.flush!
-      @shared.clear
-    end
-    
-    def self.get(name, sort)
-      @shared[name] ||= begin
-        path = File.join(SiteConfig[:content_dir], name)
-        if File.directory?(path)
-          collection = Dir[path + '/*.yml'].inject([]) do |a, y|
-            a << YAML.load_file(y)
-            a
-          end          
-          collection.sort! {|a, b| a[sort] <=> b[sort]} if sort
-          collection
-        else
-          YAML.load_file(path + ".yml")
-        end
-      end
-    end
-    
+    # Initialize stores the reference to the page instance so that it can 
+    # expose it to the view when rendering.
     def initialize(page)
       @page = page
       @is_layout = false
     end
     
-    def get(name, sort = nil)
-      self.class.get(name, sort)
-    end
-    
+    # A shortcut to the site configuration. This is here to allow users to 
+    # store and access common, re-used details like the site title.
     def config
-      SiteConfig
+      Config
     end
     
-    def text(markup, val)
-      case markup
-        when :markdown then markdown(val)
-        when :textile then markdown(textile)
-        else val
-      end
+    # A shortcut to the Formatters module. Users call methods on the module,
+    # which then calls the relevant formatter.
+    #
+    #   format.textile(content[:body])
+    #
+    # Formatters accept a format like textile or haml and transform it into 
+    # HTML markup.
+    def format
+      Format::Formatters
     end
     
-    def markdown(val)
-      unless Kernel.const_defined? :Markdown
-        require 'rdiscount'
-      end
-
-      Markdown.new(val, :smart).to_html
+    # Shortcut to the filters module. Filters accept HTML markup and manipulate
+    # it in some way. For example, extracting an modifying links. They're called
+    # in the same way as the formatters.
+    #
+    #   filter.links(markup)
+    #
+    def filter
+      Format::Filters
     end
     
-    def textile(val)
-      unless Kernel.const_defined? :RedCloth
-        require 'RedCloth'
-      end
-      
-      RedCloth.new(val).to_html
+    # Makes a call to Content#get and returns the content specified by the path
+    # argument. An argument of a directory name will return an array of content
+    # objects. The path to a single YAML file will return just the one object.
+    def get(path)
+      Content.get(path)
     end
-    
+
+    # Renders the specified partial. The partial should only have it's name 
+    # specified, not it's entire extension i.e. no '.html.haml'
+    #
+    #   partial('profiles/full')
+    #
     def partial(path)
-      file_name = "#{path}.html.#{SiteConfig[:templating]}"
-      path = File.join(SiteConfig[:partials_dir], file_name)
+      file_name = "#{path}.html.#{Config[:templating]}"
+      path = File.join(Config[:partials_dir], file_name)
       Tilt.new(path).render(self)
     end
     
+    # A helper for injecting views into layouts. This method should be called
+    # at least once inside a layout. If you try calling it inside a view it will
+    # output a warning.
     def view
       if @is_layout
         @view_output
@@ -75,29 +73,52 @@ module Pekky
       end
     end
     
+    # Generates a link to a stylesheet. At it's most basic you only need to
+    # specify the name, but you can also optionally specify the media, name etc.
+    #
+    #   stylesheet('print', :media => 'print')
+    #
     def stylesheet(name, opts = {})
       opts['media'] ||= 'screen'
       opts['rel'] ||= 'stylesheet'
       opts['type'] = 'text/css'
-      opts['href'] = "#{qualify_path("#{SiteConfig[:stylesheets_path]}/#{name}")}.css"
+      opts['href'] = "#{Format::Util.qualify_path("#{Config[:stylesheets_path]}/#{name}")}.css"
       
       self_closing_tag('link', opts)
     end
     
+    # Generates a javascript tag.
     def javascript(name)
-      tag('script', '', :src => "#{qualify_path("#{SiteConfig[:javascripts_path]}/#{name}")}.js", :type => 'text/javascript')
+      tag('script', '', :src => "#{Format::Util.qualify_path("#{Config[:javascripts_path]}/#{name}")}.js", :type => 'text/javascript')
     end
     
+    # Generates an image tag. As a bare minimum, only the name is required, but
+    # you can optionally provide additional attributes.
+    #
+    #   image('pix.jpg', :alt => 'Wicked Cool')
+    #
     def image(path, opts = {})
-      opts['src'] = qualify_path("#{SiteConfig[:images_path]}/#{path}")
+      opts['src'] = Format::Util.qualify_path("#{Config[:images_path]}/#{path}")
       self_closing_tag('img', opts)
     end
-    
+        
+    # Creates an anchor tag with the specified URL. It will also accept 
+    # additional options for the anchor attributes. If you pass in a link with 
+    # the 'pekky://' protocol, the string will be used as a name look up for an
+    # internal page and the URL will be replaced with a real path to the page.
+    #
+    #   link('ZOMG', 'pekky://news_archive') #=> '<a href="/news/archive">ZOMG</a>'
+    #
     def link(text, url, opts = {})
-      opts['href'] = qualify_path(url)
+      if url.index("pekky://") == 0
+        url = Format::Util.look_up_page(url)
+      end
+      opts['href'] = Format::Util.qualify_path(url)
       tag('a', text, opts)
     end
     
+    # Generates a content tag of the specified type. The child can either be
+    # text or HTML markup.
     def tag(type, child, opts = nil)
       if opts
         "<#{type} #{attrs(opts)}>#{child}</#{type}>"
@@ -106,14 +127,16 @@ module Pekky
       end
     end
     
+    # Generates a self closing tag of the specified type.
     def self_closing_tag(type, opts = nil)
       if opts
         "<#{type} #{attrs(opts)}/>"
       else
-        "<#{type}>#{contents}/>"
+        "<#{type}/>"
       end
     end
     
+    # A utility method for converting a hash into a string of attributes.
     def attrs(opts)
       out = opts.inject([]) do |a, o|
         a << "#{o[0]}=\"#{o[1]}\""
@@ -123,54 +146,62 @@ module Pekky
       out.join(" ").chomp
     end
     
-    def qualify_path(path)
-      if !path.match(/^http/) and Pekky.exporting? and SiteConfig[:path_prefix]
-        SiteConfig[:path_prefix] + path
-      else
-        path
-      end
-    end
-    
+    # A convenience method which returns the top-level pages in the site. It
+    # excludes any what have been set as hidden.
     def nav
       Pekky.tree.pages.reject {|p| p.hidden? }
     end
     
+    # Returns the page with the specified name. This name is set in the site.rb
+    # or is derived from a sanitised version of the page's path.
     def page(name)
       Pekky.tree[name]
     end
     
+    # Returns the tree of all pages in the site. You can recurse through the 
+    # entire tree by accessing the #children method on each page.
     def pages
       Pekky.tree.pages
     end
     
+    # The content assigned to the current page.
     def content
       @page.content
     end
     
+    # The path to the current page.
     def path
-      qualify_path(@page.path)
+      Format::Util.qualify_path(@page.path)
     end
     
+    # The children of the current page.
     def children
       @page.children
     end
     
+    # The pages which sit above this page in the hierarchy i.e. parent, 
+    # grant-parent etc.
     def ancestors
       collect_ancestors(@page)
     end
     
+    # The current page's parent.
     def parent
       @page.parent
     end
     
+    # Returns a boolean specifying if this page is the child of another.
     def child?
       @page.child?
     end
     
+    # Returns a boolean specifying if this page is hidden.
     def hidden?
       @page.hidden?
     end
     
+    # A helper method used to recursively collect the ancestors of the current
+    # page. It should never be called directly.
     def collect_ancestors(page, ancestors = [])
       if page.parent
         collect_ancestors(page.parent, ancestors)

data/lib/pekky/pages.rb

@@ -1,76 +1,90 @@
 module Pekky
-  class PageConfig
-    def initialize(path, content, opts = {})
-      @path = path
-      @content = content
-      @opts = opts
-    end
-    
-    def prepare
-      Page.new(@path, @content, @opts)
-    end
-  end
-  
+  # The page class encapsulates everything needed to render the actual content
+  # to disk -- the destination path, content and templates. It also contains 
+  # the meta-data for a page -- parents, children, name etc.
   class Page
-    attr_reader :path, :children, :content, :opts, :file_name, :name
+    # Various attribute accessors for storing all the values we reuse across 
+    # the different methods.
+    attr_reader :path, :directory, :children, :content, :opts, :file_name, :name
+    
+    # This accessor will be used to store a reference to the parent page -- 
+    # if there is one. The parent page will be updated when the tree gets
+    # built. See the Builder class for more info.
     attr_accessor :parent
     
-    def initialize(path, content, opts)
-      @path = path
-      @opts = opts
-      
-      # Calculate a name for the page
-      @name = if opts[:name]
-        opts.delete(:name).to_sym
-      elsif path == '/'
-        :root
+    # The Page class is initialized with the path, the content -- either a 
+    # Content instance or a hash -- and a hash of options. It then determines
+    # the name of the output file and it's path -- pages without extensions 
+    # default to 'index.html'. It also determines the format if specified.
+    def initialize(name, path, content, opts)
+      if content.is_a?(Pekky::Content)
+        @content = content
       else
-
-        path.match(/^\/(\S+)/)[1].gsub(/[\/\-]/, '_').to_sym
+        opts = content
       end
+
+      @path = path
+      @opts = opts
+      @children = []
+      @opts[:name] = name
       
-      @content = if content.is_a? String
-        content_path = File.join(SiteConfig[:content_dir], "#{content}.yml")
-        YAML.load_file(content_path)
+      if match = @path.match(/^([\S+]?\/)(\S+)\.(\S+)$/)
+        @directory = match[1]
+        @format = match[3]
+        @file_name = "#{match[2]}.#{@format}"
       else
-        content
+        @directory = path
+        @format = 'html'
+        @file_name = "index.html"
       end
-      
-      @file_name = "index.#{opts[:ext] || 'html'}"
-      
-      @view = view(:view, opts)
-      @layout = view(:layout, opts)
-      
-      @children = []
     end
     
+    # Compares one page instance with another. It does this by comparing the 
+    # name -- which will be unique.
     def ==(other)
-      path == other.path
+      name == other.name
     end
     
+    # Checks to see if the page is hidden i.e. it doesn't appear in the main 
+    # navigation. The user can specify this when declaring a page in the 
+    # site.rb
     def hidden?
       !!opts[:hidden]
     end
     
+    # Is this page a child or does it sit at the top level of the site? It just
+    # checks to see if there is only one leading slash. Cheaty, but it works ;)
     def child?
-      @path.index("/") > 0
+      @path.count("/") == 1
     end
     
+    # The business part of the page. It renders the page and outputs it to 
+    # disk. Firstly it asks the Builder to ensure the target directory is on 
+    # disk. Then it sets up the context -- encapsulating the content -- and the
+    # view and layout. Finally it renders the page and writes it to disk.
     def render
-      Builder.directory(@path)
+      Builder.directory(@directory)
       
+      @content.reload if @content
       context = Context.new(self)
-      view_output = @view.render(Context.new(self))
-      context.view_output = view_output
-      context.is_layout = true
+      view_output = view(:view, @opts).render(context)
       
-      File.open(File.join(SiteConfig[:output_dir], @path, @file_name), 'w') do |f|
-        f.write(@layout.render(context))
+      File.open(File.join(Config[:output_dir], @directory, @file_name), 'w') do |f|
+        if @opts[:layout] == false
+          f.write(view_output)
+        else
+          layout = view(:layout, opts)
+          context.view_output = view_output
+          context.is_layout = true
+          f.write(layout.render(context))
+        end
       end
     end
     
     private
     
+    # A helper for creating the instances of Tilt for rendering the templates.
+    # It handles both the view and the layout.
     def view(type, opts)
       if type == :view
         name = opts[:view] ||= 'default'
@@ -80,43 +94,22 @@ module Pekky
         dir = :layouts_dir
       end
       
-      file_name = "#{name}.#{opts[:ext] || 'html'}.#{SiteConfig[:templating]}"
-      path = File.join(SiteConfig[dir], file_name)
+      file_name = "#{name}.#{@format}.#{opts[:templating] || Config[:templating]}"
+      path = File.join(Config[dir], file_name)
       Tilt.new(path)
     end
-  end
-  
-  class GeneratorConfig
-    def initialize(path, &blk)
+  end # Page
+
+  # The directory class is used to act as a parent for pages which don't have
+  # an actual direct parent i.e. /posts/* don't have a corresponding
+  # /posts/index.html
+  class Directory
+    def initialize(path)
       @path = path
-      @blk = blk
-      @pages = []
-      matches = path.match(/:([a-zA-Z0-9_]+)/)
-      @path_params = matches[1..matches.length]
-    end
-  
-    def prepare
-      instance_eval(&@blk)
-      @pages
-    end
-    
-    def render(template, opts = {})
-      content = opts[:content] || {}
-      
-      opts[:view] = template 
-      
-      path = @path.dup
-      @path_params.each do |p|
-        path.gsub!(/:#{p}/, opts[p.to_sym].to_s)
-      end
-      
-      @pages << Page.new(path, content, opts)
     end
-    
-    private
-    
-    def get(name, sort = nil)
-      Context.get(name, sort)
+
+    def render
     end
-  end
-end
+  end # Directory
+end # Pekky
+

data/lib/pekky/server.rb

@@ -1,22 +1,28 @@
 module Pekky
   module Server
     def self.start(port)
-      require 'rack'
       Pekky.load
       app = Rack::Builder.app {
-        use Rack::Static, :urls => %w(/stylesheets /javascripts /images), :root => Pekky::SiteConfig[:output_dir]
+        use Rack::Static, :urls => %w(/stylesheets /javascripts /images), :root => Pekky::Config[:output_dir]
         run Pekky::Server
       }
-      Rack::Handler.default.run(app, :Port => port || 3000)
+      Rack::Server.new(:app => app, :Port => port || 3000).start
     end
     
-    def self.call(env)
+    def self.call(env)      
       Pekky.build
       path = env['PATH_INFO']
-      file = File.join(SiteConfig[:output_dir], path, 'index.html')
+      if path.match(/\.(\w+)$/)
+        file = File.join(Config[:output_dir], path)
+        type = Rack::Mime.mime_type(File.extname(path))
+      else
+        file = File.join(Config[:output_dir], path, "index.html")
+        type = "text/html"        
+      end
+      
       if File.exists?(file)
         output = File.open(file).read
-        [200, {"Content-Type" => "text/html"}, [output]]
+        [200, {"Content-Type" => type}, [output]]
       else
         [200, {"Content-Type" => "text/html"}, "Oh, file is not found; Pekky cries for you."]
       end

data/lib/pekky/tree.rb

@@ -3,6 +3,12 @@ module Pekky
     @pages = []
     @map = {}
     
+    class PageMissingError < PekkyError
+      def initialize(page)
+        @message = "The page ''#{page}' has not been defined. Check your site.rb"
+      end
+    end
+    
     def self.[](name)
       @map[name]
     end

data/lib/pekky.rb

@@ -1,8 +1,18 @@
-# [Tilt]: http://github.com/rtomayko/tilt is used to hanndle the template 
+# [Tilt]:http://github.com/rtomayko/tilt is used to hanndle the template 
 # rendering. Pekky assumes that you have the relevant template libraries 
 # installed.
+require 'rubygems'
 require 'tilt'
 
+# [Nokogiri]:http://nokogiri.org is required for both parsing output and 
+# updating links and also for the tests -- checking that the correct markup is 
+# output.
+require 'nokogiri'
+
+# Rack is used to run the server. It'll use the default server — generally
+# webbrick.
+require 'rack'
+
 # We need file utils for some of the generation steps, mainly adding and 
 # deleting directories.
 require 'fileutils'
@@ -10,24 +20,35 @@ require 'fileutils'
 # The actual content is stored in YAML files, so we need to require the lib.
 require 'yaml'
 
-# Require all the bits of Pekky. Without these, it is nothing. True friends!
-dir = File.expand_path(File.dirname(__FILE__))
-require dir + '/pekky/site_config'
-require dir + '/pekky/pages'
-require dir + '/pekky/tree'
-require dir + '/pekky/context'
-require dir + '/pekky/builder'
-require dir + '/pekky/server'
-require dir + '/pekky/console'
-
 # # Pekky!
 # The main module, which contains all the various kick-off methods. The majority
 # of the actual logic is defined in the other source files. This module just
 # serves as a container and shortcut.
 module Pekky
-  # The first release, dedicated to everyone's favourite washed-up super-star
-  VERSION = '0.1'
-  VERSION_NAME = "Not Rocket Fuel, But Love"
+  # The third release, dedicated to stunt-men everywhere.
+  VERSION = '0.3'
+  VERSION_NAME = "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
+  # letting other errors filter through like normal. In other words, using a
+  # rescue block won't be an impediment to development.
+  class PekkyError < StandardError
+    attr_reader :message, :title
+  end
+  
+  # Require all the bits of Pekky. Without these, it is nothing. True friends!
+  # This is done after the declaration of PekkyError to stop things blowing up.
+  dir = File.expand_path(File.dirname(__FILE__))
+  require dir + '/pekky/config'
+  require dir + '/pekky/pages'
+  require dir + '/pekky/content'
+  require dir + '/pekky/tree'
+  require dir + '/pekky/format'
+  require dir + '/pekky/context'
+  require dir + '/pekky/builder'
+  require dir + '/pekky/server'
+  require dir + '/pekky/console'
   
   # Returns the tree module. The tree module represents the sites pages and
   # contents arranged into a tree.
@@ -53,15 +74,16 @@ module Pekky
   # Requires the site file and if defined the helpers file. #load can be called
   # with an optional root. This is generally not necessary and is mainly used
   # when testing.
-  def self.load(root = Dir.pwd)
-    SiteConfig.set_root(root)
-    require 'site'
-    require 'helpers' if File.exists?('./helpers.rb')
+  def self.load(root = Dir.pwd)    
+    Config.load(root)
+    require File.join(root, 'site')
+    helpers_path = File.join(root, 'helpers.rb')
+    require helpers_path if File.exists?(helpers_path)
   end
   
   # Used by the site.rb file to define all the options in the site.
   def self.site(&blk)    
-    SiteConfig.class_eval(&blk)
+    Config.class_eval(&blk)
   end
   
   # Used bu the helpers.rb file to define additional helpers.

metadata

@@ -1,45 +1,58 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: pekky
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  version: "0.2"
+version: !ruby/object:Gem::Version
+  version: '0.4'
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Luke Matthew Sutton
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-05-09 00:00:00 +09:30
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-11-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: tilt
+  requirement: &70364329519300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: *70364329519300
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70364329518840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *70364329518840
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70364329518420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70364329518420
 description: A friendly static site builder
 email: me@lukematthewsutton.com
-executables: 
+executables:
 - pekky
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - LICENSE
 - README
-- Thorfile
 - bin/pekky
 - lib/pekky.rb
 - lib/pekky/builder.rb
@@ -47,39 +60,35 @@ files:
 - lib/pekky/context.rb
 - lib/pekky/pages.rb
 - lib/pekky/server.rb
-- lib/pekky/site_config.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: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 2
-summary: "Pekky\xE2\x80\x99s main strengths come from the fact that it chooses explicitness over magic, that it\xE2\x80\x99s defaults are configurable and that it doesn\xE2\x80\x99t assume all  content is derived from files on disk. For example Pekky can generate pages from databases, CSV files or web API calls."
+summary: Pekky’s main strengths come from the fact that it chooses explicitness over
+  magic, that it’s defaults are configurable and that it doesn’t assume all  content
+  is derived from files on disk. For example Pekky can generate pages from databases,
+  CSV files or web API calls.
 test_files: []
-

data/Thorfile

@@ -1,39 +0,0 @@
-class App < Thor
-  desc "docs", "generate Docco documentation"
-  def docs
-    if File.exists?('docs')
-      system('rm -rf doc/*')
-    else
-      system('mkdir docs')
-    end
-    system('rocco lib/pekky.rb -o docs')
-    system('rocco lib/pekky/*.rb -o docs')
-  end
-  
-  desc "gem", "build the gemfile"
-  def gem
-    system("gem build pekky.gemspec")
-  end
-  
-  desc "install", "build the gem and install it"
-  def install
-    gem
-    f = Dir["pekky-*.gem"][0]
-    system("gem install #{f}")
-  end
-end
-
-class Spec < Thor
-  desc "all", "runs all of the specs for Pekky" 
-  def all
-    path = File.expand_path(File.dirname(__FILE__)) + '/'
-    Dir["spec/*_spec.rb"].each do |s|
-      require path + s
-    end
-  end
-  
-  desc "single SPEC_PREFIX", "runs the specified spec file" 
-  def single(prefix)
-    require "spec/#{prefix}_spec"
-  end
-end

data/lib/pekky/site_config.rb

@@ -1,60 +0,0 @@
-module Pekky
-  module SiteConfig
-    @config = {
-      :content_dir      => '/content',
-      :view_dir         => '/views',
-      :layouts_dir      => '/views/layouts',
-      :partials_dir     => '/views/partials',
-      :public_dir       => '/public',
-      :output_dir       => '/output',
-      :javascripts_path => '/javascripts',
-      :stylesheets_path => '/stylesheets',
-      :images_path      => '/images',
-      :templating       => 'haml',
-      :css_processor    => 'sass'
-    }
-    
-    def self.set_root(p)
-      @config[:root] = p
-      @config.each do |k, v|
-        if k.to_s.match(/_dir$/)
-          self[k] = File.join(p, v)
-        end
-      end
-    end
-    
-    @page_configs = []    
-    
-    def self.page_configs
-      @page_configs
-    end
-    
-    def self.[](name)
-      @config[name]
-    end
-    
-    def self.[]=(name, val)
-      @config[name] = val
-    end
-  
-    def self.set(option, val)
-      if option.to_s.match(/_dir$/)
-        @config[option] = File.join(self[:root], val)
-      else
-        @config[option] = val
-      end
-    end
-    
-    def self.page(path, content, opts = {})
-      @page_configs << PageConfig.new(path, content, opts)
-    end
-    
-    def self.generate(path, &blk)
-      @page_configs << GeneratorConfig.new(path, &blk)
-    end
-    
-    def self.get(name, sort = nil)
-      Context.get(name, sort)
-    end
-  end
-end