pekky 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010 Luke Matthew Sutton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,47 @@
+
+  ########  ######## ##    ## ##    ## ##    ## #### 
+  ##     ## ##       ##   ##  ##   ##   ##  ##  #### 
+  ##     ## ##       ##  ##   ##  ##     ####   #### 
+  ########  ######   #####    #####       ##     ##  
+  ##        ##       ##  ##   ##  ##      ##         
+  ##        ##       ##   ##  ##   ##     ##    #### 
+  ##        ######## ##    ## ##    ##    ##    ####
+
+  A static site builder. It will punch your HTML... with love.
+
+  BUT WHY?!
+  Look, I know there are a bajillion site generators already, but this one is 
+  mine and it does what I want. For starters, it's simple and hackable. The
+  actual codebase is quite small. Barring some mis-organisation on my part it
+  should be readable enough. Secondly, it abandons the idea of magic and instead
+  asks users to be explicit about what they are generating. This allows for
+  reuse of content across a site and other clever tricks.
+  
+  
+  FEATURES BO!
+  * Explicitly link content to templates and output paths, allowing reuse
+  * Use any templating language supported by Tilt, but see caveats below
+  * Generate pages from any source -- CSV files, DB contents, web API calls
+  
+  
+  QUICK START -- assuming Pekky is installed
+  
+  $ pekky --generate word_up
+  $ cd word_up
+  $ pekky --server
+  
+  See pekky --help for more info
+  
+  
+  TODO
+  * Get specs up to speed
+  * Write a tutorial
+  * Gem this motherbitch up
+  
+  
+  CAVEATS
+  * Not actually finished soz
+  * No Windows support. If someone wants to build it that’s cool, but I’m lazy.
+  * Limited Mustache support. It won’t play with arbitrary contexts.
+  * May potentially be slow
+  

data/Thorfile

@@ -0,0 +1,39 @@
+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/bin/pekky

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require 'optparse'
+
+lib = File.join(File.expand_path(File.dirname(__FILE__)), '../lib/pekky.rb')
+if File.exists?(lib)
+  require lib
+else
+  require 'pekky'
+end
+
+banner = %q{
+  
+  ########  ######## ##    ## ##    ## ##    ## #### 
+  ##     ## ##       ##   ##  ##   ##   ##  ##  #### 
+  ##     ## ##       ##  ##   ##  ##     ####   #### 
+  ########  ######   #####    #####       ##     ##  
+  ##        ##       ##  ##   ##  ##      ##         
+  ##        ##       ##   ##  ##   ##     ##    #### 
+  ##        ######## ##    ## ##    ##    ##    ####
+  
+  A static site builder. It will punch your HTML... with love.
+  
+}
+
+options = OptionParser.new do |o|
+  o.banner = banner
+  
+  o.on("-s", "--server [PORT]", "starts the development server") do |port|
+    Pekky.server(port)
+  end
+  
+  o.on("-o", "--output", "outputs your site") do
+    Pekky.load
+    Pekky.build
+    puts "Site files output into ./output"
+  end
+  
+  o.on("-g", "--generate [NAME]", "stubs out the files and folders needed for development") do |name|
+    Pekky.generate(name)
+    puts "New site generated in: #{name}"
+  end
+  
+  o.on('-v', '--version', 'outputs the current version of Pekky') do
+    puts "Pekky #{Pekky::VERSION} (#{Pekky::VERSION_NAME})"
+  end
+  
+  o.on('-c', '--console', 'starts an irb session inside of Pekky') do
+    Pekky.console
+  end
+  
+  o.on('-e', '--export', 'exports the site for deployment -- this prefixes paths correctly') do
+    Pekky.load
+    Pekky.export
+    puts "Site files output into ./output"
+  end
+end
+
+if ARGV.size == 0
+  puts "PEKKY!\n type --help for a list of available commands"
+  exit 1
+end
+
+options.parse!

data/lib/pekky/builder.rb

@@ -0,0 +1,60 @@
+module Pekky
+  module Builder
+    def self.build
+      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}
+    end
+
+    def self.build!
+      clear_output_dir
+      Pekky.build
+    end
+    
+    def self.clear_output_dir
+      system("rm -rf '#{SiteConfig[:output_dir]}/*'") if File.exists?(SiteConfig[:output_dir])
+    end
+    
+    def self.check_for_output_dir
+      FileUtils.mkdir(SiteConfig[:output_dir]) unless File.exists?(SiteConfig[:output_dir])
+    end
+    
+    def self.directory(path)
+      unless File.directory?(File.join(SiteConfig[:output_dir], path))
+        parts = path.split("/")
+        fragment = SiteConfig[:output_dir].clone
+        while parts.length > 0
+          fragment = File.join(fragment, parts.shift)
+          FileUtils.mkdir(fragment) unless File.directory?(fragment)
+        end
+      end
+    end
+    
+    def self.copy_static_assets
+      system("cp -fR '#{SiteConfig[:public_dir]}/.' '#{SiteConfig[: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.each do |d|
+        FileUtils.mkdir(File.join(destination, d))
+      end
+      
+      template_dir = File.expand_path("#{File.dirname(__FILE__)}/templates")
+      system("cp '#{template_dir}/site.rb' '#{destination}'")
+      system("cp '#{template_dir}/helpers.rb' '#{destination}'")
+    end
+  end
+end

data/lib/pekky/console.rb

@@ -0,0 +1,22 @@
+module Pekky
+  module Console
+    def self.start
+      require 'irb'
+
+      Pekky.load
+      Pekky.build
+      puts %{
+
+        Welcome to the Pekky console
+        Some useful methods:
+
+        Pekky.pages           An array of the page instances in the site
+        Pekky.build           Rebuild the site
+        Pekky.build!          Destructive rebuild -- removes all previously generated files
+
+      }
+
+      IRB.start(__FILE__)
+    end
+  end
+end

data/lib/pekky/context.rb

@@ -0,0 +1,153 @@
+module Pekky
+  class Context
+    attr_writer :view_output, :is_layout
+    
+    def initialize(page)
+      @page = page
+      @is_layout = false
+    end
+    
+    def config
+      SiteConfig
+    end
+    
+    def text(markup, val)
+      case markup
+        when :markdown then markdown(val)
+        when :textile then markdown(textile)
+        else val
+      end
+    end
+    
+    def markdown(val)
+      unless Kernel.const_defined? :Markdown
+        require 'rdiscount'
+      end
+
+      Markdown.new(val, :smart).to_html
+    end
+    
+    def textile(val)
+      unless Kernel.const_defined? :RedCloth
+        require 'RedCloth'
+      end
+      
+      RedCloth.new(val).to_html
+    end
+    
+    def partial(path)
+      file_name = "#{path}.html.#{SiteConfig[:templating]}"
+      path = File.join(SiteConfig[:partials_dir], file_name)
+      Tilt.new(path).render(self)
+    end
+    
+    def view
+      if @is_layout
+        @view_output
+      else
+        tag('p', "You can't call #view within a view! This will break things. Tsk.")
+      end
+    end
+    
+    def stylesheet(name, opts = {})
+      opts['media'] ||= 'screen'
+      opts['rel'] ||= 'stylesheet'
+      opts['type'] = 'text/css'
+      opts['href'] = "#{qualify_path("#{SiteConfig[:stylesheets_path]}/#{name}")}.css"
+      
+      self_closing_tag('link', opts)
+    end
+    
+    def javascript(name)
+      tag('script', '', :src => "#{qualify_path("#{SiteConfig[:javascripts_path]}/#{name}")}.js", :type => 'text/javascript')
+    end
+    
+    def image(path, opts = {})
+      opts['src'] = qualify_path("#{SiteConfig[:images_path]}/#{path}")
+      self_closing_tag('img', opts)
+    end
+    
+    def link(text, url, opts = {})
+      opts['href'] = qualify_path(url)
+      tag('a', text, opts)
+    end
+    
+    def tag(type, child, opts = nil)
+      if opts
+        "<#{type} #{attrs(opts)}>#{child}</#{type}>"
+      else
+        "<#{type}>#{child}</#{type}>"
+      end
+    end
+    
+    def self_closing_tag(type, opts = nil)
+      if opts
+        "<#{type} #{attrs(opts)}/>"
+      else
+        "<#{type}>#{contents}/>"
+      end
+    end
+    
+    def attrs(opts)
+      out = opts.inject([]) do |a, o|
+        a << "#{o[0]}=\"#{o[1]}\""
+        a
+      end
+      
+      out.join(" ").chomp
+    end
+    
+    def qualify_path(path)
+      if Pekky.exporting? and SiteConfig[:path_prefix]
+        SiteConfig[:path_prefix] + path
+      else
+        path
+      end
+    end
+    
+    def nav
+      Pekky.tree.pages.reject {|p| p.hidden? }
+    end
+  
+    def pages
+      Pekky.tree.pages
+    end
+    
+    def content
+      @page.content
+    end
+    
+    def path
+      qualify_path(@page.path)
+    end
+    
+    def children
+      @page.children
+    end
+    
+    def ancestors
+      collect_ancestors(@page)
+    end
+    
+    def parent
+      @page.parent
+    end
+    
+    def child?
+      @page.child?
+    end
+    
+    def hidden?
+      @page.hidden?
+    end
+    
+    def collect_ancestors(page, ancestors = [])
+      if page.parent
+        collect_ancestors(page.parent, ancestors)
+        ancestors.unshift(page.parent)
+      else
+        ancestors
+      end
+    end
+  end
+end

data/lib/pekky/pages.rb

@@ -0,0 +1,104 @@
+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
+  
+  class Page
+    attr_reader :path, :children, :content, :opts, :file_name
+    attr_accessor :parent
+    
+    def initialize(path, content, opts)
+      @path = path
+      @opts = opts
+      
+      @content = if content.is_a? String
+        content_path = File.join(SiteConfig[:content_dir], "#{content}.yml")
+        YAML.load_file(content_path)
+      else
+        content
+      end
+      
+      @file_name = "index.#{opts[:ext] || 'html'}"
+      
+      @view = view(:view, opts)
+      @layout = view(:layout, opts)
+      
+      @children = []
+    end
+    
+    def ==(other)
+      path == other.path
+    end
+    
+    def hidden?
+      !!opts[:hidden]
+    end
+    
+    def child?
+      @path.index("/") > 0
+    end
+    
+    def render
+      Builder.directory(@path)
+      
+      context = Context.new(self)
+      view_output = @view.render(Context.new(self))
+      context.view_output = view_output
+      context.is_layout = true
+      
+      File.open(File.join(SiteConfig[:output_dir], @path, @file_name), 'w') do |f|
+        f.write(@layout.render(context))
+      end
+    end
+    
+    private
+    
+    def view(type, opts)
+      if type == :view
+        name = opts[:view] ||= 'default'
+        dir = :view_dir
+      else
+        name = opts[:layout] ||= 'default'
+        dir = :layouts_dir
+      end
+      
+      file_name = "#{name}.#{opts[:ext] || 'html'}.#{SiteConfig[:templating]}"
+      path = File.join(SiteConfig[dir], file_name)
+      Tilt.new(path)
+    end
+  end
+  
+  class GeneratorConfig
+    def initialize(path, &blk)
+      @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] || {}
+      
+      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
+  end
+end

data/lib/pekky/server.rb

@@ -0,0 +1,25 @@
+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]
+        run Pekky::Server
+      }
+      Rack::Handler.default.run(app, :Port => port || 3000)
+    end
+    
+    def self.call(env)
+      Pekky.build
+      path = env['PATH_INFO']
+      file = File.join(SiteConfig[:output_dir], path, 'index.html')
+      if File.exists?(file)
+        output = File.open(file).read
+        [200, {"Content-Type" => "text/html"}, [output]]
+      else
+        [200, {"Content-Type" => "text/html"}, "Oh, file is not found; Pekky cries for you."]
+      end
+    end
+  end
+end

data/lib/pekky/site_config.rb

@@ -0,0 +1,56 @@
+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
+  end
+end

data/lib/pekky/templates/helpers.rb

@@ -0,0 +1,3 @@
+Pekky.helpers do
+  
+end

data/lib/pekky/templates/site.rb

@@ -0,0 +1,3 @@
+Pekky.site do
+  
+end

data/lib/pekky/tree.rb

@@ -0,0 +1,36 @@
+module Pekky
+  module Tree
+    @pages = []
+    
+    def self.pages
+      @pages
+    end
+    
+    def self.add(pages)
+      @pages.clear
+      pages.each {|p| add_to_tree(p, pages)}
+    end
+    
+    private
+
+    def self.add_to_tree(page, pages)
+      # Loop through the existing pages and see if the current page is a child
+      # of an existing one. If we get a partial match, see if it belongs
+      # to one of the children.
+      pages.each do |p|
+        if page.path != p.path        
+          if page.path.match("^#{p.path}/[a-zA-Z0-9_\-]+$")
+            page.parent = p
+            p.children << page
+            return
+          elsif page.path.match("^#{p.path}/\S+")
+            add_to_tree(page, p.children)
+            return
+          end
+        end
+      end
+      # If none of the above works, just stick the page in the top level.
+      @pages << page
+    end
+  end
+end

data/lib/pekky.rb

@@ -0,0 +1,96 @@
+# [Tilt]: http://github.com/rtomayko/tilt is used to hanndle the template 
+# rendering. Pekky assumes that you have the relevant template libraries 
+# installed.
+require 'tilt'
+
+# We need file utils for some of the generation steps, mainly adding and 
+# deleting directories.
+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"
+  
+  # Returns the tree module. The tree module represents the sites pages and
+  # contents arranged into a tree.
+  def self.tree
+    Tree
+  end
+  
+  # Stubs out a site on disk. Is generally called with the Pekky binary.
+  def self.generate(destination)
+    Builder.generate(destination)
+  end
+  
+  # Starts up the server on the specified port.
+  def self.server(port)    
+    Server.start(port)
+  end
+  
+  # Builds the site and starts a console session.
+  def self.console
+    Console.start
+  end
+  
+  # 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')
+  end
+  
+  # Used by the site.rb file to define all the options in the site.
+  def self.site(&blk)    
+    SiteConfig.class_eval(&blk)
+  end
+  
+  # Used bu the helpers.rb file to define additional helpers.
+  def self.helpers(&blk)
+    Context.class_eval(&blk)
+  end
+  
+  # Builds the site on disk.
+  def self.build
+    Builder.build
+  end
+  
+  # First clears the existing output, then rebuilds the site.
+  def self.build!
+    Builder.build!
+  end
+  
+  @exporting = false
+  
+  # Creates an export of the site ready to go up onto a server.
+  def self.export
+    @exporting = true
+    build!
+  end
+  
+  # Used within the app to indicate if we are doing a developmental build or a
+  # proper build. This will effect helpers, which will use things like the 
+  # domain and path prefix
+  def self.exporting?
+    @exporting == true
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: pekky
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+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 
+  name: tilt
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A friendly static site builder
+email: me@lukematthewsutton.com
+executables: 
+- pekky
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README
+- Thorfile
+- bin/pekky
+- lib/pekky.rb
+- lib/pekky/builder.rb
+- lib/pekky/console.rb
+- lib/pekky/context.rb
+- lib/pekky/pages.rb
+- lib/pekky/server.rb
+- lib/pekky/site_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: 
+- 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"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: A friendly static site builder
+test_files: []
+