broadway 0.0.3.5 → 0.1.0

data/lib/broadway/processors/link.rb

@@ -0,0 +1,45 @@
+module Broadway
+  module Definition
+    class Link
+      attr_accessor :site, :context, :records
+      
+      def initialize(site, context, &block)
+        self.site = site
+        self.context = context
+        self.records =  []
+        instance_eval(&block)
+      end
+      
+      def link(*args, &block)
+        options = args.extract_options!
+        href = args.shift
+        title = args.shift || options[:title] || href.split("/").last.titleize
+        record = Broadway::Link.new(site, :href => href, :title => title, :categories => [context.to_s])
+        self.records << record
+        site.links << record
+        if block_given?
+          record.children = Broadway::Definition::Link.new(site, context, &block).records
+        end
+      end
+    end
+  end
+  
+  module Processor
+    class Link
+      class << self
+        def tree!(site, name, &block)
+          Broadway::Definition::Link.new(site, name, &block).records
+        end
+        alias menu! tree!
+      end
+      
+      def initialize(link, site, options = {})
+        link.site = site
+        link.href = options[:href]
+        link.title = options[:title]
+        link.categories = options[:categories]
+      end
+      
+    end
+  end
+end

data/lib/broadway/processors/post.rb

@@ -0,0 +1,117 @@
+module Broadway
+  module Processor
+    class Post
+      class << self
+      
+        # RULES:
+        # Pages are only index.textile files, or static .html files (TODO)
+        # Posts are leaf nodes (name.textile files)
+        # Categories are the directoryectory name split plus anything extra defined
+        # Pages and Posts can also be obtained via index.xml files
+        def build(parent, site)
+          result = Dir.entries(parent).collect do |path|
+            # removes junk, leaves us with .xml, .textile, .html
+            next if skip?(path)
+            name  = File.file_name(path)
+            next if name == "index"
+            ext   = File.file_ext(path)
+            file  = ::File.join(parent, path)
+            if %w(textile markdown html).include?(ext)
+              ::Broadway::Post.new(site, :file => file)
+            elsif page = Post.page_exists?(file)
+              ::Broadway::Post.new(site, :file => page)
+            else
+              nil
+            end
+          end.compact
+          
+          result.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
+          result.each do |post|
+            site.posts << post
+            post.categories.each { |c| site.categories[c] << post }
+            post.tags.each { |c| site.tags[c] << post }
+          end
+          
+          result
+        end
+        
+        def page_exists?(file)
+          %w(markdown textile txt).each do |extension|
+            page = ::File.join(file, "index.#{extension}")
+            return page if ::File.exists?(page)
+          end
+          nil
+        end
+        
+        # Filter out any files/directoryectories that are hidden or backup files (start
+        # with "." or "#" or end with "~"), or contain site content (start with "_"),
+        # or are excluded in the site settingsuration, unless they are web server
+        # files such as '.htaccess'
+        def skip?(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
+        
+        # sort all pages and posts
+        # determined by index.xml file (and later, for dates)
+        def sort!
+          sort_content(:post, site.posts)
+        end
+
+        def sort_content(type, contents)
+          method = type.to_s.pluralize
+          unnumbered = site.send(method).select { |content| content.position.nil? }
+          start_index = site.send(method).length - unnumbered.length
+          unnumbered.each_with_index { |content, index| content.position = start_index + index }
+          site.send(method).sort!
+          site.send(method)
+        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
+      end
+    
+      def initialize(post, site, options = {})
+        post.site = site
+        post.file = Broadway::File.new(site, options)
+        post.kind = "page" if post.file.slug == "index"
+        post.slug = Broadway::Slug.new(post.file.slug, post)
+        post.data = post.file.header
+        post.title = post.data["title"].blank? ? post.slug.titleize : post.data["title"]
+        if post.title.downcase == "index"
+          post.title = ::File.basename(post.file.directory).titleize
+        end
+        unless options[:recursive] == false
+          post.children = children(post.file.directory, site) if post.kind == "page"
+        end
+      end
+      
+      def children(path, site)
+        Post.build(path, site) if path
+      end
+      
+      def read(attribute = nil)
+        post.file.read(attribute)
+      end
+      
+      def write(to)
+        post.file.write(to)
+      end
+    end
+  end
+end

data/lib/broadway/processors/site.rb

@@ -0,0 +1,77 @@
+module Broadway
+  module Processor
+    class Site
+      attr_accessor :site, :source, :destination, :lsi, :pygments, :exclude, :lists, :configuration
+    
+      def initialize(site, settings)
+        self.site            = Broadway.site = site
+        
+        site.configuration   = Broadway::Configuration.new(site, settings)
+        
+        self.lists           = []
+        self.source          = settings[:source]
+        self.lsi             = settings[:lsi]
+        self.pygments        = settings[:pygments]
+        self.exclude         = settings[:exclude] || []
+        
+        reset
+      end
+      
+      # first
+      def reset
+        site.posts           = []
+        site.assets          = []
+        site.links           = []
+        site.files           = []
+        site.categories      = Hash.new { |hash, key| hash[key] = [] }
+        site.tags            = Hash.new { |hash, key| hash[key] = [] }
+      end
+      
+      def destination
+        settings[:destination]
+      end
+      
+      def settings
+        site.settings
+      end
+    
+      def process
+        build
+        generate
+      end
+      
+      def build
+        self.reset
+        self.read
+        site
+      end
+      
+      def generate(&block)
+        raise "pass a block to `generate`" unless block_given?
+        raise "define a destination for the site to be written to" if destination.blank?
+        Broadway::Sinatra::Processor.new(site).run(&block) if defined?(::Sinatra)
+        site
+      end
+      
+      def read
+        roots
+        links
+      end
+      
+      def roots
+        site.roots = Broadway::Processor::Post.build(source, site) if source
+      end
+      
+      def links
+        #@links ||= Broadway::Processor::Link.build(source, site)
+        @links
+      end
+      
+      def write
+        site.files.each do |file|
+          file.write(self.destination)
+        end
+      end
+    end
+  end
+end

data/lib/broadway/processors/tree.rb

@@ -0,0 +1,121 @@
+# redefine the hierarchy of posts, or order them
+# DSL for defining initial page hierarchy
+module Broadway
+  module Processor
+    class Tree
+      attr_accessor :root
+    
+      class << self
+        
+        # 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
+        def build(path)
+          list = ::File.join(source, "index.xml")
+          lists << list if ::File.exists?(list)
+          unless lists.blank?
+            require 'nokogiri'
+            lists.each do |path|
+              new_tree(path)
+            end
+          end
+        end
+        
+        def new_tree(path)
+          site.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?
+            post = post_from_xml(child)
+            next unless post
+            if post.respond_to?(:children)
+              post.children.concat parse_tree(child)
+            end
+            post.position = index
+            result << post
+          end
+          result
+        end
+    
+        def post_from_xml(post)
+          # post
+          # 1. If a "src" is defined, then we should have already created the post
+          # 2. If no "src", then post is specified inline (or there is no post yet)                                               
+          path = (post["src"] || ::File.join(site.source, post["path"]) || "").gsub(/^\//, "").gsub(/\/$/, "").squeeze("/")
+          post = site.find_post_by_path(path)
+          unless post
+            if ::File.directory?(path)
+              page = Dir.entries(path)[2..-1].detect do |file|
+                ::File.basename(file).split(".")[0..-2].join(".").downcase == "index"
+              end
+              if page
+                path = ::File.join(path, page)
+                post = site.find_post_by_path(path)
+                post ||= Broadway::Builder::Post.new_post(path)
+              end
+            end
+          end
+        
+          return unless post
+      
+          %w(title image excerpt menu_title tooltip show_children post layout).each do |key|
+            post.data[key] = post[key] if post.has_attribute?(key)
+          end
+          post
+        end
+      end
+    
+      def initialize(*args, &block)
+        self.root = ::Broadway::Definition::Post.new(*args, &block)
+      end
+    end
+  
+    module Definition
+      class Base
+        def initialize(*args, &block)
+          options = args.extract_options!
+        
+          options.each do |k, v|
+            self.send("#{k}=", v) if self.respond_to?(k)
+          end
+        
+          instance_eval(&block) if block_given?
+        end
+      end
+    
+      class Post
+        attr_accessor :title, :path, :tooltip, :show_children
+      
+        def title(value = "")
+          @title = value if value
+          @title
+        end
+      
+        def path(value = "")
+          @path = value if value
+          @path
+        end
+      
+        def tooltip(value = "")
+          @tooltip = value if value
+          @tooltip
+        end
+      
+        def show_children(value = "")
+          @show_children = value if value
+          @show_children
+        end
+      
+      end
+      
+      class Menu
+      
+      end
+    
+    end
+  end
+end

data/lib/broadway/resources/asset.rb

@@ -0,0 +1,28 @@
+module Broadway
+  class Asset
+    attr_accessor :site, :title, :tooltip, :thumb, :width, :height, :resource, :content_type, :name, :path
+    
+    include Comparable
+    include Broadway::Resourceful
+    include Broadway::Readable
+    include Broadway::Sortable
+    include Broadway::Taggable
+    include Broadway::Configurable      
+    
+    def initialize(resource, name, options = {})
+      self.resource = resource
+      self.name     = name
+      self.data     = options.recursively_symbolize_keys!
+      self.path     = options.delete(:path)
+      options.each do |k,v|
+        self.send("#{k}=", v) if self.respond_to?(k)
+      end
+      
+      self.title ||= Broadway::File.file_name(self.path).titleize
+    end
+    
+    def site
+      resource.site
+    end
+  end
+end

data/lib/broadway/resources/configuration.rb

@@ -0,0 +1,114 @@
+module Broadway
+  class Configuration
+    attr_accessor :settings, :site
+    # Default options. Overriden by values in _settings.yml or command-line opts.
+    # (Strings rather symbols used for compatability with YAML)
+    DEFAULTS = {
+      :auto           => false,
+      :server         => false,
+      :server_port    => 4000,
+
+      :source         => ".",
+      :settings       => "_config.yml",
+      :destination    => "_site",
+
+      :lsi            => false,
+      :pygments       => false,
+      :markdown       => "rdiscount",
+      :permalink      => "pretty",
+      :url_type       => "relative",
+      :url            => "http://localhost:4567",
+      :locales        => "locales",
+      :language       => "en-US",
+
+      :maruku         => {
+        :use_tex      => false,
+        :use_divs     => false,
+        :png_engine   => "blahtex",
+        :png_dir      => "images/latex",
+        :png_url      => "/images/latex"
+      },
+
+      :layouts        => "_layouts",
+      :posts_include  => [".textile", ".markdown"],
+      :theme_path     => "themes",
+      :theme_versions => ["main"]
+    } unless defined?(Broadway::Configuration::DEFAULTS)
+    
+    
+    def initialize(site, overrides)
+      self.site     = site
+      self.settings = merge(overrides)
+    end
+    
+    def merge(overrides)
+      DEFAULTS.deep_merge(read(overrides)).merge(overrides)
+    end
+    
+    def get(path)
+      result = settings
+      path.to_s.split(".").each { |node| result = result[node.to_sym] if result }
+      result.nil? ? "" : result
+    end
+    
+    def read(overrides)
+      overrides     = overrides.recursively_symbolize_keys!
+      # _settings.yml may override default source location, but until
+      # then, we need to know where to look for _settings.yml
+      source        = overrides[:source] || DEFAULTS[:source]
+      settings_file = overrides[:settings] || DEFAULTS[:settings]
+      settings_file = ::File.join(source, settings_file) unless ::File.exists?(settings_file)
+      # Get configuration from <source>/_config.yml
+      begin
+        settings    = YAML.load_file(settings_file).recursively_symbolize_keys!
+        raise "Invalid configuration - #{settings_file}" if !settings.is_a?(Hash)
+        #$stdout.puts "Configuration from #{settings_file}"
+      rescue => err
+        puts err.inspect
+        #$stderr.puts "WARNING: Could not read configuration. Using defaults (and options)."
+        #$stderr.puts "\t" + err.to_s
+        settings    = {}
+      end
+      
+      settings
+    end
+    
+    def merge_extra_settings!(settings)
+      locale = ::File.join(settings[:locales], "#{settings[:language]}.yml")
+
+      settings.merge!(YAML.load_file(locale)) if ::File.exists?(locale)
+      
+      settings_dir = ::File.join(settings[:source], "settings")
+      return unless ::File.exists?(settings_dir)
+      Dir.glob("#{settings_dir}/**/*").each do |file|
+        next if ::File.directory?(file)
+        path = file.gsub(/settings\//, "").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 =~ /\//
+          settings[name] ||= {}
+          target = settings[name]
+          name = path.split("/").last
+        else
+          target = settings
+        end
+        if target.has_key?(name)
+          target[name].merge!(data)
+        else
+          target[name] = data
+        end
+      end
+    end
+    
+    def setup
+    end
+  end
+end