broadway 0.0.3.5 → 0.1.0

data/lib/broadway/resources/file.rb

@@ -0,0 +1,88 @@
+require 'rdiscount'
+require 'redcloth'
+module Broadway
+
+  class File
+    attr_accessor :site, :path, :directory, :extension, :categories, :name, :slug, :parent, :date
+    
+    SRC_MATCHER = /^(.+\/)*(?:(\d+-\d+-\d+)-)?(.*)\.([^.]+)$/
+    URL_MATCHER = /^(.+\/)*(.*)$/
+    
+    def initialize(site, options = {})
+      self.site = site
+      self.path = options[:file] || options[:path]
+
+      site_source = self.site.source
+      self.name   = ::File.basename(self.path)
+      self.directory  = ::File.dirname(self.path)
+      
+      n, cats, date, slug, extension = *self.path.match(SRC_MATCHER)
+      
+      self.parent     = self.directory.gsub(/#{site_source}/, "").squeeze("/")
+      self.date       = Time.parse(date) if date
+      
+      base            = self.parent.blank? ? "" : self.parent
+      
+      self.categories = base.split('/').reject { |x| x.empty? }
+      self.slug       = slug
+      self.extension  = extension
+    end
+    
+    def header
+      content = IO.read(self.path)
+      
+      if content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m        
+        YAML.load($1)
+      else
+        {}
+      end
+    end
+    
+    def read(attribute = nil)
+      content = IO.read(self.path)
+      if content =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        if attribute
+          output = YAML.load($1)[attribute] || ""
+          return output
+        end
+        content = content[($1.size + $2.size)..-1]
+      end
+      content
+    end
+    
+    def render(attribute = nil, extension = self.extension)
+      content = read(attribute)
+      case extension.to_s
+      when "markdown", "md"
+        content = RDiscount.new(content).to_html
+      when "textile"
+        content = RedCloth.new(content).to_html
+      end
+      content
+    end
+    
+    def full_path
+      ::File.expand_path(self.path)
+    end
+    
+    def write(dest)
+      FileUtils.mkdir_p(File.join(dest, File.dirname(directory)))
+      FileUtils.cp(@path, File.join(dest, directory))
+    end
+    
+    def inspect
+      "#<Broadway:File @path=#{self.path.inspect}>"
+    end
+    
+    class << self
+      def file_name(full_path)
+        ::File.basename(full_path).split(".").first
+      end
+      
+      def file_ext(full_path)
+        ::File.extname(full_path).gsub(".", "")
+      end
+    end
+  end
+  
+end

data/lib/broadway/resources/layout.rb

@@ -0,0 +1,28 @@
+module Broadway
+  class Layout
+    attr_accessor :action, :file, :resource
+    
+    def initialize(attributes)
+      
+    end
+    
+    def template(theme = "")
+      # first check if it's in the posts directory (where textile files are)
+      path = File.join(file.directory, action).squeeze("/")
+      exists = false
+      extensions = %w(html haml erb html.haml html.erb)
+      extensions.each do |ext|
+        exists = true if File.exists?("#{path}.#{ext}")
+      end
+      path if exists
+    end
+    
+    def kind
+      if file.extension =~ /(haml|erb)/
+        $1
+      else
+        "file"
+      end
+    end
+  end
+end

data/lib/broadway/resources/link.rb

@@ -0,0 +1,16 @@
+module Broadway
+  class Link
+    include Comparable
+    include Broadway::Processable
+    include Broadway::Convertible
+    include Broadway::Configurable
+    include Broadway::Resourceful
+    include Broadway::Hierarchical
+    include Broadway::Sortable
+    include Broadway::Taggable
+    
+    # link category is the menu it's in, or null
+    attr_accessor :href, :rel, :target, :resource, :categories
+    
+  end
+end

data/lib/broadway/resources/post.rb

@@ -0,0 +1,63 @@
+module Broadway
+
+  class Post
+    include Comparable
+    include Broadway::Processable
+    include Broadway::Convertible
+    include Broadway::Resourceful
+    include Broadway::Readable
+    include Broadway::Configurable
+    include Broadway::Sluggable
+    include Broadway::Sortable
+    include Broadway::Taggable
+    include Broadway::Layoutable
+    include Broadway::Assetable
+    include Broadway::Hierarchical
+    include Broadway::Publishable
+    include Broadway::Themeable
+    
+    def sluggify
+      {
+        "year"       => "",# date ? date.strftime("%Y") : "",
+        "month"      => "",# date ? date.strftime("%m") : "",
+        "day"        => "",# date ? date.strftime("%d") : "",
+        "title"      => kind == "page" ? "" : slug.value,
+        "categories" => categories.join('/') # page is "categories[0..-2].join('/')"
+      }
+    end
+    
+    def to_hash
+      { "title"      => self.title,
+        "url"        => self.url,
+        "date"       => self.date,
+        "id"         => self.id,
+        "categories" => self.categories,
+        "tags"       => self.tags,
+        "content"    => self.content }.deep_merge(self.data)
+    end
+    
+    def format
+      extension
+    end
+    def updated_at
+      date
+    end
+    alias created_at updated_at
+    def body
+      read
+    end
+    
+    def description
+      unless @description
+        if data["description"]
+          @description = data["description"]
+        else
+          @description = "" # read
+        end
+      end
+
+      @description
+    end
+    
+  end
+end

data/lib/broadway/resources/site.rb

@@ -0,0 +1,164 @@
+module Broadway
+
+  class Site
+    include Broadway::Resourceful
+    include Broadway::Processable
+    include Broadway::Configurable
+    
+    attr_accessor :posts, :links, :assets, :layouts, :files, :categories, :tags, :configuration, :roots
+    
+    def initialize(settings)
+      self.processor = Broadway::Processor::Site.new(self, settings)
+    end
+    
+    def build!
+      processor.build
+    end
+    
+    def generate!
+      processor.generate
+    end
+    
+    def generate(&block)
+      processor.generate(&block)
+    end
+    
+    def url
+      settings[:url] || "http://localhost"
+    end
+    
+    def index_path
+      settings[:index_path]
+    end
+    
+    def views_path
+      settings[:views_path]
+    end
+    
+    def public_path
+      settings[:public_path]
+    end
+    
+    def setting(path)
+      configuration.get(path)
+    end
+    
+    def settings
+      configuration.settings
+    end
+    
+    def data
+      settings
+    end
+    
+    def title
+      settings[:title]
+    end
+    
+    def language
+      settings[:language]
+    end
+    
+    def permalink_style
+      settings[:permalink].to_sym
+    end
+    
+    def setup
+      configuration.setup
+    end
+    
+    def source
+      self.settings[:source]
+    end
+    
+    def posts_path
+      self.settings[:posts]
+    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
+      server.render
+    end
+    
+    def find(type, attributes)
+      result = []
+      self.send(type.to_s.pluralize).each do |resource|
+        failed_to_match = false
+        attributes.each do |method, value|
+          if resource.respond_to?(method)
+            failed_to_match = (resource.send(method) != value)
+          else
+            failed_to_match = !resource.send(method.to_s.pluralize).include?(value)
+          end
+          break if failed_to_match
+        end
+        result << resource unless failed_to_match
+      end
+      result
+    end
+    
+    def first(type, attributes)
+      find(type, attributes).first
+    end
+    
+    %w(post layout asset link file).each do |type|
+      define_method "#{type}_roots" do |attributes|
+        find(type.pluralize, attributes).select { |resource| resource.parent.nil? }
+      end
+      
+      define_method "count_#{type}_roots" do |attributes|
+        send("#{type}_roots", attributes).length
+      end
+      
+      define_method "find_#{type}" do |attributes|
+        first(type, attributes)
+      end
+      
+      define_method "find_#{type.pluralize}" do |attributes|
+        find(type, attributes)
+      end
+      
+      %w(category path tag title).each do |property|
+        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
+        
+        define_method "count_#{type.pluralize}_by_#{property}" do |value|
+          find(type.to_sym, property => value).length
+        end
+        
+        define_method "#{type}_roots_by_#{property}" do |value|
+          send("#{type}_roots", property => value)
+        end
+        
+        define_method "count_#{type}_roots_by_#{property}" do |value|
+          send("count_#{type}_roots", property => value)
+        end
+      end
+    end
+    
+    def num_posts
+      posts.length
+    end
+    
+    def num_pages
+      pages.length
+    end
+    
+    def pages
+      posts.select { |post| post.kind == "page" }
+    end
+    
+    def menu(name)
+      link_roots_by_category(name)
+    end
+  end
+end

data/lib/broadway/resources/slug.rb

@@ -0,0 +1,69 @@
+module Broadway
+  class Slug
+    attr_accessor :resource, :value, :scope
+    
+    class << self
+      attr_accessor :styles
+      
+      def default_styles
+        {
+          :category => "/:categories/:slug",
+          :date => "/:categories/:slug.:format",
+          :category_and_date => "/:categories/:year/:month/:day/:slug",
+          :page => "/:categories/:slug"
+        }
+      end
+    end
+    
+    def initialize(slug, resource)
+      self.value     = slug
+      self.resource  = resource
+    end
+    
+    def permalink
+      resource.permalink
+    end
+    
+    def site
+      resource.site
+    end
+    
+    def template
+      case self.site.permalink_style
+      when :pretty
+        "/:categories/:year/:month/:day/:title"
+      when :none
+        "/:categories/:title.html"
+      when :date
+        "/:categories/:year/:month/:day/:title.html"
+      else
+        self.site.permalink_style.to_s
+      end
+    end
+    
+    def path
+      @path ||= permalink
+      @path ||= resource.sluggify.inject(template) do |result, token|
+        result.gsub(/:#{token.first}/, token.last.nested_parameterize)
+      end.gsub(/#{site.posts_path}/, "").squeeze("/").gsub(/\/$/, "")
+      @path
+    end
+    
+    def url
+      ::File.join(site.url, path)
+    end
+    
+    def scope
+      path.split("/")[0..-2].join("/")
+    end
+    
+    def titleize
+      self.value.split('-').select { |w| w.capitalize! || w }.join(' ')
+    end
+    
+    def to_s
+      path
+    end
+    
+  end
+end

data/lib/broadway/sinatra/app.rb

@@ -0,0 +1,21 @@
+require "sinatra/base"
+Dir[File.dirname(__FILE__) + '/helpers/*'].each { |file| require file if File.extname(file) =~ /\.rb/ }
+
+helpers do
+  include Broadway::Sinatra::CollectionHelper
+  include Broadway::Sinatra::PartialHelper
+  include Broadway::Sinatra::TextHelper
+  
+  def site
+    SITE
+  end
+end
+
+# must define the SITE constant
+def site
+  SITE
+end
+
+def c(path)
+  site.setting(path)
+end