RubyGems - nesta - Versions diffs - 0.9.0 - Mend

nesta 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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