templette 0.3.0

data/bin/templette

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+#
+
+usage = <<USAGE
+Generate the templette framework.
+Usage: templette <directory>
+--help gets you this help message... Helpful!
+USAGE
+
+require 'fileutils'
+
+new_dir = ARGV.first
+
+if new_dir.nil? || new_dir.empty?
+	puts usage
+	exit(0)
+end
+
+FileUtils.mkdir(new_dir) unless File.exists?(new_dir)
+%w{/pages /templates /helpers /resources}.each do |dir|
+  FileUtils.mkdir(new_dir + dir) unless File.exists?(new_dir + dir)
+end
+
+FileUtils.cp(File.dirname(__FILE__) + '/../files/Rakefile', new_dir + '/Rakefile')
+FileUtils.cp(File.dirname(__FILE__) + '/../files/default_helper.rb', new_dir + '/helpers/default_helper.rb')

data/bin/templette.cmd

@@ -0,0 +1 @@
+@ruby "c:/ruby/bin/templette" %*

data/files/Capfile

@@ -0,0 +1 @@
+load 'deploy'

data/files/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+require 'rubygems'
+gem 'templette'
+require 'templette'
+require 'tasks/templette_tasks'

data/files/default_helper.rb

@@ -0,0 +1,11 @@
+module DefaultHelper
+  # Any methods added here will be available to all pages in your site
+  
+  def current_date
+    Time.now.strftime('%m/%d/%Y')
+  end
+  
+  def current_year
+    Time.now.year
+  end
+end

data/files/deploy.rb

@@ -0,0 +1,37 @@
+set :package_name, 'package'
+set :staging_path,    ''
+set :user,            "username"
+
+task :staging do
+  role :web,  'staging.example.com'
+  set :deploy_path, 'public_html/staging_path'
+end
+
+task :production do
+  role :web, 'example.com'
+  set :deploy_path, 'public_html/path'
+end
+
+before "deploy", "deploy:package"
+after "deploy", "deploy:cleanup"
+
+namespace :deploy do
+  
+  task :package do
+   `rake build destination=#{package_name}`
+   `tar -czvf #{package_name}.tar.gz #{package_name}`
+  end
+
+  desc "This is the main task"
+  task :default, :roles => [:web] do
+   upload "#{package_name}.tar.gz", "#{staging_path}#{package_name}.tar.gz"
+   run "tar -xzvf #{staging_path}#{package_name}.tar.gz"
+   run "rsync -r #{staging_path}#{package_name}/ #{deploy_path}"
+  end
+
+  task :cleanup do
+    run "rm -f #{staging_path}/#{package_name}"
+    run "rm -rf #{staging_path}#{package_name}"
+    `rm -rf #{package_name}.tar.gz`
+  end
+end

data/lib/file_generator.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/templette'
+module FileGenerator
+    
+  class << self
+    
+    # Called by rake generate:page template=<name> names="<file1 file2>"
+    #
+    # Generates empty page yaml files in /pages.  Takes the methods called in the template and turns them into a yaml framework.
+    def page_yaml(template, names)
+      template = Templette::Template.new(template)
+      names.split(/\s+/).each do |name|
+        unless File.exists?("pages/#{name}.yml")
+          File.open("pages/#{name}.yml", 'w') {|f| f << template.to_yaml }
+        end
+      end
+    end
+  
+    # Called by rake generate:helper name=<template_name>
+    #
+    # Generates a helper module in /helpers.  A helper will be loaded if it shares the name of the template being applied.
+    # To load a different helper, you'll have to include it in default_helper.
+    def helper(name)
+      helper_name = name =~ /_helper\Z/ ? name : "#{name}_helper"
+      module_name = helper_name.split('_').map{|str| str.capitalize}.join
+      File.open("helpers/#{helper_name}.rb", 'w') do |f|
+        f << "module #{module_name}
+  # Add methods for the #{name} template here
+end"
+      end
+    end
+  end
+  
+end

data/lib/tasks/templette_tasks.rb

@@ -0,0 +1,47 @@
+desc "Build an HTML project from template files"
+task(:build) do
+  Templette::Generator.new(ENV['destination']).run
+end
+
+desc "Remove all generated files"
+task :clean do
+  Templette::Generator.new.clean
+end
+
+namespace :cap do
+  
+  desc "Install the basic capistrano recipes and Capfile"
+  task :install do
+    files_dir = File.dirname(__FILE__) + '/../../files/'
+    %w{Capfile deploy.rb}.each do |file|
+      FileUtils.cp(files_dir + file, file) unless File.exists?(file)
+    end
+  end
+  
+end
+
+namespace :generate do
+  
+  desc "Generate empty page files based upon template= and names="
+  task :page_yaml do
+    unless ENV['template'] && ENV['names']
+      puts "You must set template and names to run this task."
+      return
+    end
+    require 'file_generator'
+    FileGenerator.page_yaml(ENV['template'], ENV['names'])
+  end
+  
+  desc "Generate an empty generator file with name=example"
+  task :helper do
+    unless ENV['name']
+      puts "You must enter a name for your helper."
+      return
+    end
+    require 'file_generator'
+    FileGenerator.helper(ENV['name'])
+  end 
+
+end
+
+task :default => :build

data/lib/templette.rb

@@ -0,0 +1,5 @@
+%w{erb yaml fileutils}.each {|lib| require lib}
+
+%w{data_accessors errors generator method_collector page template}.each do |file|
+  require File.dirname(__FILE__) +"/templette/#{file}"
+end

data/lib/templette/data_accessors.rb

@@ -0,0 +1,40 @@
+module Templette
+  module DataAccessors
+    def attributes 
+      @attributes ||= {}
+    end
+    
+    def generate_accessors(accessors = {})
+      accessors.each_pair { |k,v| generate_accessor(k, v) }
+    end
+        
+    def include_helpers(helpers)
+      helpers.each { |helper| add_helper(helper) }
+    end
+    
+    def method_missing(symbol)
+      raise PageError.new(page, "No method '#{symbol}' defined in the yaml")
+    end
+
+    private
+    
+      def generate_accessor(k, v)
+        raise TempletteError.new(page, "Method already defined: #{k}.  Change your config file and stop using it!") if self.methods.include?(k.to_s)
+        if v.kind_of?(Hash)
+          v = Page::Section.new(page, v)
+        elsif v =~ /file:(.*)/
+          raise PageError.new(page, "File requested by :#{k} no found!") unless File.exists?($1)
+          v = File.open($1) {|f| f.read}
+        end
+        attributes[k.to_s] = v
+        instance_eval "def #{k.to_s}; attributes['#{k.to_s}']; end"
+      end
+
+      def add_helper(helper)
+        if File.exists?("helpers/#{helper}.rb")
+          require "helpers/#{helper}" 
+          extend Object.module_eval("::#{helper.split('_').map {|str| str.capitalize}.join}", __FILE__, __LINE__)
+        end
+      end
+  end
+end

data/lib/templette/errors.rb

@@ -0,0 +1,20 @@
+module Templette
+  class TempletteError < Exception
+    
+    def initialize(error_source, message = nil)
+      @error_source = error_source
+      @message = message
+    end
+    
+    def to_s
+      "#{self.class.name.split('::').last} - #{@error_source.name}: #{@message}"
+    end
+  end
+  
+  class TemplateError < TempletteError  # :nodoc:
+  end
+  
+  class PageError < TempletteError  # :nodoc:
+  end
+  
+end

data/lib/templette/generator.rb

@@ -0,0 +1,39 @@
+module Templette
+  class Generator
+    def initialize(out_dir = 'out', resources_dir = 'resources')
+      @out_dir = out_dir
+      @resources_dir = resources_dir
+      @errors = []
+    end
+  
+    def run
+      FileUtils.mkdir(@out_dir) unless File.exists?(@out_dir)
+      pages = Page.find_all
+      puts "Generating site in: #{@out_dir}; contains #{pages.size} pages"
+      pages.each do |page|
+        puts "Generating page #{page.name} using template #{page.template.name}"
+        begin
+          page.generate(@out_dir)
+        rescue Templette::TempletteError => e
+          @errors.push(e)
+        end
+      end
+
+      if File.exists?(@resources_dir)
+        puts "Copying resources from #{@resources_dir} to #{@out_dir}"
+        FileUtils.cp_r("#{@resources_dir}/.", @out_dir)
+      end
+
+      if @errors.empty?
+        puts "Site generation complete!"
+      else
+        puts "SITE GENERATED WITH ERRORS!"
+        @errors.each { |e| puts e.message }
+      end 
+    end
+    
+    def clean
+      FileUtils.rm_rf(@out_dir) if File.exists?(@out_dir)
+    end
+  end
+end

data/lib/templette/method_collector.rb

@@ -0,0 +1,28 @@
+require 'erb'
+
+module Templette
+  # Loads a template and evaluates it with ERB.  When a missing method is found, 
+  # MethodColletor loads that method into a hash, to be rendered as yaml.
+  class MethodCollector
+    include Templette::DataAccessors
+  
+    def initialize(template = nil)
+      include_helpers(template.helpers) if template
+      @methods = {}
+      ERB.new(template.to_html, 0, "%<>").result(binding) if template
+    end    
+  
+    def method_missing(symbol)
+      @methods[symbol.to_s] = MethodCollector.new
+    end
+  
+    def to_hash
+      return nil if @methods.empty?
+      hash = {}
+      @methods.each_pair do |k, v|
+        hash[k] = v.to_hash
+      end
+      hash
+    end
+  end
+end

data/lib/templette/page.rb

@@ -0,0 +1,88 @@
+module Templette
+
+  # The Page is the core object of a Templette project.  Pages won't get generate
+  # unless there are available .yml files to build out the necessary info.
+  #
+  # A general Page yaml structure example:
+  #
+  #     template_name: main
+  #     sections:
+  #       title: Page Title
+  #       nav:
+  #         active-class: foo
+  #         title: Foo!
+  #
+  # The <tt>template_name</tt> will be used to load a template.
+  #
+  # Everything in <tt>sections</tt> will be made available as methods in the template when
+  # it's evaluated by ERB.  Yaml hash items nested within others will be loaded into nested
+  # objects.  To call the nav title, the template should call <tt>nav.title</tt>.
+  
+  class Page
+
+    include Templette::DataAccessors
+    attr_reader :name, :template
+    
+    class <<self
+      def pages_dir
+        @@pages_dir ||= 'pages'
+      end
+      
+      def pages_dir=(path)
+        @@pages_dir = path
+      end
+  
+      # Grabs all of the yaml files found in /pages, and loads them as
+      # Page objects.
+      def find_all
+        Dir["#{pages_dir}/**/*.yml"].map {|f| new f }
+      end
+    end
+  
+    def initialize(page_config)
+      raise PageError.new(self, "missing page #{page_config}") unless File.exists?(page_config)
+
+      data = YAML::load_file(page_config)
+      @name = page_config.dup
+      @name.slice!(self.class.pages_dir + '/')
+      @name.chomp!('.yml')
+      raise PageError.new(self, "missing required section \"template_name\" for page config #{page_config}") unless data['template_name']
+      @template = Template.new(data['template_name'])
+
+      raise PageError.new(self, "missing sections in yml for page config #{page_config}") unless data['sections']
+      generate_accessors(data['sections'])
+      include_helpers(template.helpers)
+    end
+  
+    def generate(out_dir)
+      generate_subdirectory(out_dir)
+      File.open(output_file_name(out_dir), 'w') do |f| 
+        f << ERB.new(@template.to_html, 0, "%<>").result(binding)
+      end
+    end
+
+    # A requriement of the Templette::DataAccessors interface.  Returns self.
+    def page; self end
+    
+    private
+
+      def output_file_name(out_dir)
+        "#{out_dir}/#{@name}.html"
+      end
+    
+      def generate_subdirectory(out_dir)
+        FileUtils.mkdir_p(File.expand_path("#{out_dir}/" + name.chomp(File.basename(name)))) if name.index('/')
+      end
+      
+      class Section # :nodoc:
+        include Templette::DataAccessors
+        attr_reader :page
+      
+        def initialize(page, hash={})
+          @page = page
+          generate_accessors(hash)
+        end
+      
+      end 
+  end
+end

data/lib/templette/template.rb

@@ -0,0 +1,36 @@
+module Templette
+  # The Template acts as a layout for pages.  It contains an html layout for the
+  # page and contains method calls which are answered by helper methods or the 
+  # loaded yaml of a page.
+
+  class Template
+    TEMPLATE_DIR = 'templates' unless defined?(TEMPLATE_DIR)
+    attr_accessor :name
+    
+    # The name parameter refers to the actual filename of the template.  To load
+    # templates/foo.html, a template_name of 'foo' should be given.
+    def initialize(name)
+      @name = name      
+    end
+  
+    def to_html
+      raise TemplateError.new(self, "Template rendering failed.  File not found.") unless File.exists?(path)
+      File.read(path)
+    end
+    
+    # Generates the yaml necessary to render empty page yaml files.
+    def to_yaml
+      {'template_name' => @name, 'sections' => MethodCollector.new(self).to_hash}.to_yaml
+    end
+    
+    # Provides the names of helper_modules to be loaded for a template.
+    def helpers
+      ["default_helper","#{name}_helper"]
+    end
+
+    private
+      def path
+        "#{TEMPLATE_DIR}/#{@name}.html"
+      end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: templette
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Jacob Dunphy and Steve Holder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-08-26 00:00:00 -07:00
+default_executable: templette
+dependencies: []
+
+description: HTML site generation through templates
+email: jacob.dunphy@gmail.com
+executables: 
+- templette
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/file_generator.rb
+- lib/tasks/templette_tasks.rb
+- lib/templette/data_accessors.rb
+- lib/templette/errors.rb
+- lib/templette/generator.rb
+- lib/templette/method_collector.rb
+- lib/templette/page.rb
+- lib/templette/template.rb
+- lib/templette.rb
+- bin/templette
+- bin/templette.cmd
+- files/Capfile
+- files/default_helper.rb
+- files/deploy.rb
+- files/Rakefile
+has_rdoc: true
+homepage: http://github.com/jdunphy/templette
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: templette
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: HTML site generation through templates
+test_files: []
+