nesta 0.13.0 → 0.15.0

data/lib/nesta/config.rb

@@ -1,115 +1,89 @@
+require 'singleton'
 require 'yaml'
 
+require_relative './config_file'
+
 module Nesta
   class Config
+    include Singleton
+
     class NotDefined < KeyError; end
 
-    @settings = %w[
-      cache
+    SETTINGS = %w[
+      author
+      build
       content
       disqus_short_name
+      domain
       google_analytics_code
       read_more
       subtitle
       theme
       title
     ]
-    @author_settings = %w[name uri email]
-    @yaml = nil
-    
+
     class << self
-      attr_accessor :settings, :author_settings, :yaml_conf
+      extend Forwardable
+      def_delegators *[:instance, :fetch].concat(SETTINGS.map(&:to_sym))
     end
 
-    def self.fetch(key, *default)
-      from_environment(key.to_s)
+    attr_accessor :config
+
+    def fetch(setting, *default)
+      setting = setting.to_s
+      self.config ||= read_config_file(setting)
+      env_config = config.fetch(Nesta::App.environment.to_s, {})
+      env_config.fetch(
+        setting,
+        config.fetch(setting) { raise NotDefined.new(setting) }
+      )
     rescue NotDefined
-      begin
-        from_yaml(key.to_s)
-      rescue NotDefined
-        default.empty? && raise || (return default.first)
-      end
+      default.empty? && raise || (return default.first)
     end
 
-    def self.method_missing(method, *args)
-      if settings.include?(method.to_s)
-        fetch(method, nil)
+    def method_missing(method, *args)
+      if SETTINGS.include?(method.to_s)
+        fetch(method.to_s, nil)
       else
         super
       end
     end
-    
-    def self.author
-      environment_config = {}
-      %w[name uri email].each do |setting|
-        variable = "NESTA_AUTHOR__#{setting.upcase}"
-        ENV[variable] && environment_config[setting] = ENV[variable]
-      end
-      environment_config.empty? ? from_yaml('author') : environment_config
-    rescue NotDefined
-      nil
-    end
 
-    def self.cache
-      Nesta.deprecated('Nesta::Config.cache',
-                       'see http://nestacms.com/docs/deployment/page-caching')
-    end
-    
-    def self.content_path(basename = nil)
-      get_path(content, basename)
-    end
-    
-    def self.page_path(basename = nil)
-      get_path(File.join(content_path, "pages"), basename)
+    def respond_to_missing?(method, include_private = false)
+      SETTINGS.include?(method.to_s) || super
     end
-    
-    def self.attachment_path(basename = nil)
-      get_path(File.join(content_path, "attachments"), basename)
-    end
-    
-    def self.yaml_path
-      File.expand_path('config/config.yml', Nesta::App.root)
+
+    def build
+      fetch('build', {})
     end
 
-    def self.read_more
+    def read_more
       fetch('read_more', 'Continue reading')
     end
 
-    def self.from_environment(setting)
-      value = ENV.fetch("NESTA_#{setting.upcase}")
-    rescue KeyError
+    private
+
+    def read_config_file(setting)
+      YAML::load(ERB.new(IO.read(Nesta::ConfigFile.path)).result)
+    rescue Errno::ENOENT
       raise NotDefined.new(setting)
-    else
-      overrides = { "true" => true, "false" => false }
-      overrides.has_key?(value) ? overrides[value] : value
-    end
-    private_class_method :from_environment
-    
-    def self.yaml_exists?
-      File.exist?(yaml_path)
     end
-    private_class_method :yaml_exists?
 
-    def self.from_hash(hash, setting)
-      hash.fetch(setting) { raise NotDefined.new(setting) }
-    end
-    private_class_method :from_hash
-
-    def self.from_yaml(setting)
-      raise NotDefined.new(setting) unless yaml_exists?
-      self.yaml_conf ||= YAML::load(ERB.new(IO.read(yaml_path)).result)
-      env_config = self.yaml_conf.fetch(Nesta::App.environment.to_s, {})
-      begin
-        from_hash(env_config, setting)
-      rescue NotDefined
-        from_hash(self.yaml_conf, setting)
-      end
-    end
-    private_class_method :from_yaml
-    
     def self.get_path(dirname, basename)
       basename.nil? ? dirname : File.join(dirname, basename)
     end
     private_class_method :get_path
+
+    def self.content_path(basename = nil)
+      get_path(content, basename)
+    end
+
+    def self.page_path(basename = nil)
+      get_path(File.join(content_path, "pages"), basename)
+    end
+
+    def self.attachment_path(basename = nil)
+      get_path(File.join(content_path, "attachments"), basename)
+    end
   end
 end

data/lib/nesta/config_file.rb

@@ -1,11 +1,15 @@
 module Nesta
   class ConfigFile
+    def self.path
+      File.expand_path('config/config.yml', Nesta::App.root)
+    end
+
     def set_value(key, value)
       pattern = /^\s*#?\s*#{key}:.*/
       replacement = "#{key}: #{value}"
 
       configured = false
-      File.open(Nesta::Config.yaml_path, 'r+') do |file|
+      File.open(self.class.path, 'r+') do |file|
         output = ''
         file.each_line do |line|
           if configured

data/lib/nesta/helpers.rb

@@ -60,11 +60,6 @@ module Nesta
         date.strftime("%d %B %Y")
       end
 
-      def local_stylesheet?
-        Nesta.deprecated('local_stylesheet?', 'use local_stylesheet_link_tag')
-        File.exist?(File.expand_path('views/local.sass', Nesta::App.root))
-      end
-
       def local_stylesheet_link_tag(name)
         pattern = File.expand_path("views/#{name}.s{a,c}ss", Nesta::App.root)
         if Dir.glob(pattern).size > 0

data/lib/nesta/models/file_model.rb

@@ -0,0 +1,191 @@
+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 :RDiscountTemplate, 'mdown', 'md'
+register_template_handler :RedcarpetTemplate, 'mdown', 'md'
+
+
+module Nesta
+  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
+end

data/lib/nesta/models/menu.rb

@@ -0,0 +1,67 @@
+module Nesta
+  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_class_method 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
+
+    private_class_method def self.sub_menu_for_depth(menu, depth)
+      sub_menu = menu
+      depth.times { sub_menu = sub_menu[-1] }
+      sub_menu
+    end
+
+    private_class_method 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

data/lib/nesta/models/page.rb

@@ -0,0 +1,167 @@
+module Nesta
+  class HeadingNotSet < RuntimeError; end
+  class LinkTextNotSet < RuntimeError; 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
+
+end