henshin 0.4.2 → 1.0.0.pre

data/lib/henshin/safety.rb

@@ -0,0 +1,74 @@
+module Henshin
+
+  # Allows a class to mark methods as "unsafe", using {.unsafe}. A copy of an
+  # object can then ask for a "safe" version with these methods disabled using
+  # {#safe}.
+  module Safety
+
+    module ClassMethods
+
+      # Mark a list of methods as "unsafe".
+      #
+      # @param syms [Symbol]
+      # @example
+      #
+      #   unsafe :write
+      #
+      def unsafe(*syms)
+        @unsafe_methods += syms
+      end
+
+      # Makes sure that the Safety module, and any unsafe methods that have been
+      # marked, infect any class which inherits the original class.
+      def inherited(klass)
+        super
+        klass.send :include, ::Henshin::Safety
+        klass.instance_variable_set(:@unsafe_methods, @unsafe_methods)
+      end
+    end
+
+    # Mixes {ClassMethods} into the including class.
+    def self.included(base)
+      super
+      base.extend ClassMethods
+      base.instance_variable_set(:@unsafe_methods, [])
+    end
+
+    # @return [Array<Symbol>] List of methods marked unsafe.
+    def unsafe_methods
+      self.class.instance_variable_get(:@unsafe_methods)
+    end
+
+    def safe?
+      false
+    end
+
+    # @return A cloned version of the object with unsafe methods stubbed to
+    #   return +nil+.
+    #
+    # @example
+    #
+    #   class Test
+    #     include Safety
+    #
+    #     def unsafe_method; puts "Hello"; end
+    #     unsafe :unsafe_method
+    #   end
+    #
+    #   Test.new.unsafe_method       #=> "Hello"
+    #   Test.new.safe.unsafe_method  #=> nil
+    #
+    def safe
+      return @safe_clone if @safe_clone
+
+      @safe_clone = self.clone
+      unsafe_methods.each do |sym|
+        @safe_clone.singleton_class.send(:define_method, sym) {|*| nil }
+      end
+      @safe_clone.singleton_class.send(:define_method, :safe?) { true }
+
+      @safe_clone
+    end
+
+  end
+end

data/lib/henshin/scope.rb

@@ -0,0 +1,55 @@
+module Henshin
+
+  # Add methods here to make them available in templates.
+  module Helpers
+    def url_for(path)
+      file = @site.all_files.find {|i| i.path === path }
+      if file
+        file.url
+      else
+        path
+      end
+    end
+  end
+
+  # Creates an object that can be passed to a template from a Hash of data. Each
+  # key becomes a method that returns it's value, this is recursive and works
+  # over Arrays.
+  #
+  # @example
+  #
+  #   data  = {a: 1, b: 2}
+  #   scope = Scope.new(data)
+  #
+  #   scope.a #=> 1
+  #   scope.b #=> 2
+  #   scope.c #=> 3
+  #
+  class Scope
+
+    # @param data [Hash]
+    def initialize(data)
+      meta = (class << self; self; end)
+
+      data.each do |name, val|
+        case val
+        when ::Hash
+          meta.send(:define_method, name) { Scope.new(val) }
+        when ::Array
+          meta.send(:define_method, name) {
+            val.map {|i|
+              i.is_a?(::Hash) ? Scope.new(i) : i
+            }
+          }
+        else
+          meta.send(:define_method, name) { val }
+        end
+      end
+    end
+
+    def method_missing(sym, *args)
+      nil
+    end
+  end
+
+end

data/lib/henshin/site.rb

@@ -1,249 +1,312 @@
 module Henshin
 
+  DEFAULT_TEMPLATE = 'default'
+
+  # The Site represents a site in the filesystem, it is in charge of reading and
+  # writing files.
   class Site
-    
-    # @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
-    
-    attr_accessor :gens, :posts, :statics, :layouts
-    attr_accessor :tags, :categories, :archive
-    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
-      self.configure(override)
-      self.load_plugins
-      self
-    end
-    
-    # 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       = 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')
-      
-      # 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)
+
+    include Safety
+
+    # Error for when a path given to {Site#initialize} does not contain a
+    # config.yml file.
+    class NotSiteError < StandardError
+
+      # @param place [Pathname, String] Path where site is expected
+      def initialize(place)
+        @place = place
       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
+
+      def message
+        <<EOS
+'#{@place}' does not contain a henshin site. No config.yml can be found.
+Create one using `henshin new`, or find out more by reading `henshin help`.
+EOS
       end
-      
-      Henshin::Generator.subclasses.each do |plugin|
-        plugin = plugin.new(self)
-        plugin.extensions[:input].each do |ext|
-          @plugins[:generators][ext] = plugin
-        end
+
+      # @return Empty array as backtrace is unnecessary.
+      def backtrace
+        []
       end
-      
-      @plugins[:layoutors] = Henshin::Layoutor.subclasses.map {|l| l.new(self)}.sort
-    end
-    
-    ##
-    # Read, process, render and write
-    def build
-      self.reset
-      self.read
-      self.process
-      self.render
-      self.write
-    end
-    
-    
-    ##
-    # 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
-    def read_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
+
+    class_attr_accessor :files_list, :file_list, :ignore_list, :default => []
+
+    # Adds the methods specified to the file list. These methods must returns
+    # a single File object (or subclass). This adds the File to those returned
+    # by {#all_files}, and so they will be written and served properly.
+    #
+    # @param names [Symbol]
+    # @see .files
+    # @example
+    #
+    #   class IndexFile < File::Abstract
+    #     # ...
+    #   end
+    #
+    #   class IndexedSite < Site
+    #     def index
+    #       IndexFile.new(self)
+    #     end
+    #
+    #     file :index
+    #   end
+    #
+    def self.file(*names)
+      names.each {|n| file_list << n }
     end
-    
-    # Adds all items in '/posts' to the posts array
-    def read_posts
-      path = File.join(@root, 'posts')
-      Dir.glob(path + '/**/*.*').each do |post|
-        @posts << Post.new(post.to_p, self).read
-      end
+
+    # Adds the methods specified to the files list. These methods must return
+    # a list of File objects (or subclasses). This adds the Files to those
+    # returned by {#all_files}, and so they will be written and served
+    # properly.
+    #
+    # @param names [Symbol]
+    # @see .file
+    # @example
+    #
+    #   class Recipe < File::Physical
+    #     # ...
+    #   end
+    #
+    #   class RecipeSite < Site
+    #     def recipes
+    #       @reader.read_all('recipes').map do |path|
+    #         Recipe.new(self, path)
+    #       end
+    #     end
+    #
+    #     files :recipes
+    #   end
+    #
+    def self.files(*names)
+      names.each {|n| files_list << n }
     end
-    
-    # Adds all files that need to be run through a plugin in an array
-    def read_gens
-      files = Dir.glob( File.join(@root, '**', '*.*') )
-      gens = files.select {|i| gen?(i) }
-      gens.each do |gen|
-        @gens << Gen.new(gen.to_p, self).read
-      end
+
+    # Makes this site ignore the paths given. This has the same effect as
+    # setting the ignore option in a site's +config.yml+, but has effect for any
+    # site using this specific class, regardless of the config.
+    #
+    # @param paths [String]
+    # @example
+    #
+    #   class DataSite
+    #     ignore 'data'
+    #     # ...
+    #   end
+    #
+    def self.ignore(*paths)
+      paths.each {|p| ignore_list << p }
     end
-    
-    # Adds all static files to an array
-    def read_statics
-      files = Dir.glob( File.join(@root, '**', '*.*') )
-      static = files.select {|i| static?(i) }
-      static.each do |static|
-        @statics << Static.new(static.to_p, self)
+
+    # Creates a new instance of Site.
+    #
+    # @param root [String, Pathname]
+    #   Path to where the site is located.
+    #
+    # @raise [NotSiteError]
+    #   Raised if +root+ does not contain a +config.yml+ file.
+    #
+    def initialize(root='.')
+      @reader = Reader.new(root)
+      @source = Pathname.new(root)
+
+      unless (@source + 'config.yml').exist?
+        raise NotSiteError, @source
+      end
+
+      @reader.ignore *ignore_list
+      if config[:ignore]
+        @reader.ignore *config[:ignore]
       end
     end
 
-    
-    ## 
-    # Processes all of the necessary files
-    def process
-      @posts.sort!
-      @gens.sort!
-      
-      @posts.each do |post|
-        @tags << post if post.data['tags']
-        @categories << post if post.data['category']
-        @archive << post
+    # @return [Pathname] Path of site being read
+    attr_reader :source
+
+    # Destination folder to build into. Uses destination set in config if
+    # available which can be either a relative path or absolute. By default uses
+    # 'build'.
+    #
+    # @return [Pathname] Path to build site to
+    def dest
+      @source.expand_path + (config[:dest] || 'build')
+    end
+
+    # Root url, this is guaranteed to begin and end with a forward-slash. All
+    # urls and permalinks should begin with this. Uses +:root+ option from
+    # config if set, otherwise defaults to using +/+.
+    #
+    # @return [Pathname] Root url
+    def root
+      u = config[:root] || '/'
+      u = '/' + u if u[0] != '/'
+      u = u + '/' if u[-1] != '/'
+      Pathname.new(u)
+    end
+
+    # @return [Hash] Defaults to for the Site.
+    def defaults
+      {
+        permalink: '/:title/index.html',
+        sass: {
+          load_paths: [@source + 'assets' + 'styles']
+        },
+        md: {
+          no_intra_emphasis:  true,
+          fenced_code_blocks: true,
+          strikethrough:      true,
+          superscript:        true
+        },
+        compress: {
+          scripts: true,
+          styles:  true,
+          images:  true
+        }
+      }
+    end
+
+    private :defaults
+
+    # @return [Hashie::Mash] Loaded contents of +config.yml+.
+    def yaml
+      Hashie::Mash.new Henshin.load_yaml (@source + 'config.yml').read
+    end
+
+    private :yaml
+
+    # @return [Hashie::Mash] Returns the configuration for the Site object, this
+    #   is the combination of the options loaded from +config.yml+ and the
+    #   defaults.
+    def config
+      Hashie::Mash.new defaults.merge(yaml)
+    end
+
+    # @return [Package::Script] The script package file. This is a combined and
+    #   minified file containing the contents of the files in +assets/scripts+.
+    def script
+      Package::Script.new self, @reader.read_all('assets', 'scripts')
+    end
+
+    # @return [Package::Style] The style package file. This is a combined and
+    #   minified file containing the contents of the files in +assets/styles+.
+    def style
+      Package::Style.new self, @reader.read_all('assets', 'styles')
+    end
+
+    file :script, :style
+
+    # @return [Array<File::Post>] The Posts read from the +posts+ folder.  These
+    #   are sorted and all posts have had the next and previous posts set
+    #   correctly.
+    def posts
+      weave_posts read(:all, 'posts')
+    end
+
+    # @return [Array<File>] Returns all other files, those which have no special
+    #   meaning to Henshin.
+    def files
+      read :safe_paths
+    end
+
+    files :posts, :files
+
+    # @return [Array<File>] Returns a list of all files set using {.files} and
+    #   {.file}. These are the files which should be written, served, etc.
+    def all_files
+      files_list.map {|fs| send(fs) }.reduce(:+) + file_list.map {|f| send(f) }
+    end
+
+    # @return [Array<File::Template>] Returns a list of all template files read from
+    #   the +templates+ directory.
+    def templates
+      read :all, 'templates'
+    end
+
+    # Reads the paths using the method specified. It returns not a list of
+    # Pathname objects but the correct File objects, using {File.create}.
+    #
+    # @param sym [Symbol] Method to use for reading.
+    # @param args Any arguments to pass along with +sym+.
+    def read(sym, *args)
+      @reader.send(sym, *args).map {|p| File.create(self, p) }.sort
+    end
+
+    private :read
+
+    # For the given posts sets the correct previous and next posts.
+    #
+    # @param posts [Array<#next=,#prev=>] List of Post objects, must be sorted.
+    def weave_posts(posts)
+      posts.each_index do |i|
+        if i < posts.length
+          posts[i].prev = posts[i+1]
+        end
+
+        if i > 0
+          posts[i].next = posts[i-1]
+        end
       end
-      self
+
+      posts
     end
-    
-    # @return [Hash] the payload for the layout engine
-    def payload
-      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 {|post| post.render}
-      @gens.each {|gen| gen.render}
-      
-      self
+
+    private :weave_posts
+
+    # If +sym+ is a key in the loaded +config.yml+ file, the value is returned,
+    # otherwise returns +nil+. This is so the Site object itself can be passed
+    # to templates.
+    def method_missing(sym, *args, &block)
+      if yaml.key?(sym)
+        yaml[sym]
+      else
+        nil
+      end
     end
-    
-    
-    ##
-    # Writes the files
-    def write
-      @posts.each {|post| post.write}
-      @gens.each {|gen| gen.write}
-      @statics.each {|static| static.write}
-      
-      @archive.write
-      @tags.write
-      @categories.write
+
+    # Writes the site using the given +writer+.
+    #
+    # @param writer [#write]
+    # @example
+    #
+    #   class MyWriter
+    #     def write(path, contents)
+    #       # ...
+    #     end
+    #   end
+    #
+    #   site.write MyWriter.new
+    #
+    def write(writer)
+      all_files.each do |file|
+        file.write writer
+      end
       self
     end
-    
-    
-    # @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
-    
-    # @param [String] path to test
-    # @return [Bool] whether the path points to a layout
-    def layout?( path )
-      path.include?('layouts/') && !ignored?(path)
-    end
-    
-    # @param [String] path to test
-    # @return [Bool] whether the path points to a post
-    def post?( path )
-      path.include?('posts/') && !ignored?(path)
-    end
-    
-    # @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 @plugins[:generators].has_key? path.to_p.extname[1..-1]
-      return true if File.open(path, "r").read(3) == "---"
-      false
-    end
-    
-    # @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(@root, i)}
-      ignored.each do |i|
-        return true if path.include? i
+
+    unsafe :write
+
+    # Finds the template with the name given. Given a list of names it tries to
+    # find a template for a single name working down the list, this allows
+    # "fallback" options to be given. If none are found it returns an instance
+    # of the {File::EmptyTemplate}.
+    #
+    # @param names [String]
+    # @return [File::Template, File::EmptyTemplate]
+    # @example
+    #
+    #   site.template('recipe', Henshin::DEFAULT_TEMPLATE)
+    #   #=> #<Henshin::File::Template ...>
+    #
+    def template(*names)
+      names.each do |name|
+        if tmp = templates.find {|t| t.name == name }
+          return tmp
+        end
       end
-      false
+
+      File::EmptyTemplate.new
     end
-  
+
   end
-end
+end