nesta 0.13.0 → 0.15.0

data/lib/nesta/models.rb

@@ -1,424 +1,5 @@
-require 'time'
-
 require 'rdiscount'
 
-def register_template_handler(class_name, *extensions)
-  Tilt.register Tilt.const_get(class_name), *extensions
-rescue LoadError
-  # Only one of the Markdown processors needs to be available, so we can
-  # safely ignore these load errors.
-end
-
-register_template_handler :MarukuTemplate, 'mdown', 'md'
-register_template_handler :KramdownTemplate, 'mdown', 'md'
-register_template_handler :BlueClothTemplate, 'mdown', 'md'
-register_template_handler :RDiscountTemplate, 'mdown', 'md'
-register_template_handler :RedcarpetTemplate, 'mdown', 'md'
-
-module Nesta
-  class HeadingNotSet < RuntimeError; end
-  class LinkTextNotSet < RuntimeError; end
-  class MetadataParseError < RuntimeError; end
-
-  class FileModel
-    FORMATS = [:mdown, :md, :haml, :textile]
-    @@model_cache = {}
-    @@filename_cache = {}
-
-    attr_reader :filename, :mtime
-
-    class CaseInsensitiveHash < Hash
-      def [](key)
-        super(key.to_s.downcase)
-      end
-    end
-
-    def self.model_path(basename = nil)
-      Nesta::Config.content_path(basename)
-    end
-
-    def self.find_all
-      file_pattern = File.join(model_path, "**", "*.{#{FORMATS.join(',')}}")
-      Dir.glob(file_pattern).map do |path|
-        relative = path.sub("#{model_path}/", "")
-        load(relative.sub(/\.(#{FORMATS.join('|')})/, ""))
-      end
-    end
-
-    def self.find_file_for_path(path)
-      if ! @@filename_cache.has_key?(path)
-        FORMATS.each do |format|
-          [path, File.join(path, 'index')].each do |basename|
-            filename = model_path("#{basename}.#{format}")
-            if File.exist?(filename)
-              @@filename_cache[path] = filename
-              break
-            end
-          end
-        end
-      end
-      @@filename_cache[path]
-    end
-
-    def self.needs_loading?(path, filename)
-      @@model_cache[path].nil? || File.mtime(filename) > @@model_cache[path].mtime
-    end
-
-    def self.load(path)
-      if (filename = find_file_for_path(path)) && needs_loading?(path, filename)
-        @@model_cache[path] = self.new(filename)
-      end
-      @@model_cache[path]
-    end
-
-    def self.purge_cache
-      @@model_cache = {}
-      @@filename_cache = {}
-    end
-
-    def initialize(filename)
-      @filename = filename
-      @format = filename.split('.').last.to_sym
-      if File.zero?(filename)
-        @metadata = {}
-        @markup = ''
-      else
-        @metadata, @markup = parse_file
-      end
-      @mtime = File.mtime(filename)
-    end
-
-    def ==(other)
-      other.respond_to?(:path) && (self.path == other.path)
-    end
-
-    def index_page?
-      @filename =~ /\/?index\.\w+$/
-    end
-
-    def abspath
-      file_path = @filename.sub(self.class.model_path, '')
-      if index_page?
-        File.dirname(file_path)
-      else
-        File.join(File.dirname(file_path), File.basename(file_path, '.*'))
-      end
-    end
-
-    def path
-      abspath.sub(/^\//, '')
-    end
-
-    def permalink
-      File.basename(path)
-    end
-
-    def layout
-      (metadata('layout') || 'layout').to_sym
-    end
-
-    def template
-      (metadata('template') || 'page').to_sym
-    end
-
-    def to_html(scope = Object.new)
-      convert_to_html(@format, scope, markup)
-    end
-
-    def last_modified
-      @last_modified ||= File.stat(@filename).mtime
-    end
-
-    def description
-      metadata('description')
-    end
-
-    def keywords
-      metadata('keywords')
-    end
-
-    def metadata(key)
-      @metadata[key]
-    end
-
-    def flagged_as?(flag)
-      flags = metadata('flags')
-      flags && flags.split(',').map { |name| name.strip }.include?(flag)
-    end
-
-    def parse_metadata(first_paragraph)
-      is_metadata = first_paragraph.split("\n").first =~ /^[\w ]+:/
-      raise MetadataParseError unless is_metadata
-      metadata = CaseInsensitiveHash.new
-      first_paragraph.split("\n").each do |line|
-        key, value = line.split(/\s*:\s*/, 2)
-        next if value.nil?
-        metadata[key.downcase] = value.chomp
-      end
-      metadata
-    end
-
-    private
-      def markup
-        @markup
-      end
-
-      def parse_file
-        contents = File.open(@filename).read
-      rescue Errno::ENOENT
-        raise Sinatra::NotFound
-      else
-        first_paragraph, remaining = contents.split(/\r?\n\r?\n/, 2)
-        begin
-          return parse_metadata(first_paragraph), remaining
-        rescue MetadataParseError
-          return {}, contents
-        end
-      end
-
-      def add_p_tags_to_haml(text)
-        contains_tags = (text =~ /^\s*%/)
-        if contains_tags
-          text
-        else
-          text.split(/\r?\n/).inject('') do |accumulator, line|
-            accumulator << "%p #{line}\n"
-          end
-        end
-      end
-
-      def convert_to_html(format, scope, text)
-        text = add_p_tags_to_haml(text) if @format == :haml
-        template = Tilt[format].new { text }
-        template.render(scope)
-      end
-  end
-
-  class Page < FileModel
-    def self.model_path(basename = nil)
-      Nesta::Config.page_path(basename)
-    end
-
-    def self.find_by_path(path)
-      page = load(path)
-      page && page.hidden? ? nil : page
-    end
-
-    def self.find_all
-      super.select { |p| ! p.hidden? }
-    end
-
-    def self.find_articles
-      find_all.select do |page|
-        page.date && page.date < DateTime.now
-      end.sort { |x, y| y.date <=> x.date }
-    end
-
-    def draft?
-      flagged_as?('draft')
-    end
-
-    def hidden?
-      draft? && Nesta::App.production?
-    end
-
-    def heading
-      regex = case @format
-        when :mdown, :md
-          /^#\s*(.*?)(\s*#+|$)/
-        when :haml
-          /^\s*%h1\s+(.*)/
-        when :textile
-          /^\s*h1\.\s+(.*)/
-        end
-      markup =~ regex
-      Regexp.last_match(1) or raise HeadingNotSet, "#{abspath} needs a heading"
-    end
-
-    def link_text
-      metadata('link text') || heading
-    rescue HeadingNotSet
-      raise LinkTextNotSet, "Need to link to '#{abspath}' but can't get link text"
-    end
-
-    def title
-      metadata('title') || link_text
-    rescue LinkTextNotSet
-      return Nesta::Config.title if abspath == '/'
-      raise
-    end
-
-    def date(format = nil)
-      @date ||= if metadata("date")
-        if format == :xmlschema
-          Time.parse(metadata("date")).xmlschema
-        else
-          DateTime.parse(metadata("date"))
-        end
-      end
-    end
-
-    def atom_id
-      metadata('atom id')
-    end
-
-    def read_more
-      metadata('read more') || Nesta::Config.read_more
-    end
-
-    def summary
-      if summary_text = metadata("summary")
-        summary_text.gsub!('\n', "\n")
-        convert_to_html(@format, Object.new, summary_text)
-      end
-    end
-
-    def body_markup
-      case @format
-        when :mdown, :md
-          markup.sub(/^#[^#].*$\r?\n(\r?\n)?/, '')
-        when :haml
-          markup.sub(/^\s*%h1\s+.*$\r?\n(\r?\n)?/, '')
-        when :textile
-          markup.sub(/^\s*h1\.\s+.*$\r?\n(\r?\n)?/, '')
-      end
-    end
-
-    def body(scope = Object.new)
-      convert_to_html(@format, scope, body_markup)
-    end
-
-    def categories
-      paths = category_strings.map { |specifier| specifier.sub(/:-?\d+$/, '') }
-      valid_paths(paths).map { |p| Page.find_by_path(p) }
-    end
-
-    def priority(category)
-      category_string = category_strings.detect do |string|
-        string =~ /^#{category}([,:\s]|$)/
-      end
-      category_string && category_string.split(':', 2)[-1].to_i
-    end
-
-    def parent
-      if abspath == '/'
-        nil
-      else
-        parent_path = File.dirname(path)
-        while parent_path != '.' do
-          parent = Page.load(parent_path)
-          return parent unless parent.nil?
-          parent_path = File.dirname(parent_path)
-        end
-        return categories.first unless categories.empty?
-        Page.load('index')
-      end
-    end
-
-    def pages
-      in_category = Page.find_all.select do |page|
-        page.date.nil? && page.categories.include?(self)
-      end
-      in_category.sort do |x, y|
-        by_priority = y.priority(path) <=> x.priority(path)
-        if by_priority == 0
-          x.link_text.downcase <=> y.link_text.downcase
-        else
-          by_priority
-        end
-      end
-    end
-
-    def articles
-      Page.find_articles.select { |article| article.categories.include?(self) }
-    end
-
-    def receives_comments?
-      ! date.nil?
-    end
-
-    private
-      def category_strings
-        strings = metadata('categories')
-        strings.nil? ? [] : strings.split(',').map { |string| string.strip }
-      end
-
-      def valid_paths(paths)
-        page_dir = Nesta::Config.page_path
-        paths.select do |path|
-          FORMATS.detect do |format|
-            [path, File.join(path, 'index')].detect do |candidate|
-              File.exist?(File.join(page_dir, "#{candidate}.#{format}"))
-            end
-          end
-        end
-      end
-  end
-
-  class Menu
-    INDENT = " " * 2
-
-    def self.full_menu
-      menu = []
-      menu_file = Nesta::Config.content_path('menu.txt')
-      if File.exist?(menu_file)
-        File.open(menu_file) { |file| append_menu_item(menu, file, 0) }
-      end
-      menu
-    end
-
-    def self.top_level
-      full_menu.reject { |item| item.is_a?(Array) }
-    end
-
-    def self.for_path(path)
-      path.sub!(Regexp.new('^/'), '')
-      if path.empty?
-        full_menu
-      else
-        find_menu_item_by_path(full_menu, path)
-      end
-    end
-
-    private
-      def self.append_menu_item(menu, file, depth)
-        path = file.readline
-      rescue EOFError
-      else
-        page = Page.load(path.strip)
-        current_depth = path.scan(INDENT).size
-        if page
-          if current_depth > depth
-            sub_menu_for_depth(menu, depth) << [page]
-          else
-            sub_menu_for_depth(menu, current_depth) << page
-          end
-        end
-        append_menu_item(menu, file, current_depth)
-      end
-
-      def self.sub_menu_for_depth(menu, depth)
-        sub_menu = menu
-        depth.times { sub_menu = sub_menu[-1] }
-        sub_menu
-      end
-
-      def self.find_menu_item_by_path(menu, path)
-        item = menu.detect do |item|
-          item.respond_to?(:path) && (item.path == path)
-        end
-        if item
-          subsequent = menu[menu.index(item) + 1]
-          item = [item]
-          item << subsequent if subsequent.respond_to?(:each)
-        else
-          sub_menus = menu.select { |menu_item| menu_item.respond_to?(:each) }
-          sub_menus.each do |sub_menu|
-            item = find_menu_item_by_path(sub_menu, path)
-            break if item
-          end
-        end
-        item
-      end
-  end
-end
+require_relative './models/file_model'
+require_relative './models/menu'
+require_relative './models/page'

data/lib/nesta/navigation.rb

@@ -64,11 +64,6 @@ module Nesta
         raise
       end
 
-      def breadcrumb_label(page)
-        Nesta.deprecated('breadcrumb_label', 'use link_text')
-        link_text(page)
-      end
-
       def current_item?(item)
         request.path_info == item.abspath
       end

data/lib/nesta/overrides.rb

@@ -1,30 +1,47 @@
 module Nesta
   module Overrides
     module Renderers
-      def haml(template, options = {}, locals = {})
-        defaults, engine = Overrides.render_options(template, :haml)
-        super(template, defaults.merge(options), locals)
-      end
-
-      def erb(template, options = {}, locals = {})
-        defaults, engine = Overrides.render_options(template, :erb)
-        super(template, defaults.merge(options), locals)
+      def find_template(views, name, engine, &block)
+        user_paths = [
+          Nesta::Overrides.local_view_path,
+          Nesta::Overrides.theme_view_path,
+          views
+        ].flatten.compact
+        user_paths.each do |path|
+          super(path, name, engine, &block)
+        end
       end
 
       def scss(template, options = {}, locals = {})
-        defaults, engine = Overrides.render_options(template, :scss)
-        super(template, defaults.merge(options), locals)
+        find_template(Nesta::App.settings.views, template, Tilt::ScssTemplate) do |file|
+          return Tilt.new(file).render if File.exist?(file)
+        end
+        raise IOError, "SCSS template not found: #{template}"
       end
 
       def sass(template, options = {}, locals = {})
-        defaults, engine = Overrides.render_options(template, :sass)
-        super(template, defaults.merge(options), locals)
+        find_template(Nesta::App.settings.views, template, Tilt::SassTemplate) do |file|
+          return Tilt.new(file).render if File.exist?(file)
+        end
+        raise IOError, "Sass template not found: #{template}"
       end
 
       def stylesheet(template, options = {}, locals = {})
-        defaults, engine = Overrides.render_options(template, :sass, :scss)
-        renderer = Sinatra::Templates.instance_method(engine)
-        renderer.bind(self).call(template, defaults.merge(options), locals)
+        scss(template, options, locals)
+      rescue IOError
+        sass(template, options, locals)
+      end
+    end
+
+    def self.local_view_path
+      Nesta::Path.local("views")
+    end
+  
+    def self.theme_view_path
+      if Nesta::Config.theme.nil?
+        nil
+      else
+        Nesta::Path.themes(Nesta::Config.theme, "views")
       end
     end
 
@@ -39,33 +56,5 @@ module Nesta
         require app_file if File.exist?(app_file)
       end
     end
-
-    private
-      def self.template_exists?(engine, views, template)
-        views && File.exist?(File.join(views, "#{template}.#{engine}"))
-      end
-
-      def self.render_options(template, *engines)
-        [local_view_path, theme_view_path].each do |path|
-          engines.each do |engine|
-            if template_exists?(engine, path, template)
-              return { views: path }, engine
-            end
-          end
-        end
-        [{}, :sass]
-      end
-
-      def self.local_view_path
-        Nesta::Path.local("views")
-      end
-    
-      def self.theme_view_path
-        if Nesta::Config.theme.nil?
-          nil
-        else
-          Nesta::Path.themes(Nesta::Config.theme, "views")
-        end
-      end
   end
 end

data/lib/nesta/plugin.rb

@@ -15,21 +15,5 @@ module Nesta
     def self.initialize_plugins
       self.loaded.each { |name| require "#{name}/init" }
     end
-
-    def self.load_local_plugins
-      # This approach is deprecated; plugins should now be distributed
-      # as gems. See http://nestacms.com/docs/plugins/writing-plugins
-      plugins = Dir.glob(File.expand_path('../plugins/*', File.dirname(__FILE__)))
-      plugins.each { |path| require_local_plugin(path) }
-    end
-
-    def self.require_local_plugin(path)
-      Nesta.deprecated(
-          'loading plugins from ./plugins', "convert #{path} to a gem")
-      require File.join(path, 'lib', File.basename(path))
-    rescue LoadError => e
-      $stderr.write("Couldn't load plugins/#{File.basename(path)}: #{e}\n")
-    end
-    private_class_method :require_local_plugin
   end
 end

data/lib/nesta/static/assets.rb

@@ -0,0 +1,50 @@
+require 'rake'
+
+module Nesta
+  module Static
+    class Assets
+      def initialize(build_dir, logger = nil)
+        @build_dir = build_dir
+        @logger = logger
+      end
+
+      def copy_attachments
+        dest_basename = File.basename(Nesta::Config.attachment_path)
+        dest_dir = File.join(@build_dir, dest_basename)
+        copy_file_tree(Nesta::Config.attachment_path, dest_dir)
+      end
+
+      def copy_public_folder
+        copy_file_tree(Nesta::App.settings.public_folder, @build_dir)
+      end
+
+      private
+
+      def log(message)
+        @logger.call(message) if @logger
+      end
+
+      def copy_file_tree(source_dir, dest_dir)
+        files_in_tree(source_dir).each do |file|
+          target = File.join(dest_dir, file.sub(/^#{source_dir}\//, ''))
+          task = Rake::FileTask.define_task(target => file) do
+            target_dir = File.dirname(target)
+            FileUtils.mkdir_p(target_dir) unless Dir.exist?(target_dir)
+            FileUtils.cp(file, target_dir)
+            log("Copied #{file} to #{target}")
+          end
+          task.invoke
+        end
+      end
+
+      def files_in_tree(directory)
+        Rake::FileList["#{directory}/**/*"].tap do |assets|
+          assets.exclude('~*')
+          assets.exclude do |f|
+            File.directory?(f)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nesta/static/html_file.rb

@@ -0,0 +1,26 @@
+module Nesta
+  module Static
+    class HtmlFile
+      def initialize(build_dir, page)
+        @build_dir = build_dir
+        @content_path = page.filename
+      end
+
+      def page_shares_path_with_directory?(dir, base_without_ext)
+        Dir.exist?(File.join(dir, base_without_ext))
+      end
+
+      def filename
+        dir, base = File.split(@content_path)
+        base_without_ext = File.basename(base, File.extname(base))
+        subdir = dir.sub(/^#{Nesta::Config.page_path}/, '')
+        path = File.join(@build_dir, subdir, base_without_ext)
+        if page_shares_path_with_directory?(dir, base_without_ext)
+          File.join(path, 'index.html')
+        else
+          path + '.html'
+        end
+      end
+    end
+  end
+end