henshin 0.3.0 → 0.4.0

data/lib/henshin/plugin.rb

@@ -1,63 +1,100 @@
 module Henshin
-  class StandardPlugin
-    # the main class for plugins to inherit from eg
+
+  class Plugin
+   
+    # @return [Hash{:input, :output => Array, String}]
+    #  the file extensions that can be read by the plugin and the extension
+    #  of the output
     #
-    #   class MyPlugin < NoName::StandardPlugin
-    #
-    # or it can (and should) inherit a subclass from below
+    # @example
+    #  
+    #  @extensions = {:input => ['md', 'markdown'],
+    #                 :output => 'html'}
+    attr_accessor :extensions
     
-    attr_accessor :extensions, :config
+    # @return [Hash{Symbol => Object}]
+    #  the config for the plugin
+    attr_accessor :config
     
-    # Defaults = {}
+    # @return [Integer]
+    #  The plugins are sorted on priority, high priority plugins are called first.
+    #  You could really use any number, but stick to 1 to 5.
+    attr_accessor :priority
     
-    def initialize
-      # inputs are the file types it will take
-      # output should be the type it creates
+    # Create a new instance of Plugin
+    #
+    # @param [Site] site that the plugin belongs to
+    def initialize(site)
       @extensions = {:input => [],
                      :output => ''}
+      @config = {}
+      @priority = 3
     end
     
-    def configure( override )
-      if Defaults
-        if override 
-          @config = Defaults.merge(override) 
+    # Finds all classes that subclass this particular class
+    #
+    # @return [Array] an array of class objects
+    # @see http://www.ruby-forum.com/topic/163430 
+    #   modified from the answer given on ruby-forum by black eyes
+    def self.subclasses     
+      r = Henshin.constants.find_all do |c_klass| 
+        if (c_klass != c_klass.upcase) && (Henshin.const_get(c_klass).is_a?(Class))
+          self > Henshin.const_get(c_klass)
         else
-          @config = Defaults
+          nil
         end
-      elsif override
-        @config = override
       end
+      r.collect {|k| Henshin.const_get(k)}
     end
     
+    # Plugins are sorted by priority
     def <=>(other)
       self.priority <=> other.priority
     end
     
-    # Uncomment to have the plugin loaded
-    # Henshin.register! self, :standard_plugin
-  end
+  end 
   
-  class Generator < StandardPlugin
-    # a plugin which returns anything*
+  # Generator is the plugin type for processing things like markdown
+  #
+  # @example
+  #
+  #  class MyMarkupPlugin < Henshin::Generator
+  #    def generate(content)
+  #      MyMarkup.do_stuff(content)
+  #    end
+  #  end
+  #
+  class Generator < Plugin
     
+    # This is the method that is called when rendering content
+    #
+    # @param [String] content to be rendered
+    # @return [String]
     def generate( content )
-      # return string
     end
-    
-    # Uncomment to have the plugin loaded
-    # Henshin.register! self, :generator
+
   end
   
-  class LayoutParser < StandardPlugin
-    # a plugin which returns anything*
+  # Layoutor is the plugin type for things like liquid
+  #
+  # @example
+  #
+  #  class MyLayoutPlugin < Henshin::Layoutor
+  #    def generate(content, data)
+  #      MyLayout.do_stuff(content).render(data)
+  #    end
+  #  end
+  #
+  class Layoutor < Plugin
     
-    # given a layout and data to insert
-    def generate( layout, data )
-      # return string
+    # This is the method called when rendering content
+    #
+    # @param [String] content to be rendered
+    # @param [Hash] data to be put into the content
+    # @return [String]
+    def generate( content, data )
     end
     
-    # Uncomment to have the plugin loaded
-    # Henshin.register! self, :generator
   end
   
 end

data/lib/henshin/plugins/highlight.rb

@@ -1,31 +1,24 @@
-require 'henshin/plugin'
 require 'simplabs/highlight'
 
-class HighlightPlugin < Henshin::Generator
-  
-  attr_accessor :priority, :config, :extensions
-  
-  def initialize
-    @extensions = {:input => ['*']}
-    @config = {}
-    @priority = 1
-  end
-  
-  def configure( override )
-    @config.merge!(override) if override
-  end
-  
-  def generate( content )
-    content =~ /(\$highlight)\s+(.+)((\n.*)+)(\$end)/
-    if $1
-      lang = $2.to_sym
-      code = $3[1..-1] # removes first new line
-      insert = '<pre><code>' + Simplabs::Highlight.highlight(lang, code) + '</code></pre>'
-      content.gsub(/(\$highlight.*\$end)/m, insert)
-    else
-      content
+module Henshin
+  class HighlightPlugin < Generator
+    
+    def initialize(site)
+      @extensions = {:input => ['*']}
+      @config = {}
+      @priority = 1
+    end
+    
+    def generate( content )
+      content =~ /(\$highlight)\s+(.+)((\n.*)+)(\$end)/
+      if $1
+        lang = $2.to_sym
+        code = $3[1..-1] # removes first new line
+        insert = '<pre><code>' + Simplabs::Highlight.highlight(lang, code) + '</code></pre>'
+        content.gsub(/(\$highlight.*\$end)/m, insert)
+      else
+        content
+      end
     end
   end
-  
-  Henshin.register! self
 end

data/lib/henshin/plugins/liquid.rb

@@ -1,63 +1,61 @@
-require 'henshin/plugin'
 require 'liquid'
 
-class LiquidPlugin < Henshin::LayoutParser
-
-  attr_accessor :config
-  
-  def initialize
-    @config = {}
-  end
-  
-  def configure( override )
-    @config.merge!(override) if override
-  end
-  
-  def generate( layout, data )
-    reg = {:include_dir => @config['include_dir']}
-    Liquid::Template.parse(layout).render(data, :registers => reg)
-  end
-  
-  module Filters
-    def date_to_string(dt)
-      dt.strftime "%d %b %Y"
-    end
+module Henshin
+  class LiquidPlugin < Layoutor
     
-    def date_to_long(dt)
-      dt.strftime "%d %B %Y at %H:%M"
-    end
-  
-    def time_to_string(dt)
-      dt.strtime "%H:%M"
+    def initialize(site)
+      @config = {}
+      
+      if site.config['liquid']
+        @config = site.config['liquid']
+        @config['include_dir'] = File.join(site.root, @config['include_dir'])
+      end
     end
     
-    def titlecase(str)
-      str.upcase
+    def generate( content, data )
+      reg = {:include_dir => @config['include_dir']}
+      Liquid::Template.parse(content).render(data, :registers => reg)
     end
     
-    def escape(str)
-      CGI::escape str
-    end
+    module Filters
+      def date_to_string(dt)
+        dt.strftime "%d %b %Y"
+      end
+      
+      def date_to_long(dt)
+        dt.strftime "%d %B %Y at %H:%M"
+      end
     
-    def escape_html(str)
-      CGI::escapeHTML str
-    end
-  end
-  Liquid::Template.register_filter(Filters)
-  
-  class Include < Liquid::Tag
-    def initialize(tag_name, file, tokens)
-      super
-      @file = file.strip
-    end
+      def time_to_string(dt)
+        dt.strtime "%H:%M"
+      end
+      
+      def titlecase(str)
+        str.upcase
+      end
+      
+      def escape(str)
+        CGI::escape str
+      end
+      
+      def escape_html(str)
+        CGI::escapeHTML str
+      end
+    end
+    Liquid::Template.register_filter(Filters)
+    
+    class Include < Liquid::Tag
+      def initialize(tag_name, file, tokens)
+        super
+        @file = file.strip
+      end
+      
+      def render(context)
+        include = File.join(context.registers[:include_dir], @file)
+        File.open(include, 'r') {|f| f.read}
+      end
+    end
+    Liquid::Template.register_tag('include', Include)
     
-    def render(context)
-      include = File.join(context.registers[:include_dir], @file)
-      File.open(include, 'r') {|f| f.read}
-    end
   end
-  Liquid::Template.register_tag('include', Include)
-  
-  Henshin.register! self, :liquid
 end
-

data/lib/henshin/plugins/maruku.rb

@@ -1,20 +1,18 @@
-require 'henshin/plugin'
 require 'maruku'
 
-class MarukuPlugin < Henshin::Generator
-  
-  attr_accessor :extensions, :config, :priority
-  
-  def initialize( override={} )
-    @extensions = {:input => ['markdown', 'mkdwn', 'md'],
-                   :output => 'html'}
-    @config = {}
-    @priority = 5
+module Henshin
+  class MarukuPlugin < Generator
+    
+    def initialize(site)
+      @extensions = {:input => ['markdown', 'mkdwn', 'md'],
+                     :output => 'html'}
+      @config = {}
+      @priority = 5
+    end
+    
+    def generate( content )
+      Maruku.new(content).to_html
+    end
+    
   end
-  
-  def generate( content )
-    Maruku.new(content).to_html
-  end
-  
-  Henshin.register! self
 end

data/lib/henshin/plugins/sass.rb

@@ -1,28 +1,24 @@
-require 'henshin/plugin'
 require 'sass'
 
-class SassPlugin < Henshin::Generator
+module Henshin
+  class SassPlugin < Generator
+    
+    def initialize(site)
+      @extensions = {:input => ['sass', 'scss'],
+                     :output => 'css'}
+      @config = {'ignore_layouts' => true,
+                 'style' => :nested,
+                 'load_paths' => Dir.glob((site.root + '*').to_s),
+                 'syntax' => :sass}
   
-  attr_accessor :extensions, :config, :priority
-  
-  Defaults = {:ignore_layouts => true,
-              :style => :nested}
-  
-  def initialize
-    @extensions = {:input => ['sass', 'scss'],
-                   :output => 'css'}
-    @config = {:ignore_layouts => true,
-               :style => :nested}
-    @priority = 5
-  end
-  
-  def configure( override )
-    @config.merge!(override) if override
-  end
-  
-  def generate( content )
-    Sass::Engine.new(content, @config).render
+      @config.merge!(site.config['sass']) if site.config['sass']
+      
+      @priority = 5
+    end
+    
+    def generate( content )
+      Sass::Engine.new(content, @config.to_options).render
+    end
+
   end
-  
-  Henshin.register! self, :sass
 end

data/lib/henshin/plugins/textile.rb

@@ -1,20 +1,18 @@
-require 'henshin/plugin'
 require 'redcloth'
 
-class TextilePlugin < Henshin::Generator
-  
-  attr_accessor :extensions, :config, :priority
-  
-  def initialize( override={} )
-    @extensions = {:input => ['textile'],
-                   :output => 'html'}
-    @config = {}
-    @priority = 5
-  end
-  
-  def generate( content )
-    RedCloth.new(content).to_html
+module Henshin
+  class TextilePlugin < Generator
+
+    def initialize(site)
+      @extensions = {:input => ['textile'],
+                     :output => 'html'}
+      @config = {}
+      @priority = 5
+    end
+    
+    def generate( content )
+      RedCloth.new(content).to_html
+    end
+    
   end
-  
-  Henshin.register! self
 end

data/lib/henshin/post.rb

@@ -2,112 +2,55 @@ module Henshin
 
   class Post < Gen
     
-    attr_accessor :title, :author, :tags, :category, :date
+    attr_accessor :path, :data, :content, :site, :layout, :generators
     
     def initialize( path, site )
       @path = path
       @site = site
-      @config = site.config
-      @extension = path.extension
-      @layout = site.layouts[ site.config[:layout] ]
-      @author = @config[:author]
-      @tags = []
-      @date = Time.now
+      
+      @content = ''
+      @data = {}
+      @generators = []
+      
+      @data['input'] = @path.extname[1..-1]
     end
     
     
     ##
-    # Processes the file
-    def process
+    # Reads the file
+    def read
       self.read_name
-      self.read_yaml
+      self.read_file if @path.exist?
+      self.get_generators
+      self.get_layout
+      
+      # now tidy up data
+      @data['output'] ||= @data['input']
+      @data['date'] = Time.parse(@data['date'])
+      @data['tags'] = @data['tags'].flatten.uniq if @data['tags']
+      self
     end
     
     # Reads the filename and extracts information from it
     def read_name
-    
-      parser = {'title' => '([a-zA-Z0-9 ]+)',
-                'title-with-dashes' => '([a-zA-Z0-9-]+)',
-                'date' => '(\d{4}-\d{2}-\d{2})',
-                'date-time' => '(\d{4}-\d{2}-\d{2} at \d{2}:\d{2})',
-                'xml-date-time' => '(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?((\+|-)\d{2}:\d{2})?)',
-                'category' => '([a-zA-Z0-9_ -]+)',
-                'extension' => "([a-zA-Z0-9_-]+)"}
       
-      file_parser = config[:file_name]
-      data_order = []
+      result = Parsey.parse(@path.to_s[(@site.root + 'posts').to_s.size..-1], @site.config['file_name'], Partials)
 
-      # put together regex
-      m = file_parser.gsub(/\{([a-z-]+)\}/) do
-        data_order << $1
-        parser[$1]
-      end
-      
-      # replace optional '<stuff>'
-      m.gsub!(/<(.+)>/) do
-        # this may lead to problems, well I say may...
-        data_order.unshift( 'optional' )
-        "(#{$1})?"
-      end
-
-      # convert string to actual regex
-      matcher = Regexp.new(m)
-      
-      override = {}
-      name = @path[ (config[:root]+'/posts/').size..-1 ]
-
-      file_data = name.match( matcher ).captures
-      file_data.each_with_index do |data, i|      
-        if data_order[i].include? 'title'
-          if data_order[i].include? 'dashes'
-            override[:title] = data.gsub(/-/, ' ')
-          else
-            override[:title] = data
+      result.each do |k, v|
+        unless v.nil?
+          case k
+            when 'title-with-dashes'
+              @data['title'] = v.gsub(/-/, ' ').titlecase
+            when 'title'
+              @data['title'] = v.titlecase
+            else
+              @data[k] = v
           end
-        elsif data_order[i].include? 'date'
-          override[:date] = data
-        elsif data_order[i].include? 'extension'
-          override[:extension] = data
-        elsif data_order[i].include? 'category'
-          override[:category] = data
         end
       end
-      self.override( override )
-    end
-    
-    # Reads the files yaml frontmatter and uses it to override some settings, then grabs content
-    def read_yaml
-      file = File.read(self.path)
-
-      if file =~ /^(---\s*\n.*?\n?^---\s*$\n?)/m
-        override = YAML.load_file(@path).to_options
-        self.override(override)
-        @content = file[$1.size..-1]
-      else
-        @content = file
-      end
-    end
-    
-    # Uses the loaded data to override settings
-    #
-    # @param [Hash] override data to override settings with
-    def override( override )
-      @title     = override[:title].titlecase         if override[:title]
-      @layout    = @site.layouts[ override[:layout] ] if override[:layout]
-      @date      = Time.parse( override[:date] )      if override[:date]
-      @tags      = override[:tags].split(', ')        if override[:tags]
-      @category  = override[:category]                if override[:category]
-      @author    = override[:author]                  if override[:author]
-      @extension = override[:extension]               if override[:extension]
-      @category  = override[:category]                if override[:category]
       
-      if override[:tags]
-        @tags << override[:tags].split(', ')
-        @tags.flatten!.uniq!
-      end
     end
     
-    
     # Creates the data to be sent to the layout engine
     #
     # @return [Hash] the payload for the layout engine
@@ -117,8 +60,8 @@ module Henshin
         'site'  => @site.payload['site'],
         'post'  => self.to_hash
       }
-      r['post']['next'] = self.next.to_hash if self.next
-      r['post']['prev'] = self.prev.to_hash if self.prev
+      #r['post']['next'] = self.next.to_hash if self.next
+      #r['post']['prev'] = self.prev.to_hash if self.prev
       r
     end
     
@@ -126,20 +69,34 @@ module Henshin
     #
     # @return [Hash]
     def to_hash
-      tags = []
-      @site.tags.select{ |t| @tags.include?(t) }.each do |k, tag|
-        tags << {'name' => tag.name, 'url' => tag.url}
+      if @hashed
+        @hashed
+      else
+        @hashed = @data.dup
+        @hashed['content'] = @content
+        @hashed['url'] = self.url
+        @hashed['permalink'] = self.permalink
+        
+        
+      
+        if @data['tags']
+          @hashed['tags'] = []
+          @site.tags.select{|t| @data['tags'].include?(t.name)}.each do |tag|
+            # can't call Tag#to_hash or it creates an infinite loop!
+            @hashed['tags'] << {'name' => tag.name, 'url' => tag.url}
+          end
+        end
+      
+        if @data['category']
+          @site.categories.each do |cat|
+            if cat.name == @data['category']
+              @hashed['category'] = {'name' => cat.name, 'url' => cat.url}
+            end
+          end
+        end
+      
+        @hashed
       end
-      { 
-        'title'      => @title,
-        'author'     => @author,
-        'permalink'  => self.permalink,
-        'url'        => self.url,
-        'date'       => @date,
-        'category'   => @category,
-        'tags'       => tags,
-        'content'    => @content
-      }
     end
     
     # Gets the post after this one
@@ -167,32 +124,22 @@ module Henshin
         end
       end
     end
-
-    
-    ##
-    # Writes the file to the correct place
-    def write
-      write_path = File.join( config[:root], config[:target], permalink )
-      FileUtils.mkdir_p write_path.directory
-      file = File.new( write_path, "w" )
-      file.puts( @content )
-    end
     
-    # Creates the permalink for the post
+    # @return [String] the permalink of the post
     def permalink
-      partials = {'year' => self.date.year,
-                  'month' => self.date.month,
-                  'date' => self.date.day,
-                  'title' => self.title.slugify,
-                  'category' => self.category || ''}
+      partials = {'year' => @data['date'].year,
+                  'month' => @data['date'].month,
+                  'date' => @data['date'].day,
+                  'title' => @data['title'].slugify,
+                  'category' => @data['category'] || ''}
                   
-      config[:permalink].gsub(/\{([a-z-]+)\}/) do
-        partials[$1]
-      end
+      perm = @site.config['permalink'].gsub(/\{([a-z-]+)\}/) { partials[$1] }
+      File.join(@site.base, perm)
     end
     
+    # Sorts on date first, then permalink if dates are equal
     def <=>(other)
-      s = self.date <=> other.date
+      s = @data['date'] <=> other.data['date']
       if s == 0
         self.permalink <=> other.permalink
       else