zzot-semi-static 0.0.2

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

data/lib/semi-static/snippet.rb

@@ -0,0 +1,12 @@
+module SemiStatic
+    class Snippet < Base
+        include Convertable
+        
+        attr_reader :name
+        
+        def initialize(site, path)
+            super
+            @name = File.basename(source_path, source_ext)
+        end
+    end
+end

data/lib/semi-static/statistics.rb

@@ -0,0 +1,45 @@
+module SemiStatic
+    class Statistics
+        def initialize
+            self.reset
+        end
+        
+        def reset
+            @data = Hash.new { |hash,key| hash[key] = Hash.new }
+        end
+        
+        def record(category, item)
+            raise ArgumentError unless block_given?
+            before = Time.now
+            result = yield
+            @data[category][item] = Time.now - before
+            return result
+        end
+        
+        def display
+            # details = {}
+            @data.each do |category,items|
+                next if category == :site
+                sum = 0; items.values.each { |time| sum += time }
+                list = items.sort { |l,r| l.last <=> r.last }
+                
+                if list.length > 1
+                    printf "%10s c:%-3d sum:%9.6f min:%.6f max:%.6f avg:%.6f\n",
+                           category, items.length, sum, list.first.last,
+                           list.last.last, sum / items.length
+                    # details[category] = list.reverse.first(5).collect { |pair| { pair.first => pair.last } }
+                else
+                    printf "%10s c:%-3d sum:%9.6f\n", category, items.length, sum
+                end
+            end
+            puts '---'
+            @data[:site].each { |cat,time| printf "%15s %9.6f\n", cat.to_s.capitalize, time }
+            
+            # unless details.empty?
+            #     puts '---'
+            #     puts
+            #     puts details.to_yaml
+            # end
+        end
+    end
+end

data/lib/semi-static/stylesheet.rb

@@ -0,0 +1,33 @@
+module SemiStatic
+    class Stylesheet < Base
+        attr_reader :name, :options, :output_dir, :output_path
+        
+        def initialize(site, name, options={})
+            path = "#{name}.sass"
+            path = "#{name}.css" unless File.file?(path)
+            super(site, path)
+            
+            @name, @options = name, options
+            @output_dir = 'css'
+            @output_path = "#{output_dir}/#{name}.css"
+        end
+        
+        def load
+            super
+            Dir.chdir(File.dirname(full_source_path)) do
+                @content = case source_ext
+                when '.sass'
+                    Sass::Engine.new(source_content, :filename => source_path).render
+                when '.css'
+                    source_content
+                else
+                    raise ArgumentError, "Unsupported format: #{self.source_path}"
+                end
+            end
+        end
+        
+        def render
+            @content
+        end
+    end
+end

data/test/helper.rb

@@ -0,0 +1,111 @@
+$VERBOSE = false # Haml creates a lot of noise with this set
+
+require 'tempfile'
+require 'test/unit'
+require "#{File.dirname __FILE__}/../lib/semi-static"
+
+class Test::Unit::TestCase
+    TEST_SOURCE_DIR = File.join(File.dirname(__FILE__), 'source')
+    TEST_OUTPUT_DIR = File.join(File.dirname(__FILE__), 'output')
+    
+    def with_test_site
+        raise ArgumentError, "block required" unless block_given?
+        site = SemiStatic::Site.open(TEST_SOURCE_DIR) do |site|
+            assert_not_nil site
+            yield site
+        end
+    end
+    
+    def with_test_cli
+        raise ArgumentError, "block required" unless block_given?
+        cli = SemiStatic::CLI.new
+        cli.source_dir = TEST_SOURCE_DIR
+        cli.output_dir = TEST_OUTPUT_DIR
+        yield cli
+    end
+    
+    def with_test_site_page(page_name)
+        raise ArgumentError, "block required" unless block_given?
+        with_test_site do |site|
+            page = site.pages[page_name]
+            assert_not_nil page
+            yield site, page
+        end
+    end
+    
+    def with_test_site_post(post_name)
+        raise ArgumentError, "block required" unless block_given?
+        with_test_site do |site|
+            post = site.posts[post_name]
+            assert_not_nil post
+            yield site, post
+        end
+    end
+    
+    def ref(name)
+        path = File.join File.dirname(__FILE__), 'ref', name
+        return File.read(path)
+    end
+    
+    def out(path)
+        path = File.join File.dirname(__FILE__), 'output', path
+        return File.read(path)
+    end
+    
+    def diff(left, right, options={})
+        Tempfile.open('left') do |t1|
+            t1.write left
+            t1.close
+            Tempfile.open('right') do |t2|
+                t2.write right
+                t2.close
+                
+                cmd = 'diff -ub -I \'^[[:space:]]*$\''
+                
+                cmd << " --label '#{options[:left]}'" if options.include?(:left)
+                cmd << " #{t1.path}"
+                
+                cmd << " --label '#{options[:right]}'" if options.include?(:right)
+                cmd << " #{t2.path}"
+                
+                return `#{cmd}`
+            end
+        end
+    end
+
+    def assert_equal_diff(expected, actual, diff_options={})
+        msg = diff expected, actual, diff_options
+        assert_block(msg) { expected == actual }
+    end
+    
+    def assert_render_equal_ref(ref_name, renderable, render_options={}, diff_options={})
+        expected = ref(ref_name)
+        actual = renderable.render(render_options)
+        diff_options = { :left => ref_name, :right => renderable.name }.merge diff_options
+
+        # diff_options[:left] = ref_name unless diff_options.include?(:left)
+        # diff_options[:right] = renderable.output_path unless diff_options.include?(:right)
+        
+        msg = diff expected, actual, diff_options
+        assert_block(msg) { $?.success? }
+    end
+    
+    def assert_directory(path, msg=nil)
+        msg = build_message msg, "Expected to be a directory: <?>", path
+        assert_block(msg) { File.directory? path }
+    end
+    
+    def assert_file(path, msg=nil)
+        msg = build_message msg, "Expected to be a regular file: <?>", path
+        assert_block(msg) { File.file? path }
+    end
+    
+    def assert_file_equal_ref(ref_name, out_path, diff_options={})
+        expected = ref(ref_name)
+        actual = out(out_path)
+        diff_options = { :left => ref_name, :right => out_path }.merge diff_options
+        
+        msg = diff expected, actual, diff_options
+        assert_block(msg) { $?.success? }
+    end
+end