laze 0.2.0

data/lib/laze/stores/filesystem.rb

@@ -0,0 +1,127 @@
+module Laze
+  module Stores #:nodoc:
+    class Filesystem < Store
+      # Path from the project root to where includes are stored.
+      INCLUDES_DIR = 'includes'
+
+      # Path from the project root to where layouts are stored.
+      LAYOUTS_DIR  = 'layouts'
+
+      # Path from the project root to where all input files are stored.
+      INPUT_DIR    = 'input'
+
+      # Create a new filesystem object for a given project root directory,
+      # which defaults to the current working directory.
+      def initialize(root = Dir.pwd)
+        @root = root
+        super()
+      end
+
+      def each(&block)
+        scan_directory(File.join(@root, INPUT_DIR), &block)
+      end
+
+      def find_layout(layout_name)
+        FileWithMetadata.new(read_template_file(layout_name, LAYOUTS_DIR)).to_layout
+      end
+
+      def read_template_file(include_name, from_dir = INCLUDES_DIR)
+        Laze.debug "Reading template file #{include_name}"
+        raise FileSystemException, "Illegal filename '#{include_name}'" unless include_name =~ /^[^.\/][a-zA-Z0-9_\/]+$/
+        full_path = File.join(@root, from_dir, "#{include_name}.html")
+        raise FileSystemException, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(@root)}/
+        File.read(full_path)
+      end
+
+    private
+
+      def scan_directory(path)
+        Laze.debug "Recursing into #{path}"
+
+        Dir.foreach(path) do |filename|
+          # Skip directories
+          next if %w[. ..].include?(filename)
+
+          # Get current entry path
+          full_path = File.join(path, filename)
+
+          if File.file?(full_path)
+            relative_path = File.dirname(full_path.sub(File.join(@root, 'input/'), ''))
+            file_content = File.read(full_path)
+            file = FileWithMetadata.new(file_content, { :filename => filename, :path => relative_path })
+            yield case File.extname(filename)
+            when /\.(css|less)/: file.to_stylesheet
+            when '.js': file.to_javascript
+            else
+              if file_content =~ /---|\{%.+%\}|\{\{.+\}\}/
+                file.to_page
+              else
+                # just copy over without modification
+                file.to_item
+              end
+            end
+
+          elsif File.directory?(full_path)
+            section = Section.new({ :filename => filename })
+            scan_directory(full_path) do |subitem|
+              section << subitem
+            end
+            yield section
+
+          else
+            Laze.debug "Skipping #{path}"
+          end
+        end
+      end
+
+      class FileWithMetadata #:nodoc:
+        attr_reader :content, :properties
+
+        METADATA_SEPARATOR = /^---$\s*/
+
+        def initialize(file_contents, extra_metadata = {})
+          @file_contents, @properties = file_contents, extra_metadata
+          split
+        end
+
+        def has?(key)
+          properties.has_key?(key)
+        end
+
+        def to_item
+          Item.new(properties, content)
+        end
+
+        def to_page
+          Page.new(properties, content)
+        end
+
+        def to_layout
+          Layout.new(properties, content)
+        end
+
+        def to_stylesheet
+          Stylesheet.new(properties, content)
+        end
+
+        def to_javascript
+          Javascript.new(properties, content)
+        end
+
+      private
+
+        def split
+          @content = @file_contents
+          if @file_contents =~ METADATA_SEPARATOR
+            yaml_string, @content = @file_contents.split(METADATA_SEPARATOR, 2)
+            @properties = yaml_string_to_properties(yaml_string).merge(@properties)
+          end
+        end
+
+        def yaml_string_to_properties(yaml_string)
+          properties = YAML.load(yaml_string).symbolize_keys
+        end
+      end
+    end
+  end
+end

data/lib/laze/stylesheet.rb

@@ -0,0 +1,6 @@
+module Laze
+  # A special Item aimed at Cascading Stylesheets (CSS-files)
+  class Stylesheet < Asset
+    include_plugins :stylesheet
+  end
+end

data/lib/laze/target.rb

@@ -0,0 +1,56 @@
+module Laze
+  class Target
+
+    # Generic exception to be raised for store-specific exceptions.
+    TargetException = Class.new(Exception)
+
+    # Exception for when interacting with the filesystem goes bad.
+    FileSystemException = Class.new(TargetException)
+
+    @targets = []
+
+    # The base directory to create all the files in. This is relative
+    # the location where laze is run from.
+    attr_reader :output_dir
+
+    # Find a target deployment engine by name and return its class.
+    #
+    # When loading <tt>Laze::Targets::Filesystem</tt> you would call:
+    #
+    #   Target.find(:filesystem)
+    #
+    def self.find(kind)
+      targets = @targets.select { |s| s.name.to_s.split('::').last.downcase.to_sym == kind }
+      raise TargetException, 'No such target.' unless targets.any?
+      targets.first
+    end
+
+    def self.inherited(child) #:nodoc:
+      @targets << child
+    end
+
+    def initialize(output_dir) #:nodoc:
+      @output_dir = output_dir
+      reset
+      Laze::Plugins.each(:target) { |plugin| extend plugin }
+    end
+
+    # Finalize the generation and process any after hooks.
+    def save
+      raise 'This is a generic target. Please use a subclass.'
+    end
+
+    # Given an item this will create the output file in the right output
+    # location.
+    def create(item)
+      raise 'This is a generic target. Please use a subclass.'
+    end
+
+    # Empty the current output directory
+    def reset
+      FileUtils.rm_rf(output_dir) if File.directory?(output_dir)
+      FileUtils.mkdir(output_dir) unless File.directory?(output_dir)
+      Laze.debug "Emptied output directory #{output_dir}"
+    end
+  end
+end

data/lib/laze/targets/filesystem.rb

@@ -0,0 +1,41 @@
+module Laze
+  module Targets #:nodoc:
+    class Filesystem < Target
+
+      # Manifest an item -- write it to disk
+      def create(item)
+        case item
+        when Page, Asset: create_page(item)
+        when Section: create_section(item)
+        when Item: copy_file(item)
+        end
+      end
+
+      def save
+        # already done...
+      end
+
+    private
+
+      def copy_file(item)
+        File.open(File.join(output_dir, item.properties[:path], item.properties[:filename]), 'w') { |f| f.write item.content }
+      end
+
+      def create_page(item)
+        File.open(dir(item), 'w') { |f| f.write Renderer.render(item) }
+      end
+
+      def create_section(item)
+        FileUtils.mkdir(dir(item))
+        item.each { |subitem| create(subitem) }
+      end
+
+      # Get the correct path for a given item.
+      # This finds all the ancestors for an item, joins them together
+      # as directories and returns the path name.
+      def dir(item)
+        File.join(output_dir, *(item.ancestors.map{ |i| i.filename } << item.filename))
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'laze'
+
+class Test::Unit::TestCase
+  include Laze
+end

data/test/test_assets.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class TestAssets < Test::Unit::TestCase
+  context "generic asset" do
+    should "take content and options" do
+      asset = Asset.new({ :title => 'foo' }, 'bar')
+      assert_equal({:title => 'foo'}, asset.properties)
+      assert_equal('bar', asset.content)
+    end
+
+    should "return its filename" do
+      asset = Asset.new({:filename => 'foo'}, 'bar')
+      assert_equal('foo', asset.filename)
+    end
+  end
+
+  context "stylesheet" do
+    setup do
+      @less_stylesheet = Stylesheet.new({ :filename => 'base.less' }, 'foo')
+      @stylesheet      = Stylesheet.new({ :filename => 'base.css' }, 'foo')
+    end
+
+    should "convert the filename to css" do
+      assert_equal('base.css', @less_stylesheet.filename)
+      assert_equal('base.css', @stylesheet.filename)
+    end
+  end
+end

data/test/test_core_extensions.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestCoreExtensions < Test::Unit::TestCase
+  context "hashes" do
+    setup do
+      @a = { 'foo' => 'bar' }
+      @b = { :foo => 'bar' }
+    end
+
+    should "convert keys to strings" do
+      assert_equal(@a, @b.stringify_keys)
+    end
+
+    should "convert keys to symbols" do
+      assert_equal(@b, @a.symbolize_keys)
+    end
+  end
+
+end

data/test/test_item.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+class TestItemPageAndSection < Test::Unit::TestCase
+  context "with children" do
+
+    setup do
+      @x = Page.new({ :title => 'x', :filename => 'foo' }, 'page x')
+      @y = Page.new({ :title => 'y' }, 'page y')
+      @z = Page.new({ :title => 'z' }, 'page z')
+      @a = Section.new({ :title => 'a' })
+      @b = Section.new({ :title => 'b' })
+      @a.add_item @x
+      @b.add_item @y
+      @b.add_item @z
+      @a.add_item @b
+    end
+
+    should "tell it has a property" do
+      assert @x.has?(:title)
+      assert !@x.has?(:foo)
+    end
+
+    should "inspect nicely" do
+      assert_match(/#<Laze::Page:0x\w+? foo>/, @x.inspect)
+    end
+
+    should "tell its filename" do
+      assert_equal('foo', @x.filename)
+      assert_equal(@x.filename, @x.properties[:filename])
+    end
+
+    should "convert to string by its filename" do
+      assert_equal('foo', @x.to_s)
+    end
+
+    should 'have subitems' do
+      assert_equal(4, @a.number_of_subitems)
+    end
+
+    should "remove subitems" do
+      assert_equal(3, @a.remove_item(@x).number_of_subitems)
+      assert_nil(@x.parent)
+    end
+
+    should "enumerate over subitems" do
+      i = 0
+      @b.each do |item|
+        assert_kind_of(Item, item)
+        i += 1
+      end
+      assert_equal(2, i)
+    end
+
+    should "count the number of ancestors" do
+      assert_equal(2, @y.ancestors.size)
+      assert_equal(0, @a.ancestors.size)
+    end
+  end
+end

data/test/test_layout.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+class TestLayout < Test::Unit::TestCase
+  context "when creating" do
+    should "store content" do
+      assert_equal('foo', Layout.new({}, 'foo').content)
+    end
+
+    should "return nil for a nil layout" do
+      assert_nil(Layout.find(nil))
+    end
+
+    should "ask secretary for a layout" do
+      store = mock()
+      current = mock()
+      store.expects(:find_layout).with('foo').returns('bar')
+      current.expects(:store).returns(store)
+      Secretary.expects(:current).returns(current)
+      assert_equal('bar', Layout.find('foo'))
+    end
+  end
+
+  context "simple layout" do
+    setup do
+      @layout = Layout.new({ :layout => 'foo' }, 'bar: {{ yield }}')
+    end
+
+    should "return its layout" do
+      assert_equal('foo', @layout.layout)
+    end
+
+    should "wrap itself around a string" do
+      assert_equal("bar: baz", @layout.wrap('baz'))
+    end
+  end
+
+  context "complex layout" do
+    setup do
+      @layout = Layout.new({ :layout => 'foo' }, "bar\n    {{ yield }}\n")
+    end
+
+    should "preserve whitespace indent" do
+      assert_equal("bar\n    foo", @layout.wrap('foo'))
+    end
+  end
+
+end

data/test/test_renderer.rb

@@ -0,0 +1,71 @@
+require 'helper'
+
+class TestRenderer < Test::Unit::TestCase
+  context 'with bad options' do
+    should 'raise an error with no arguments' do
+      assert_raise(ArgumentError) { Renderer.new }
+    end
+
+    should 'raise an error with too many arguments' do
+      assert_raise(ArgumentError) { Renderer.new(0, 1, 2) }
+    end
+
+    should "raise an error when not passed in an item or string" do
+      assert_raise(ArgumentError) { Renderer.new(0) }
+      assert_nothing_raised(ArgumentError) { Renderer.new(Page.new({}, 'foo')) }
+      assert_nothing_raised(ArgumentError) { Renderer.new('foo', {}) }
+    end
+
+    should "raise an error when using the generic class" do
+      assert_raise(RuntimeError) { Renderer.new('foo', {}).render }
+    end
+  end
+
+  context 'when creating' do
+    should 'take a string and options' do
+      renderer = Renderer.new('foo', { :bar => 'bar' })
+      assert_equal('foo', renderer.string)
+      assert_equal({ :locals => { :bar => 'bar' }}, renderer.options)
+    end
+
+    should 'take a page as string and options' do
+      renderer = Renderer.new(Page.new({ :bar => 'bar'}, 'foo'))
+      assert_equal('foo', renderer.string)
+      assert_equal({ :locals => { :bar => 'bar' }}, renderer.options)
+    end
+  end
+
+  should "render a stylesheet" do
+    s = Stylesheet.new({ :filename => 'foo.css' }, 'foo')
+    x = Renderers::StylesheetRenderer.new(s)
+    x.expects(:render).returns('foo')
+    Renderers::StylesheetRenderer.expects(:new).at_least_once.returns(x)
+    Renderer.render(s)
+  end
+
+  should "render a javascript" do
+    s = Javascript.new({ :filename => 'foo.js' }, 'foo')
+    x = Renderers::JavascriptRenderer.new(s)
+    x.expects(:render).returns('foo')
+    Renderers::JavascriptRenderer.expects(:new).at_least_once.returns(x)
+    Renderer.render(s)
+  end
+
+  context "when rendering a page" do
+    setup do
+      @page = Page.new({ :layout => 'foo' }, 'bar')
+      @layout = Layout.new({}, 'layout: {{ yield }}')
+      Layout.expects(:find).with('foo').returns(@layout)
+      Layout.expects(:find).with(nil).returns(nil)
+    end
+
+    should "wrap in layout" do
+      assert_equal("layout: <p>bar</p>\n", Renderer.render(@page))
+    end
+
+    should "take extra locals" do
+      Renderers::PageRenderer.any_instance.expects(:liquify).with("layout: <p>bar</p>\n", { :layout => 'foo', :title => 'bla' }).returns('foo')
+      Renderer.render(@page, :title => 'bla')
+    end
+  end
+end