henshin 0.4.2 → 1.0.0.pre

data/lib/henshin/files/abstract.rb

@@ -0,0 +1,102 @@
+module Henshin
+
+  class File
+
+    # @abstract You will want to implement {#raw_text}, {#path} and maybe
+    #   {#text}.
+    #
+    # This class implements all the functionality that is required to build or
+    # serve a file. {Abstract} instances do not relate to a file in the file
+    # system, use {Physical} in this case.
+    class Abstract
+
+      include  Henshin::Helpers, Safety, Comparable
+      extend   Attributes
+
+      attr_reader :site
+
+      def initialize(site)
+        @site = site.safe
+      end
+
+      # Simple version of text. This is raw in that it has not been run through
+      # a template. It may still have been passed through an ordinary rendering
+      # engine (for instance a Markdown engine).
+      #
+      # @return [String]
+      # @see #text
+      def raw_text
+        ""
+      end
+
+      # @return [String] Text to write to the file.
+      def text
+        raw_text
+      end
+
+      # @return [Path] Path to the file.
+      def path
+
+      end
+
+      # @return [String] The absolute url to the file.
+      def permalink
+        path.permalink
+      end
+
+      # @return [Pathname] A pretty url to the file, the permalink with
+      #   'index.html' stripped from the end generally.
+      def url
+        path.url
+      end
+
+      # @return [String] Extension for the file to be written.
+      def extension
+        path.extension
+      end
+
+      # Allow template to be set, needed for Template to work properly.
+      def template
+        @template || nil
+      end
+      attr_writer :template
+
+      # Writes the file.
+      #
+      # @param writer [#write] Object which is able to write text to a path.
+      def write(writer)
+        return unless writeable?
+        start = Time.now if Henshin.profile?
+        writer.write Pathname.new(permalink.sub(/^\//, '')), text
+        if Henshin.profile?
+          UI.wrote permalink, (Time.now - start)
+        else
+          UI.wrote permalink
+        end
+      rescue => e
+        Error.prettify("Error writing #{inspect}", e)
+      end
+
+      unsafe :write
+
+      # Compares the files based on their permalinks.
+      #
+      # @param other [File]
+      def <=>(other)
+        permalink <=> other.permalink
+      end
+
+      def inspect
+        "#<#{self.class} #{permalink}>"
+      end
+
+      private
+
+      # @return Whether this file should be written.
+      def writeable?
+        true
+      end
+
+    end
+  end
+end

data/lib/henshin/files/attributes.rb

@@ -0,0 +1,31 @@
+require 'set'
+
+module Henshin
+
+  class File
+
+    # Extend any module (classes will generally be inheriting from {Abstract} so
+    # will pick this up) with this module to gain the ability to set required
+    # yaml keys and default templates.
+    module Attributes
+
+      def requires(*keys)
+        @required ||= Set.new
+        @required  += keys
+      end
+
+      def required
+        @required || Set.new
+      end
+
+      def template(name)
+        @template = name
+      end
+
+      def default_template
+        @template
+      end
+
+    end
+  end
+end

data/lib/henshin/files/empty_template.rb

@@ -0,0 +1,24 @@
+module Henshin
+
+  class File
+    class EmptyTemplate < Abstract
+
+      def initialize
+        # ...
+      end
+
+      def raw_text
+        ""
+      end
+
+      def name
+        "none"
+      end
+
+      def render(*args)
+        ""
+      end
+
+    end
+  end
+end

data/lib/henshin/files/physical.rb

@@ -0,0 +1,117 @@
+module Henshin
+
+  class File
+
+    # A file physically located on the file system. A subclass of file will
+    # have a @path variable with it's location.
+    class Physical < Abstract
+
+      # Regular expression to match the text of the file, contains two match
+      # groups; the first matches the yaml part, the second any text.
+      YAML_REGEX = /\A---\n^(.*?)\n^---\n?(.*)\z/m
+
+      # @param site [Site] Site the file is in.
+      # @param path [Pathname] Path to the file.
+      def initialize(site, path)
+        @site = site.safe
+        @path = path
+      end
+
+      # Allow yaml attributes to be accessed in templates.
+      def method_missing(sym, *args, &block)
+        if yaml.key?(sym)
+          yaml[sym]
+        else
+          nil
+        end
+      end
+
+      # Allow template to be set, needed for Template to work properly.
+      def template
+        @template || yaml[:template]
+      end
+
+      def yield
+        text
+      end
+
+      # @return [String] Text of the file.
+      def raw_text
+        read[1]
+      end
+
+      # @return [Path] If a permalink has been set in the yaml frontmatter uses
+      #   that, otherwise uses the path to the file.
+      def path
+        if yaml.key?(:permalink)
+          if yaml[:permalink].start_with?('/')
+            Path @site.root, yaml[:permalink][1..-1]
+          else
+            Path @site.root, yaml[:permalink]
+          end
+
+        else
+          rel = @path
+
+          if @path.same_type?(@site.source)
+            rel = @path.relative_path_from(@site.source)
+          end
+
+          if @path.basename.to_s.count('.') == 1
+            Path @site.root, rel
+          else
+            ext  = @path.extname
+            file = rel.to_s[0..-ext.size-1]
+            Path @site.root, file
+          end
+        end
+      end
+
+      private
+
+      # Reads the file, splitting it in to two parts; the yaml and the text.
+      #
+      # @example
+      #
+      #   file = File.new(site, "hello-world.md")
+      #   file.read
+      #   #=> ["title: Hello World\ndate:  2012-02-03",
+      #   #    "Hello, world!"]
+      #
+      # @return [Array<String>] An array of two parts. The first is the yaml part
+      #   of the file, the second is the text part.
+      def read
+        contents = @path.read || ""
+        if match = contents.match(YAML_REGEX)
+          match.to_a[1..2]
+        else
+          ['', contents]
+        end
+      rescue
+        ['', contents]
+      end
+
+      # @return [Hash{Symbol=>Object}] Returns the data loaded from the file's
+      #   yaml frontmatter.
+      def yaml
+        loaded = Henshin.load_yaml read[0]
+
+        singleton_class.ancestors.find_all {|klass|
+          klass.singleton_class.include?(Attributes)
+
+        }.map {|klass|
+          klass.required.to_a
+
+        }.flatten.reject {|key|
+        respond_to?(key) || loaded.key?(key)
+
+        }.each {|key|
+          UI.fail(inspect + " requires #{key}.")
+        }
+
+        loaded
+      end
+
+    end
+  end
+end

data/lib/henshin/files/post.rb

@@ -0,0 +1,64 @@
+module Henshin
+
+  class File
+    # A post, stored in the /posts folder.
+    module Post
+      include Templatable
+      extend  Attributes
+
+      requires :title, :date
+      template 'post'
+
+      def rss_date
+        date.rfc2822
+      end
+
+      def next=(post)
+        @next = post
+      end
+
+      def prev=(post)
+        @prev = post
+      end
+
+      def next_post
+        @next
+      end
+
+      def prev_post
+        @prev
+      end
+
+      def published?
+        true
+      end
+
+      def path
+        style = @site.config[:permalink]
+
+        data = {
+          year:  date.strftime('%Y'),
+          month: date.strftime('%m'),
+          day:   date.strftime('%d'),
+          title: title.slugify
+        }
+
+        url = data.inject(style) {|res, (tok, val)|
+          res.gsub /:#{Regexp.escape(tok)}/, val
+        }
+        
+        Path @site.root, url[1..-1]
+      end
+
+      # Compares posts on date, then on permalink if dates are the same.
+      def <=>(other)
+        c = other.respond_to?(:date) ? other.date <=> date : 0
+        c.zero? ? super : c
+      end
+
+    end
+
+    apply %r{(^|/)posts/}, Post
+
+  end
+end

data/lib/henshin/files/templatable.rb

@@ -0,0 +1,29 @@
+module Henshin
+
+  class File
+
+    module Templatable
+
+      # Overrides #text in the included class so that the result from it is passed
+      # into a template. Uses the template set with .template, or if not found, the
+      # default template.
+      #
+      # @return [String]
+      def text
+        res  = raw_text
+        data = safe
+
+        return res if data.template == "none"
+
+        data.singleton_class.send(:define_method, :text) { res }
+
+        default = nil
+        singleton_class.ancestors.find {|klass|
+          default = klass.default_template if klass.respond_to?(:default_template)
+        }
+
+        @site.template(default, Henshin::DEFAULT_TEMPLATE).render(data)
+      end
+    end
+  end
+end

data/lib/henshin/files/template.rb

@@ -0,0 +1,45 @@
+module Henshin
+
+  class File
+
+    # Used to extend template files. These will generally be written in a language
+    # such as slim, as they have the ability to include data.
+    #
+    # @example
+    #
+    #   t = SlimFile.new(site, path)
+    #   t.extend Template
+    #
+    #   t.template other_file
+    #   #=> "..."
+    #
+    module Template
+
+      # Name used to refer to the template.
+      # @return [String]
+      def name
+        @path.basename.to_s.split('.').first
+      end
+
+      # Sets the data and then uses the superclasses #text method to render the
+      # template.
+      #
+      # @param data [Hash]
+      def template(data)
+        data.template = 'none'
+        @data = data.safe
+        text
+      end
+
+      alias_method :render, :template
+
+      # @return [Hash] The data set by #template.
+      def data
+        @data
+      end
+    end
+
+    apply %r{(^|/)templates/}, Template
+
+  end
+end

data/lib/henshin/files/tilt.rb

@@ -0,0 +1,50 @@
+module Henshin
+
+  class File
+
+    # Renders a file using an engine from Tilt. This particular class deals
+    # with file types which would never use templates.
+    #
+    # @see http://github.com/rtomayko/tilt
+    class Tilt < Physical
+
+      EXTENSIONS = %w(sass scss less coffee).map(&:to_sym)
+
+      # Renders the files text using the appropriate Tilt engine. Also gets the
+      # configuration for the engine, if any, from {Site#config}.
+      #
+      # @return [String] The rendered file contents
+      def raw_text
+        ext    = @path.extname[1..-1].to_sym
+        config = (@site.config[ext] || {}).to_hash.symbolise
+        ::Tilt[ext].new(nil, nil, config) { super }.render
+      end
+    end
+
+    register /\.(#{Tilt::EXTENSIONS.join('|')})\Z/, Tilt
+
+
+    # Renders a file using an engine from Tilt. This class, unlike {Tilt} deals
+    # with file types which generally would use a template. To prevent a
+    # template being used, you need to add to the YAML frontmatter:
+    #
+    #     template: none
+    #
+    # And to use a different template than 'default' simply use the template's
+    # name instead of "none". For example, to use the template "page" I would
+    # add:
+    #
+    #     template: page
+    #
+    class TiltWithTemplate < Tilt
+      include Templatable
+
+      EXTENSIONS = %w(str markdown mkd md textile rdoc wiki
+                      creaole mediawiki mw).map(&:to_sym)
+
+    end
+
+    register /\.(#{TiltWithTemplate::EXTENSIONS.join('|')})\Z/, TiltWithTemplate
+
+  end
+end