zzot-zzot-semi-static 0.0.1

data/lib/semi-static/core_ext/hash.rb

@@ -0,0 +1,19 @@
+module SemiStatic
+    module CoreExt #:nodoc:
+        module Hash
+            # Replace self with a hash whose keys have been converted to symbols.
+            def symbolize_keys
+                hash = to_a.inject({}) do |memo,item|
+                    key, value = item
+                    memo[key.to_sym] = value
+                    memo
+                end
+                replace(hash)
+            end
+        end
+    end
+end
+
+class Hash #:nodoc:
+    include SemiStatic::CoreExt::Hash
+end

data/lib/semi-static/index.rb

@@ -0,0 +1,12 @@
+module SemiStatic
+    class Index < Base
+        include Convertable
+        
+        attr_accessor :posts, :context
+        
+        def initialize(site, path)
+            super
+            @metadata = [ :layout ]
+        end
+    end
+end

data/lib/semi-static/layout.rb

@@ -0,0 +1,14 @@
+module SemiStatic
+    class Layout < Base
+        include Convertable
+        
+        attr_reader :name
+        
+        def initialize(site, path)
+            super
+            @metadata = [ :layout ]
+            
+            @name = File.basename(source_path, source_ext)
+        end
+    end
+end

data/lib/semi-static/page.rb

@@ -0,0 +1,58 @@
+module SemiStatic
+    # Page represents a static page in the site.  Page itself only
+    # represents a single source file, but can have a Layout and any number
+    # of Snippets, each of which has its own source file.  Page's modification
+    # time is the most recent of itself, its layout, and any Snippets used.
+    class Page < Base
+        include Convertable
+        
+        ##
+        # The Page's output directory
+        attr_reader :output_dir
+
+        ##
+        # The Page's output path
+        attr_reader :output_path
+
+        ##
+        # The Page's name
+        attr_reader :name
+
+        ##
+        # The Page's URI
+        attr_reader :uri
+        
+        ##
+        # Initializes a new Page
+        #
+        # +site+:: The Site object we belong to
+        # +path+:: The relative path to the source file
+        def initialize(site, path)
+            super
+            @metadata = [ :title, :layout ]
+            
+            src_base = File.basename(source_path, source_ext)
+            output_ext = File.extname(src_base)
+            if output_ext.nil? || output_ext.empty?
+                output_ext = '.html'
+            else
+                src_base = File.basename(src_base, output_ext)
+            end
+            @output_dir, src_file = File.split(source_path)
+            
+            if output_dir == '.'
+                prefix = ''
+            else
+                prefix = "#{output_dir}/"
+            end
+            @name = "/#{prefix}#{src_base}"
+            @output_path = "#{prefix}#{src_base}#{output_ext}"
+            
+            if src_base == 'index'
+                @uri = "/#{output_dir}/"
+            else
+                @uri = "/#{output_path}"
+            end
+        end
+    end
+end

data/lib/semi-static/post.rb

@@ -0,0 +1,133 @@
+module SemiStatic
+    # Post represents a single post in the site.  Post itself only
+    # represents a single source file, but can have a Layout and any number
+    # of Snippets, each of which has its own source file.  Post's modification
+    # time is the most recent of itself, its Layout, and any Snippets used.
+    class Post < Base
+        include Convertable
+        
+        ##
+        # The Post's name
+        attr_reader :name
+        
+        ##
+        # The Post's Category
+        attr_reader :category
+        
+        ##
+        # The Post's Tags
+        attr_reader :tags
+        
+        ##
+        # The Post's output directory
+        attr_reader :output_dir
+        
+        ##
+        # The Post's output path
+        attr_reader :output_path
+        
+        ##
+        # The Post's slug
+        attr_reader :slug
+        
+        ##
+        # The Post's URI
+        attr_reader :uri
+        
+        ##
+        # Date Post was created
+        attr_reader :created
+        
+        ##
+        # Date the Post was last updated
+        attr_reader :updated
+        
+        # attr_reader :year
+        # attr_reader :month
+        # attr_reader :day
+        
+        ##
+        # Initializes a new Post
+        #
+        # +site+:: The Site object we belong to
+        # +path+:: The relative path to the source file
+        def initialize(site, path)
+            super
+            @metadata = [ :title, :layout, :author ]
+            
+            @name = File.basename(source_path, source_ext)
+            
+            @category = site.categories[source_metadata[:category]]
+            @category << self
+            
+            @tags = []
+            unless source_metadata[:tags].nil?
+                for tag in source_metadata[:tags]
+                    @tags << site.tags[tag]
+                    @tags.last << self
+                end
+            end
+            
+            if name =~ /^(\d+-\d+-\d+)-(.+)$/
+                @created = Time.parse $1
+                @updated ||= @created
+                @slug = $2
+                @output_dir = created.strftime('%Y/%m/%d')
+                @output_path = File.join output_dir, "#{slug}.html"
+                @uri = "/#{output_path}"
+            else
+                raise ArgumentError, "Bad file name: #{name}"
+            end
+        end
+        
+        ##
+        # Get the Post's unique identifier
+        def id
+            name.gsub /-/, '_'
+        end
+        
+        ##
+        # Get the Post's permalink
+        def permalink
+            return "#{uri}"
+        end
+        
+        # def comments_link
+        #     "#{uri}#comments"
+        # end
+        # 
+        # def comment_count
+        #     0
+        # end
+        
+        ##
+        # Formatted date the Post was published (i.e., "March 15, 2009")
+        def date
+            created.strftime '%B %e, %Y'
+        end
+        
+        ##
+        # Year the Post was published as a String (i.e., "2009")
+        def year
+            created.strftime '%Y'
+        end
+        
+        ##
+        # Month the Post was published as a String (i.e., "03")
+        def month
+            created.strftime '%m'
+        end
+        
+        ##
+        # Day the Post was published as a String (i.e., "15")
+        def day
+            created.strftime '%d'
+        end
+        
+        ##
+        # Does the post have a Time set?
+        def time?
+            false
+        end
+    end
+end

data/lib/semi-static/posts.rb

@@ -0,0 +1,110 @@
+module SemiStatic
+    class Posts
+        attr_reader :site, :posts, :names, :indices
+        
+        def initialize(site)
+            @site = site
+            @posts = []
+            @names = {}
+            @indices = Set.new
+        end
+        
+        NAME_RE = /^([0-9]{4})-([0-9]{2})-([0-9]{2})-(.*)/
+        
+        def <<(source_path)
+            unless File.file?(source_path)
+                $stderr.puts "[#{source_path}]"
+                return
+            end
+            if source_path =~ NAME_RE
+                post = Post.new site, source_path
+                self.posts.push post
+                names[post.name] = post
+                indices << File.join(post.year, post.month, post.day)
+                indices << File.join(post.year, post.month)
+                indices << post.year
+            else
+                $stderr.puts "{#{source_path}}"
+            end
+        end
+        
+        def chop!(count)
+            raise ArgumentError unless count > 0
+            posts = self.posts.first(count)
+            @posts = []
+            @names = {}
+            @indices = Set.new
+            for post in posts
+                self.posts << post
+                names[post.name] = post
+                indices << File.join(post.year, post.month, post.day)
+                indices << File.join(post.year, post.month)
+                indices << post.year
+            end
+        end
+        
+        def length
+            self.posts.length
+        end
+        
+        def first(n=nil)
+            if n.nil?
+                self.posts.first
+            else
+                self.posts.first(n)
+            end
+        end
+        
+        def last(n=nil)
+            if n.nil?
+                self.posts.last
+            else
+                self.posts.last(n).reverse
+            end
+        end
+        
+        def from(year, month=nil, day=nil)
+            if year.is_a?(String) && month.nil? && day.nil?
+                date = year.split('/', 3)
+                year, month, day = date.collect { |c| c.to_i }
+            end
+            
+            if month.nil?
+                from = Time.local year
+                to = Time.local(year + 1) - 1
+            elsif day.nil?
+                from = Time.local year, month
+                if month == 12
+                    to = Time.local(year + 1, 1) - 1
+                else
+                    to = Time.local(year, month + 1) - 1
+                end
+            else
+                from = Time.local year, month, day
+                to = Time.local year, month, day, 23, 59, 59
+            end
+            range = from..to
+            result = self.posts.select { |p| range.include?(p.created) }
+            class << result
+                alias_method :last_without_reverse, :last
+                def last_with_reverse(n=nil)
+                    last_without_reverse(n).reverse
+                end
+                alias_method :last, :last_with_reverse
+            end
+            return result
+        end
+        
+        def [](name)
+            return self.names[name]
+        end
+        
+        def each(&block)
+            self.posts.each(&block)
+        end
+        
+        def each_index(&block)
+            indices.each(&block)
+        end
+    end
+end

data/lib/semi-static/pygmentize.rb

@@ -0,0 +1,54 @@
+module SemiStatic
+    module Pygmentize
+        LEXER_FORMAT = /^[a-z]+$/i
+        
+        def pygmentize(code, lang)
+            Pygmentize.pygmentize code, lang
+        end
+
+        def self.pygmentize(code, lang)
+            unless lang =~ LEXER_FORMAT
+                raise ArgumentError, "invalid lexer: #{lang}"
+            end
+        
+            Tempfile.open('semistatic-pygmentize') do |temp|
+                temp.write code
+                temp.close
+            
+                cmd = "pygmentize -f html -l #{lang} #{temp.path}"
+                IO.popen(cmd) do |proc|
+                    return proc.read
+                end
+            end
+        end
+        
+        @@enabled = false
+        def self.enabled
+            @@enabled
+        end
+        def self.enabled=(value)
+            @@enabled = value
+        end
+    end
+end
+
+module MaRuKu #:nodoc:
+    module Out #:nodoc:
+        module HTML #:nodoc:
+            alias_method :to_html_code_without_pygments, :to_html_code
+            def to_html_code_with_pygments
+                if SemiStatic::Pygmentize.enabled
+                    source = self.raw_code
+                    lang = self.attributes[:lang] || 'text'
+                    html = SemiStatic::Pygmentize.pygmentize source, lang
+                    doc = Document.new html, :respect_whitespace => :all
+
+                    add_ws doc.root
+                else
+                    to_html_code_without_pygments
+                end
+            end
+            alias_method :to_html_code, :to_html_code_with_pygments
+        end
+    end
+end

data/lib/semi-static/site.rb

@@ -0,0 +1,232 @@
+module SemiStatic
+    class Site
+        attr_accessor :clean_first, :check_mtime, :quick_mode, :show_statistics
+        
+        attr_reader :time
+        attr_reader :source_dir, :layouts, :pages, :posts, :snippets, :categories, :tags
+        attr_reader :year_index, :month_index, :day_index
+        attr_reader :metadata, :stylesheets
+        
+        attr_reader :stats
+        
+        def initialize(source_dir)
+            @clean_first = false
+            @first_pass = true
+            @quick_mode = false
+            @check_mtime = false
+            @show_statistics = false
+            @source_dir = source_dir
+            @time = Time.now
+            @stats = Statistics.new
+            stats.record(:site, :load) { load }
+        end
+        
+        def self.open(source_dir)
+            raise ArugmentError, "block required" unless block_given?
+            site = SemiStatic::Site.new source_dir
+            yield site
+        end
+        
+        def output(path)
+            if @first_pass
+                @first_pass = false
+                FileUtils.rm_rf path if clean_first
+            end
+            FileUtils.mkdir_p path
+            
+            if quick_mode
+                posts.chop! 20
+            end
+            @stats.reset
+            
+            unless metadata.nil? || !metadata['static'].is_a?(Array)
+                stats.record(:site, :static) do
+                    for dir in metadata['static']
+                        FileUtils.cp_r File.join(source_dir, dir), File.join(path, dir)
+                    end
+                end
+            end
+            
+            before = Time.now
+            Dir.chdir(path) do
+                stats.record(:site, :pages) do
+                    pages.each do |name, page|
+                        FileUtils.mkdir_p page.output_dir unless File.directory?(page.output_dir)
+                        if check_mtime
+                            if File.file?(page.output_path) && File.mtime(page.output_path) > page.source_mtime
+                                next
+                            end
+                            page.load
+                        end
+                        File.open(page.output_path, 'w') { |f| f.write page.render }
+                    end
+                end
+                
+                stats.record(:site, :posts) do
+                    posts.each do |post|
+                        FileUtils.mkdir_p post.output_dir unless File.directory?(post.output_dir)
+                        if check_mtime
+                            if File.file?(post.output_path) && File.mtime(post.output_path) > post.source_mtime
+                                next
+                            end
+                            post.load
+                        end
+                        File.open(post.output_path, 'w') { |f| f.write post.render }
+                    end
+                end
+                
+                stats.record(:site, :stylesheets) do
+                    unless stylesheets.nil?
+                        stylesheets.each do |name, stylesheet|
+                            FileUtils.mkdir_p stylesheet.output_dir unless File.directory?(stylesheet.output_dir)
+                            if check_mtime
+                                if File.file?(stylesheet.output_path) && File.mtime(stylesheet.output_path) > stylesheet.source_mtime
+                                    next
+                                end
+                                stylesheet.load
+                            end
+                            File.open(stylesheet.output_path, 'w') { |f| f.write stylesheet.render }
+                        end
+                    end
+                end
+                
+                stats.record(:site, :indices) do
+                    unless year_index.nil? && month_index.nil? && day_index.nil?
+                        posts.each_index do |dir|
+                            posts = self.posts.from(dir)
+                            Dir.chdir(dir) do
+                                context = dir.split('/').collect { |c| c.to_i }
+                                date_index = case context.length
+                                when 1
+                                    year_index
+                                when 2
+                                    month_index
+                                when 3
+                                    day_index
+                                else
+                                    nil
+                                end
+                                date_index.posts = posts
+                                date_index.context = Time.local *context
+                                File.open('index.html', 'w') { |f| f.write date_index.render }
+                            end
+                        end
+                    end
+                end
+            end
+            
+            self.stats.display if show_statistics
+        end
+        
+      private
+        def with_source_files(subdir, pattern)
+            raise ArgumentError unless block_given?
+            Dir.chdir(File.join(source_dir, subdir)) do
+                Dir.glob(pattern) do |path|
+                    yield path
+                end
+            end
+        end
+        
+        def config_file_path
+            File.join source_dir, 'semi.yml'
+        end
+        
+        def load
+            if File.file?(config_file_path)
+                @metadata = File.open(config_file_path) { |io| YAML.load io }
+            end
+            load_stylesheets
+            load_layouts
+            load_pages
+            load_posts
+            load_snippets
+            load_indices
+        end
+        
+        def load_stylesheets
+            unless metadata.nil? || metadata['stylesheets'].nil?
+                Dir.chdir(File.join(source_dir, 'stylesheets')) do
+                    config = metadata['stylesheets']
+                    if config.is_a?(Array)
+                        config = config.inject({}) { |hash,name| hash[name] = {}; hash }
+                    end
+                    @stylesheets = config.inject({}) do |hash,pair|
+                        name, opts = pair
+                        hash[name.to_sym] = Stylesheet.new self, name, opts
+                        hash
+                    end
+                end
+            end
+        end
+        
+        def load_layouts
+            @layouts = Hash.new
+            with_source_files('layouts', '*.{haml,erb}') do |path|
+                next unless File.file?(path)
+                
+                file = File.basename(path)
+                if file[0..0] != '_'
+                    layout = Layout.new self, path
+                    self.layouts[layout.name.to_sym] = layout
+                end
+            end
+        end
+        
+        def load_pages
+            @pages = Hash.new
+            with_source_files('pages', '**/*.{html,haml,erb,txt,md,markdown}') do |path|
+                next if File.directory?(path)
+                next unless path.split('/').grep(/^_/).empty?
+                
+                page = Page.new self, path
+                self.pages[page.name] = page
+            end
+        end
+        
+        def load_posts
+            @posts = Posts.new(self)
+            @categories = Categories.new
+            @tags = Categories.new
+            with_source_files('posts', '*.{html,haml,erb,txt,md,markdown}') do |path|
+                posts << path
+            end
+            posts.posts.sort! { |l,r| l.created <=> r.created }
+        end
+        
+        def load_snippets
+            return unless File.directory?(File.join(source_dir, 'snippets'))
+            
+            @snippets = Hash.new
+            with_source_files('snippets', '*.{html,haml,erb,txt,md,markdown}') do |path|
+                next unless File.file?(path)
+                next unless ('a'..'z').include?(path[0..0].downcase)
+                
+                snippet = Snippet.new self, path
+                self.snippets[snippet.name] = snippet
+            end
+        end
+        
+        def load_indices
+            return unless File.directory?(File.join(source_dir, 'indices'))
+            
+            with_source_files('indices', '{year,month,day}.{haml,erb}') do |path|
+                # puts path
+                next unless File.file?(path)
+                
+                file = File.basename(path)
+                name = File.basename(file, File.extname(file))
+                case name
+                when 'year'
+                    @year_index = Index.new self, path
+                when 'month'
+                    @month_index = Index.new self, path
+                when 'day'
+                    @day_index = Index.new self, path
+                else
+                    raise ArgumentError, "Unexpected index file: #{path}"
+                end
+            end
+        end
+    end
+end