broadway 0.0.1

data/lib/broadway/resource.rb

@@ -0,0 +1,5 @@
+module Broadway
+  module Resource
+    
+  end
+end

data/lib/broadway/runner.rb

@@ -0,0 +1,49 @@
+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)
+      begin
+        Net::HTTP.start(url.host, url.port) do |http|
+          self.content.each do |item|
+            response = http.get(item.url)
+            # if the file doesn't exist or is not rendered correctly
+            next if error?(response, item.url, false)
+            write_dir = File.expand_path(File.join(site.config[:destination], item.dir))
+            name = File.join(write_dir, "index.html")
+            FileUtils.mkdir_p(write_dir)
+            text = ""
+            text << "---\n"
+            text << "categories: #{item.categories.sort.join(" ")}\n"
+            text << "---\n"
+            text << response.body
+            yield text if block_given?
+            File.write(name, text)
+          end
+        end
+      rescue Exception => e
+        puts e.inspect
+        raise "Make sure you've started the server, run: 'ruby app.rb'"
+      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/site.rb

@@ -0,0 +1,398 @@
+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("locales", "#{config[:language]}.yml")
+      if File.exists?(locale)
+        config.merge!(YAML.load_file(locale))
+      end
+      config_dir = "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
+      list = File.join(config[:source], "index.xml")
+      lists << list if File.exists?(list)
+      lists.each do |path|
+        new_tree(path)
+      end
+      
+      # 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 do |child|
+        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
+        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).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).each do |key|
+        page.data[key] = content[key] if content.has_attribute?(key)
+      end
+      page
+    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