RubyGems - nesta - Versions diffs - 0.9.0 - Mend

nesta 0.9.0

Files changed (53) hide show

data/.gitignore +13 -0
data/Gemfile +6 -0
data/Gemfile.lock +58 -0
data/LICENSE +19 -0
data/README.md +45 -0
data/Rakefile +12 -0
data/bin/nesta +67 -0
data/config.ru +9 -0
data/config/config.yml.sample +73 -0
data/config/deploy.rb.sample +62 -0
data/lib/nesta/app.rb +199 -0
data/lib/nesta/cache.rb +139 -0
data/lib/nesta/commands.rb +135 -0
data/lib/nesta/config.rb +87 -0
data/lib/nesta/models.rb +313 -0
data/lib/nesta/nesta.rb +0 -0
data/lib/nesta/overrides.rb +59 -0
data/lib/nesta/path.rb +11 -0
data/lib/nesta/plugins.rb +15 -0
data/lib/nesta/version.rb +3 -0
data/nesta.gemspec +49 -0
data/scripts/import-from-mephisto +207 -0
data/spec/atom_spec.rb +138 -0
data/spec/commands_spec.rb +220 -0
data/spec/config_spec.rb +69 -0
data/spec/model_factory.rb +94 -0
data/spec/models_spec.rb +445 -0
data/spec/overrides_spec.rb +113 -0
data/spec/page_spec.rb +428 -0
data/spec/path_spec.rb +28 -0
data/spec/sitemap_spec.rb +102 -0
data/spec/spec.opts +1 -0
data/spec/spec_helper.rb +72 -0
data/templates/Gemfile +8 -0
data/templates/Rakefile +35 -0
data/templates/config.ru +9 -0
data/templates/config/config.yml +73 -0
data/templates/config/deploy.rb +47 -0
data/views/analytics.haml +12 -0
data/views/atom.builder +28 -0
data/views/categories.haml +3 -0
data/views/comments.haml +8 -0
data/views/error.haml +13 -0
data/views/feed.haml +3 -0
data/views/index.haml +5 -0
data/views/layout.haml +27 -0
data/views/master.sass +246 -0
data/views/not_found.haml +13 -0
data/views/page.haml +29 -0
data/views/sidebar.haml +3 -0
data/views/sitemap.builder +15 -0
data/views/summaries.haml +14 -0
metadata +302 -0

data/lib/nesta/cache.rb ADDED Viewed

@@ -0,0 +1,139 @@
+require 'fileutils'
+# require 'sinatra/base'
+module Sinatra
+  # Sinatra Caching module
+  #
+  #  TODO:: Need to write documentation here
+  #
+  module Cache
+    VERSION = 'Sinatra::Cache v0.2.0'
+    def self.version; VERSION; end
+    module Helpers
+      # Caches the given URI to a html file in /public
+      #
+      # <b>Usage:</b>
+      #    >> cache( erb(:contact, :layout => :layout))
+      #      =>  returns the HTML output written to /public/<CACHE_DIR_PATH>/contact.html
+      #
+      # Also accepts an Options Hash, with the following options:
+      #  * :extension => in case you need to change the file extension
+      #
+      #  TODO:: implement the opts={} hash functionality. What other options are needed?
+      #
+      def cache(content, opts={})
+        return content unless options.cache_enabled
+        unless content.nil?
+          content = "#{content}\n#{page_cached_timestamp}\n"
+          path = cache_page_path(request.path_info,opts)
+          FileUtils.makedirs(File.dirname(path))
+          open(path, 'wb+') { |f| f << content }
+          log("Cached Page: [#{path}]",:info)
+          content
+        end
+      end
+      # Expires the cached URI (as .html file) in /public
+      #
+      # <b>Usage:</b>
+      #    >> cache_expire('/contact')
+      #      =>  deletes the /public/<CACHE_DIR_PATH>contact.html page
+      #
+      #    get '/contact' do
+      #     cache_expire   # deletes the /public/<CACHE_DIR_PATH>contact.html page as well
+      #    end
+      #
+      #  TODO:: implement the options={} hash functionality. What options are really needed ?
+      def cache_expire(path = nil, opts={})
+        return unless options.cache_enabled
+        path = (path.nil?) ? cache_page_path(request.path_info) : cache_page_path(path)
+        if File.exist?(path)
+          File.delete(path)
+          log("Expired Page deleted at: [#{path}]",:info)
+        else
+          log("No Expired Page was found at the path: [#{path}]",:info)
+        end
+      end
+      # Prints a basic HTML comment with a timestamp in it, so that you can see when a file was cached last.
+      #
+      # *NB!* IE6 does NOT like this to be the first line of a HTML document, so output
+      # inside the <head> tag. Many hours wasted on that lesson ;-)
+      #
+      # <b>Usage:</b>
+      #    >> <%= page_cached_timestamp %>
+      #      => <!--  page cached: 2009-02-24 12:00:00 -->
+      #
+      def page_cached_timestamp
+        "<!-- page cached: #{Time.now.strftime("%Y-%d-%m %H:%M:%S")} -->\n" if options.cache_enabled
+      end
+      private
+        # Establishes the file name of the cached file from the path given
+        #
+        # TODO:: implement the opts={} functionality, and support for custom extensions on a per request basis.
+        #
+        def cache_file_name(path,opts={})
+          name = (path.empty? || path == "/") ? "index" : Rack::Utils.unescape(path.sub(/^(\/)/,'').chomp('/'))
+          name << options.cache_page_extension unless (name.split('/').last || name).include? '.'
+          return name
+        end
+        # Sets the full path to the cached page/file
+        # Dependent upon Sinatra.options .public and .cache_dir variables being present and set.
+        #
+        def cache_page_path(path,opts={})
+          # test if given a full path rather than relative path, otherwise join the public path to cache_dir
+          # and ensure it is a full path
+          cache_dir = (options.cache_dir == File.expand_path(options.cache_dir)) ?
+              options.cache_dir : File.expand_path("#{options.public}/#{options.cache_dir}")
+          cache_dir = cache_dir[0..-2] if cache_dir[-1,1] == '/'
+          "#{cache_dir}/#{cache_file_name(path,opts)}"
+        end
+        #  TODO:: this implementation really stinks, how do I incorporate Sinatra's logger??
+        def log(msg,scope=:debug)
+          if options.cache_logging
+            "Log: msg=[#{msg}]" if scope == options.cache_logging_level
+          else
+            # just ignore the stuff...
+            # puts "just ignoring msg=[#{msg}] since cache_logging => [#{options.cache_logging.to_s}]"
+          end
+        end
+    end #/module Helpers
+    # Sets the default options:
+    #
+    #  * +:cache_enabled+ => toggle for the cache functionality. Default is: +true+
+    #  * +:cache_page_extension+ => sets the default extension for cached files. Default is: +.html+
+    #  * +:cache_dir+ => sets cache directory where cached files are stored. Default is: ''(empty) == root of /public.<br>
+    #      set to empty, since the ideal 'system/cache/' does not work with Passenger & mod_rewrite :(
+    #  * +cache_logging+ => toggle for logging the cache calls. Default is: +true+
+    #  * +cache_logging_level+ => sets the level of the cache logger. Default is: <tt>:info</tt>.<br>
+    #      Options:(unused atm) [:info, :warn, :debug]
+    #
+    def self.registered(app)
+      app.helpers(Cache::Helpers)
+      app.set :cache_enabled, true
+      app.set :cache_page_extension, '.html'
+      app.set :cache_dir, ''
+      app.set :cache_logging, true
+      app.set :cache_logging_level, :info
+    end
+  end #/module Cache
+  register(Sinatra::Cache)
+end #/module Sinatra

data/lib/nesta/commands.rb ADDED Viewed

@@ -0,0 +1,135 @@
+require 'erb'
+require 'fileutils'
+require File.expand_path('app', File.dirname(__FILE__))
+require File.expand_path('path', File.dirname(__FILE__))
+require File.expand_path('version', File.dirname(__FILE__))
+module Nesta
+  module Commands
+    class UsageError < RuntimeError; end
+    module Command
+      def fail(message)
+        $stderr.puts "Error: #{message}"
+        exit 1
+      end
+      def template_root
+        File.expand_path('../../templates', File.dirname(__FILE__))
+      end
+      def copy_template(src, dest)
+        FileUtils.mkdir_p(File.dirname(dest))
+        template = ERB.new(File.read(File.join(template_root, src)))
+        File.open(dest, 'w') { |file| file.puts template.result(binding) }
+      end
+      def copy_templates(templates)
+        templates.each { |src, dest| copy_template(src, dest) }
+      end
+    end
+    class New
+      include Command
+      def initialize(path, options = {})
+        path.nil? && (raise UsageError.new('path not specified'))
+        fail("#{path} already exists") if File.exist?(path)
+        @path = path
+        @options = options
+      end
+      def make_directories
+        %w[content/attachments content/pages].each do |dir|
+          FileUtils.mkdir_p(File.join(@path, dir))
+        end
+      end
+      def have_rake_tasks?
+        @options['heroku'] || @options['vlad']
+      end
+      def execute
+        make_directories
+        templates = {
+          'config.ru' => "#{@path}/config.ru",
+          'config/config.yml' => "#{@path}/config/config.yml",
+          'Gemfile' => "#{@path}/Gemfile"
+        }
+        templates['Rakefile'] = "#{@path}/Rakefile" if have_rake_tasks?
+        if @options['vlad']
+          templates['config/deploy.rb'] = "#{@path}/config/deploy.rb"
+        end
+        copy_templates(templates)
+      end
+    end
+    module Theme
+      class Create
+        include Command
+        def initialize(name, options = {})
+          name.nil? && (raise UsageError.new('name not specified'))
+          @name = name
+          @theme_path = Nesta::Path.themes(@name)
+          fail("#{@theme_path} already exists") if File.exist?(@theme_path)
+        end
+        def make_directories
+          FileUtils.mkdir_p(File.join(@theme_path, 'public', @name))
+          FileUtils.mkdir_p(File.join(@theme_path, 'views'))
+        end
+        def execute
+          make_directories
+          copy_templates(
+            'themes/README.md' => "#{@theme_path}/README.md",
+            'themes/app.rb' => "#{@theme_path}/app.rb"
+          )
+        end
+      end
+      class Install
+        include Command
+        def initialize(url, options = {})
+          url.nil? && (raise UsageError.new('URL not specified'))
+          @url = url
+          @name = File.basename(url, '.git').sub(/nesta-theme-/, '')
+        end
+        def execute
+          system('git', 'clone', @url, "themes/#{@name}")
+          FileUtils.rm_r(File.join("themes/#{@name}", '.git'))
+          enable(@name)
+        end
+      end
+      class Enable
+        include Command
+        def initialize(name, options = {})
+          name.nil? && (raise UsageError.new('name not specified'))
+          @name = name
+        end
+        def execute
+          theme_config = /^\s*#?\s*theme:.*/
+          configured = false
+          File.open(Nesta::Config.yaml_path, 'r+') do |file|
+            output = ''
+            file.each_line do |line|
+              output << line.sub(theme_config, "theme: #{@name}")
+              configured = true if line =~ theme_config
+            end
+            output << "theme: #{@name}\n" unless configured
+            file.pos = 0
+            file.print(output)
+            file.truncate(file.pos)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nesta/config.rb ADDED Viewed

@@ -0,0 +1,87 @@
+require "yaml"
+require "rubygems"
+require "sinatra"
+module Nesta
+  class Config
+    @settings = %w[
+      title subtitle description keywords theme disqus_short_name
+      cache content google_analytics_code
+    ]
+    @author_settings = %w[name uri email]
+    @yaml = nil
+    class << self
+      attr_accessor :settings, :author_settings, :yaml_conf
+    end
+    def self.method_missing(method, *args)
+      setting = method.to_s
+      if settings.include?(setting)
+        from_environment(setting) || from_yaml(setting)
+      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
+    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)
+    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)
+    end
+    def self.from_environment(setting)
+      value = ENV["NESTA_#{setting.upcase}"]
+      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.can_use_yaml?
+      ENV.keys.grep(/^NESTA/).empty? && yaml_exists?
+    end
+    private_class_method :can_use_yaml?
+    def self.from_yaml(setting)
+      if can_use_yaml?
+        self.yaml_conf ||= YAML::load(IO.read(yaml_path))
+        rack_env_conf = self.yaml_conf[Nesta::App.environment.to_s]
+        (rack_env_conf && rack_env_conf[setting]) || self.yaml_conf[setting]
+      end
+    rescue Errno::ENOENT  # config file not found
+      raise unless Nesta::App.environment == :test
+      nil
+    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
+  end
+end

data/lib/nesta/models.rb ADDED Viewed

@@ -0,0 +1,313 @@
+require "time"
+require "rubygems"
+require "maruku"
+require "redcloth"
+module Nesta
+  class FileModel
+    FORMATS = [:mdown, :haml, :textile]
+    @@cache = {}
+    attr_reader :filename, :mtime
+    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.needs_loading?(path, filename)
+      @@cache[path].nil? || File.mtime(filename) > @@cache[path].mtime
+    end
+    def self.load(path)
+      FORMATS.each do |format|
+        filename = model_path("#{path}.#{format}")
+        if File.exist?(filename) && needs_loading?(path, filename)
+          @@cache[path] = self.new(filename)
+          break
+        end
+      end
+      @@cache[path]
+    end
+    def self.purge_cache
+      @@cache = {}
+    end
+    def self.deprecated(name, message)
+      if Nesta::App.environment != :test
+        $stderr.puts "DEPRECATION WARNING: #{name} is deprecated; #{message}"
+      end
+    end
+    def self.menu_items
+      deprecated("Page.menu_items", "see Menu.top_level and Menu.for_path")
+      Menu.top_level
+    end
+    def initialize(filename)
+      @filename = filename
+      @format = filename.split(".").last.to_sym
+      parse_file
+      @mtime = File.mtime(filename)
+    end
+    def permalink
+      File.basename(@filename, ".*")
+    end
+    def path
+      abspath.sub(/^\//, "")
+    end
+    def abspath
+      prefix = File.dirname(@filename).sub(Nesta::Config.page_path, "")
+      File.join(prefix, permalink)
+    end
+    def layout
+      (metadata("layout") || "layout").to_sym
+    end
+    def template
+      (metadata("template") || "page").to_sym
+    end
+    def to_html(scope = nil)
+      case @format
+      when :mdown
+        Maruku.new(markup).to_html
+      when :haml
+        Haml::Engine.new(markup).to_html(scope || Object.new)
+      when :textile
+        RedCloth.new(markup).to_html
+      end
+    end
+    def last_modified
+      @last_modified ||= File.stat(@filename).mtime
+    end
+    def description
+      metadata("description")
+    end
+    def keywords
+      metadata("keywords")
+    end
+    private
+    def markup
+      @markup
+    end
+    def metadata(key)
+      @metadata[key]
+    end
+    def paragraph_is_metadata(text)
+      text.split("\n").first =~ /^[\w ]+:/
+    end
+    def parse_file
+      first_para, remaining = File.open(@filename).read.split(/\r?\n\r?\n/, 2)
+      @metadata = {}
+      if paragraph_is_metadata(first_para)
+        @markup = remaining
+        for line in first_para.split("\n") do
+          key, value = line.split(/\s*:\s*/, 2)
+          @metadata[key.downcase] = value.chomp
+        end
+      else
+        @markup = [first_para, remaining].join("\n\n")
+      end
+    rescue Errno::ENOENT  # file not found
+      raise Sinatra::NotFound
+    end
+  end
+  class Page < FileModel
+    def self.model_path(basename = nil)
+      Nesta::Config.page_path(basename)
+    end
+    def self.find_by_path(path)
+      load(path)
+    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 ==(other)
+      other.respond_to?(:path) && (self.path == other.path)
+    end
+    def heading
+      regex = case @format
+              when :mdown
+                /^#\s*(.*)/
+              when :haml
+                /^\s*%h1\s+(.*)/
+              when :textile
+                /^\s*h1\.\s+(.*)/
+              end
+      markup =~ regex
+      Regexp.last_match(1)
+    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") || "Continue reading"
+    end
+    def summary
+      if summary_text = metadata("summary")
+        summary_text.gsub!('\n', "\n")
+        case @format
+        when :textile
+          RedCloth.new(summary_text).to_html
+        else
+          Maruku.new(summary_text).to_html
+        end
+      end
+    end
+    def body
+      case @format
+      when :mdown
+        body_text = markup.sub(/^#[^#].*$\r?\n(\r?\n)?/, "")
+        Maruku.new(body_text).to_html
+      when :haml
+        body_text = markup.sub(/^\s*%h1\s+.*$\r?\n(\r?\n)?/, "")
+        Haml::Engine.new(body_text).render
+      when :textile
+        body_text = markup.sub(/^\s*h1\.\s+.*$\r?\n(\r?\n)?/, "")
+        RedCloth.new(body_text).to_html
+      end
+    end
+    def categories
+      categories = metadata("categories")
+      paths = categories.nil? ? [] : categories.split(",").map { |p| p.strip }
+      valid_paths(paths).map { |p| Page.find_by_path(p) }.sort do |x, y|
+        x.heading.downcase <=> y.heading.downcase
+      end
+    end
+    def parent
+      Page.load(File.dirname(path))
+    end
+    def pages
+      Page.find_all.select do |page|
+        page.date.nil? && page.categories.include?(self)
+      end.sort do |x, y|
+        x.heading.downcase <=> y.heading.downcase
+      end
+    end
+    def articles
+      Page.find_articles.select { |article| article.categories.include?(self) }
+    end
+    private
+      def valid_paths(paths)
+        paths.select do |path|
+          FORMATS.detect do |format|
+            File.exist?(File.join(Nesta::Config.page_path, "#{path}.#{format}"))
+          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)
+        if page
+          current_depth = path.scan(INDENT).size
+          if current_depth > depth
+            sub_menu_for_depth(menu, depth) << [page]
+          else
+            sub_menu_for_depth(menu, current_depth) << page
+          end
+          append_menu_item(menu, file, current_depth)
+        end
+      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