broadway 0.0.1

data/lib/broadway/base.rb

@@ -0,0 +1,121 @@
+def files(path, from = __FILE__, &block)
+  Dir.glob(File.join(File.dirname(from), path)) {|file| yield file}
+end
+
+def require_local(path, from = __FILE__)
+  files(path, from) {|file| require file}
+end
+
+require "rubygems"
+require 'redcloth'
+require 'nokogiri'
+require 'active_support'
+require 'action_mailer'
+require 'action_view'
+require 'action_view/base'
+
+# core
+require 'fileutils'
+require 'time'
+require 'yaml'
+require 'nokogiri'
+require 'cgi'
+require 'sinatra'
+require 'sinatra/base'
+require 'sinatra_more'
+require 'haml'
+
+# stdlib
+
+# 3rd party
+require 'redcloth'
+
+$:.push(File.dirname(__FILE__))
+require 'core_ext'
+require 'convertible'
+require 'resource'
+require 'site'
+require 'asset'
+require 'page'
+require 'post'
+require 'static_file'
+require 'runner'
+require "helpers"
+
+module Broadway
+  VERSION = "0.0.1"
+  # Default options. Overriden by values in _config.yml or command-line opts.
+  # (Strings rather symbols used for compatability with YAML)
+  DEFAULTS = {
+    :auto         => false,
+    :server       => false,
+    :server_port  => 4000,
+
+    :source       => '.',
+    :destination  => File.join('..', '_posts'),
+
+    :lsi          => false,
+    :pygments     => false,
+    :markdown     => 'maruku',
+    :permalink    => 'pretty',
+    :url_type     => 'relative',
+    :url          => 'http://localhost:4567',
+    :language     => 'en-US',
+    
+    :maruku       => {
+      :use_tex    => false,
+      :use_divs   => false,
+      :png_engine => 'blahtex',
+      :png_dir    => 'images/latex',
+      :png_url    => '/images/latex'
+    },
+    
+    :layouts     => "_layouts",
+    :posts       => "",#"_posts"
+    :posts_include => [".textile", ".markdown"]
+  }
+
+  # Generate a Broadway configuration Hash by merging the default options
+  # with anything in _config.yml, and adding the given options on top
+  #   +override+ is a Hash of config directives
+  #
+  # Returns Hash
+  def self.configuration(override)
+    # _config.yml may override default source location, but until
+    # then, we need to know where to look for _config.yml
+    source = override[:source] || Broadway::DEFAULTS[:source]
+
+    # Get configuration from <source>/_config.yml
+    config_file = File.join(source, '_config.yml')
+    begin
+      config = YAML.load_file(config_file)
+      raise "Invalid configuration - #{config_file}" if !config.is_a?(Hash)
+      $stdout.puts "Configuration from #{config_file}"
+    rescue => err
+      $stderr.puts "WARNING: Could not read configuration. Using defaults (and options)."
+      $stderr.puts "\t" + err.to_s
+      config = {}
+    end
+    
+    # Merge DEFAULTS < _config.yml < override
+    Broadway::DEFAULTS.deep_merge(config).deep_merge(override)
+  end
+    
+  def self.build(options = {})
+    self.process(:build, options)
+  end
+  
+  def self.generate(options = {})
+    self.process(:process, options)
+  end
+  
+  def self.process(method, options = {})
+    options = Broadway.configuration(options)
+    
+    site = Broadway::Site.new(options)
+    
+    site.send method
+    
+    site
+  end
+end

data/lib/broadway/convertible.rb

@@ -0,0 +1,89 @@
+# Convertible provides methods for converting a pagelike item
+# from a certain type of markup into actual content
+#
+# Requires
+#   self.site -> Jekyll::Site
+#   self.content=
+#   self.data=
+#   self.ext=
+#   self.output=
+require 'liquid'
+module Broadway
+  module Convertible
+    # Return the contents as a string
+    def to_s
+      self.content || ''
+    end
+
+    # Read the YAML frontmatter
+    #   +base+ is the String path to the dir containing the file
+    #   +name+ is the String filename of the file
+    # You can also get the content from xml, so this might not need to run
+    # Returns nothing
+    def read_yaml(path)
+      return if !File.exists?(path) || File.directory?(path)
+      
+      self.content = IO.read(path)
+      
+      if self.content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        self.content = self.content[($1.size + $2.size)..-1]
+      
+        self.data.merge!(YAML.load($1))
+      end
+    end
+    
+    # Transform the contents based on the file extension.
+    #
+    # Returns nothing
+    def transform
+      case self.content_type
+      when 'textile'
+        self.ext = ".html"
+        self.content = self.site.textile(self.content)
+      when 'markdown'
+        self.ext = ".html"
+        self.content = self.site.markdown(self.content)
+      end
+    end
+
+    # Determine which formatting engine to use based on this convertible's
+    # extension
+    #
+    # Returns one of :textile, :markdown or :unknown
+    def content_type
+      case self.ext[1..-1]
+      when /textile/i
+        return 'textile'
+      when /markdown/i, /mkdn/i, /md/i, /mkd/i
+        return 'markdown'
+      end
+      return 'unknown'
+    end
+
+    # Add any necessary layouts to this convertible document
+    #   +layouts+ is a Hash of {"name" => "layout"}
+    #   +site_payload+ is the site payload hash
+    #
+    # Returns nothing
+    def do_layout(payload, layouts)
+      info = { :filters => [], :registers => { :site => self.site } }
+      
+      # render and transform content (this becomes the final content of the object)
+      payload["content_type"] = self.content_type
+      self.content = Liquid::Template.parse(self.content).render(payload, info)
+      self.transform
+
+      # output keeps track of what will finally be written
+      self.output = self.content
+
+      # recursively render layouts
+      layout = layouts[self.data["layout"]]
+      while layout
+        payload = payload.deep_merge({"content" => self.output, "page" => layout.data})
+        self.output = Liquid::Template.parse(layout.content).render(payload, info)
+
+        layout = layouts[layout.data["layout"]]
+      end
+    end
+  end
+end

data/lib/broadway/core_ext.rb

@@ -0,0 +1,93 @@
+class Hash
+  def recursive_symbolize_keys!
+    self.symbolize_keys!
+    self.values.each do |v|
+      if v.is_a? Hash
+        v.recursive_symbolize_keys!
+      elsif v.is_a? Array
+        v.recursive_symbolize_keys!
+      end
+    end
+    self
+  end
+end
+
+class Array
+  def recursive_symbolize_keys!
+    self.each do |item|
+      if item.is_a? Hash
+        item.recursive_symbolize_keys!
+      elsif item.is_a? Array
+        item.recursive_symbolize_keys!
+      end
+    end
+  end
+  
+  # http://snippets.dzone.com/posts/show/3486
+  def chunk(pieces)
+    q, r = length.divmod(pieces)
+    (0..pieces).map { |i| i * q + [r, i].min }.enum_cons(2).map { |a, b| slice(a...b) }
+  end
+  
+  def / len
+    a = []
+    each_with_index do |x,i|
+      a << [] if i % len == 0
+      a.last << x
+    end
+    a
+  end
+end
+
+class Hash
+  # Merges self with another hash, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = dup
+
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+
+      target[key] = hash[key]
+    end
+
+    target
+  end
+
+  # Read array from the supplied hash favouring the singular key
+  # and then the plural key, and handling any nil entries.
+  #   +hash+ the hash to read from
+  #   +singular_key+ the singular key
+  #   +plural_key+ the singular key
+  #
+  # Returns an array
+  def pluralized_array(singular_key, plural_key)
+    hash = self
+    if hash.has_key?(singular_key)
+      array = [hash[singular_key]] if hash[singular_key]
+    elsif hash.has_key?(plural_key)
+      case hash[plural_key]
+      when String
+        array = hash[plural_key].split
+      when Array
+        array = hash[plural_key].compact
+      end
+    end
+    array || []
+  end
+end
+
+# Thanks, ActiveSupport!
+class Date
+  # Converts datetime to an appropriate format for use in XML
+  def xmlschema
+    strftime("%Y-%m-%dT%H:%M:%S%Z")
+  end if RUBY_VERSION < '1.9'
+end

data/lib/broadway/helpers.rb

@@ -0,0 +1,7 @@
+require_local "helpers/*"
+
+helpers do
+  files("helpers/*") do |file|
+    include "Broadway::Helpers::#{File.basename(file).split(".").first.camelize}".constantize
+  end
+end

data/lib/broadway/helpers/collection_helper.rb

@@ -0,0 +1,152 @@
+module Broadway
+  module Helpers
+    module CollectionHelper
+      
+      # comment from http://openmonkey.com/articles/2009/02/a-cycle-helper-for-sinatra
+      # You can then call it like this: 
+      # .user_badge{ :class => cycle('normal', 'normal', 'last') }
+      def cycle(*states) 
+        states[@_cycle = ((@_cycle || -1) + 1) % states.size] 
+      end
+      
+      def grid_for(array, options = {}, &block)
+        return "" if array.empty?
+        columns = options[:columns] || 3
+        (array / columns).each do |row|
+          yield row
+        end
+      end
+      
+      def row_for(array, options = {}, &block)
+        return "" if array.empty?
+        array.each_with_index do |node, i|
+          attributes = options.has_key?(:li_attributes) ? options[:li_attributes] : {}
+          attributes[:class] ||= ""
+          if i == 0 and options.has_key?(:first)
+            attributes[:class] << "#{options[:first]}"
+          elsif i == array.length - 1 and options.has_key?(:last)
+            attributes[:class] << "#{options[:last]}"
+          end
+          haml_tag :li, attributes do
+            if block_given?
+              yield node, i
+            else
+              haml_concat node.title
+            end
+          end
+        end
+      end
+      
+      def menu_for(item, options = {}, &block)
+        if item.is_a?(Site)
+          menu_tag(item.tree, options, &block)
+        elsif item.is_a?(Page)
+          menu_tag(item.children, options, &block)
+        elsif item.is_a?(Post)
+          ""
+        else
+          menu_tag(item, options, &block)
+        end
+      end
+      
+      # - menu_tag(c(:menu)) do |attributes, node|
+      # 	- attributes[:class] = "one two"
+      # 	- node[:title]
+      def menu_tag(array, options = {}, &block)
+        return "" if array.empty?
+        menu_attributes = nil
+        if options.has_key?(:menu_attributes)
+          menu_attributes = options[:menu_attributes]
+          options.delete(:menu_attributes)
+        end
+        haml_tag :ul, menu_attributes do
+          array.each_with_index do |node, i|
+            attributes = options.has_key?(:li_attributes) ? options[:li_attributes] : {}
+            attributes[:class] ||= ""
+            if i == 0 and options.has_key?(:first)
+              attributes[:class] << " #{options[:first]}"
+            elsif i == array.length - 1 and options.has_key?(:last)
+              attributes[:class] << " #{options[:last]}"
+            end
+            haml_tag :li, attributes do
+              if block_given?
+                yield node
+              else
+                haml_concat node.title
+              end
+              next if (options.has_key?(:show_children) and options[:show_children] == false)
+              next unless (node.respond_to?(:children) and node.show_children?)
+              
+              menu_tag(node.children, options, &block)
+            end
+          end
+        end
+      end
+      
+      def breadcrumb_for(item, options = {}, &block)
+        options[:from] ||= "/" + item.url.gsub(/^\//, "").split("/").first
+        options[:to] ||= item.url
+        breadcrumb(options[:from], options, &block)
+      end
+      
+      def breadcrumb(current_url, options, &block)
+        item = site.find_by_url(current_url)
+        return "" unless item
+        haml_tag :a, options.merge(:href => current_url) do
+          if block_given?
+            yield item
+          else
+            haml_concat item.title
+          end
+        end
+        if options[:to] != current_url
+          haml_concat options[:delimiter] || " » "
+          next_node = options[:to].gsub(/#{current_url}\/?/, "").split("/").first
+          breadcrumb("#{current_url}/#{next_node}", options, &block)
+        end
+      end
+      
+      def find_index_dir(dir)
+        return dir if File.exists?(File.join(dir, "index.haml"))
+        return dir == "." ? dir : find_index_dir(File.dirname(dir))
+      end
+
+      # TODO
+      def load_tree
+        root = File.expand_path("public")
+        dir = params[:dir]
+        result = "<ul class=\"jqueryFileTree\" style=\"display: none;\">"
+        begin
+        	path = File.expand_path(File.join(root, dir)).untaint
+        	if (path.split("/").length >= root.split("/").length)
+          	current_dir = Dir.pwd
+          	Dir.chdir(File.expand_path(path).untaint);
+        		#loop through all directories
+        		Dir.glob("*") {
+        			|x|
+        			if not File.directory?(x.untaint) then next end 
+        			result << "<li class=\"directory collapsed\"><a href=\"#\" rel=\"#{dir}#{x}/\">#{x}</a></li>";
+        		}
+
+        		#loop through all files
+        		Dir.glob("*") {
+        			|x|
+        			if not File.file?(x.untaint) then next end 
+        			ext = File.extname(x)[1..-1]
+        			result << "<li class=\"file ext_#{ext}\"><a href=\"#\" rel=\"#{dir}#{x}\">#{x}</a></li>"
+        		}
+        	else
+        		#only happens when someone tries to go outside your root directory...
+        		result << "You are way out of your league"
+        	end 
+        rescue 
+        	result << "Internal Error"
+        end
+        Dir.chdir(current_dir)
+        result << "</ul>"
+        result
+      end
+    
+    end
+  end
+end