pebble 0.2.6.alpha1

data/bin/pebble

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'pebble'
+
+Pebble.application.run

data/lib/pebble/cli_parser.rb

@@ -0,0 +1,40 @@
+require 'cli'
+
+module Pebble
+
+  class CliParser
+  
+    def initialize(arguments = ARGV)
+    
+      @options = CLI.new do
+        version(Pebble::VERSION)
+        switch(:force, {:short => :f, :description => 'Overwrites "dst-dir" without asking'})
+        argument(:src_dir, {:required => false, :description => 'Current working directory is taken if omitted'})
+        argument(:dst_dir, {:required => false, :description => 'Name of "src-dir" prefixed with "rendered_" if omitted'})
+      end.parse!(arguments)
+
+    end
+
+    def force
+      !@options.force.nil?
+    end
+  
+    def src_dir
+      if (@options.src_dir)
+        File.expand_path(@options.src_dir)
+      else
+        Dir.pwd
+      end
+    end
+
+    def dst_dir
+      if (@options.dst_dir)
+        File.expand_path(@options.dst_dir)
+      else
+        File.join(File.dirname(src_dir), 'rendered_' + File.basename(src_dir))
+      end
+    end
+  
+  end
+
+end

data/lib/pebble/crawler.rb

@@ -0,0 +1,49 @@
+module Pebble
+
+  class Crawler
+
+    attr_reader :pages, :layouts, :follow_layouts, :snippets, :slots, :static
+
+    def initialize(root_path)
+      @root = root_path
+
+      @pages = Array.new
+      @layouts = Array.new
+      @follow_layouts = Array.new
+      @snippets = Array.new
+      @slots = Array.new
+      @static = Array.new
+      
+      run
+    end
+
+    def run
+      Find.find(@root) do |path|
+        if FileTest.directory?(path)
+          if File.basename(path)[0] == ?.
+            Find.prune       # Don't look any further into this directory.
+          else
+            next
+          end
+        elsif FileTest.file?(path)
+          case File.basename(path)
+            when /\..+\.layout$/
+              @follow_layouts << path
+            when /\.layout$/
+              @layouts << path
+            when /\.snippet$/
+              @snippets << path
+            when /\..+\.html$/
+              @slots << path
+            when /\.html$/
+              @pages << path
+            else
+              @static << path
+          end
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/pebble/layout_render_item.rb

@@ -0,0 +1,41 @@
+require 'pebble/render_item'
+
+module Pebble
+
+  class LayoutRenderItem < RenderItem
+
+    def initialize(path, next_item)
+      super(path)
+      @next = next_item
+    end
+    
+    def render(indent = "")
+      content = String.new
+      IO.foreach(@path) do |line|
+        if line =~ /(.*)\{\{ content \}\}(.*)/
+          unless @next.nil?        
+            prepend = $1
+            append = $2
+            if (prepend =~ /^\s*$/) && (append =~ /^\s*$/)
+              content << @next.render(indent + prepend) unless @next.nil?
+              content << "\n"
+            else
+              content << "#{indent + prepend}"
+              content << @next.render unless @next.nil?
+              content << "#{append}\n"
+            end
+          else
+            content << indent
+            content << line
+          end        
+        else
+          content << indent
+          content << line
+        end
+      end
+      content.chomp
+    end
+
+  end
+
+end

data/lib/pebble/render_item.rb

@@ -0,0 +1,26 @@
+module Pebble
+
+  class RenderItem
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def read(indent = "")
+      content = String.new
+      IO.foreach(@path) do |line|
+        content << indent
+        content << line
+      end
+      content.chomp
+    end
+
+    def length
+      @path.length
+    end
+
+  end
+
+end

data/lib/pebble/render_seq.rb

@@ -0,0 +1,119 @@
+module Pebble
+
+  #--
+  # RenderSeq class
+  #++
+  #
+  # A *.html file has zero or more _layouts_, _slots_ and _snippets_ that are
+  # rendered together. This class manages all of the parts that are rendered
+  # for a single page of output.
+  #
+  class RenderSeq
+
+    # Hashes of parts of pages that are to be rendered
+    attr_accessor :layout, :snippets, :slots
+    # 
+    attr_reader :page
+
+    # Set up a new RenderSeq. _page_ is 
+    def initialize(page)
+      @page = page
+      @layout = nil
+      @snippets = nil
+      @slots = nil
+      
+      @content = String.new
+    end
+    
+    def render
+      render_layout
+      render_page
+      render_slots
+      render_snippets
+    end
+    
+    private
+    
+    def render_layout
+      @content = @layout.render
+    end
+    
+    def render_page
+      content = String.new
+      @content.each_line do |line|
+        if line =~ /(.*)\{\{ content \}\}(.*)/
+          prepend = $1
+          append = $2
+          if (prepend =~ /^\s*$/) && (append =~ /^\s*$/)
+            content << @page.read(prepend)
+            content << "\n"
+          else
+            content << "#{prepend}"
+            content << @page.read
+            content << "#{append}\n"
+          end
+        else
+          content << line
+        end
+      end
+      content.chomp
+      @content = content
+    end
+    
+    def render_slots
+      content = String.new
+      @content.each_line do |line|
+        if line =~ /(.*)\{\{ content "(.*)" \}\}(.*)/
+          prepend = $1
+          slot = $2
+          append = $3
+          if (!@slots.nil?) && (@slots.has_key?(slot))
+            if (prepend =~ /^\s*$/) && (append =~ /^\s*$/)
+              content << @slots[slot].read(prepend)
+              content << "\n"
+            else
+              content << "#{prepend}"
+              content << @slots[slot].read
+              content << "#{append}\n"
+            end
+          else
+            $stderr.puts "WARNING: Slot with name '#{slot}' not found"
+          end
+        else
+          content << line
+        end
+      end
+      content.chomp
+      @content = content
+    end
+    
+    def render_snippets
+      content = String.new
+      @content.each_line do |line|
+        if line =~ /(.*)\{\{ snippet "(.*)" \}\}(.*)/
+          prepend = $1
+          snippet = $2
+          append = $3
+          if (!@snippets.nil?) && (@snippets.has_key?(snippet))
+            if (prepend =~ /^\s*$/) && (append =~ /^\s*$/)
+              content << @snippets[snippet].read(prepend)
+              content << "\n"
+            else
+              content << "#{prepend}"
+              content << @snippets[snippet].read
+              content << "#{append}\n"
+            end
+          else
+            $stderr.puts "WARNING: Snippet with name '#{snippet}' not found"
+          end
+        else
+          content << line
+        end
+      end
+      content.chomp
+      @content = content
+    end
+    
+  end
+
+end

data/lib/pebble/site.rb

@@ -0,0 +1,69 @@
+module Pebble
+
+  class Site
+
+    # The current value of the directory tree to be rendered 
+    attr_reader :site_root
+    
+    # The current value of where to save the rendered site
+    attr_reader :rendered_root
+
+    def initialize(site_root, rendered_root)
+      @site_root = site_root
+      @rendered_root = rendered_root
+      @sequences = Array.new    
+    end
+    
+    # Add a RenderSeq to Site that needs to be rendered
+    def add_sequence(seq)
+      @sequences << seq
+    end
+    
+    # Iterates over every RenderSeq and calls it to render itself
+    def render
+      @sequences.each do |seq|
+        target = get_and_prepare_target(seq.page.path)
+        content = seq.render
+        File.open(target, "w") do |file|
+          file.puts content
+        end
+      end
+      
+    end
+    
+    # Checks and possibly deletes everything that is at the location
+    # of _rendered_root_ where the new rendered site goes.
+    # If _force_ is set to +true+, no question is asked if the directory
+    # already exists.
+    def clean_target(force = false)
+      if File.exists?(@rendered_root)
+        unless force
+          print "Are you sure to overwrite directory '#{@rendered_root}' [yN] ? "
+          exit unless $stdin.gets.chomp.downcase == 'y'
+        end
+        Dir.rmdir_rec(@rendered_root)
+      end
+    end
+
+    # Copies the static files to the destination
+    def copy_static(files)
+    
+      files.each do |file|
+        target = get_and_prepare_target(file)
+        File.cp(file, target)
+      end
+              
+    end
+    
+    private
+    
+    def get_and_prepare_target(source)
+      filename = source.sub(@site_root, @rendered_root)
+      dirname = File.dirname(filename)
+      Dir.mkdir_rec(dirname) unless File.directory?(dirname)
+      filename
+    end
+
+  end
+
+end

data/lib/pebble/version.rb

@@ -0,0 +1,3 @@
+module Pebble
+  VERSION = '0.2.6.alpha1'
+end

data/lib/pebble.rb

@@ -0,0 +1,217 @@
+#--
+# Copyright (c) 2007, Christian Luginbuehl
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   * Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#   * Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#   * No names of its contributors may be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# = Pebble -- Simple static CMS
+#      
+# This is the main file for the Pebble application.  Normally it is referenced
+# as a library via a require statement and invoked using the +pebble+ 
+# executable.
+
+require 'find'
+require 'fileutils'
+require 'pebble/site'
+require 'pebble/cli_parser'
+require 'pebble/crawler'
+require 'pebble/render_item'
+require 'pebble/layout_render_item'
+require 'pebble/render_seq'
+require 'pebble/version'
+
+###############################################################################
+# Some extensions to Dir
+#
+class Dir
+
+  # Recursively delete a directory tree including files (like rm -rf)
+  def Dir.rmdir_rec(dir)
+    Dir.foreach(dir) do |e|
+      next if [".", ".."].include? e
+      fullname = dir + File::Separator + e
+      if FileTest::directory?(fullname)
+        Dir.rmdir_rec(fullname)
+      else
+        File.delete(fullname)
+      end
+    end
+    Dir.delete(dir)
+  end
+
+  # Recursively create directories (like mkdir -p)
+  def Dir.mkdir_rec(dir)
+    parent = File.expand_path(File.join(dir, ".."))
+    Dir.mkdir_rec(File.expand_path(File.join(dir, ".."))) unless File.directory?(parent)
+    Dir.mkdir(dir)
+  end
+
+end
+
+##############################################################################
+# Pebble module
+#
+module Pebble
+
+  # Pebble module singleton methods.
+  #
+  class << self
+    # Current Pebble Application
+    def application
+      @application ||= Pebble::Application.new
+    end
+  end
+
+  class Application
+  
+    def initialize
+      parser = CliParser.new()
+      
+      @force = parser.force
+      @src = parser.src_dir
+      @dst = parser.dst_dir
+    end
+  
+    # Runs *pebble* by first putting together all RenderSeq's, preparing the
+    # destination directory and then rendering and saving the files. As its
+    # last step, all the static files are copied to the destination.
+    def run
+      @crawler = Crawler.new(@src)
+      
+      @site = Site.new(@src, @dst)
+      
+      find_render_sequences
+      
+      @site.clean_target(@force)
+      @site.render
+      @site.copy_static(@crawler.static)
+
+    end
+
+    private
+    
+    # Find the render sequences for every page to be rendered
+    def find_render_sequences
+      @crawler.pages.each do |path|
+
+        page = RenderItem.new(path)
+        
+        seq = RenderSeq.new(page)
+
+        filename = File.basename(path, ".html")
+        dirname = File.dirname(path)
+
+        # search in local dir for [filename].layout
+        if @crawler.layouts.include?(File.join(dirname, "#{filename}.layout"))
+          item = LayoutRenderItem.new(File.join(dirname, "#{filename}.layout"), nil)
+          seq.layout = item
+        end
+
+        # search in local dir for [filename].follow.layout
+        if seq.layout.nil? && @crawler.follow_layouts.include?(File.join(dirname, "#{filename}.follow.layout"))
+          item = LayoutRenderItem.new(File.join(dirname, "#{filename}.follow.layout"), item)
+        end
+
+        # search in local dir for default.layout
+        if seq.layout.nil? && @crawler.layouts.include?(File.join(dirname, "default.layout"))
+          item = LayoutRenderItem.new(File.join(dirname, "default.layout"), item)
+          seq.layout = item
+        end
+
+        # search in local dir for default.follow.layout
+        if seq.layout.nil? && @crawler.follow_layouts.include?(File.join(dirname, "default.follow.layout"))
+          item = LayoutRenderItem.new(File.join(dirname, "default.follow.layout"), item)
+        end
+
+        if seq.layout.nil?
+          # search in parents for default.layout
+          possible_layouts = Array.new
+          @crawler.layouts.each do |layout|
+            if (layout =~ /default\.layout$/) && (dirname.include? File.dirname(layout))
+              possible_layouts << layout
+            end
+          end
+        
+          possible_layouts.sort { |a, b| b.length <=> a.length }
+          
+          # search in parents for default.follow.layout
+          possible_follow_layouts = Array.new
+          @crawler.follow_layouts.each do |layout|
+            if (layout =~ /default\.follow\.layout$/) && (dirname.include? File.dirname(layout)) && (!File.dirname(layout).include? dirname)
+              possible_follow_layouts << layout
+            end
+          end
+          
+          possible_follow_layouts.sort { |a, b| b.length <=> a.length }
+
+          possible_follow_layouts.each do |layout|
+            if layout.length - 7 > possible_layouts[0].length
+              item = LayoutRenderItem.new(layout, item)
+            end
+          end
+
+          item = LayoutRenderItem.new(possible_layouts[0], item) unless possible_layouts.empty?
+
+        end
+        
+        seq.layout = item if seq.layout.nil?
+        
+        # search for all possible snippets (in case of same name, higher level will be ignored)
+        possible_snippets = Hash.new
+        @crawler.snippets.each do |snippet|
+          if dirname.include? File.dirname(snippet)
+            name = File.basename(snippet, ".snippet")
+            if (!possible_snippets.has_key?(name)) || (possible_snippets[name].length < snippet.length)
+              possible_snippets[name] = RenderItem.new(snippet)
+            end
+          end
+        end
+
+        seq.snippets = possible_snippets
+
+        # search for all possible slots (in case of 'default' and specific name, the latter is used)
+        possible_slots = Hash.new
+        @crawler.slots.each do |slot|
+          if dirname.eql? File.dirname(slot)
+            if File.basename(slot, ".html").include? filename
+              name = File.basename(slot, ".html").sub("#{filename}.", '')
+              possible_slots[name] = RenderItem.new(slot)
+            elsif File.basename(slot, ".html").include? 'default'
+              name = File.basename(slot, ".html").sub("default.", '')
+              possible_slots[name] = RenderItem.new(slot)
+            end
+          end
+        end
+
+        seq.slots = possible_slots
+        
+        @site.add_sequence(seq)
+      end
+    end
+
+  end
+  
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: pebble
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 2
+  - 6
+  - alpha1
+  version: 0.2.6.alpha1
+platform: ruby
+authors: 
+- Christian Luginbuehl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-15 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cli
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  version_requirements: *id001
+description: A simple static CMS
+email: dinkel@pimprecords.com
+executables: 
+- pebble
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pebble.rb
+- lib/pebble/site.rb
+- lib/pebble/layout_render_item.rb
+- lib/pebble/version.rb
+- lib/pebble/render_seq.rb
+- lib/pebble/render_item.rb
+- lib/pebble/cli_parser.rb
+- lib/pebble/crawler.rb
+- bin/pebble
+has_rdoc: true
+homepage: https://github.com/dinkel/pebble/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Pebble
+test_files: []
+