nanoc 1.6.2 → 2.0

data/lib/nanoc/base/plugin.rb

@@ -0,0 +1,19 @@
+module Nanoc
+  class Plugin
+
+    class << self
+      attr_accessor :_identifiers
+    end
+
+    def self.identifiers(*identifiers)
+      self._identifiers = [] unless instance_variable_defined?(:@_identifiers)
+      identifiers.empty? ? self._identifiers || [] : self._identifiers = (self._identifiers || []) + identifiers
+    end
+
+    def self.identifier(identifier=nil)
+      self._identifiers = [] unless instance_variable_defined?(:@_identifiers)
+      identifier.nil? ? self.identifiers.first : self.identifiers(identifier)
+    end
+
+  end
+end

data/lib/nanoc/base/plugin_manager.rb

@@ -0,0 +1,33 @@
+module Nanoc
+  class PluginManager
+
+    @@data_sources       = {}
+    @@filters            = {}
+    @@layout_processors  = {}
+
+    def self.subclasses_of(superclass)
+      subclasses = []
+      ObjectSpace.each_object(Class) { |subclass| subclasses << subclass if subclass < superclass }
+      subclasses
+    end
+
+    def self.data_source_named(name)
+      @@data_sources[name.to_sym] ||= subclasses_of(DataSource).find do |klass|
+        klass.identifiers.include?(name.to_sym)
+      end
+    end
+
+    def self.filter_named(name)
+      @@filters[name.to_sym] ||= subclasses_of(Filter).find do |klass|
+        klass.identifiers.include?(name.to_sym)
+      end
+    end
+
+    def self.layout_processor_for_extension(ext)
+      @@filters[ext.to_sym] ||= subclasses_of(LayoutProcessor).find do |klass|
+        klass.extensions.include?(ext)
+      end
+    end
+
+  end
+end

data/lib/nanoc/base/site.rb

@@ -0,0 +1,143 @@
+module Nanoc
+  class Site
+
+    DEFAULT_CONFIG = {
+      :output_dir   => 'output',
+      :eruby_engine => 'erb',
+      :data_source  => 'filesystem'
+    }
+
+    attr_reader :config
+    attr_reader :compiler, :data_source
+    attr_reader :code, :pages, :page_defaults, :layouts, :templates
+
+    # Creating a Site object
+
+    def self.from_cwd
+      File.file?('config.yaml') ? new : nil
+    end
+
+    def initialize
+      # Load configuration
+      @config = DEFAULT_CONFIG.merge((YAML.load_file('config.yaml') || {}).clean)
+
+      # Create data source
+      @data_source_class = PluginManager.data_source_named(@config[:data_source])
+      error "Unrecognised data source: #{@config[:data_source]}" if @data_source_class.nil?
+      @data_source = @data_source_class.new(self)
+
+      # Create compiler
+      @compiler     = Compiler.new(self)
+      @autocompiler = AutoCompiler.new(self)
+
+      # Set not loaded
+      @data_loaded = false
+    end
+
+    def load_data(force=false)
+      return if @data_loaded and !force
+
+      # Load data
+      @data_source.loading do
+        @code           = @data_source.code
+        @pages          = @data_source.pages.map { |p| Page.new(p, self) }
+        @page_defaults  = @data_source.page_defaults
+        @layouts        = @data_source.layouts
+        @templates      = @data_source.templates
+      end
+
+      # Setup child-parent links
+      @pages.each do |page|
+        # Skip pages without parent
+        next if page.path == '/'
+
+        # Get parent
+        parent_path = page.path.sub(/[^\/]+\/$/, '')
+        parent = @pages.find { |p| p.path == parent_path }
+
+        # Link
+        page.parent = parent
+        parent.children << page
+      end
+
+      # Set loaded
+      @data_loaded = true
+    end
+
+    # Creating a new site on disk
+
+    def self.create(sitename)
+      # Check whether site exists
+      error "A site named '#{sitename}' already exists." if File.exist?(sitename)
+
+      FileUtils.mkdir_p sitename
+      in_dir([sitename]) do
+        # Create output
+        FileManager.create_dir 'output'
+
+        # Create config
+        FileManager.create_file 'config.yaml' do
+          "output_dir:  \"output\"\n" +
+          "data_source: \"filesystem\"\n"
+        end
+
+        # Create rakefile
+        FileManager.create_file 'Rakefile' do
+          "Dir['tasks/**/*.rake'].sort.each { |rakefile| load rakefile }\n" +
+          "\n" +
+          "task :default do\n" +
+          "  puts 'This is an example rake task.'\n" +
+          "end\n"
+        end
+
+        # Create tasks
+        FileManager.create_file 'tasks/default.rake' do
+          "task :example do\n" +
+          "  puts 'This is an example rake task in tasks/default.rake.'\n" +
+          "end\n"
+        end
+
+        # Setup site
+        Site.from_cwd.setup
+      end
+    end
+
+    # Compiling
+
+    def compile
+      @compiler.run
+    end
+
+    def autocompile(port)
+      @autocompiler.start(port)
+    end
+
+    # Creating
+
+    def setup
+      @data_source.loading { @data_source.setup }
+    end
+
+    def create_page(name, template_name='default')
+      load_data
+
+      template = @templates.find { |t| t[:name] == template_name }
+      error "A template named '#{template_name}' was not found; aborting." if template.nil?
+
+      @data_source.loading { @data_source.create_page(name, template) }
+    end
+
+    def create_template(name)
+      load_data
+
+      @data_source.loading {@data_source.create_template(name) }
+    end
+
+    def create_layout(name)
+      load_data
+
+      @data_source.loading { @data_source.create_layout(name) }
+    end
+
+  end
+end

data/lib/nanoc/data_sources/database.rb

@@ -0,0 +1,259 @@
+begin ; require 'active_record' ; rescue LoadError ; end
+
+module Nanoc::DataSource::Database
+
+  ########## Helper classes ##########
+
+  begin
+
+    class DatabasePage < ActiveRecord::Base
+      set_table_name 'pages'
+    end
+
+    class DatabasePageDefault < ActiveRecord::Base
+      set_table_name 'page_defaults'
+    end
+
+    class DatabaseTemplate < ActiveRecord::Base
+      set_table_name 'templates'
+    end
+
+    class DatabaseLayout < ActiveRecord::Base
+      set_table_name 'layouts'
+    end
+
+    class DatabaseCodePiece < ActiveRecord::Base
+      set_table_name 'code_pieces'
+    end
+
+  rescue NameError
+  end
+
+  class DatabaseDataSource < Nanoc::DataSource
+
+    ########## Attributes ##########
+
+    identifier  :database
+
+    ########## Preparation ##########
+
+    def up
+      nanoc_require 'active_record'
+
+      # Connect to the database
+      ActiveRecord::Base.establish_connection(@site.config[:database])
+    end
+
+    def down
+      # Disconnect from the database
+      ActiveRecord::Base.remove_connection
+    end
+
+    def setup
+      # Create tables
+      schema = ActiveRecord::Schema
+      schema.verbose = false
+      schema.define do
+
+        create_table :pages, :force => true do |t|
+          t.column :content, :text
+          t.column :path,    :string
+          t.column :meta,    :text
+        end
+
+        create_table :page_defaults, :force => true do |t|
+          t.column :meta, :text
+        end
+
+        create_table :layouts, :force => true do |t|
+          t.column :name,      :string
+          t.column :content,   :text
+          t.column :extension, :string
+        end
+
+        create_table :templates, :force => true do |t|
+          t.column :content,  :text
+          t.column :name,     :string
+          t.column :meta,     :text
+        end
+
+        create_table :code_pieces, :force => true do |t|
+          t.column :name, :string
+          t.column :code, :text
+        end
+
+      end
+
+      # Create first page
+      DatabasePage.create(
+        :path    => '/',
+        :content => "I'm a brand new root page. Please edit me!\n",
+        :meta    => "# Built-in\n" +
+                    "\n" +
+                    "# Custom\n" +
+                    "title: \"A New Root Page\"\n"
+      )
+
+      # Create page defaults
+      DatabasePageDefault.create(
+        :meta => "# Built-in\n" +
+                 "custom_path:  none\n" +
+                 "extension:    \"html\"\n" +
+                 "filename:     \"index\"\n" +
+                 "filters_post: []\n" +
+                 "filters_pre:  []\n" +
+                 "is_draft:     false\n" +
+                 "layout:       \"default\"\n" +
+                 "skip_output:  false\n" +
+                 "\n" +
+                 "# Custom\n"
+      )
+
+      # Create default layout
+      DatabaseLayout.create(
+        :name      => 'default',
+        :content   => "<html>\n" +
+                      "  <head>\n" +
+                      "    <title><%= @page.title %></title>\n" +
+                      "  </head>\n" +
+                      "  <body>\n" +
+                      "<%= @page.content %>\n" +
+                      "  </body>\n" +
+                      "</html>",
+        :extension => '.erb'
+      )
+
+      # Create default template
+      DatabaseTemplate.create(
+        :name    => 'default',
+        :content => 'Hi, I\'m a new page!',
+        :meta    => "# Built-in\n" +
+                    "\n" +
+                    "# Custom\n" +
+                    "title: \"A New Page\"\n"
+      )
+
+      # Create default code piece
+      DatabaseCodePiece.create(
+        :name => 'default',
+        :code => "def html_escape(str)\n" +
+                 "  str.gsub('&', '&amp;').str('<', '&lt;').str('>', '&gt;').str('\"', '&quot;')\n" +
+                 "end\n" +
+                 "alias h html_escape\n"
+      )
+
+      log(:high, "Set up database schema.")
+    end
+
+    ########## Loading data ##########
+
+    def pages
+      # Create Pages for each database object
+      DatabasePage.find(:all).inject([]) do |pages, page|
+        # Read metadata
+        hash = (YAML.load(page.meta || '') || {}).clean
+
+        if hash[:is_draft]
+          # Skip drafts
+          pages
+        else
+          # Get extra info
+          extras = { :path => page.path, :uncompiled_content => page.content }
+
+          # Add to list of pages
+          pages + [ hash.merge(extras) ]
+        end
+      end
+    end
+
+    def page_defaults
+      YAML.load(DatabasePageDefault.find(:first).meta) || {}
+    end
+
+    def layouts
+      DatabaseLayout.find(:all).map do |layout|
+        {
+          :name      => layout.name,
+          :content   => layout.content,
+          :extension => layout.extension
+        }
+      end
+    end
+
+    def templates
+      DatabaseTemplate.find(:all).map do |template|
+        {
+          :name     => template.name,
+          :content  => template.content,
+          :meta     => template.meta
+        }
+      end
+    end
+
+    def code
+      DatabaseCodePiece.find(:all).map { |p| p.code }.join("\n")
+    end
+
+    ########## Creating data ##########
+
+    def create_page(path, template)
+      # Make sure path does not start or end with a slash
+      sanitized_path = ('/' + path + '/').gsub(/^\/+|\/+$/, '/')
+
+      # Make sure the page doesn't exist yet
+      unless DatabasePage.find_all_by_path(sanitized_path).empty?
+        error "A page named '#{sanitized_path}' already exists."
+      end
+
+      # Create page
+      DatabasePage.create(
+        :path    => sanitized_path,
+        :content => "I'm a brand new page. Please edit me!\n",
+        :meta    => "# Built-in\n\n# Custom\ntitle: A New Page\n"
+      )
+
+      log(:high, "Created page '#{sanitized_path}'.")
+    end
+
+    def create_layout(name)
+      # Make sure the layout doesn't exist yet
+      unless DatabaseLayout.find_all_by_name(name).empty?
+        error "A layout named '#{name}' already exists."
+      end
+
+      # Create layout
+      DatabaseLayout.create(
+        :name      => name,
+        :content   => "<html>\n" +
+                      "  <head>\n" +
+                      "    <title><%= @page.title %></title>\n" +
+                      "  </head>\n" +
+                      "  <body>\n" +
+                      "<%= @page.content %>\n" +
+                      "  </body>\n" +
+                      "</html>",
+        :extension => '.erb'
+      )
+
+      log(:high, "Created layout '#{name}'.")
+    end
+
+    def create_template(name)
+      # Make sure the layout doesn't exist yet
+      unless DatabaseTemplate.find_all_by_name(name).empty?
+        error "A template named '#{name}' already exists."
+      end
+
+      # Create template
+      DatabaseTemplate.create(
+        :name    => name,
+        :content => "Hi, I'm a brand new page!\n",
+        :meta    => "# Built-in\n\n# Custom\ntitle: A New Page\n"
+      )
+
+      log(:high,"Created template '#{name}'.")
+    end
+
+  end
+
+end