plato 0.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+/pkg
+/content
+/template
+/resources
+/config.rb

data/Rakefile

@@ -0,0 +1,33 @@
+ROOT_DIR = File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems' rescue nil
+require 'rake'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc "Run all specs in spec directory."
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{ROOT_DIR}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+# gemification with jeweler
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "plato"
+    gemspec.summary = "An ideal static site generator"
+    gemspec.description = "use templates and content to generate static sites."
+    gemspec.email = "matt@freels.name"
+    gemspec.homepage = "http://github.com/freels/plato"
+    gemspec.authors = ["Matt Freels"]
+    gemspec.add_dependency 'tilt', '>= 1.0.1'
+
+    # development
+    gemspec.add_development_dependency 'rspec'
+    gemspec.add_development_dependency 'rr'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/plato/config.rb

@@ -0,0 +1,65 @@
+module Plato
+  module Config
+    extend self
+
+    def read(dsl_class, string = nil, &block)
+      config = dsl_class.new
+
+      if string
+        config.instance_eval(string)
+      else
+        block.arity == 1 ? call.block(config) : config.instance_eval(&block)
+      end
+
+      extract_ivars(config)
+    end
+
+    private
+
+    def extract_ivars(config)
+      config.instance_variables.inject({}) do |result, ivar|
+        result.update(ivar.sub('@', '') => config.instance_variable_get(ivar))
+      end
+    end
+  end
+
+  class ConfigDSL
+    # Config DSL
+
+    def base_url(url)
+      @base_url = url
+    end
+    alias url base_url
+
+    def options(hash)
+      @options = hash
+    end
+
+    def content(name, content_path_template, opts = {})
+      @content_categories ||= {}
+      @content_categories[name.to_s] =
+        ContentCategory.new(name, content_path_template,
+          opts[:to] || content_path_template, opts[:sort], opts[:template])
+    end
+  end
+
+  class ContentCategory
+    attr_reader :name, :documents, :src_parser, :dest_parser, :template
+
+    def initialize(name, src_t, dest_t, sort, template)
+      @name = name
+      @documents = DocumentCollection.new(sort)
+      @src_parser = PathTemplate.new(src_t)
+      @dest_parser = PathTemplate.new(dest_t)
+      @template = "_#{template}" if template
+    end
+
+    def match(path); src_parser.parse(path) end
+    def dest_path(data); dest_parser.materialize(data) end
+
+    def method_missing(method, *args, &block)
+      documents.send(method, *args, &block)
+    end
+  end
+
+end

data/lib/plato/document.rb

@@ -0,0 +1,131 @@
+require 'time'
+require 'date'
+
+module Plato
+  class Document
+    attr_reader :category, :attributes
+
+    def initialize(category, attributes)
+      @category = category
+      @attributes = attributes
+    end
+
+    def previous_document
+      category.documents.prev(self)
+    end
+
+    def next_document
+      category.documents.next(self)
+    end
+
+    def format
+      attributes["format"] || 'text'
+    end
+
+    def path
+      category.dest_path(self)
+    end
+
+    def date
+      @date ||= (attributes["date"] ? Time.parse(attributes["date"]) : nil)
+    end
+
+    RAW_TEXT = %w(text txt raw)
+
+    def body(context = nil)
+      if RAW_TEXT.include? format
+        attributes["body"]
+      else
+        @template ||= Tilt.new(format) { attributes["body"] }
+        @template.render(context)
+      end
+    end
+
+    def values_at(*keys)
+      keys.map {|k| send(k) }
+    end
+
+    def respond_to?(attr)
+      attributes.has_key? attr.to_s or super
+    end
+
+    def method_missing(attr)
+      if date and date.respond_to? attr
+        date.send(attr)
+      else
+        attributes[attr.to_s] or super
+      end
+    end
+  end
+
+  class DocumentCollection
+    include Enumerable
+
+    attr_accessor :sort_attribute, :sort_order
+
+    def initialize(sort = nil)
+      @documents = []
+      @sort_attribute, @sort_order = sort.split(' ') if sort
+    end
+
+    def <<(doc)
+      @to_a = nil
+      @documents << doc
+    end
+
+    def [](*args); to_a.[](*args) end
+
+    def index(doc, strict = false)
+      unless index = to_a.index(doc)
+        raise ArgumentError, "document is not a member of this collection" unless strict
+      end
+      index
+    end
+
+    def first
+      to_a.first
+    end
+
+    def prev(doc)
+      idx = index(doc)
+      idx.zero? ? nil : to_a[idx - 1]
+    end
+
+    def next(doc)
+      to_a[index(doc) + 1]
+    end
+
+    def to_a
+      sort! unless @to_a
+      @to_a.dup
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    def sort!
+      @to_a =
+        if sorted?
+          @documents.sort! do |a, b|
+          a,b = [a, b].map {|d| d.send(sort_attribute) }
+          ascending? ? a <=> b : b <=> a
+        end
+        else
+          @documents
+        end
+    end
+
+    def sorted?
+      !!@sort_attribute
+    end
+
+    def descending?
+      sorted? && !!(sort_order =~ /^desc/i)
+    end
+
+    def ascending?
+      sorted? && !descending?
+    end
+  end
+end

data/lib/plato/manifest.rb

@@ -0,0 +1,57 @@
+module Plato
+  class Manifest
+    include Enumerable
+
+    attr_reader :contents, :codec
+
+    def initialize(contents = nil, opts = {})
+      opts = { :codec => opts } unless opts.is_a? Hash
+      @codec = opts[:codec]
+
+      @contents =
+        if contents.nil?
+          {}
+        elsif contents.is_a? Hash
+          contents
+        elsif contents.is_a? String
+          Repo.new(contents, @codec).all &opts[:filter]
+        else
+          raise ArgumentError, "invalid contents"
+        end
+    end
+
+    def save_to(path, codec = nil)
+      repo = Repo.new(path, codec || self.codec)
+      @contents.each {|path, hash| repo.save(path, hash) }
+    end
+
+    def [](key)
+      contents[key]
+    end
+
+    def []=(key, value)
+      contents[key] = value
+    end
+    alias store []=
+
+    # if given a block, block should return a hash of the new path and
+    # new data, or nil if the file should be skipped
+    def map(new_codec = nil)
+      new_contents =
+        if block_given?
+          @contents.inject({}) do |hash, (path, data)|
+            new_path_data = yield(path, data)
+            new_path_data ? hash.update(new_path_data) : hash
+          end
+        else
+          @contents.dup
+        end
+
+      self.class.new(new_contents, new_codec || self.codec)
+    end
+
+    def each(&block)
+      contents.each(&block)
+    end
+  end
+end

data/lib/plato/path_template.rb

@@ -0,0 +1,56 @@
+module Plato
+  class PathTemplate
+    attr_reader :template, :keys
+
+    def initialize(string)
+      @template = string
+      compile!
+    end
+
+    def materialize(attributes)
+      values = attributes.values_at(*keys).compact
+      unless values.length == keys.length
+        raise ArgumentError, "missing required values for path materialization (#{keys.join(', ')})"
+      end
+
+      @materializer.call(values)
+    end
+
+    def parse(path)
+      match = path.match(@parser)
+      return nil unless match
+
+      match = match.to_a
+      match.shift
+
+      Hash[*keys.zip(match).flatten]
+    end
+
+    private
+
+    # basically lifted from sinatra
+
+    SCANNER = /(:\w+(?:\\\*)?)/
+
+    def compile!
+      @keys = []
+
+      pattern = Regexp.escape(@template).gsub SCANNER do |match|
+        case match
+        when /\\\*$/
+          keys << match[1..-3]
+          "(.*?)"
+        else
+          keys << match[1..-1]
+          "([^/?&#]+)"
+        end
+      end
+
+      @parser = /\A#{pattern}\Z/
+
+      interpolation = @template.gsub('#', '\\#').gsub(SCANNER, '#{vals.shift}')
+
+      @materializer = eval(%{proc {|vals| "#{interpolation}" } })
+    end
+  end
+end

data/lib/plato/rendering.rb

@@ -0,0 +1,87 @@
+module Plato
+  class RenderContext
+    include Tilt::CompileSite
+
+    attr_reader :site, :document
+    alias post document
+
+    def initialize(site, document)
+      @site = site
+      @document = document
+    end
+
+    def template(key)
+      site.templates["#{key}.html"] || site.templates[key]
+    end
+
+    def render(template, locals = {}, &block)
+      template = self.template(template) if template.is_a? String
+      raise ArgumentError, "template #{template.inspect} not found" unless template
+      template.render(self, locals, &block)
+    end
+
+    def render_with_layout(template, format = nil, &block)
+      layout = template("_layout.#{format}") if format
+
+      if layout
+        render(layout) { render(template, &block) }
+      else
+        render(template, &block)
+      end
+    end
+
+    def render_body
+      document.body(self)
+    end
+    alias body render_body
+
+    def self.load_view_helpers(path)
+      return if @helpers_loaded
+      @helpers_loaded = true
+
+      mod = Module.new
+      mod.module_eval(File.read(path), path, 1)
+      include mod.const_get(mod.constants.first)
+    end
+
+    # base set of helpers
+
+    def url_for(doc, opts = {})
+      return doc if doc.is_a? String and doc =~ /\Ahttp:\/\//
+      base = opts[:absolute] ? site.base_url : '/'
+      File.join(base, doc.respond_to?(:path) ? doc.path : doc.to_s)
+    end
+
+    def link_to(title, url)
+      %{<a href="#{url}">#{title}</a>}
+    end
+
+    def content; site.content end
+
+    def attribute_pairs(hash)
+      hash.map {|k,v| %{#{k}="#{v}"} }.join(' ')
+    end
+
+    def css_include(url, opts = {})
+      url = "#{url.gsub(/\.css\Z/, '')}.css"
+      opts = opts.merge :type => "text/css", :rel => "stylesheet", :href=> url_for(url)
+      %{<link #{attribute_pairs(opts)} />}
+    end
+
+    def script_include(url, opts = {})
+      url = "#{url.gsub(/\.js\Z/, '')}.js"
+      opts = opts.merge :src => url_for(url)
+      %{<script #{attribute_pairs(opts)}></script>}
+    end
+  end
+
+  class RubyTiltTemplate < Tilt::Template
+    def prepare; end
+
+    def precompiled_template(locals)
+      data
+    end
+  end
+
+  ::Tilt.register('rb', RubyTiltTemplate)
+end

data/lib/plato/repo.rb

@@ -0,0 +1,198 @@
+require 'yaml'
+require 'fileutils'
+
+module Plato
+  class Repo
+    attr_reader :root, :codec
+
+    CODEC_MAP = {}
+
+    def initialize(root, codec = nil)
+      unless root == File.expand_path(root)
+        raise ArgumentError, "root is not an absolute path"
+      end
+
+      @codec = CODEC_MAP[codec] || StringCodec
+      @root = root.sub(/\/+\Z/, '') #remove trailing slash(es)
+    end
+
+    def load(path)
+      path = expanded_path(path)
+      if File.exist? path
+        @codec.read(path)
+      else
+        raise Filestore::NotFound
+      end
+    end
+
+    def save(path, data)
+      path = expanded_path(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      @codec.write(path, data)
+    end
+
+    def destroy(path)
+      File.unlink expanded_path(path)
+
+      until (path = File.dirname(path)) == '.'
+        expanded = expanded_path(path)
+
+        if Dir[File.join(expanded, '*')].empty?
+          File.unlink expanded
+        else
+          return
+        end
+      end
+    end
+
+    def all
+      paths = Dir[File.join(root, '**/*')].select {|e| File.file? e }
+
+      if block_given?
+        paths = paths.select {|p| yield relative_path(p) }
+      end
+
+      paths.inject({}) do |hash, path|
+        hash.update relative_path(path) => load(path)
+      end
+    end
+
+    private
+
+    def expanded_path(path)
+      File.expand_path(path, root)
+    end
+
+    def relative_path(path)
+      path.sub(/\A#{Regexp.escape(root)}\//, '').tap do |relative|
+        raise ArgumentError, "path must subpath of root" if relative == path
+      end
+    end
+
+    module RefCodec
+      extend self
+
+      def write(path, ref)
+        FileUtils.cp(ref, path)
+      end
+
+      def read(ref)
+        ref
+      end
+    end
+    CODEC_MAP[:refs] = RefCodec
+
+    module StringCodec
+      extend self
+
+      def write(path, data)
+        File.open(path, 'w') {|f| f.write data }
+      end
+
+      def read(path)
+        File.read(path)
+      end
+    end
+    CODEC_MAP[:string] = StringCodec
+
+    module TemplateCodec
+      extend self
+
+      def read(path)
+        if template_class = Tilt[path]
+          template_class.new(path)
+        else
+          path
+        end
+      end
+
+      def write(path, data)
+        raise "Templates cannot be directly written"
+      end
+    end
+    CODEC_MAP[:template] = TemplateCodec
+
+    module HashCodec
+      extend StringCodec
+      extend self
+
+      def write(path, hash)
+        hash = stringify_keys(hash)
+        body = hash.delete('body')
+
+        data = [].tap do |buffer|
+          buffer << hash.map do |key, value|
+            "#{header_for(key)}: #{Sanitize.header(value)}"
+          end.join("\n")
+
+          buffer << "\n\n" << Sanitize.body(body) if body
+          buffer << "\n" unless buffer.last =~ /\n\Z/
+        end.join
+
+        super(path, data)
+      end
+
+      def read(path)
+        string = super
+
+        {}.tap do |result|
+          headers, body = string.split(/\n\n/, 2)
+
+          headers.split("\n").each do |line|
+            header, val = line.split(/:\s*/, 2)
+
+            result.update hash_key_for(header) => deserialize_value(val)
+          end
+
+          result['body'] = body.chomp if body
+        end
+      end
+
+      private
+
+      def stringify_keys(hash)
+        hash.inject({}) {|h, (k, v)| h.update k.to_s => v }
+      end
+
+      def header_for(attr)
+        attr.to_s.gsub('_', ' ').gsub(/\b([a-z])/) {|m| m.capitalize }
+      end
+
+      def hash_key_for(header)
+        header.gsub(/\s+/, '_').downcase.to_s
+      end
+
+      def deserialize_value(val)
+        YAML.load(val) rescue val
+      end
+    end
+    CODEC_MAP[:hash] = HashCodec
+
+    module Sanitize
+      extend self
+
+      def header(header_val)
+        header_val.gsub(/(\r|\n)/) {|m| {"\r" => '\r', "\n" => '\n'}[m] }
+      end
+
+      def path_elem(elem)
+        elem.to_s.gsub(/\s+/, '_').gsub(/[^a-zA-Z0-9_-]/,'')
+      end
+
+      def body(body)
+        body # do we really need to do anything here?
+      end
+
+      def method_missing(method, value)
+        warn "Warning: not sanitizing #{method}."
+        value.to_s
+      end
+
+      private
+
+      def warn(warning)
+        $stderr.puts warning
+      end
+    end
+  end
+end

data/lib/plato/site.rb

@@ -0,0 +1,120 @@
+module Plato
+  class Site
+    attr_accessor :root
+
+    def initialize(root = '.')
+      @root = File.expand_path(root)
+    end
+
+    def generate!
+      RenderContext.load_view_helpers(File.join(template_path, 'view_helpers.rb'))
+      resources.save_to(cache_path)
+      template_resources.save_to(cache_path)
+      rendered_templates.save_to(cache_path)
+      rendered_content.save_to(cache_path)
+    end
+
+    def base_url; config['base_url'] end
+
+    def config_path; File.join(root, "config.rb") end
+    def template_path; File.join(root, "template") end
+    def content_path; File.join(root, "content") end
+    def resources_path; File.join(root, "resources") end
+    def cache_path; File.join(root, "cache") end
+
+    def config
+      @config ||= Config.read(ConfigDSL, File.read(config_path))
+    end
+
+    def templates
+      return @templates if @templates
+
+      manifest = Manifest.new template_path, {
+        :codec => :template,
+        :filter => lambda {|p| p !~ /\Aview_helpers\.rb/ }
+      }
+
+      path_parser = PathTemplate.new(":name*.:format.:engine")
+      sass_parser = PathTemplate.new(":name*.sass")
+
+      @template_resources = Manifest.new({}, :refs)
+      @templates = manifest.map do |path, template|
+        if template.is_a? String
+          # could not find a template engine, assume we're a raw resource
+          @template_resources[path] = template
+          nil
+        else
+          if match = path_parser.parse(path)
+            name, format = match.values_at("name", "format")
+            { "#{name}.#{format}" => Template.new(template, format) }
+          else name = sass_parser.parse(path).values_at("name")
+            { "#{name}.css" => Template.new(template, 'css') }
+          end
+        end
+      end
+    end
+
+    def content
+      return @content if @content
+
+      @content = config["content_categories"]
+      categories = @content.values
+      manifest = Manifest.new(content_path, :hash)
+
+      manifest.each do |path, content_data|
+        if category = categories.find {|c| c.match path }
+          data = category.match(path).merge(content_data)
+
+          category.documents << Document.new(category, data)
+        end
+      end
+
+      @content
+    end
+
+    def template_resources
+      templates unless @templates
+      @template_resources
+    end
+
+    def resources
+      @resources ||= Manifest.new(resources_path, :refs)
+    end
+
+
+    # helpers
+
+    Template = Struct.new(:renderer, :format)
+
+    class Template
+      def method_missing(m, *a, &b); renderer.send(m, *a, &b)  end
+    end
+
+    def render(template, format, document)
+      RenderContext.new(self, document).render_with_layout(template, format)
+    end
+
+    def rendered_templates
+      templates.map(:string) do |path, template|
+        if path =~ /\A_/
+          nil
+        else
+          { path => render(template, template.format, nil) }
+        end
+      end
+    end
+
+    def rendered_content
+      rendered = content.values.inject({}) do |hash, category|
+        if template = templates["_#{category.name}.html"]
+          category.documents.each do |document|
+            hash[document.path] = render(template, "html", document)
+          end
+        end
+        hash
+      end
+
+      Manifest.new(rendered)
+    end
+  end
+end

data/lib/plato.rb

@@ -0,0 +1,11 @@
+require 'tilt'
+
+module Plato
+  require 'plato/config'
+  require 'plato/document'
+  require 'plato/manifest'
+  require 'plato/path_template'
+  require 'plato/repo'
+  require 'plato/rendering'
+  require 'plato/site'
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: plato
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Matt Freels
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
+        version: 1.0.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: use templates and content to generate static sites.
+email: matt@freels.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Rakefile
+- VERSION
+- lib/plato.rb
+- lib/plato/config.rb
+- lib/plato/document.rb
+- lib/plato/manifest.rb
+- lib/plato/path_template.rb
+- lib/plato/rendering.rb
+- lib/plato/repo.rb
+- lib/plato/site.rb
+has_rdoc: true
+homepage: http://github.com/freels/plato
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ideal static site generator
+test_files: []
+