broadway 0.0.3.5 → 0.1.0

data/lib/broadway/rails.rb

@@ -1,3 +0,0 @@
-module Broadway::Rails
-  
-end

data/lib/broadway/resource.rb

@@ -1,128 +0,0 @@
-module Broadway::Resource
-  
-  def self.included(base)
-    base.class_eval do
-      include InstanceMethods
-    end
-  end
-  
-  module InstanceMethods
-    attr_accessor :site, :position # order
-    # where the file is
-    attr_accessor :path, :dir, :basename, :ext, :title
-    attr_accessor :data, :content, :output
-    attr_accessor :date, :slug, :published, :categories, :asset
-    
-    # Extract information from the post filename
-    #   +name+ is the String filename of the post file
-    #
-    # Returns nothing
-    def process(options = {})
-      return if options.has_key?(:process) and options[:process] == false
-      
-      self.read_yaml(path)
-      
-      self.title = data["title"] || self.slug.split('-').select {|w| w.capitalize! || w }.join(' ')
-      
-      # If we've added a date and time to the yaml, use that instead of the filename date
-      # Means we'll sort correctly.
-      self.date = Time.parse(self.data["date"].to_s) if self.data.has_key?('date')
-      
-      if self.data.has_key?('published') && self.data['published'] == false
-        self.published = false
-      else
-        self.published = true
-      end
-      
-      if self.data.has_key?("asset")
-        data["asset"]["title"] ||= self.title
-        self.asset = ::Broadway::Asset.new(data["asset"])
-      end
-      
-      self.tags = self.data["tags"]
-      self.tags ||= []
-    end
-    
-    def children
-      key = self.categories.last
-      length = self.url.split("/").length
-      @children = site.find_pages_by_category(key) + site.find_posts_by_category(key)
-      @children.delete_if do |child|
-        (child.url == self.url) ||
-        (child.url.split("/").length <= length) ||
-        (child.is_a?(Broadway::Post) && child.categories != self.categories) ||
-        (child.is_a?(Broadway::Page) && child.categories[0..-2] != self.categories)
-      end
-    end
-    
-    # The UID for this post (useful in feeds)
-    # e.g. /2008/11/05/my-awesome-post
-    #
-    # Returns <String>
-    def id
-      File.join(self.dir, self.slug)
-    end
-    
-    def menu_title
-      self.data['menu_title'] || self.title
-    end
-    
-    def tooltip
-      self.data["tooltip"]
-    end
-    
-    def permalink
-      self.data['permalink']
-    end
-    
-    def excerpt
-      self.data['excerpt']
-    end
-    
-    def show_children?
-      return true if self.data.nil?
-      if self.data.has_key?("show_children")
-        return self.data["show_children"] == "true" || self.data["show_children"] == true
-      end
-      return true
-    end
-    
-    def parent
-      url ? site.find_page_by_url(url[1..-1].split("/").first) : nil
-    end
-    
-    def layout
-      self.data and self.data.has_key?("layout") ? self.data["layout"] : self.categories.first
-    end
-    
-    def tags=(value)
-      @tags = case value
-      when Hash
-        value = value.each { |k, v| value[k] = tag_array(v) }
-      else
-        {"tags" => tag_array(value)}
-      end
-    end
-    
-    # tags can be stored under multiple contexts
-    # default is "tags" (use "categories" or whatever else you want)
-    def tags(context = "tags")
-      @tags[context.to_s]
-    end
-    
-    private
-    
-      # helper method to convert tags to arrays
-      def tag_array(value)
-        result = case value
-        when String
-          value.split(",\s+")
-        when Array
-          value
-        end
-        result
-      end
-    
-  end
-  
-end

data/lib/broadway/runner.rb

@@ -1,62 +0,0 @@
-module Broadway
-
-  class Runner
-    
-    attr_accessor :site, :content, :url
-    
-    def initialize(site)
-      self.site = site
-      self.url = URI.parse(site.config[:url])
-      self.content = site.pages + site.posts
-    end
-    
-    def run(&block)
-      versions = site.config[:theme_versions]
-      puts "Connecting to... #{url.scheme}://#{url.host}:#{url.port}"
-      item_url = nil
-      versions.each do |version|
-        prefix = version == "main" ? "" : version
-        begin
-          Net::HTTP.start(url.host, url.port) do |http|
-            self.content.each do |item|
-              if block_given?
-                item_url = yield(item)
-              else
-                if prefix == "touch"
-                  item_url = "/touch#{item.url.gsub(".", "")}?layout=false"
-                else
-                  item_url = ("/" + File.join(prefix, item.url.gsub(".", ""))).squeeze("/")
-                end
-              end
-              puts "Connecting to... #{url.scheme}://#{url.host}:#{url.port}#{item_url}"
-              item_dir = File.expand_path(File.join(site.config[:destination], prefix, item.url).squeeze("/"))
-              response = http.get(item_url)
-              # if the file doesn't exist or is not rendered correctly
-              next if error?(response, item_url, false)
-              FileUtils.mkdir_p(item_dir)
-              name = File.join(item_dir, "index.html").squeeze("/")
-              text = ""
-              text << response.body
-              puts "Writing... #{name}"
-              File.open(name, "w") {|f| f.write(text) }
-            end
-          end
-        rescue Exception => e
-          puts e.inspect
-          raise "Make sure you've started the server, run: 'ruby app.rb'"
-        end
-      end
-    end
-    
-    def error?(response, path, whiny = true)
-      if !response.is_a?(Net::HTTPSuccess)
-        raise message if whiny
-        puts "Error at '#{path}': #{response.to_s}"
-        return true
-      end
-      false
-    end
-    
-  end
-  
-end

data/lib/broadway/sinatra.rb

@@ -1,5 +0,0 @@
-module Broadway::Sinatra
-  
-end
-
-require_local "sinatra/*"

data/lib/broadway/sinatra/base.rb

@@ -1,90 +0,0 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
-require "sinatra"
-require "sinatra/base"
-require "sinatra_more"
-
-@site = site = Broadway.build
-
-Sinatra::Application.instance_eval do
-  cattr_accessor :site
-  self.site = site
-end
-
-def site
-  @site
-end
-
-def default_locals(locals = {})
-  {
-    :environment    => Sinatra::Application.environment,
-    :theme_version  => "main"
-  }.merge(locals)
-end
-
-def default_options(options = {})
-  if params.has_key?("layout") and params["layout"] == false
-    options[:layout] = false
-  else
-    options[:layout] = !request.xhr?
-  end
-  options
-end
-
-def theme_path(version = "main")
-  File.join(site.config[:theme_path], site.config[:theme], version)
-end
-
-# "main" is the default, so remove it
-def theme_versions
-  site.config[:theme_versions]
-end
-
-def pages
-  Dir.entries("public")
-end
-
-Sinatra::Application.class_eval do
-  register SinatraMore::MarkupPlugin
-  register SinatraMore::RoutingPlugin
-end
-
-def page_path(page, version)
-  content_path(page, version, "index")
-end
-
-def post_path(post, version)
-  content_path(post, version, "show")
-end
-
-def c(path)
-  result = site.config
-  path.to_s.split(".").each { |node| result = result[node.to_sym] if result }
-  result.nil? ? [] : result
-end
-
-def content_path(content, version, action)
-  # first check if it's in the posts directory (where textile files are)
-  path = File.join(content.dir, action).squeeze("/")
-  exists = false
-  extensions = %w(html haml erb html.haml html.erb)
-  target_path = File.join(site.config[:source], path)
-  extensions.each do |ext|
-    exists = true if File.exists?("#{target_path}.#{ext}")
-  end
-  return path if exists
-  # then check if it's in the theme directory
-  checked = [target_path]
-  path = target_path = File.join(theme_path(version), content.layout, action).squeeze("/")
-  exists = false
-  extensions.each do |ext|
-    exists = true if File.exists?(File.join(site.config[:source], "#{target_path}.#{ext}"))
-  end
-  return path if exists
-  return File.join(theme_path(version), "index") if content.url == "/"
-  checked << target_path
-  
-  puts "Couldn't find any paths for #{content.class.to_s.downcase.split(":").last} '#{content.url}': #{checked.inspect}"
-  return nil
-end

data/lib/broadway/sinatra/helpers.rb

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

data/lib/broadway/site.rb

@@ -1,421 +0,0 @@
-module Broadway
-
-  class Site
-    attr_accessor :config, :layouts, :posts, :pages, :static_files, :categories, :exclude,
-                  :source, :dest, :lsi, :pygments, :permalink_style, :tags, :tree
-    
-    def self.generate
-      
-    end
-    
-    # Initialize the site
-    #   +config+ is a Hash containing site configurations details
-    #
-    # Returns <Site>
-    def initialize(config)
-      merge_extra_config!(config)
-      
-      config.recursive_symbolize_keys!
-
-      self.config          = config.clone
-      
-      self.source          = config[:source]
-      self.dest            = config[:destination]
-      self.lsi             = config[:lsi]
-      self.pygments        = config[:pygments]
-      self.permalink_style = config[:permalink].to_sym
-      self.exclude         = config[:exclude] || []
-      self.tree            = []
-      
-      self.reset
-      self.setup
-    end
-    
-    def merge_extra_config!(config)
-      locale = File.join(config[:locales], "#{config[:language]}.yml")
-
-      config.merge!(YAML.load_file(locale)) if File.exists?(locale)
-
-
-      config_dir = File.join(config[:source], "config")
-      return unless File.exists?(config_dir)
-      Dir.glob("#{config_dir}/**/*").each do |file|
-        next if File.directory?(file)
-        path = file.gsub(/config\//, "").split(".")[0..-2].join("")
-        ext = File.extname(file)
-        if ext =~ /yml/
-          data = YAML.load_file(file)
-        elsif ext =~ /xml/
-          data = parse_children Nokogiri::XML(IO.read(file)).children[0]
-        else
-          data = IO.read(file)
-        end
-        next unless data
-        name = path.split("/").first
-        if path =~ /\//
-          config[name] ||= {}
-          target = config[name]
-          name = path.split("/").last
-        else
-          target = config
-        end
-        if target.has_key?(name)
-          target[name].merge!(data)
-        else
-          target[name] = data
-        end
-      end
-    end
-    
-    # first
-    def reset
-      self.layouts         = {}
-      self.posts           = []
-      self.pages           = []
-      self.static_files    = []
-      self.categories      = Hash.new { |hash, key| hash[key] = [] }
-      self.tags            = Hash.new { |hash, key| hash[key] = [] }
-    end
-    
-    # second
-    # this just sets configuration variables on the dependencies, if necessary
-    def setup
-      # Check to see if LSI is enabled.
-      require 'classifier' if self.lsi
-
-      # Set the Markdown interpreter (and Maruku self.config, if necessary)
-      case self.config[:markdown]
-        when 'rdiscount'
-          begin
-            require 'rdiscount'
-
-            def markdown(content)
-              RDiscount.new(content).to_html
-            end
-
-          rescue LoadError
-            puts 'You must have the rdiscount gem installed first'
-          end
-        when 'maruku'
-          begin
-            require 'maruku'
-
-            def markdown(content)
-              Maruku.new(content).to_html
-            end
-
-            if self.config[:maruku][:use_divs]
-              require 'maruku/ext/div'
-              puts 'Maruku: Using extended syntax for div elements.'
-            end
-
-            if self.config[:maruku][:use_tex]
-              require 'maruku/ext/math'
-              puts "Maruku: Using LaTeX extension. Images in `#{self.config[:maruku][:png_dir]}`."
-
-              # Switch off MathML output
-              MaRuKu::Globals[:html_math_output_mathml] = false
-              MaRuKu::Globals[:html_math_engine] = 'none'
-
-              # Turn on math to PNG support with blahtex
-              # Resulting PNGs stored in `images/latex`
-              MaRuKu::Globals[:html_math_output_png] = true
-              MaRuKu::Globals[:html_png_engine] =  self.config[:maruku][:png_engine]
-              MaRuKu::Globals[:html_png_dir] = self.config[:maruku][:png_dir]
-              MaRuKu::Globals[:html_png_url] = self.config[:maruku][:png_url]
-            end
-          rescue LoadError
-            puts "The maruku gem is required for markdown support!"
-          end
-        else
-          raise "Invalid Markdown processor: '#{self.config[:markdown]}' -- did you mean 'maruku' or 'rdiscount'?"
-      end
-    end
-
-    def textile(content)
-      RedCloth.new(content).to_html
-    end
-
-    # third
-    # Do the actual work of processing the site and generating the
-    # real deal.  Now has 4 phases; reset, read, render, write.  This allows
-    # rendering to have full site payload available.
-    #
-    # Returns nothing
-    def process
-      build
-      generate
-    end
-    
-    def build
-      puts "Building site: #{config[:source]} -> #{config[:destination]}"
-      self.reset
-      self.read
-      puts "Successfully built site, nothing was written."
-    end
-    
-    def generate
-      puts "Generating site: #{config[:source]} -> #{config[:destination]}"
-      self.render
-      self.write
-      puts "Successfully generated site: #{config[:source]} -> #{config[:destination]}"
-    end
-    
-    def read
-      self.read_layouts # existing implementation did this at top level only so preserved that
-      self.read_directories
-    end
-
-    # Read all the files in <source>/<dir>/_layouts and create a new Layout
-    # object with each one.
-    #
-    # Returns nothing
-    def read_layouts(dir = '')
-      base = File.join(self.source, dir, config[:layouts])
-      return unless File.exists?(base)
-      entries = []
-      Dir.chdir(base) { entries = filter_entries(Dir['*.*']) }
-      entries.each do |f|
-        name = f.split(".")[0..-2].join(".")
-        self.layouts[name] = Layout.new(self, base, f)
-      end
-    end
-    
-    # Reads the directories and finds posts, pages and static files that will 
-    # become part of the valid site according to the rules in +filter_entries+.
-    #   The +dir+ String is a relative path used to call this method
-    #            recursively as it descends through directories
-    #
-    # Returns nothing
-    def read_directories(dir = '')
-      base = File.join(self.source, dir).gsub(/\/$/, "")
-      lists = []
-
-      # RULES:
-      # Pages are only index.textile files, or static .html files (TODO)
-      # Posts are leaf nodes (name.textile files)
-      # Categories are the directory name split plus anything extra defined
-      # Pages and Posts can also be obtained via index.xml files
-      Dir.glob("#{base}/**/*").each do |path|
-        # removes junk, leaves us with .xml, .textile, .html
-        next if filtered?(path)
-        name = File.basename(path).split(".").first
-        ext = File.extname(path).gsub(".", "")
-        if name == "index"
-          if ext != "xml"
-            new_page(path)
-          end
-        elsif %w(textile markdown).include?(ext)
-          new_post(path) 
-        else
-          self.static_files << StaticFile.new(:site => self, :path => path)
-        end
-      end
-      
-      # lists are xml files we've collect, but we want to make sure we've
-      # created all the posts we need to beforehand
-      # this also sorts everything
-      list = File.join(config[:source], "index.xml")
-      lists << list if File.exists?(list)
-      lists.each do |path|
-        new_tree(path)
-      end
-      
-      sort!
-            
-      # finally, we have set all the initial variables on the
-      # pages and posts we need, now we can process them to find
-      # the content and generate the urls
-      self.pages.each do |page|
-        page.process
-        page.categories.each { |c| self.categories[c] << page }
-        page.tags.each { |c| self.tags[c] << page }
-      end
-      self.posts.each do |post|
-        post.process
-        post.categories.each { |c| self.categories[c] << post }
-        post.tags.each { |c| self.tags[c] << post }
-      end
-    end
-    
-    def new_page(path, options = {})
-      return if path.nil? || path.empty?
-      page = Page.new(options.merge(:site => self, :path => path, :process => false))
-      self.pages << page
-      page
-    end
-    
-    def new_post(path, options = {})
-      return if path.nil? || path.empty?
-      post = Post.new(options.merge(:site => self, :path => path, :process => false))
-      self.posts << post
-      post
-    end
-    
-    def new_tree(path)
-      self.tree.concat parse_tree(Nokogiri::XML(IO.read(path)).root)
-    end
-    
-    def parse_tree(parent)
-      result = []
-      return result if parent.nil? || parent.children.nil? || parent.children.empty?
-      parent.children.each_with_index do |child, index|
-        next unless child.elem?
-        content = child.children.empty? ? post_from_xml(child) : page_from_xml(child)
-        next unless content
-        if content.respond_to?(:children)
-          content.children.concat parse_tree(child)
-        end
-        content.position = index
-        result << content
-      end
-      result
-    end
-    
-    # http://stackoverflow.com/questions/1769126/fastest-one-liner-way-to-get-xml-nodes-into-array-of-path-to-nodes-in-ruby
-    def node_list(elem, &proc)
-      return [] unless elem.class == Nokogiri::XML::Element
-      str = proc.call(elem)
-      [str] + elem.children.inject([]){|a,c| a+node_list(c,&proc)}.map{|e| "#{str}/#{e}"}
-    end
-    
-    def post_from_xml(content)
-      # post
-      # 1. If a "src" is defined, then we should have already created the post
-      # 2. If no "src", then content is specified inline (or there is no content yet)
-      post = find_post_by_path(content["src"]) || find_post_by_url(content["url"])
-      path = (content["src"] || content["url"] || "").gsub(/^\//, "")
-      post ||= new_post(path)
-      return unless post
-      %w(title image excerpt menu_title tooltip show_children content layout).each do |key|
-        post.data[key] = content[key] if content.has_attribute?(key)
-      end
-      post
-    end
-    
-    def page_from_xml(content)
-      # page
-      # 1. If a "src" is defined, then we should have already created the post
-      # 2. If no "src", then content is specified inline (or there is no content yet)
-      page = find_page_by_path(content["src"]) || find_page_by_url(content["url"])
-      path = (content["src"] || content["url"] || "").gsub(/^\//, "")
-      page ||= new_page(path)
-      return unless page
-      %w(title image excerpt menu_title tooltip show_children content layout).each do |key|
-        page.data[key] = content[key] if content.has_attribute?(key)
-      end
-      page
-    end
-    
-    # sort all pages and posts
-    # determined by index.xml file (and later, for dates)
-    def sort!
-      sort_content(:page, self.pages)
-      sort_content(:post, self.posts)
-    end
-    
-    def sort_content(type, contents)
-      
-      method = type.to_s.pluralize
-      unnumbered = self.send(method).select { |content| content.position.nil? }
-      start_index = self.send(method).length - unnumbered.length
-      unnumbered.each_with_index { |content, index| content.position = start_index + index }
-      self.send(method).sort!
-      self.send(method)
-    end
-    
-    # While in Jekyll this method renders the content explicitly,
-    # I'm using Sinatra, partly because I like having the flexibility
-    # of using their get/post methods, and partly because I don't have
-    # the time/desire to try to hack jekyll to use haml.
-    # I'd rather just start over
-    def render
-      Runner.new(self).run
-    end
-    
-    # Write static files, pages and posts
-    #
-    # Returns nothing
-    def write
-      self.static_files.each do |sf|
-        sf.write(self.dest)
-      end
-    end
-
-    # Constructs a hash map of Posts indexed by the specified Post attribute
-    #
-    # Returns {post_attr => [<Post>]}
-    def post_attr_hash(post_attr)
-      # Build a hash map based on the specified post attribute ( post attr => array of posts )
-      # then sort each array in reverse order
-      hash = Hash.new { |hash, key| hash[key] = Array.new }
-      self.posts.each { |p| p.send(post_attr.to_sym).each { |t| hash[t] << p } }
-      hash.values.map { |sortme| sortme.sort! { |a, b| b <=> a} }
-      return hash
-    end
-
-    # The Hash payload containing site-wide data
-    #
-    # Returns {"site" => {"time" => <Time>,
-    #                     "posts" => [<Post>],
-    #                     "categories" => [<Post>]}
-    def site_payload
-      {"site" => self.config.merge({
-          "time"       => Time.now,
-          "posts"      => self.posts.sort { |a,b| b <=> a },
-          "categories" => post_attr_hash('categories'),
-          "tags"       => post_attr_hash('tags')})}
-    end
-
-    # Filter out any files/directories that are hidden or backup files (start
-    # with "." or "#" or end with "~"), or contain site content (start with "_"),
-    # or are excluded in the site configuration, unless they are web server
-    # files such as '.htaccess'
-    def filtered?(path)
-      return true if File.directory?(path)
-      file = File.basename(path)
-      return true if ['.htaccess'].include?(file)
-      ['.', '_', '#'].include?(file[0..0]) || file[-1..-1] == '~' || self.exclude.include?(file)
-    end
-    
-    def find(type, method, value)
-      self.send(type.to_s.pluralize).select do |content|
-        if content.respond_to?(method)
-          content.send(method) == value
-        else
-          content.send(method.to_s.pluralize).include?(value)
-        end
-      end
-    end
-    
-    def first(type, method, value)
-      find(type, method, value).first
-    end
-    
-    %w(category url path tag title).each do |property|
-      %w(post page).each do |type|
-        define_method "find_#{type}_by_#{property}" do |value|
-          first(type.to_sym, property, value)
-        end
-        define_method "find_#{type.pluralize}_by_#{property}" do |value|
-          find(type.to_sym, property, value)
-        end
-      end
-      define_method "find_by_#{property}" do |value|
-        first(:page, property, value) || first(:post, property, value)
-      end
-    end
-    
-    def page_count
-      self.pages ? self.pages.length : 0
-    end
-    
-    def post_count
-      self.posts ? self.posts.length : 0
-    end
-    
-    def inspect
-      "#<Broadway:Site @page_count=#{self.page_count.to_s} @post_count=#{self.post_count.to_s}>"
-    end
-  end
-end