henshin 0.4.2 → 1.0.0.pre

data/lib/henshin/files/tilt_template.rb

@@ -0,0 +1,45 @@
+module Henshin
+
+  class File
+
+    class TiltTemplate < Physical
+
+      EXTENSIONS = %w(erb rhtml erubis
+                      haml
+                      nokogiri
+                      builder
+                      mab
+                      liquid
+                      radius
+                      slim
+                      yajl).map(&:to_sym)
+
+      def data
+        self.safe
+      end
+
+      def text
+        ext = @path.extname[1..-1].to_sym
+        scope = data
+
+        text = ::Tilt[ext].new(nil, nil, (@site.config[ext] || {}).to_hash.symbolise) {
+          raw_text
+        }.render(scope) { scope.yield }
+
+        return text if scope.template == 'none'
+
+        default = nil
+        singleton_class.ancestors.find {|klass|
+          default = klass.default_template if klass.respond_to?(:default_template)
+        }
+
+        templates = [scope.template, default, Henshin::DEFAULT_TEMPLATE].compact
+
+        @site.template(*templates).render(data)
+      end
+    end
+
+    register /\.(#{TiltTemplate::EXTENSIONS.join('|')})\Z/, TiltTemplate
+
+  end
+end

data/lib/henshin/package.rb

@@ -0,0 +1,27 @@
+module Henshin
+
+  # @abstract Must implement {#path}.
+  # Concatenates multiple files into one, compressed file.
+  class Package < File::Abstract
+
+    # @param site [Site]
+    # @param compressor [Compressor]
+    def initialize(site, compressor)
+      @site = site
+      @compressor = compressor
+    end
+
+    def enabled?
+      true
+    end
+
+    # @return [String]
+    def text
+      enabled? ? @compressor.compress : @compressor.join
+    end
+
+    def path
+      # Path site, '...'
+    end
+  end
+end

data/lib/henshin/packages/script.rb

@@ -0,0 +1,23 @@
+module Henshin
+
+  class Package
+    # Concatenates script files (java/coffee-script) then minifies them.
+    class Script < Package
+
+      # @param site [Site]
+      # @param paths [Array<Pathname>]
+      def initialize(site, paths)
+        compressor = Compressor::Js.new(paths.map {|p| File.create(site, p) })
+        super(site, compressor)
+      end
+
+      def enabled?
+        @site.config[:compress][:scripts]
+      end
+
+      def path
+        Path @site.root, 'script.js'
+      end
+    end
+  end
+end

data/lib/henshin/packages/style.rb

@@ -0,0 +1,20 @@
+module Henshin
+
+  class Package
+    class Style < Package
+
+      def initialize(site, paths)
+        compressor = Compressor::Css.new(paths.map {|p| File.create(site, p) })
+        super(site, compressor)
+      end
+
+      def enabled?
+        @site.config[:compress][:styles]
+      end
+
+      def path
+        Path @site.root, 'style.css'
+      end
+    end
+  end
+end

data/lib/henshin/path.rb

@@ -0,0 +1,143 @@
+module Henshin
+
+  # @example
+  #
+  #   path = Path('/blog', 'tag', 'code', 'index.html')
+  #   path.extension   #=> 'html'
+  #   path.permalink   #=> '/blog/tag/code/index.html'
+  #   path.url         #=> '/blog/tag/code'
+  #
+  #   path == '/blog/tag/code/'
+  #   #=> true
+  #
+  class Path
+
+    # Creates a new Path instance for the site given with the path provided.
+    # The path is constructed from the parts passed in.
+    #
+    # @param path [String, Pathname] The path to the file the Path instance
+    #   refers to.
+    #
+    # @example
+    #
+    #   Path.new('/', 'folder', 'another-folder', 'file.txt')
+    #   #=> #<Henshin::Path /folder/another-folder/file.txt>
+    #
+    def initialize(*path)
+      @path = path.flatten.map {|p| Pathname.new(p) }
+    end
+
+    # @return [String] Extension of the Path
+    def extension
+      ::File.extname @path.last
+    end
+
+    # Returns a full url path to the location specified.
+    #
+    # @return [String] Full url to Path
+    # @example
+    #
+    #   Path('/', 'blog', '2011', 'hello-world', 'index.html').permalink
+    #   #=> '/blog/2011/hello-world/index.html'
+    #
+    def permalink
+      url = @path.inject(:+).to_s
+
+      Henshin.local? ? url[1..-1] : url
+    end
+
+    alias_method :to_s, :permalink
+
+    # Returns the url without +index.html+ at the end if possible.
+    #
+    # @return [String] Pretty url to Path
+    # @example
+    #
+    #   Path('/', 'blog', '2011', 'hello-world', 'index.html').permalink
+    #   #=> '/blog/2011/hello-world/'
+    #
+    def url
+      if Henshin.local?
+        permalink
+      else
+        permalink.sub /index\.html$/, ''
+      end
+    end
+
+    # Appends a path onto the Path.
+    #
+    # @param other [String, Pathname]
+    # @return [Path]
+    # @example
+    #
+    #   path = Path('folder')
+    #   path << 'another' << 'file.txt'
+    #   path #=> #<Henshin::Path folder/another/file.txt>
+    #
+    def << other
+      @path << other
+      self
+    end
+
+    # Checks (strictly) whether a Path instance is equal to another. This
+    # compares them using {#to_s}, so both Paths will need to have the same
+    # root _and_ path to be equal.
+    #
+    # @param other [Path]
+    # @example
+    #
+    #   a = Path 'a', 'test.txt'
+    #   b = Path 'b', 'test.txt'
+    #
+    #   a == b
+    #   #=> false
+    #
+    #   a == Path('a', 'test.txt')
+    #   #=> true
+    #
+    def == other
+      return false unless other.is_a?(Path)
+      self.to_s == other.to_s
+    end
+
+    # Checks (loosely) whether this Path instance is equal to the given
+    # argument. The argument can be another Path instance or a String, in which
+    # case the String is checked for equality against the {#url} and
+    # {#permalink}.
+    #
+    # @param other [Path, String]
+    # @example
+    #
+    #   index = Path '/blog', 'index.html'
+    #   index.permalink #=> '/blog/index.html'
+    #   index.url #=> '/blog/'
+    #
+    #   index === '/blog/index.html'
+    #   index === '/blog/'
+    #   index === '/blog'
+    #
+    def === other
+      case other
+      when String
+        url == other || url[0..-2] == other || permalink == other
+      when Path
+        self == other
+      else
+        false
+      end
+    end
+
+    def inspect
+      "#<#{self.class} #{to_s}>"
+    end
+
+  end
+end
+
+module Kernel
+
+  # @see Henshin::Path#initialize
+  def Path(*args)
+    Henshin::Path.new(*args)
+  end
+end

data/lib/henshin/publisher.rb

@@ -0,0 +1,42 @@
+module Henshin
+
+  # Publishes a site to your server.
+  class Publisher < Writer
+
+    # @return [#write]
+    def self.create(opts={})
+
+    end
+
+    # Checks that +hash+ contains all keys in +list+, raises error if not.
+    #
+    # @param hash [Hash]
+    # @param list [Array]
+    def self.requires_keys(hash, list)
+      list.each do |key|
+        unless hash.key?(key)
+          UI.fail "Publish hash must contain :#{name} key."
+        end
+      end
+      true
+    end
+
+    def self.get_required_opt(hsh, name)
+      hsh[name] || UI.fail("Must give :#{name} option to publish.")
+    end
+
+    def self.get_password(hsh, name)
+      if hsh.key?(name)
+        val = hsh[name]
+        if val =~ /^\$(\w+)\s+(.*)$/
+          `#{$1} -c '#{$2}'`.chomp
+        else
+          val
+        end
+      else
+        HighLine.new.ask("Enter password: ") {|q| q.echo = false }
+      end
+    end
+
+  end
+end

data/lib/henshin/publishers/sftp.rb

@@ -0,0 +1,79 @@
+require 'net/sftp'
+
+module Henshin
+
+  class Publisher
+
+    # Publishes the site using sftp. Writes files directly to the server. Requires
+    # the following configuration in config.yml:
+    #
+    #   publish:
+    #     host: sftp.example.com
+    #     base: /path/to/public
+    #     user: your_username
+    #     pass: your_password
+    #
+    # It's a bad idea writing down your password in plain text so you can set
+    # pass to be a shell command which returns your password, for example:
+    #
+    #   publish:
+    #     pass: $sh get-sftp-password
+    #
+    # would run +sh -c 'get-sftp-password'+.
+    #
+    class Sftp < Publisher
+
+      def self.create(opts={})
+        opts[:pass] = get_password(opts, :pass)
+        requires_keys(opts, [:host, :base, :user, :pass])
+        opts[:base] = Pathname.new(opts[:base])
+
+        sftp = nil
+        unless Henshin.dry_run?
+          sftp = Net::SFTP.start(opts[:host], opts[:user], password: opts[:pass])
+        end
+
+        new(sftp, opts[:base])
+      end
+
+      # @param sftp [Net::SFTP::Session] Connected session to use for transfers
+      # @param root [Pathname] Directory to write Site into
+      def initialize(sftp, root)
+        @sftp = sftp
+        @root = root
+      end
+
+      private
+
+      # @param path [Pathname] Path to check
+      # @return Whether +path+ exists
+      def exist?(path)
+        @sftp.lstat!(path.to_s)
+        true
+      rescue Net::SFTP::StatusException
+        false
+      end
+
+      # Creates a directory at +dir+.
+      #
+      # @param dir [Pathname] Path of directory to create
+      def write_dir(dir)
+        dir.descend do |sub|
+          @sftp.mkdir!(sub) unless exist?(sub)
+        end
+      end
+
+      # Writes the file at +path+ with the +contents+ given.
+      #
+      # @param path [Pathname] Path to file to be written
+      # @param contents [String] Text to write to the file
+      def write_file(path, contents)
+        file = @sftp.file
+        file.open(path.to_s, 'w') do |file|
+          file.puts contents.force_encoding('binary')
+        end
+      end
+
+    end
+  end
+end

data/lib/henshin/reader.rb

@@ -0,0 +1,68 @@
+module Henshin
+
+  class Reader
+
+    RESERVED_DIRS = %w(assets drafts posts templates build)
+
+    # @param root [Pathname] Path to read under.
+    def initialize(root)
+      @root = root
+      @ignore = ['config.yml', 'init.rb']
+    end
+
+    # Adds the list of files given to the list to be ignored.
+    #
+    # @param files [Array<String>]
+    def ignore(*files)
+      @ignore += files
+    end
+
+    # @param path [String]
+    # @return Whether the path given is to be ignored. Returns true if the path
+    #   is to be ignored, see #ignore; or if the path, or any directory above,
+    #   begins with an underscore.
+    def ignore?(path)
+      path = Pathname.new(path).relative_path_from(@root)
+      
+      path.ascend do |part| 
+        return true if part.basename.to_s[0] == "_" 
+        return true if @ignore.include?(part.to_s)
+      end
+    end
+
+    # Reads the files using the glob pattern given. Ignores files matching
+    # {#ignore?}.
+    #
+    # @example
+    #
+    #   reader.read('assets', '**', '*')
+    #   #=> [#<Pathname:assets/styles/screen.sass>, ...]
+    #
+    # @param path [Array<String>]
+    # @return [Array<Pathname>]
+    def read(*path)
+      glob = path.flatten.inject(@root, :+)
+      Pathname.glob(glob).reject {|p| p.directory? || ignore?(p) }
+    end
+
+    # Reads all files under the path given.
+    #
+    # @param path [Array<String>]
+    # @return [Array<Pathname>]
+    def read_all(*path)
+      read(path << '*')
+    end
+
+    alias_method :all, :read_all
+
+    # Reads all paths under the root this Reader was initialised with, but
+    # ignores all those under "reserved directories". These are directories used
+    # by henshin for posts, templates, etc.
+    #
+    # @return [Array<Pathname>]
+    def safe_paths
+      read_all('**') - read_all("{#{RESERVED_DIRS.join(',')}}", '**')
+    end
+
+  end
+end