henshin 0.4.2 → 1.0.0.pre

data/LICENCE

@@ -0,0 +1,18 @@
+Copyright (c) 2012 Joshua Hawxwell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,133 @@
+# Henshin
+
+Yes it's another static site generator. Out of the box it's set up for blogging
+but henshin is so flexible and configurable it is useful in most situations
+where you need to generate a static site from some data.
+
+
+## Usage
+
+First install the gem (it requires ruby 1.9.3),
+
+``` bash
+$ gem install henshin
+```
+
+Next create an empty site,
+
+``` bash
+$ henshin new my_site
+```
+
+Now we can start a server to view the site,
+
+``` bash
+$ cd my_site
+$ henshin view
+...
+```
+
+Henshin rebuilds the pages when requested so edit `index.slim.html` and reload
+the page now.
+
+To build the site into the `build` folder, run:
+
+``` bash
+$ henshin build
+```
+
+But one of the key features of henshin is that you (probably) __never__ need to
+run `henshin build`. Henshin can upload your site straight to a server using
+sftp. To set it up you just need to add this to the `config.yml` file,
+
+``` yaml
+publish:
+  host: sftp.myserver.com
+  base: /path/to/public
+  user: username
+```
+
+And when running `henshin publish` you will be prompted for the password.
+
+
+## Structure
+
+Sites have a lot in common. Henshin forces some conventions but not too many.
+
+### ./config.yml
+
+Contains configuration and data for your site. Anything in here is accessible in
+templates and files. For instance you could add,
+
+``` yaml
+likes:
+- Italian food
+- Football
+- ...
+```
+
+So that you can add a list of things you like to the homepage,
+
+``` slim
+ul
+  h1 I like
+  - for like in site.likes
+    li = like
+```
+
+### ./init.rb
+
+This file lets you alter Henshin in any way you imagine.
+
+### ./posts/
+
+These are your published posts. They must contain yaml frontmatter with at least
+title and date attributes.
+
+``` md
+---
+title:  My First Post
+date:   2012-01-01
+---
+
+So, ...
+```
+
+### ./drafts/
+
+These are your unpublished posts and will not be in your built site. They are
+shown when previewing your site with `henshin view` so it is easy to see what
+they will look like when finished.
+
+### ./templates/
+
+Most files will try to use a template, the default template used is called
+"default", posts will attempt to use the "post" template if it exists. And you
+can force a file to use a different template by setting `template:` in the
+yaml frontmatter, for instance
+
+``` md
+---
+...
+template: strange
+---
+...
+```
+
+### ./assets/scripts/
+
+Contains scripts (these can be javascript or coffeescript). They are combined
+and minimised when you build your site.
+
+### ./assets/styles/
+
+Contains stylesheet files (css, sass, scss or less files). Like scripts they are
+combined and minimised when you build your site.
+
+
+## Configuration
+
+
+## Extending/Hacking
+
+...

data/Rakefile

@@ -1,57 +1,12 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "henshin"
-    gem.summary = %Q{Henshin is a static site generator}
-    gem.description = %Q{Henshin is a static site generator, with a plugin system and more}
-    gem.email = "m@hawx.me"
-    gem.homepage = "http://github.com/hawx/henshin"
-    gem.authors = ["hawx"]
-    gem.add_dependency "titlecase", ">= 0.1.0"
-    gem.add_dependency "directory_watcher", ">= 1.3.1"
-    gem.add_dependency "maruku", ">= 0.6.0"
-    gem.add_dependency "liquid", ">= 2.0.0"
-    gem.add_dependency "parsey", ">= 0.1.3"
-    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    gem.add_development_dependency "yard", ">= 0"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+Rake::TestTask.new :test do |t|
+  t.libs << 'lib' << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
-task :test => :check_dependencies
+task :lint do
+  system "RBENV_VERSION='rbx-2.0.0-dev' sh -c 'rbx -S pelusa'"
+end
 
 task :default => :test
-
-begin
-  require 'yard'
-  YARD::Rake::YardocTask.new
-rescue LoadError
-  task :yardoc do
-    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
-  end
-end

data/bin/henshin

@@ -1,149 +1,142 @@
 #!/usr/bin/env ruby
 
-require 'henshin'
-require 'henshin/exec/files'
-
-require 'optparse'
-require 'fileutils'
-
-banner = <<EOS
-Usage: henshin    
-       henshin [source]
-       henshin [source]:[destination]
-       
-       henshin create
-       henshin create [path for site]
-       
-EOS
-
-
-if ARGV[0] == "create"
-  if ARGV[1]
-    # create the directory
-    FileUtils.mkdir_p ARGV[1]
-    # and cd to it
-    Dir.chdir ARGV[1]
-  end
-  
-  # create directories
-  dirs = ['layouts', 'posts']
-  dirs.each {|d| FileUtils.mkdir_p d}
-
-  # write files  
-  files = {'options.yaml' => opt_content,
-           'index.html' => index_content, 
-           'layouts/main.html' => layout_content, 
-           'posts/hello-world.markdown' => post_content}
-  files.each do |f, c|
-    file = File.new( f, "w" )
-    file.puts c
-  end
+require 'clive'
+
+require_relative '../lib/henshin'
+
+module Henshin
 
-else
+  class CLI < Clive
 
-  override = {}
-  build = {:server => false, :auto => false, :port => 9991, :address => '0.0.0.0'}
-  opts = OptionParser.new do |opts|
-    opts.banner = banner
-    
-    opts.on("--server", "-s", "Start server") do
-      build[:server] = true
+    config name: 'henshin'
+
+    desc 'Builds the site'
+    command :build, arg: '[<root>]', as: Pathname, default: '.' do
+      action do
+        Henshin.eval_init root
+        Henshin.build root
+      end
     end
-    
-    opts.on("--auto", "-a", "Auto regenerate files") do
-      build[:auto] = true
+
+    desc 'Creates a new site'
+    command :new, arg: '[<root>]', as: Pathname, default: '.' do
+      action do
+        Henshin.copy_site root
+      end
     end
-    
-    opts.on("--version", "Display current version of Henshin") do
-      puts "Henshin #{Henshin.version}"
-      exit 0
+
+    desc 'Serves the site to view in a web browser'
+    command :view, arg: '[<root>]', as: Pathname, default: '.' do
+
+      desc 'Specify port number'
+      opt :p, :port, arg: '<num>', as: Integer
+
+      desc 'Hostname to run on'
+      opt :host, arg: '<addr>'
+
+      desc 'Handler to use'
+      opt :H, :handler, arg: '<name>'
+
+      desc 'Daemonise process'
+      opt :D, :daemonise
+
+      action do
+        require_relative '../lib/rack/henshin'
+        Henshin.eval_init root
+
+        site = ::Henshin::SETTINGS[:klass].new(root)
+        site.extend ::Henshin::Site::Servable
+        ::Henshin::File::Abstract.send :include, ::Henshin::File::Servable
+
+        Henshin.serve site, @state.to_h
+      end
     end
-    
-  end
-  opts.parse!
-  
-  if ARGV[0]
-    override['root'] = ARGV[0].split(':')[0]
-    if ARGV[0].split(':')[1]
-      override['target'] = ARGV[0].split(':')[1]
-    else
-      override['target'] = File.join(override['root'], Henshin::Defaults['target'])
+
+    desc 'Publishes the site'
+    command :publish, arg: '[<root>]', as: Pathname, default: '.' do
+      action do
+        Henshin.eval_init root
+        Henshin.publish root
+      end
     end
-  else
-    override['root'] = Henshin::Defaults['root']
-    override['target'] = Henshin::Defaults['target']
-  end
-  
-  
-  site = Henshin::Site.new(override)
-  unless build[:auto]
-    start = Time.now
-    # build normally
-    puts "Building site..."
-    site.build
-    puts "Site created in #{site.config['target']} (#{Time.now - start}s)"
-  end
-  
-  threads = []
-  # start a server
-  if build[:server]
-    begin
-      require 'mongrel'
-      
-      threads << Thread.new {
-        @h = Mongrel::HttpServer.new(build[:address], build[:port])
-        @h.register("/", Mongrel::DirHandler.new(override['target']))
-        puts "Server launched at http://#{build[:address]}:#{build[:port]}"
-        trap("INT") { 
-          @h.stop
-          puts "\n"
-        }
-        @h.run.join
-      }
-    rescue LoadError
-    
-      require 'webrick'
-      threads << Thread.new { 
-        server = WEBrick::HTTPServer.new(
-          :Port => build[:port],
-          :DocumentRoot => override['target'],
-          :MimeTypes => WEBrick::HTTPUtils::DefaultMimeTypes
-        )
-        trap("INT") { server.shutdown }
-        server.start
-      }
-      
+
+    desc 'Only display errors'
+    opt :quiet do
+      Henshin.set :quiet
     end
-  end
-  
-  # regenerate files when changed
-  if build[:auto]
-    require 'directory_watcher'
-    
-    puts "", "Auto-build initiated..."
-    
-    # build the glob pattern
-    gl = Dir[ File.join(override['root'], '*')].select { |x| File.directory?(x) }
-    ['/_site', '/plugins'].each do |r|
-      gl = gl.select {|i| !i.include?( File.join(override['root'], r) )}
+
+    desc 'Shows what a command will do, without writing any files'
+    opt :dry_run do
+      puts "Starting dry run..."
+      Henshin.set :dry_run
+    end
+
+    desc 'Use local links between files'
+    opt :local do
+      Henshin.set :local
+    end
+
+    desc 'Print time taken to generate site'
+    opt :profile do
+      Henshin.set :profile
+    end
+
+    desc 'Do not use colours in output'
+    opt :no_colour do
+      Henshin.unset :colour
+    end
+
+    desc 'Kills any running henshin daemon'
+    opt :kill do
+      if ::File.exist?('henshin.pid')
+        pid = ::File.read('henshin.pid').to_i
+        Process.kill('INT', pid)
+      end
+    end
+
+    desc 'Display the current version'
+    opt :version, tail: true do
+      puts Henshin::VERSION
+      exit 0
     end
-    gl.collect! {|x| "#{x}/**/*"[override['root'].size+1..-1]}
-    gl += ['*']
-
-    dw = DirectoryWatcher.new(override['root'], :glob => gl)
-    dw.interval = 1
-    dw.add_observer do |*args| 
-      if args.size > 1
-        puts "rebuilding -> #{args.size} files"
+
+  end
+
+  def self.copy_site(to)
+    from = Pathname.new(__FILE__) + '..' + '..' + 'site'
+    FileUtils.cp_r(from, to) unless Henshin.dry_run?
+
+    Pathname.glob(from + '**' + '*').each do |path|
+      if path.directory?
+        UI.made(to + path.relative_path_from(from))
       else
-        puts "rebuilding -> #{args[0].path}"
+        UI.wrote(to + path.relative_path_from(from))
       end
-      site.build
     end
-    
-    threads << Thread.new { dw.start }
-    loop { sleep 1000 } unless build[:server]
-  end  
+  end
+
+  def self.serve(site, opts={})
+    if opts[:daemonise]
+      cwd = FileUtils.pwd
+      Process.daemon
+      FileUtils.cd cwd
+      ::File.open('henshin.pid', 'w') {|f| f.write "#{Process.pid}" }
+      at_exit { ::File.delete('henshin.pid') if ::File.exist?('henshin.pid') }
+    end
+
+    config  = site.config.server || Hashie::Mash.new
+    handler = Rack::Handler.get(opts[:handler] || config.handler)
+    handler = Rack::Handler.default unless handler
+
+    app = Rack::Builder.new do
+      use Rack::ShowExceptions
+      run Rack::Henshin.new(nil, site: site)
+    end
 
-  threads.each {|t| t.join}
+    handler.run app,
+                Host: (opts[:host] || config.host),
+                Port: (opts[:port] || config.port)
+  end
 end
+
+Henshin::CLI.run