henshin 0.3.0 → 0.4.0

data/lib/henshin/site.rb

@@ -1,31 +1,120 @@
 module Henshin
 
   class Site
-  
-    attr_accessor :posts, :gens, :statics, :archive, :tags, :categories
-    attr_accessor :layouts, :config
     
-    def initialize( config )
+    # @return [Hash] the configuration made up of the override, options.yaml and Henshin::Defaults
+    attr_accessor :config
+    
+    # @return [Pathname] the path to the site to generate from where the command is executed
+    attr_accessor :root
+    
+    # @return [Pathname] the path to where the finished site should be written
+    attr_accessor :target
+    
+    # @return [String] a path which should be prepended to all urls
+    attr_accessor :base
+    
+    # @return [Array]
+    attr_accessor :gens, :posts, :statics
+    
+    # @return [Hash{String => String}]
+    attr_accessor :layouts
+    
+    # @return [Tags]
+    attr_accessor :tags
+    
+    # @return [Categories]
+    attr_accessor :categories
+    
+    # @return [Archive]
+    attr_accessor :archive
+    
+    # @return [Hash{String => Plugin}]
+    attr_accessor :plugins
+    
+    # A new instance of site
+    #
+    # @param [Hash{String => Object}] override data to override loaded options
+    # @return [self]
+    def initialize(override={})
       self.reset
-      @config = config
+      self.configure(override)
+      self.load_plugins
+      self
     end
     
-    # Resets everything
-    def reset
-      @posts = []
-      @gens = []
+    # Resets all instance variables, except +config+ and +plugins+ as these shouldn't
+    # need to be reloaded each time.
+    #
+    # @return [self]
+    def reset     
+      @gens    = []
+      @posts   = []
       @statics = []
+      @layouts = {}
       
-      @archive = Archive.new( self )
-      @tags = Hash.new { |h, k| h[k] = Tag.new(k) }
-      @categories = Hash.new { |h, k| h[k] = Category.new(k) }
+      @archive    = Archive.new(self)
+      @tags       = Labels.new('tag', self)
+      @categories = Labels.new('category', self)
+      self
+    end
+    
+    # Creates the configuration hash by merging defaults, supplied options and options 
+    # read from the 'options.yaml' file. Then sets root, target, base and appends 
+    # special directories to @config['exclude']
+    #
+    # @param [Hash] override to override other set options
+    def configure(override)  
+      @config = {}
+      config_file = File.join((override['root'] || Defaults['root']), '/options.yaml')
       
-      @layouts = {}
+      # change target to represent given root, only if root given
+      if override['root'] && !override['target']
+        override['target'] = File.join(override['root'], Defaults['target'])
+      end
+      
+      begin
+        config = YAML.load_file(config_file)
+        @config = Defaults.merge(config).merge(override)
+      rescue => e
+        $stderr.puts "\nCould not read configuration, falling back to defaults..."
+        $stderr.puts "-> #{e.to_s}"
+        @config = Defaults.merge(override)
+      end
+      @root = @config['root'].to_p
+      @target = @config['target'].to_p
+      
+      @base = @config['base'] || "/"
+      @base = '/' + @base unless @base[0] == '/' # need to make sure it starts with slash
+      
+      @config['exclude'] << '/_site' << '/plugins'
     end
     
+    # Requires each plugin in @config['plugins'], then loads and sorts them into
+    # +plugins+ by type
+    def load_plugins
+      @plugins = {:generators => {}, :layoutors => []}
+    
+      @config['plugins'].each do |plugin|
+        begin
+          require File.join('henshin', 'plugins', plugin)
+        rescue LoadError
+          require File.join(@root, 'plugins', plugin)
+        end
+      end
+      
+      Henshin::Generator.subclasses.each do |plugin|
+        plugin = plugin.new(self)
+        plugin.extensions[:input].each do |ext|
+          @plugins[:generators][ext] = plugin
+        end
+      end
+      
+      @plugins[:layoutors] = Henshin::Layoutor.subclasses.map {|l| l.new(self)}.sort
+    end
     
     ##
-    # Read, process, render and write everything
+    # Read, process, render and write
     def build
       self.reset
       self.read
@@ -37,45 +126,48 @@ module Henshin
     
     ##
     # Reads all necessary files and puts them into the necessary arrays
+    #
+    # @return [self]
     def read
       self.read_layouts
       self.read_posts
       self.read_gens
       self.read_statics
+      self
     end
     
-    # Adds all items in 'layouts' to the layouts array
+    # Adds all items in '/layouts' to the layouts array
     def read_layouts
-      path = File.join(@config[:root], 'layouts')
+      path = File.join(@root, 'layouts')
       Dir.glob(path + '/*.*').each do |layout|
         layout =~ /([a-zA-Z0-9 _-]+)\.([a-zA-Z0-9-]+)/
         @layouts[$1] = File.open(layout, 'r') {|f| f.read}
       end
     end
     
-    # Adds all items in 'posts' to the posts array
+    # Adds all items in '/posts' to the posts array
     def read_posts
-      path = File.join(@config[:root], 'posts')
+      path = File.join(@root, 'posts')
       Dir.glob(path + '/**/*.*').each do |post|
-        @posts << Post.new(post, self)
+        @posts << Post.new(post.to_p, self).read
       end
     end
     
     # Adds all files that need to be run through a plugin in an array
     def read_gens
-      files = Dir.glob( File.join(@config[:root], '**', '*.*') )
+      files = Dir.glob( File.join(@root, '**', '*.*') )
       gens = files.select {|i| gen?(i) }
-      gens.each do |g|
-        @gens << Gen.new(g, self)
+      gens.each do |gen|
+        @gens << Gen.new(gen.to_p, self).read
       end
     end
     
     # Adds all static files to an array
     def read_statics
-      files = Dir.glob( File.join(@config[:root], '**', '*.*') )
+      files = Dir.glob( File.join(@root, '**', '*.*') )
       static = files.select {|i| static?(i) }
-      static.each do |s|
-        @statics << Static.new(s, self)
+      static.each do |static|
+        @statics << Static.new(static.to_p, self)
       end
     end
 
@@ -83,153 +175,84 @@ module Henshin
     ## 
     # Processes all of the necessary files
     def process
-      @posts.each_parallel {|p| p.process}
       @posts.sort!
-      @gens.each_parallel {|g| g.process}
+      @gens.sort!
       
-      self.build_tags
-      self.build_categories
-      self.build_archive
+      @posts.each do |post|
+        @tags << post if post.data['tags']
+        @categories << post if post.data['category']
+        @archive << post
+      end
+      self
     end
     
     # @return [Hash] the payload for the layout engine
     def payload
-      {
-        'site' => {
-          'author' => @config[:author],
-          'title' => @config[:title],
-          'description' => @config[:description],
-          'time_zone' => @config[:time_zone],
-          'created_at' => Time.now,
-          'posts' => @posts.collect{|i| i.to_hash},
-          'tags' => @tags.collect {|k, t| t.to_hash},
-          'categories' => @categories.collect {|k, t| t.to_hash},
-          'archive' => @archive.to_hash
-        }
-      }
-    end
-    
-    # Creates tags from posts and adds them to @tags
-    def build_tags
-      @posts.each do |p|
-        p.tags.each do |t|
-          @tags[t].posts << p
-        end
-      end
-    end
-    
-    # Create categories from posts and add to @categories
-    def build_categories
-      @posts.each do |p|
-        @categories[p.category].posts << p unless p.category.nil?
-      end
-    end
-    
-    # @return [Hash] archive hash
-    def build_archive
-      @posts.each {|p| @archive.add_post(p)}
+      r = {'site' => @config}
+      r['site']['created_at'] = Time.now
+      r['site']['posts'] = @posts.collect{|i| i.to_hash}
+      r['site']['tags'] = @tags.to_hash
+      r['site']['categories'] = @categories.to_hash
+      r['site']['archive'] = @archive.to_hash
+      r
     end
     
     ##
     # Renders the files
     def render
-      @posts.each_parallel {|p| p.render}
-      @gens.each {|g| g.render}
+      @posts.each {|post| post.render}
+      @gens.each {|gen| gen.render}
+      
+      self
     end
     
     
     ##
     # Writes the files
     def write
-      @posts.each_parallel {|p| p.write}
-      @gens.each_parallel {|g| g.write}
-      @statics.each_parallel {|s| s.write}
+      @posts.each {|post| post.write}
+      @gens.each {|gen| gen.write}
+      @statics.each {|static| static.write}
       
       @archive.write
-      self.write_tags
-      self.write_categories
-    end
-    
-    # Writes the necessary pages for tags, but only if the correct layouts are present
-    def write_tags
-      if @layouts['tag_index']
-        write_path = File.join( @config[:root], 'tags', 'index.html' )
-      
-        tag_index = Gen.new(write_path, self)
-        tag_index.layout = @layouts['tag_index']
-        
-        tag_index.render
-        tag_index.write
-      end
-      
-      if @layouts['tag_page']
-        @tags.each do |n, tag|
-          write_path = File.join( @config[:root], 'tags', tag.name, 'index.html' )
-          
-          payload = {:name => 'tag', :payload => tag.to_hash}
-          tag_page = Gen.new(write_path, self, payload)
-          tag_page.layout = @layouts['tag_page']
-          
-          tag_page.render
-          tag_page.write
-        end
-      end
-    end
-    
-    # Writes the necessary pages for categories, but only if the correct layouts are present
-    def write_categories
-      if @layouts['category_index']
-        write_path = File.join( @config[:root], 'categories', 'index.html' )
-        
-        category_index = Gen.new(write_path, self)
-        category_index.layout = @layouts['category_index']
-        
-        category_index.render
-        category_index.write
-      end
-      
-      if @layouts['category_page']
-        @categories.each do |n, category|
-          write_path = File.join( @config[:root], 'categories', category.name, 'index.html' )
-          
-          payload = {:name => 'category', :payload => category.to_hash}
-          category_page = Gen.new(write_path, self, payload)
-          category_page.layout = @layouts['category_page']
-          
-          category_page.render
-          category_page.write
-        end
-      end
+      @tags.write
+      @categories.write
+      self
     end
     
     
-    # @return [Bool]
+    # @param [String] path to test
+    # @return [Bool] whether the path points to a static
     def static?( path )
       !( layout?(path) || post?(path) || gen?(path) || ignored?(path) )
     end
     
-    # @return [Bool]
+    # @param [String] path to test
+    # @return [Bool] whether the path points to a layout
     def layout?( path )
       path.include?('layouts/') && !ignored?(path)
     end
     
-    # @return [Bool]
+    # @param [String] path to test
+    # @return [Bool] whether the path points to a post
     def post?( path )
       path.include?('posts/') && !ignored?(path)
     end
     
-    # @return [Bool]
+    # @param [String] path to test
+    # @return [Bool] whether the path points to a gen
     def gen?( path )
       return false if post?(path) || layout?(path) || ignored?(path)
-      return true if @config[:plugins][:generators].has_key? path.extension 
+      return true if @plugins[:generators].has_key? path.to_p.extname[1..-1]
       return true if File.open(path, "r").read(3) == "---"
       false
     end
     
-    # @return [Bool]
+    # @param [String] path to test
+    # @return [Bool] whether the path points to a file which should be ignored
     def ignored?( path )
-      ignored = ['/options.yaml'] + @config[:exclude]
-      ignored.collect! {|i| File.join(@config[:root], i)}
+      ignored = ['/options.yaml'] + @config['exclude']
+      ignored.collect! {|i| File.join(@root, i)}
       ignored.each do |i|
         return true if path.include? i
       end

data/lib/henshin/static.rb

@@ -2,25 +2,27 @@ module Henshin
 
   class Static
     
-    attr_accessor :path, :site, :config, :content
+    attr_accessor :path, :site, :content
     
     def initialize( path, site )
       @path = path
       @site = site
-      @config = site.config
-      @content = File.read( path )
+      @content = File.read(path)
     end
     
     ##
     # Writes the file to the correct place
     def write
-      write_path = File.join( config[:root], config[:target], @path[ config[:root].size..-1 ] )
-      
-      FileUtils.mkdir_p File.join( write_path.directory )
-      file = File.new( File.join( write_path ), "w" )
-      file.puts( @content )
+      FileUtils.mkdir_p(self.write_path.dirname)
+      file = File.new(self.write_path, "w")
+      file.puts(@content)
     end
     
+    # @return [Pathname] path to write the file
+    def write_path
+      rel = @path.relative_path_from(@site.root)
+      @site.target + File.join(@site.base, rel)[1..-1]
+    end
     
     def inspect
       "#<Static:#{@path}>"

data/test/helper.rb

@@ -1,22 +1,23 @@
-require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'rr'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'henshin'
+require File.dirname(__FILE__) + '/../lib/henshin'
 
 class Test::Unit::TestCase
 
   include RR::Adapters::TestUnit
   
+  def site_override
+    {'root' => root_dir, 'target' => target_dir}
+  end
+  
   def root_dir
     File.join(File.dirname(__FILE__), 'site')
   end
   
   def target_dir
-    "_site"
+    File.join(root_dir, "_site")
   end
 
   def remove_site
@@ -24,9 +25,20 @@ class Test::Unit::TestCase
   end
   
   def new_site
-    override = {:root => File.join(File.dirname(__FILE__), 'site'), :target => '_site'}
-    config = Henshin.configure(override)
-    Henshin::Site.new(config)
+    Henshin::Site.new(site_override)
+  end
+  
+  
+  
+  # Determines whether +instance+ is a +klass+ using #is_a?. 
+  # This is similar to assert_instance_of except it doesn't 
+  # have to be an instance of +klass+ just an instance of a 
+  # decendant of +klass+.
+  #
+  # @param [Class] klass the klass to test for
+  # @param [Object] instance of the object to test
+  def assert_is_a(klass, instance)
+    assert instance.is_a?(klass), "Expected #{instance} to be a #{klass}"
   end
   
 end