laze 0.2.0

data/lib/laze/plugins/jsmin.rb

@@ -0,0 +1,31 @@
+begin
+  require 'jsmin'
+  module Laze #:nodoc:
+    module Plugins #:nodoc:
+      # This plugin uses the jsmin gem to minify your javascript files
+      # and thereby reduce your website's bandwidth usage.
+      #
+      # This plugin is a decorator for JavascriptRenderer and fires after
+      # JavascriptRenderer#render.
+      #
+      # *Note*: when the jsmin gem is unavailable this plugin will quietly
+      # fail, leaving the .js files untouched and generating a warning in the
+      # logs.
+      module Jsmin
+        def self.applies_to?(kind) #:nodoc:
+          kind == 'Laze::Renderers::JavascriptRenderer'
+        end
+
+        def render(locals = {})
+          return super unless Secretary.current.options[:minify_js]
+          @minified_content = begin
+            Laze.info "Minifying #{options[:locals][:filename]}"
+            ::JSMin.minify(super)
+          end
+        end
+      end
+    end
+  end
+rescue LoadError
+  Laze.warn 'The jsmin gem is required to minify .js files.'
+end

data/lib/laze/plugins/less.rb

@@ -0,0 +1,35 @@
+begin
+  require 'less'
+  module Laze #:nodoc:
+    module Plugins #:nodoc:
+      # This plugin parses stylesheets written in Less to normal CSS files.
+      # The filename extension is converted to end in .css.
+      #
+      # See http://lesscss.org for more information.
+      #
+      # *Note*: when the less gem is unavailable this plugin will quietly fail,
+      # leaving the .less files untouched and generating a warning in the
+      # logs.
+      module Less
+        def self.applies_to?(kind) #:nodoc:
+          kind == :stylesheet
+        end
+
+        # Parse the contents of the file with Less if the original filename
+        # ends with <tt>.less</tt>
+        def content
+          return super unless properties[:filename] =~ /\.less$/
+          @less_content ||= ::Less.parse(super)
+        end
+
+        # Overrides a stylesheet's filename to replace .less with .css, so
+        # that <tt>screen.less</tt> becomes <tt>screen.css</tt>
+        def filename
+          super.sub(/\.less$/, '.css')
+        end
+      end
+    end
+  end
+rescue LoadError
+  Laze.warn 'The Less gem is required to convert .less files.'
+end

data/lib/laze/plugins/robots.rb

@@ -0,0 +1,28 @@
+module Laze #:nodoc:
+  module Plugins #:nodoc:
+    # This plugin creates a very simple robots.txt file with a reference
+    # to the sitemap.
+    #--
+    # TODO: check to make sure there is not already a robots.txt
+    # TODO: auto-build the file based on properties in the pages.
+    module Robots
+      # This plugin is a decorator for Target and fires before Target#save.
+      def self.applies_to?(kind) #:nodoc:
+        kind == :target
+      end
+
+      def save
+        create_robots_txt
+        super
+      end
+
+    private
+
+      def create_robots_txt
+        File.open(File.join(output_dir, 'robots.txt'), 'w') do |f|
+          f.write 'Sitemap: sitemap.xml'
+        end
+      end
+    end
+  end
+end

data/lib/laze/plugins/sitemap.rb

@@ -0,0 +1,63 @@
+begin
+  require 'builder'
+  require 'zlib'
+  module Laze  #:nodoc:
+    module Plugins #:nodoc:
+      # This plugin will generate a sitemap for your website after it has been
+      # generated. It will scan for all HTML files in your output directory
+      # and will collect these in a sitemap.xml file.
+      #
+      # This plugin will also create a gzipped sitemap in sitemap.xml.gz.
+      #
+      # This plugin is a decorator for Target and fires before Target#save.
+      #
+      # *Note*: when the builder or zlib gems are unavailable this plugin will
+      # quietly fail, generating no sitemap files and generating a warning in
+      # the logs.
+      module Sitemap
+        def self.applies_to?(kind) #:nodoc:
+          kind == :target
+        end
+
+        def save
+          create_and_deflate_sitemap(generate_sitemap)
+          super
+        end
+
+      private
+
+        def create_and_deflate_sitemap(sitemap)
+          path = File.join(output_dir, 'sitemap.xml')
+          Laze.debug 'Writing sitemap.xml'
+          File.open(path, 'w') do |f|
+            f.write sitemap
+          end
+          Laze.debug 'Writing sitemap.xml.gz'
+          Zlib::GzipWriter.open(path + '.gz') do |gz|
+              gz.write sitemap
+          end
+        end
+
+        def generate_sitemap
+          Laze.info 'Generating XML sitemap'
+          sitemap = ''
+          xml = Builder::XmlMarkup.new(:target => sitemap, :indent => 2)
+          xml.instruct!
+          xml.urlset(:xmlns=>'http://www.sitemaps.org/schemas/sitemap/0.9') do
+            Dir[File.join(output_dir, '**/*.html')].each do |page|
+              Laze.debug "Including #{page}"
+              xml.url do
+                xml.loc(page.sub(output_dir, (Secretary.current.options[:domain]) || ''))
+                xml.lastmod(File.mtime(page).strftime("%Y-%m-%dT%H:%M:%S+00:00"))
+                xml.changefreq('weekly')
+              end
+            end
+          end
+          sitemap
+        end
+      end
+    end
+  end
+rescue LoadError
+  Laze.warn 'The builder and zlib gems are needed to generate sitemaps'
+end

data/lib/laze/renderer.rb

@@ -0,0 +1,47 @@
+module Laze
+  # The renderer takes an item and creates output to write to the target.
+  # This is a generic rendering class, which will dispatch various Item's
+  # to specialised subclasses, like PageRenderer or StylesheetRenderer.
+  #
+  # This class's +render+ method will commonly be used to create and call a
+  # new renderer.
+  class Renderer
+
+    # Options for rendering. The +:locals+ key will also contain any
+    # variables to be available in the liquid templates.
+    attr_reader :options
+
+    # The string contents to render
+    attr_reader :string
+
+    def initialize(item_or_string, options = nil) #:nodoc:
+      raise ArgumentError, 'Please provide an item' unless item_or_string.kind_of?(Item) || (item_or_string.is_a?(String) && options.is_a?(Hash))
+      if item_or_string.is_a?(Item)
+        @string  = item_or_string.content
+        @options = { :locals => item_or_string.properties }
+      else
+        @string = item_or_string
+        @options = { :locals => options }
+      end
+
+      # Add plugins
+      Plugins.each(self.class.to_s) { |p| extend p }
+    end
+
+    # Convert the item to a string to be output to the deployment target.
+    def render
+      raise 'This is a generic store. Please use a subclass.'
+    end
+
+    # Shortcut method to <tt>new(...).render</tt>
+    # This will automatically select the right subclass to use for the
+    # incoming item.
+    def self.render(item, locals = {})
+      case item
+      when Page: Renderers::PageRenderer
+      when Stylesheet: Renderers::StylesheetRenderer
+      when Javascript: Renderers::JavascriptRenderer
+      end.new(item).render(locals)
+    end
+  end
+end

data/lib/laze/renderers/javascript_renderer.rb

@@ -0,0 +1,16 @@
+module Laze
+  module Renderers #:nodoc:
+    # Render javascript source files to output files. Does nothing right now,
+    # just output the javascript directly.
+    class JavascriptRenderer < Renderer
+      def initialize(page) #:nodoc:
+        raise ArgumentError unless page.is_a?(Javascript)
+        super
+      end
+
+      def render(locals = {})
+        string
+      end
+    end
+  end
+end

data/lib/laze/renderers/page_renderer.rb

@@ -0,0 +1,40 @@
+module Laze
+  module Renderers #:nodoc:
+    # Renders Page objects to an HTML page. This means applying text filters,
+    # layouts and the Liquid templating engine to a source file and returning
+    # the full HTML result file.
+    class PageRenderer < Renderer
+      def initialize(page) #:nodoc:
+        raise ArgumentError unless page.is_a?(Page)
+        super(page.filtered_content, page.properties)
+      end
+
+      # Apply layouts and the liquid templating language.
+      def render(locals = {})
+        liquify(wrap_in_layout(string), (options[:locals] || {}).merge(locals))
+      end
+
+    private
+
+      def wrap_in_layout(content_to_wrap)
+        # do nothing if there is no layout option
+        return content_to_wrap unless options[:locals] && options[:locals][:layout]
+
+        # do nothing if there is a layout option, but it can't be found
+        return content_to_wrap unless layout = Layout.find(options[:locals][:layout])
+
+        # Recursively wrap string in layout
+        output = content_to_wrap
+        while layout
+          output = layout.wrap(output)
+          layout = Layout.find(layout.layout)
+        end
+        output
+      end
+
+      def liquify(string, locals = {})
+        Liquid::Template.parse(string).render('page' => locals.stringify_keys)
+      end
+    end
+  end
+end

data/lib/laze/renderers/stylesheet_renderer.rb

@@ -0,0 +1,16 @@
+module Laze
+  module Renderers #:nodoc:
+    # Render CSS source files to output files. Does nothing right now,
+    # just output the CSS directly.
+    class StylesheetRenderer < Renderer
+      def initialize(page) #:nodoc:
+        raise ArgumentError unless page.is_a?(Stylesheet)
+        super
+      end
+
+      def render(locals = {})
+        string
+      end
+    end
+  end
+end

data/lib/laze/secretary.rb

@@ -0,0 +1,74 @@
+module Laze
+  # The Secretary combines all other classes to a working application and
+  # serves as a central point of information for other classes that need to
+  # know stuff that are none of their primary concern.
+  #
+  # The secretary keeps track of the build options and the storage and
+  # target engines that are currently used.
+  class Secretary
+
+    # Options that tell Laze what to do and how to do it.
+    attr_reader :options
+
+    class << self
+      # Since there should only be a singe secretary object, we let the
+      # singleton class keep track of the current instance.
+      attr_accessor :current
+
+      # Read configuration from the laze.yml file in the current directory.
+      #--
+      # TODO: make sure this reads from the source directory, not the current.
+      def site_config
+        if File.exists?('laze.yml')
+          YAML.load_file('laze.yml').symbolize_keys
+        else
+          {}
+        end
+      end
+    end
+
+    def initialize(options = {}) #:nodoc:
+      default_options = {
+        :store      => :filesystem,
+        :target     => :filesystem,
+        :source     => '.',
+        :directory  => 'output',
+        :minify_js  => false,
+        :minify_css => false,
+        :loglevel   => :warn,
+        :logfile    => 'stderr'
+      }
+      @options = default_options.merge(self.class.site_config).merge(options)
+
+      # Set the logger options
+      logger = Logger.new((@options[:logfile] == 'stderr' ? STDERR : @options[:logfile]))
+      logger.level = Logger.const_get(@options[:loglevel].to_s.upcase)
+      logger.datetime_format = "%H:%M:%S"
+      Laze.const_set('LOGGER', logger) unless Laze.const_defined?('LOGGER')
+
+      Secretary.current = self
+    end
+
+    # The current storage engine.
+    def store
+      @store ||= Store.find(options[:store]).new(options[:source])
+    end
+
+    # The current target deployment engine.
+    def target
+      @target ||= Target.find(options[:target]).new(options[:directory])
+    end
+
+    # Run laze to build the output website.
+    def run
+      Laze.debug 'Starting source processing'
+      target.reset
+      store.each do |item|
+        target.create item
+      end
+      target.save
+      Laze.debug 'Source processing ready'
+    end
+
+  end
+end

data/lib/laze/section.rb

@@ -0,0 +1,39 @@
+module Laze
+  # A section is a special kind of Item that maps to a filesystem directory.
+  # You can move it around like an item, but it is actually a container object
+  # for its subitems.
+  #
+  # A Section's subitems can be accessed as an Enumerable.
+  class Section < Item
+    include Enumerable
+
+    def initialize(properties) #:nodoc:
+      super(properties, nil)
+      @items = []
+    end
+
+    def each
+      @items.each { |item| yield item }
+    end
+
+    # Add a new subitem to this section.
+    def add_item(item)
+      @items << item
+      item.parent = self
+    end
+    alias_method :<<, :add_item
+
+    # Remove the given subitem from this section.
+    def remove_item(item)
+      @items.delete(item)
+      item.parent = nil
+      self
+    end
+    alias_method :delete, :remove_item
+
+    # Count the number of subitems (and their subitems)
+    def number_of_subitems
+      @items.inject(0) { |total, item| total += 1 + item.number_of_subitems }
+    end
+  end
+end

data/lib/laze/store.rb

@@ -0,0 +1,51 @@
+module Laze
+  class Store
+    include Enumerable
+
+    # Generic exception to be raised for store-specific exceptions.
+    StoreException = Class.new(Exception)
+
+    # Exception for when interacting with the filesystem goes bad.
+    FileSystemException = Class.new(StoreException)
+
+    @stores = []
+
+    # Find a storage engine by name and return its class.
+    #
+    # When loading <tt>Laze::Stores::Filesystem</tt> you would call:
+    #
+    #   Store.find(:filesystem)
+    #
+    def self.find(kind)
+      stores = @stores.select { |s| s.name.to_s.split('::').last.downcase.to_sym == kind }
+      raise StoreException, 'No such store.' unless stores.any?
+      stores.first
+    end
+
+    def self.inherited(child) #:nodoc:
+      @stores << child
+    end
+
+    def initialize #:nodoc:
+      Liquid::Template.file_system = self
+    end
+
+    # Loop over all the items in the current project and yield them
+    # to the block.
+    def each
+      raise 'This is a generic store. Please use a subclass.'
+    end
+
+    # Return a new instance of Layout by finding a layout by the given name
+    # in the current project.
+    def find_layout
+      raise 'This is a generic store. Please use a subclass.'
+    end
+
+    # Return the contents of any project file. This method is also used
+    # by the Liquid templating engine to read includes.
+    def read_template_file
+      raise 'This is a generic store. Please use a subclass.'
+    end
+  end
+end