hydeweb 0.0.8.pre2 → 0.1.0

data/lib/hyde/page.rb

@@ -1,209 +1,257 @@
-module Hyde
-  class Page 
-    include Hyde::Utils
+class Hyde
+class Page
+  attr_reader :project
+  attr_reader :file
+
+  # Returns the URL path for a page.
+  def path
+    path = @file.sub(root_path, '')
+
+    # if xx.haml (but not xx.html.haml), 
+    if tilt?
+      path = path.sub(/\.[^\.]*$/, "")
+      path += ".#{default_ext}"  unless File.basename(path).include?('.')
+    end
 
-    attr :renderer
+    path
+  end
 
-    # The filename of the source file.
-    #
-    # @example
-    #   puts page.name
-    #   puts page.filename
-    #
-    #   # about/index.html
-    #   # about/index.html.haml
-    #
-    attr_accessor :filename
+  def title
+    (meta.title if tilt?) || path
+  end
 
-    # Metadata hash
-    attr_accessor :meta
+  alias to_s title
 
-    # Path
-    # @see {#filename} for an example
-    attr_accessor :name
+  def <=>(other)
+    result   = self.position <=> other.position
+    result ||= self.position.to_s <=> other.position.to_s
+    result
+  end
 
-    # A reference to the parent {Project} instance
-    attr_reader :project
+  def html?
+    mime_type == 'text/html'
+  end
 
-    attr_accessor :referrer
+  def mime_type
+    return nil  unless tilt?
 
-    DEFAULT_LAYOUT = 'default'
+    mime = nil
+    mime = tilt_engine.default_mime_type  if tilt_engine.respond_to?(:default_mime_type)
 
-    # Factory
-    #
-    def self.[](path, project, def_page_class = Page)
-      PageFactory.create path, project, def_page_class
+    mime ||= case tilt_engine.name
+      when 'Tilt::SassTemplate' then 'text/css'
+      when 'Tilt::ScssTemplate' then 'text/css'
+      when 'Tilt::LessTemplate' then 'text/css'
+      when 'Tilt::CoffeeScriptTemplate' then 'application/javascript'
+      when 'Tilt::NokogiriTemplate' then 'text/xml'
+      when 'Tilt::BuilderTemplate' then 'text/xml'
+      else 'text/html'
     end
+  end
 
-    # Returns the rendered output.
-    def render(data = {}, &block)
-      output = content(data, &block)
-      output = layout.render(get_data(data)) { output }  unless layout.nil?
-      output
+  def default_ext
+    case mime_type
+    when 'text/html' then 'html'
+    when 'text/css' then 'css'
+    when 'text/xml' then 'xml'
+    when 'application/javascript' then 'js'
     end
+  end
 
-    # Returns the HTML content.
-    def content(data = {}, &block)
-      @renderer.render(get_data(data), &block)
-    end
+  def self.[](id, project=$project)
+    site = lambda { |*x| File.join root_path(project), *(x.compact) }
+    try  = lambda { |id| p = new(id, project); p if p.exists? }
 
-    def layout=(val)
-      @layout = val
+    # Account for:
+    #   ~/mysite/site/about/us.html.haml
+    #   about/us.html.haml => ~/mysite/site/about/us.html.haml
+    #   about/us.html      => ~/mysite/site/about/us.html.*
+    #   about/us.html      => ~/mysite/site/about/us.*
+    #   about/us           => ~/mysite/site/about/us/index.*
+    #
+    page   = try[id]
+    page ||= try[site[id]]
+    page ||= try[Dir[site["#{id}.*"]].first]
+    page ||= try[Dir[site["#{id.to_s.sub(/\.[^\.]*/,'')}.*"]].first]
+    page ||= try[Dir[site[id, "index.*"]].first]
+
+    # Subclass
+    if page && page.tilt? && page.meta.type
+      klass = Page.get_type(page.meta.type)
+      raise Error, "Class for type '#{page.meta.type}' not found"  unless klass
+      page = klass.new(id, project)
     end
+    page
+  end
 
-    def layout
-      begin
-        @layout ||= project[DEFAULT_LAYOUT, :Layout]  if !@renderer.nil? and @renderer.layoutable? and meta.layout != false
-        @layout
-      rescue NotFound
-        nil
-      end
-    end
+  # Returns a page subtype.
+  # @example Page.get_type('post') => Hyde::Page::Post
+  def self.get_type(type)
+    klass = type[0].upcase + type[1..-1].downcase
+    klass = klass.to_sym
+    self.const_get(klass)  if self.const_defined?(klass)
+  end
 
-    def title
-      @title ||= if meta.title
-        meta.title
-      elsif is_index?
-        File.basename(File.dirname(filename))
-      else
-        File.basename(filename, '.*')
-      end
-    end
+  def initialize(file, project=$project)
+    @file = file
+    @project = project
+    raise Error  if project.nil?
+  end
 
-    # Returns the URL path for the page.
-    def path
-      @url ||= begin
-        if renderer.is_a?(Renderer::Passthru)
-          '/' + @name
-        else
-          url = [ File.dirname(@name), File.basename(@filename) ]
-          url[1] = File.basename(url[1], '.*')
-          url[1] = (url[1] + @renderer.default_ext)  unless url[1].include?('.')
-          '/' + url.join('/')
-        end
-      end
-    end
+  def exists?
+    @file and File.file?(@file) and valid?
+  end
 
-    def output_path
-      File.join(project.config.output_path, path)
-    end
+  # Make sure that it's in the right folder.
+  def valid?
+    prefix = File.expand_path(root_path)
+    prefix == File.expand_path(@file)[0...prefix.size]
+  end
 
-    def get_binding #(&blk)
-      binding
-    end
+  def content(locals={}, &blk)
+    return markup  unless tilt?
+    # Build scope
+    scope = self.dup
+    scope.extend Helpers
+    scope.meta.merge! locals
 
-    def to_s
-      name
-    end
+    tilt.render(scope, &blk)
+  end
 
-    def to_sym
-      (filename).to_sym
-    end
+  def to_html(locals={}, &blk)
+    html = content(locals, &blk)
+    html = layout.to_html(locals) { html }  if layout?
+    html
+  end
 
-    def <=>(other)
-      result = self.position <=> other.position
-      result ||= self.position.to_s <=> other.position.to_s
-      result
-    end
+  def layout
+    layout = meta.layout
+    layout ||= default_layout  unless meta.layout == false
+    Layout[layout, page]  if layout
+  end
 
-    def position
-      meta.position || title
-    end
+  def page
+    self
+  end
 
-    def parent
-      folder = File.dirname(@name)
-      folder = File.join(folder, '..')  if is_index?
-      folder = File.expand_path(folder)
+  def layout?
+    !! layout
+  end
 
-      files = Dir[File.join(folder, 'index.*')]
-      return nil  if files.empty?
+  def meta
+    @meta ||= Meta.new(YAML::load(parts.first))
+  end
 
-      page = PageFactory.create(files.first, @project)
-      return nil  if page === self
+  # Writes to the given output file.
+  def write(out=nil)
+    out ||= project.path(:output, path)
+    FileUtils.mkdir_p File.dirname(out)
 
-      page
+    if tilt?
+      File.open(out, 'w') { |f| f.write to_html }
+    else
+      FileUtils.cp file, out
     end
+  end
 
-    def children
-      return []  unless is_index?
-      folder = File.dirname(@name)
+  # Checks if the file is supported by tilt.
+  def tilt?
+    !! tilt_engine
+  end
 
-      get_pages_from folder
-    end
+  # Returns the Tilt engine (eg Tilt::HamlEngine).
+  def tilt_engine
+    Tilt[@file]
+  end
 
-    def siblings
-      folder = File.dirname(@name)
-      folder = File.join(folder, '..')  if is_index?
+  def tilt_engine_name
+    tilt_engine.name.match(/:([^:]*)(?:Template?)$/)[1]
+  end
 
-      get_pages_from folder
+  # Returns the tilt layout.
+  def tilt
+    if tilt?
+      begin
+        # HAML options and such (like :escape_html)
+        options = project.config.tilt_options_for(@file)
+        offset = parts.first.count("\n") + 2
+        @tilt ||= Tilt.new(@file, offset, options) { markup }
+      rescue LoadError => e
+        gem = e.message.split(' ').last
+        ext = File.extname(@file)
+        raise NoGemError, "You need the '#{gem}' gem to parse #{ext} files."
+      end
     end
+  end
 
-    def get_pages_from(folder)
-      # Sanity check: don't go beyond the root
-      return []  unless File.expand_path(folder).include?(File.expand_path(@project.root(:site)))
+  def markup
+    parts.last
+  end
 
-      files  = Dir[@project.root(:site, folder, '*')]
-      files.inject([]) do |a, name|
-        if File.directory?(name)
-          name = Dir[File.join(name, 'index.*')].first
-          a << PageFactory.create(name, @project)  unless name.nil?
+  def method_missing(meth, *args, &blk)
+    super  unless meta.instance_variable_get(:@table).keys.include?(meth.to_sym)
+    meta.send(meth)
+  end
 
-        else
-          page = PageFactory.create name, @project
-          a << page  unless page.is_index?
+  def parent
+    parts = path.split('/')
+    parent_path = index? ? parts[0...-2] : parts[0...-1]
+    self.class[parent_path.join('/'), project]
+  end
 
-        end
-        a
-      end.sort
+  def children
+    files = if index?
+      # about/index.html => about/*
+      File.expand_path('../*', @file)
+    else
+      # products.html => products/*
+      base = File.basename(@file, '.*')
+      File.expand_path("../#{base}/*", @file)
     end
 
-    # Returns an array of the page's ancestors, starting from the root page.
-    def breadcrumbs
-      @crumbs ||= parent.nil? ? [] : (parent.breadcrumbs + [parent])
-    end
+    Dir[files].reject { |f| f == @file }.map { |f| self.class[f, project] }.compact.sort
+  end
 
-    def ===(other)
-      return false  if other.nil?
-      super || (File.expand_path(self.filename) === File.expand_path(other.filename))
-    end
+  def siblings
+    p = parent and p.children
+  end
 
-    def next
-      siblings.each_cons(2) { |(i, other)| return other  if i === self }
-    end
+  def breadcrumbs
+    parent? ? (parent.breadcrumbs + [self]) : [self]
+  end
+  
+  def index?
+    File.basename(path, '.*') == 'index'
+  end
 
-    def previous
-      siblings.each_cons(2) { |(other, i)| return other  if i === self }
-    end
+  def parent?
+    !parent.nil?
+  end
 
-    def is_index?
-      !@name.match(/(^|\/)index/).nil?
-    end
+  def root?
+    parent.nil?
+  end
 
-    protected
+protected
+  def default_layout
+    'default'  if html?
+  end
 
-    # Constructor.
-    # The `page` argument is a page name
-    # Don't use me: use {Project#[]}
-    #
-    def initialize(path, project, renderer, filename)
-      @project    = project
-      @name     ||= path
-      @meta     ||= Meta.new self
-      @filename   = filename
-      @renderer   = renderer.new(self, filename)
-    end
-    
-    def self.get_filename(path, project)
-      project.root(:site, path)
+  # Returns the two parts of the markup.
+  def parts
+    @parts ||= begin
+      t = File.open(@file).read.force_encoding('UTF-8')
+      m = t.match(/^(.*)--+\n(.*)$/m)
+      m.nil? ? ['', t] : [m[1], m[2]]
     end
+  end
 
-  private
+  def self.root_path(project, *a)
+    project.path(:site, *a)
+  end
 
-    # Data for rendering
-    def get_data(data)
-      data = @meta | data
-      data[:page] ||= self
-      data
-    end
+  def root_path(*a)
+    self.class.root_path(project, *a)
   end
 end
+end

data/lib/hyde/partial.rb

@@ -1,7 +1,12 @@
-module Hyde
-  class Partial < Layout
-    def self.get_filename(path, project)
-      project.root(:partials, path)
-    end
+class Hyde
+class Partial < Layout
+protected
+  def self.root_path(project, *a)
+    project.path(:partials, *a)
   end
+
+  def default_layout
+    nil
+  end
+end
 end