henshin 0.4.2 → 1.0.0.pre

data/lib/henshin/gen.rb

@@ -1,154 +0,0 @@
-module Henshin
-  
-  # This is the main class for files which need to be rendered with plugins
-  class Gen
-    
-    attr_accessor :path, :data, :content, :site, :to_inject, :generators
-    
-    # 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
-      @data = {}
-      @content = ''
-      @to_inject = to_inject
-      @generators = []
-      
-      @data['input'] = @path.extension
-    end
-    
-    
-    ##
-    # 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
-    
-    # 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)
-        @data = @data.merge(override)
-        @content = file[$1.size..-1]
-      else
-        @content = file
-      end 
-    end
-    
-    # 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 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
-      @generators.each do |plugin|
-        @content = plugin.generate(@content)
-      end
-
-      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.
-    #
-    # @return [Hash] the payload for the layout engine
-    def payload
-      hash = {
-        'yield' => @content,
-        'gen'   => self.to_hash,
-        'site'  => @site.payload['site']
-      }
-      hash[ @to_inject[:name] ] = @to_inject[:payload] if @to_inject
-      hash
-    end
-    
-    # Turns all of the gens data into a hash.
-    #
-    # @return [Hash]
-    def to_hash
-      @data['content'] = @content
-      @data['url'] = self.url
-      @data['permalink'] = self.permalink
-      @data
-    end
-    
-    
-    ##
-    # Writes the file to the correct place
-    def write
-      FileUtils.mkdir_p(self.write_path.dirname)
-      file = File.new(self.write_path, "w")
-      file.puts(@content)
-    end
-    
-    # @return [String] the permalink of the gen
-    def permalink
-      rel = @path.relative_path_from(@site.root).to_s
-      rel.gsub!(".#{@data['input']}", ".#{@data['output']}")
-      File.join(@site.base, rel)
-    end
-    
-    # @return [String] the pretty url for the gen
-    def url
-      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
-    
-    # Sorts gens based on permalink only
-    def <=>( other )
-      self.permalink <=> other.permalink
-    end
-    
-    def inspect
-      "#<Gen:#{@path}>"
-    end
-  end
-end

data/lib/henshin/labels.rb

@@ -1,144 +0,0 @@
-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

data/lib/henshin/plugin.rb

@@ -1,100 +0,0 @@
-module Henshin
-
-  class Plugin
-   
-    # @return [Hash{:input, :output => Array, String}]
-    #  the file extensions that can be read by the plugin and the extension
-    #  of the output
-    #
-    # @example
-    #  
-    #  @extensions = {:input => ['md', 'markdown'],
-    #                 :output => 'html'}
-    attr_accessor :extensions
-    
-    # @return [Hash{Symbol => Object}]
-    #  the config for the plugin
-    attr_accessor :config
-    
-    # @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
-    
-    # Create a new instance of Plugin
-    #
-    # @param [Site] site that the plugin belongs to
-    def initialize(site)
-      @extensions = {:input => [],
-                     :output => ''}
-      @config = {}
-      @priority = 3
-    end
-    
-    # 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
-          nil
-        end
-      end
-      r.collect {|k| Henshin.const_get(k)}
-    end
-    
-    # Plugins are sorted by priority
-    def <=>(other)
-      self.priority <=> other.priority
-    end
-    
-  end 
-  
-  # 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 )
-    end
-
-  end
-  
-  # 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
-    
-    # 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
-    
-  end
-  
-end

data/lib/henshin/plugins/highlight.rb

@@ -1,24 +0,0 @@
-require 'simplabs/highlight'
-
-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
-end

data/lib/henshin/plugins/liquid.rb

@@ -1,61 +0,0 @@
-require 'liquid'
-
-module Henshin
-  class LiquidPlugin < Layoutor
-    
-    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 generate( content, data )
-      reg = {:include_dir => @config['include_dir']}
-      Liquid::Template.parse(content).render(data, :registers => reg)
-    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 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)
-    
-  end
-end