henshin 0.3.0 → 0.4.0

data/lib/henshin/ext.rb

@@ -1,53 +1,8 @@
-require 'thread'
-
-module Enumerable
-  
-  # Like an each loop but runs each task in parallel
-  # Which will probably be very useful for writing and rendering
-  # from http://t-a-w.blogspot.com/2010/05/very-simple-parallelization-with-ruby.html
-  def each_parallel( n=10 )
-    todo = Queue.new
-    ts = (1..n).map do
-      Thread.new do 
-        while x = todo.deq
-          Exception.ignoring_exceptions { yield(x[0]) }
-        end
-      end
-    end
-    each {|x| todo << [x] }
-    n.times { todo << nil }
-    ts.each {|t| t.join }
-  end
-  
-end
-
-def Exception.ignoring_exceptions
-  begin
-    yield
-  rescue Exception => e
-    STDERR.puts e
-  end
-end
-
-
-class Hash
-
-  # stripped straight out of rails
-  # converts string keys to symbol keys
-  # from http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html
-  def to_options
-    inject({}) do |options, (key, value)|
-      options[(key.to_sym rescue key) || key] = value
-      options
-    end
-  end
-  
-end
-
-
 class String
   
   # Turns the string to a slug
+  #
+  # @return [String] the created slug
   def slugify
     slug = self.clone
     slug.gsub!(/[']+/, '')
@@ -58,21 +13,43 @@ class String
     slug
   end
   
-  # Gets the extension from a string
-  def extension
-    parts = self.split('.')
-    parts[parts.size-1]
+  # Converts the String to a Pathname object
+  #  
+  # @return [Pathname]
+  def to_p
+    Pathname.new(self)    
   end
   
-  # Gets the directory from a string
-  def directory
-    self =~ /((\.?\/?[a-zA-Z0-9 _-]+\/)+)/
-    $1
+  # Checks whether it is a valid number in a string, or not
+  # @see http://www.railsforum.com/viewtopic.php?id=19081
+  def numeric?
+    true if Float(self) rescue false
   end
   
-  # Gets the filename from a string
-  def file_name
-    self.dup.gsub(/([a-zA-Z0-9_-]+\/)/, '')
+end
+
+class Hash
+
+  # Converts string hash keys to symbol keys
+  #
+  # @see http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/Hash/Keys.html
+  #   stolen from rails
+  def to_options
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
   end
+
+end
+
+class Pathname
   
+  # Gets just the extension of the pathname
+  #
+  # @return [String] the extension of the path, without the '.'
+  def extension
+    self.extname[1..-1]
+  end
+
 end

data/lib/henshin/gen.rb

@@ -1,133 +1,148 @@
 module Henshin
   
-  # This is the main class for all pages, posts, sass, etc, that need to be run through a plugin
+  # This is the main class for files which need to be rendered with plugins
   class Gen
     
-    attr_accessor :path, :extension, :content, :layout, :title
-    attr_accessor :site, :config, :renderer, :data, :output
+    attr_accessor :path, :data, :content, :site, :to_inject, :generators
     
-    def initialize( path, site, data=nil )
+    # Creates a new instance of Gen
+    #
+    # @param [Pathname] path to the file
+    # @param [Site] the site the gen belongs to
+    # @param [Hash] an optional payload to add when rendered
+    def initialize(path, site, to_inject=nil)
       @path = path
       @site = site
-      @config = site.config
-      @extension = path.extension
-      @data = data
+      @data = {}
+      @content = ''
+      @to_inject = to_inject
+      @generators = []
+      
+      @data['input'] = @path.extension
     end
     
     
     ##
-    # Processes the file
-    def process
-      self.read_yaml
+    # Reads the file if it exists, if not gets generators and layout, then cleans up @data
+    def read
+      self.read_file if @path.exist?
+      self.get_generators
+      self.get_layout
+      
+      # tidy up data
+      @data['output'] ||= @data['input']
+      self
     end
     
-    # Reads the files yaml frontmatter and uses it to override some settings, then grabs content
-    def read_yaml
-      file = File.read(self.path)
-
+    # Opens the file and reads the yaml frontmatter if any exists, and
+    # also gets the contents of the file.
+    def read_file
+      file = @path.read
+    
       if file =~ /^(---\s*\n.*?\n?^---\s*$\n?)/m
-        override = YAML.load_file(@path).to_options
-        self.override(override)
+        override = YAML.load_file(@path)
+        @data = @data.merge(override)
         @content = file[$1.size..-1]
       else
         @content = file
-      end  
+      end 
     end
     
-    # Uses the loaded data to override settings
-    #
-    # @param [Hash] override data to override settings with
-    def override( override )
-      @title  = override[:title]                    if override[:title]
-      @layout = @site.layouts[ override[:layout] ]  if override[:layout]
+    # Finds the correct plugins to render this gen and sets output
+    def get_generators
+      @site.plugins[:generators].each do |k, v|
+        if k == @data['input'] || k == '*'
+          @generators << v
+          @data['output'] ||= v.extensions[:output]
+          @data['ignore_layout'] ||= (v.config['ignore_layouts'] ? true : false)
+        end
+      end
+      @generators.sort!
     end
     
+    # Gets the correct layout for the gen, or the default if none exists.
+    # It gets the default layout from options.yaml or looks for one called 
+    # 'main' or 'default'.
+    def get_layout
+      if @data['layout']
+        @data['layout'] = site.layouts[ @data['layout'] ]
+      else
+        # get default layout
+        @data['layout'] = site.layouts[(site.config['layout'] || 'main' || 'default')]
+      end
+    end
     
     ##
-    # Renders the files content
+    # Renders the files content using the generators from #get_generators and all layout parsers. 
+    # Passed through layout parser twice so that markup in the gen is processed.
     def render
-      ignore_layout = false
-      plugins = []
-     
-      config[:plugins][:generators].each do |k, v|
-        if k == @extension || k == '*'
-          plugins << v
-        end
-      end
-      plugins.sort!
-      
-      plugins.each do |plugin|
+      @generators.each do |plugin|
         @content = plugin.generate(@content)
-        @output = plugin.extensions[:output] if plugin.extensions[:output]
-        ignore_layout = true if plugin.config[:ignore_layouts]
       end
-      
-      @layout ||= site.layouts[ site.config[:layout] ]
-      unless ignore_layout || @layout.nil?
-        config[:plugins][:layout_parsers].each do |plugin|
-          @content = plugin.generate( @layout, self.payload )
-          @content = plugin.generate( @content, self.payload )
+
+      unless @data['ignore_layout'] || @data['layout'].nil?
+        @site.plugins[:layoutors].each do |plugin|
+          @content = plugin.generate(@data['layout'], self.payload)
+          @content = plugin.generate(@content, self.payload)
         end
       end
       
     end
     
-    # Creates the data to be sent to the layout engine. Adds optional data if available
+    # Creates the data to be sent to the layout engine. Adds optional data if available.
     #
     # @return [Hash] the payload for the layout engine
     def payload
       hash = {
         'yield' => @content,
         'gen'   => self.to_hash,
-        'site'  => @site.payload['site'],
+        'site'  => @site.payload['site']
       }
-      hash[ @data[:name] ] = @data[:payload] if @data
-      
+      hash[ @to_inject[:name] ] = @to_inject[:payload] if @to_inject
       hash
     end
     
-    # Turns all of the post data into a hash
+    # Turns all of the gens data into a hash.
     #
     # @return [Hash]
     def to_hash
-      { 
-        'title'      => @title,
-        'permalink'  => self.permalink,
-        'url'        => self.url,
-        'content'    => @content 
-      }
+      @data['content'] = @content
+      @data['url'] = self.url
+      @data['permalink'] = self.permalink
+      @data
     end
     
     
     ##
     # Writes the file to the correct place
     def write
-      write_path = File.join( config[:root], config[:target], @path[config[:root].size..-1] )
-      
-      # change extension if necessary
-      write_path.gsub!(".#{@extension}", ".#{@output}") if @output
-
-      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
     
-    # Returns the permalink for the gen
+    # @return [String] the permalink of the gen
     def permalink
-      @path[config[:root].size..-1]
+      rel = @path.relative_path_from(@site.root).to_s
+      rel.gsub!(".#{@data['input']}", ".#{@data['output']}")
+      File.join(@site.base, rel)
     end
     
-    # Returns the (pretty) url for the gen
+    # @return [String] the pretty url for the gen
     def url
-      if config[:permalink].include? "/index.html"
-        self.permalink[0..-11]
+      if @site.config['permalink'].include?("/index.html") && @data['output'] == 'html'
+        self.permalink.to_p.dirname.to_s
       else
         self.permalink
       end
     end
     
+    # @return [Pathname] path to write the file to
+    def write_path
+      @site.target + self.permalink[1..-1]
+    end
     
-    # Needed to sort the posts by date, newest first
+    # Sorts gens based on permalink only
     def <=>( other )
       self.permalink <=> other.permalink
     end

data/lib/henshin/labels.rb

@@ -0,0 +1,144 @@
+module Henshin
+
+  # This is basically a front for tags and categories, because they are so similar
+  # it makes sense to condense them into one class!
+  #
+  class Labels < Array
+  
+    attr_accessor :base, :site
+    
+    # Creates a new instance of labels
+    #
+    # @param [String] base the base part of the urls, eg. category, tag
+    # @param [Site] site that the labels belong to
+    def initialize(base, site)
+      @base = base
+      @site = site
+    end
+    
+    # Adds the given post to the correct category object in the array
+    # or creates the category and adds the post to that
+    #
+    # @param [Post] post to be added
+    # @param [String, Array] k label(s) to be added to
+    #
+    # @todo Make it a bit more abstract, actually hard coding stuff in will
+    #   lead to problems!
+    def <<(post)
+      k = nil
+      if base == 'tag'
+        k = post.data['tags']
+      elsif base == 'category'
+        k = [post.data['category']]
+      end
+      
+      k.each do |j|
+        unless self.map{|i| i.name}.include?(j)
+          super Henshin::Label.new(j, @base, @site)
+        end
+        i = self.find_index {|i| i.name == j}
+        self[i].posts << post
+      end
+    end
+    
+    # Converts the labels to a hash for use in a layout parser
+    def to_hash
+      r = []
+      self.each do |i|
+        r << i.to_hash
+      end
+      r
+    end
+    
+    # @return [String] permalink for label index
+    def permalink
+      File.join(@site.base, @base, "index.html")
+    end
+    
+    # @return [String] base url for label
+    def url
+      File.join(@site.base, @base)
+    end
+    
+    # Need a fake path where the file would have been so as to 
+    # trick the gen into constructing the correct paths
+    #
+    # @return [Pathname] the path for the gen
+    def fake_write_path
+      @site.root + self.permalink[1..-1]
+    end
+    
+    # Writes the category index, then writes the individual
+    # category pages
+    def write
+      if @site.layouts["#{@base}_index"]
+        page = Gen.new(self.fake_write_path, @site)
+        page.read
+        page.data['layout'] = @site.layouts["#{@base}_index"]
+        
+        page.render
+        page.write
+      end
+      if @site.layouts["#{@base}_page"]
+        self.each {|label| label.write }
+      end
+    end
+  
+  end
+  
+  class Label
+    attr_accessor :name, :posts, :site
+    
+    # Creates a new instance of label
+    #
+    # @param [String] name of the label
+    # @param [String] base of the url for the label (see Labels#initialize)
+    # @param [Site] site that the label belongs to
+    def initialize(name, base, site)
+      @name = name
+      @base = base      
+      @site = site
+      @posts = []
+    end
+    
+    # Converts the label to a hash
+    def to_hash
+      hash = {
+        'name' => @name,
+        'posts' => @posts.sort.collect {|i| i.to_hash},
+        'url' => self.url
+      }
+    end
+    
+    # @return [String] permalink for the label
+    def permalink
+      File.join(@site.base, @base, "#{@name.slugify}/index.html")
+    end
+    
+    # @return [String] url for the label
+    def url
+      File.join(@site.base, @base, "#{@name.slugify}")
+    end
+    
+    # @see Labels#fake_write_path
+    def fake_write_path
+      @site.root + self.permalink[1..-1]
+    end
+    
+    # Writes the label page
+    def write
+      payload = {:name => @base, :payload => self.to_hash}
+      page = Gen.new(self.fake_write_path, @site, payload)
+      page.read
+      page.data['layout'] = @site.layouts["#{@base}_page"]
+      
+      page.render
+      page.write
+    end
+    
+    def inspect
+      "#<Label:#{@base}/#{@name}>"
+    end
+  end
+  
+end