bunto 1.0.0

data/lib/bunto/command.rb

@@ -0,0 +1,65 @@
+module Bunto
+  class Command
+    class << self
+      # A list of subclasses of Bunto::Command
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # Keep a list of subclasses of Bunto::Command every time it's inherited
+      # Called automatically.
+      #
+      # base - the subclass
+      #
+      # Returns nothing
+      def inherited(base)
+        subclasses << base
+        super(base)
+      end
+
+      # Run Site#process and catch errors
+      #
+      # site - the Bunto::Site object
+      #
+      # Returns nothing
+      def process_site(site)
+        site.process
+      rescue Bunto::Errors::FatalException => e
+        Bunto.logger.error "ERROR:", "YOUR SITE COULD NOT BE BUILT:"
+        Bunto.logger.error "", "------------------------------------"
+        Bunto.logger.error "", e.message
+        exit(1)
+      end
+
+      # Create a full Bunto configuration with the options passed in as overrides
+      #
+      # options - the configuration overrides
+      #
+      # Returns a full Bunto configuration
+      def configuration_from_options(options)
+        Bunto.configuration(options)
+      end
+
+      # Add common options to a command for building configuration
+      #
+      # c - the Bunto::Command to add these options to
+      #
+      # Returns nothing
+      def add_build_options(c)
+        c.option 'config',  '--config CONFIG_FILE[,CONFIG_FILE2,...]', Array, 'Custom configuration file'
+        c.option 'destination', '-d', '--destination DESTINATION', 'The current folder will be generated into DESTINATION'
+        c.option 'source', '-s', '--source SOURCE', 'Custom source directory'
+        c.option 'future',  '--future', 'Publishes posts with a future date'
+        c.option 'limit_posts', '--limit_posts MAX_POSTS', Integer, 'Limits the number of posts to parse and publish'
+        c.option 'watch',   '-w', '--[no-]watch', 'Watch for changes and rebuild'
+        c.option 'force_polling', '--force_polling', 'Force watch to use polling'
+        c.option 'lsi',     '--lsi', 'Use LSI for improved related posts'
+        c.option 'show_drafts',  '-D', '--drafts', 'Render posts in the _drafts folder'
+        c.option 'unpublished', '--unpublished', 'Render posts that were marked as unpublished'
+        c.option 'quiet',   '-q', '--quiet', 'Silence output.'
+        c.option 'verbose', '-V', '--verbose', 'Print verbose output.'
+        c.option 'incremental', '-I', '--incremental', 'Enable incremental rebuild.'
+      end
+    end
+  end
+end

data/lib/bunto/commands/build.rb

@@ -0,0 +1,77 @@
+module Bunto
+  module Commands
+    class Build < Command
+      class << self
+        # Create the Mercenary command for the Bunto CLI for this Command
+        def init_with_program(prog)
+          prog.command(:build) do |c|
+            c.syntax      'build [options]'
+            c.description 'Build your site'
+            c.alias :b
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              options["serving"] = false
+              Bunto::Commands::Build.process(options)
+            end
+          end
+        end
+
+        # Build your bunto site
+        # Continuously watch if `watch` is set to true in the config.
+        def process(options)
+          # Adjust verbosity quickly
+          Bunto.logger.adjust_verbosity(options)
+
+          options = configuration_from_options(options)
+          site = Bunto::Site.new(options)
+
+          if options.fetch('skip_initial_build', false)
+            Bunto.logger.warn "Build Warning:", "Skipping the initial build. This may result in an out-of-date site."
+          else
+            build(site, options)
+          end
+
+          if options.fetch('detach', false)
+            Bunto.logger.info "Auto-regeneration:", "disabled when running server detached."
+          elsif options.fetch('watch', false)
+            watch(site, options)
+          else
+            Bunto.logger.info "Auto-regeneration:", "disabled. Use --watch to enable."
+          end
+        end
+
+        # Build your Bunto site.
+        #
+        # site - the Bunto::Site instance to build
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def build(site, options)
+          t = Time.now
+          source      = options['source']
+          destination = options['destination']
+          incremental = options['incremental']
+          Bunto.logger.info "Source:", source
+          Bunto.logger.info "Destination:", destination
+          Bunto.logger.info "Incremental build:", (incremental ? "enabled" : "disabled. Enable with --incremental")
+          Bunto.logger.info "Generating..."
+          process_site(site)
+          Bunto.logger.info "", "done in #{(Time.now - t).round(3)} seconds."
+        end
+
+        # Private: Watch for file changes and rebuild the site.
+        #
+        # site - A Bunto::Site instance
+        # options - A Hash of options passed to the command
+        #
+        # Returns nothing.
+        def watch(_site, options)
+          External.require_with_graceful_fail 'bunto-watch'
+          Bunto::Watcher.watch(options)
+        end
+      end # end of class << self
+    end
+  end
+end

data/lib/bunto/commands/clean.rb

@@ -0,0 +1,42 @@
+module Bunto
+  module Commands
+    class Clean < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:clean) do |c|
+            c.syntax 'clean [subcommand]'
+            c.description 'Clean the site (removes site output and metadata file) without building.'
+
+            add_build_options(c)
+
+            c.action do |_, options|
+              Bunto::Commands::Clean.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          options = configuration_from_options(options)
+          destination = options['destination']
+          metadata_file = File.join(options['source'], '.bunto-metadata')
+
+          if File.directory? destination
+            Bunto.logger.info "Cleaning #{destination}..."
+            FileUtils.rm_rf(destination)
+            Bunto.logger.info "", "done."
+          else
+            Bunto.logger.info "Nothing to do for #{destination}."
+          end
+
+          if File.file? metadata_file
+            Bunto.logger.info "Removing #{metadata_file}..."
+            FileUtils.rm_rf(metadata_file)
+            Bunto.logger.info "", "done."
+          else
+            Bunto.logger.info "Nothing to do for #{metadata_file}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto/commands/doctor.rb

@@ -0,0 +1,114 @@
+module Bunto
+  module Commands
+    class Doctor < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:doctor) do |c|
+            c.syntax 'doctor'
+            c.description 'Search site and print specific deprecation warnings'
+            c.alias(:hyde)
+
+            c.option '--config CONFIG_FILE[,CONFIG_FILE2,...]', Array, 'Custom configuration file'
+
+            c.action do |_, options|
+              Bunto::Commands::Doctor.process(options)
+            end
+          end
+        end
+
+        def process(options)
+          site = Bunto::Site.new(configuration_from_options(options))
+          site.read
+
+          if healthy?(site)
+            Bunto.logger.info "Your test results", "are in. Everything looks fine."
+          else
+            abort
+          end
+        end
+
+        def healthy?(site)
+          [
+            fsnotify_buggy?(site),
+            !deprecated_relative_permalinks(site),
+            !conflicting_urls(site),
+            !urls_only_differ_by_case(site)
+          ].all?
+        end
+
+        def deprecated_relative_permalinks(site)
+          if site.config['relative_permalinks']
+            Bunto::Deprecator.deprecation_message "Your site still uses relative" \
+                                " permalinks, which was removed in" \
+                                " Bunto v3.0.0."
+            return true
+          end
+        end
+
+        def conflicting_urls(site)
+          conflicting_urls = false
+          urls = {}
+          urls = collect_urls(urls, site.pages, site.dest)
+          urls = collect_urls(urls, site.posts.docs, site.dest)
+          urls.each do |url, paths|
+            next unless paths.size > 1
+            conflicting_urls = true
+            Bunto.logger.warn "Conflict:", "The URL '#{url}' is the destination" \
+              " for the following pages: #{paths.join(", ")}"
+          end
+          conflicting_urls
+        end
+
+        def fsnotify_buggy?(_site)
+          return true unless Utils::Platforms.osx?
+          if Dir.pwd != `pwd`.strip
+            Bunto.logger.error "  " + <<-STR.strip.gsub(/\n\s+/, "\n  ")
+              We have detected that there might be trouble using fsevent on your
+              operating system, you can read https://github.com/thibaudgg/rb-fsevent/wiki/no-fsevents-fired-(OSX-bug)
+              for possible work arounds or you can work around it immediately
+              with `--force-polling`.
+            STR
+
+            false
+          end
+
+          true
+        end
+
+        def urls_only_differ_by_case(site)
+          urls_only_differ_by_case = false
+          urls = case_insensitive_urls(site.pages + site.docs_to_write, site.dest)
+          urls.each do |case_insensitive_url, real_urls|
+            next unless real_urls.uniq.size > 1
+            urls_only_differ_by_case = true
+            Bunto.logger.warn "Warning:", "The following URLs only differ" \
+              " by case. On a case-insensitive file system one of the URLs" \
+              " will be overwritten by the other: #{real_urls.join(", ")}"
+          end
+          urls_only_differ_by_case
+        end
+
+        private
+        def collect_urls(urls, things, destination)
+          things.each do |thing|
+            dest = thing.destination(destination)
+            if urls[dest]
+              urls[dest] << thing.path
+            else
+              urls[dest] = [thing.path]
+            end
+          end
+          urls
+        end
+
+        def case_insensitive_urls(things, destination)
+          things.inject({}) do |memo, thing|
+            dest = thing.destination(destination)
+            (memo[dest.downcase] ||= []) << dest
+            memo
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto/commands/help.rb

@@ -0,0 +1,31 @@
+module Bunto
+  module Commands
+    class Help < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:help) do |c|
+            c.syntax 'help [subcommand]'
+            c.description 'Show the help message, optionally for a given subcommand.'
+
+            c.action do |args, _|
+              cmd = (args.first || "").to_sym
+              if args.empty?
+                puts prog
+              elsif prog.has_command? cmd
+                puts prog.commands[cmd]
+              else
+                invalid_command(prog, cmd)
+                abort
+              end
+            end
+          end
+        end
+
+        def invalid_command(prog, cmd)
+          Bunto.logger.error "Error:", "Hmm... we don't know what the '#{cmd}' command is."
+          Bunto.logger.info  "Valid commands:", prog.commands.keys.join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/bunto/commands/new.rb

@@ -0,0 +1,82 @@
+require 'erb'
+
+module Bunto
+  module Commands
+    class New < Command
+      class << self
+        def init_with_program(prog)
+          prog.command(:new) do |c|
+            c.syntax 'new PATH'
+            c.description 'Creates a new Bunto site scaffold in PATH'
+
+            c.option 'force', '--force', 'Force creation even if PATH already exists'
+            c.option 'blank', '--blank', 'Creates scaffolding but with empty files'
+
+            c.action do |args, options|
+              Bunto::Commands::New.process(args, options)
+            end
+          end
+        end
+
+        def process(args, options = {})
+          raise ArgumentError.new('You must specify a path.') if args.empty?
+
+          new_blog_path = File.expand_path(args.join(" "), Dir.pwd)
+          FileUtils.mkdir_p new_blog_path
+          if preserve_source_location?(new_blog_path, options)
+            Bunto.logger.abort_with "Conflict:", "#{new_blog_path} exists and is not empty."
+          end
+
+          if options["blank"]
+            create_blank_site new_blog_path
+          else
+            create_sample_files new_blog_path
+
+            File.open(File.expand_path(initialized_post_name, new_blog_path), "w") do |f|
+              f.write(scaffold_post_content)
+            end
+          end
+
+          Bunto.logger.info "New bunto site installed in #{new_blog_path}."
+        end
+
+        def create_blank_site(path)
+          Dir.chdir(path) do
+            FileUtils.mkdir(%w(_layouts _posts _drafts))
+            FileUtils.touch("index.html")
+          end
+        end
+
+        def scaffold_post_content
+          ERB.new(File.read(File.expand_path(scaffold_path, site_template))).result
+        end
+
+        # Internal: Gets the filename of the sample post to be created
+        #
+        # Returns the filename of the sample post, as a String
+        def initialized_post_name
+          "_posts/#{Time.now.strftime('%Y-%m-%d')}-welcome-to-bunto.markdown"
+        end
+
+        private
+
+        def preserve_source_location?(path, options)
+          !options["force"] && !Dir["#{path}/**/*"].empty?
+        end
+
+        def create_sample_files(path)
+          FileUtils.cp_r site_template + '/.', path
+          FileUtils.rm File.expand_path(scaffold_path, path)
+        end
+
+        def site_template
+          File.expand_path("../../site_template", File.dirname(__FILE__))
+        end
+
+        def scaffold_path
+          "_posts/0000-00-00-welcome-to-bunto.markdown.erb"
+        end
+      end
+    end
+  end
+end

data/lib/bunto/commands/serve.rb

@@ -0,0 +1,204 @@
+module Bunto
+  module Commands
+    class Serve < Command
+      class << self
+        COMMAND_OPTIONS = {
+          "ssl_cert" => ["--ssl-cert [CERT]", "X.509 (SSL) certificate."],
+          "host"     => ["host", "-H", "--host [HOST]", "Host to bind to"],
+          "open_url" => ["-o", "--open-url", "Launch your browser with your site."],
+          "detach"   => ["-B", "--detach", "Run the server in the background (detach)"],
+          "ssl_key"  => ["--ssl-key [KEY]", "X.509 (SSL) Private Key."],
+          "port"     => ["-P", "--port [PORT]", "Port to listen on"],
+          "baseurl"  => ["-b", "--baseurl [URL]", "Base URL"],
+          "skip_initial_build" => ["skip_initial_build", "--skip-initial-build",
+            "Skips the initial site build which occurs before the server is started."]
+        }
+
+        #
+
+        def init_with_program(prog)
+          prog.command(:serve) do |cmd|
+            cmd.description "Serve your site locally"
+            cmd.syntax "serve [options]"
+            cmd.alias :server
+            cmd.alias :s
+
+            add_build_options(cmd)
+            COMMAND_OPTIONS.each do |key, val|
+              cmd.option key, *val
+            end
+
+            cmd.action do |_, opts|
+              opts["serving"] = true
+              opts["watch"  ] = true unless opts.key?("watch")
+              Build.process(opts)
+              Serve.process(opts)
+            end
+          end
+        end
+
+        #
+
+        def process(opts)
+          opts = configuration_from_options(opts)
+          destination = opts["destination"]
+          setup(destination)
+
+          server = WEBrick::HTTPServer.new(webrick_opts(opts)).tap { |o| o.unmount("") }
+          server.mount(opts["baseurl"], Servlet, destination, file_handler_opts)
+          Bunto.logger.info "Server address:", server_address(server, opts)
+          launch_browser server, opts if opts["open_url"]
+          boot_or_detach server, opts
+        end
+
+        # Do a base pre-setup of WEBRick so that everything is in place
+        # when we get ready to party, checking for an setting up an error page
+        # and making sure our destination exists.
+
+        private
+        def setup(destination)
+          require_relative "serve/servlet"
+
+          FileUtils.mkdir_p(destination)
+          if File.exist?(File.join(destination, "404.html"))
+            WEBrick::HTTPResponse.class_eval do
+              def create_error_page
+                @header["Content-Type"] = "text/html; charset=UTF-8"
+                @body = IO.read(File.join(@config[:DocumentRoot], "404.html"))
+              end
+            end
+          end
+        end
+
+        #
+
+        private
+        def webrick_opts(opts)
+          opts = {
+            :BuntoOptions      => opts,
+            :DoNotReverseLookup => true,
+            :MimeTypes          => mime_types,
+            :DocumentRoot       => opts["destination"],
+            :StartCallback      => start_callback(opts["detach"]),
+            :BindAddress        => opts["host"],
+            :Port               => opts["port"],
+            :DirectoryIndex     => %W(
+              index.htm
+              index.html
+              index.rhtml
+              index.cgi
+              index.xml
+            )
+          }
+
+          enable_ssl(opts)
+          enable_logging(opts)
+          opts
+        end
+
+        # Recreate NondisclosureName under utf-8 circumstance
+
+        private
+        def file_handler_opts
+          WEBrick::Config::FileHandler.merge({
+            :FancyIndexing     => true,
+            :NondisclosureName => [
+              '.ht*', '~*'
+            ]
+          })
+        end
+
+        #
+
+        private
+        def server_address(server, opts)
+          address = server.config[:BindAddress]
+          baseurl = "#{opts["baseurl"]}/" if opts["baseurl"]
+          port = server.config[:Port]
+
+          "http://#{address}:#{port}#{baseurl}"
+        end
+
+        #
+
+        private
+        def launch_browser(server, opts)
+          command =
+            if Utils::Platforms.windows?
+              "start"
+            elsif Utils::Platforms.osx?
+              "open"
+            else
+              "xdg-open"
+            end
+          system command, server_address(server, opts)
+        end
+
+        # Keep in our area with a thread or detach the server as requested
+        # by the user.  This method determines what we do based on what you
+        # ask us to do.
+
+        private
+        def boot_or_detach(server, opts)
+          if opts["detach"]
+            pid = Process.fork do
+              server.start
+            end
+
+            Process.detach(pid)
+            Bunto.logger.info "Server detached with pid '#{pid}'.", \
+              "Run `pkill -f bunto' or `kill -9 #{pid}' to stop the server."
+          else
+            t = Thread.new { server.start }
+            trap("INT") { server.shutdown }
+            t.join
+          end
+        end
+
+        # Make the stack verbose if the user requests it.
+
+        private
+        def enable_logging(opts)
+          opts[:AccessLog] = []
+          level = WEBrick::Log.const_get(opts[:BuntoOptions]["verbose"] ? :DEBUG : :WARN)
+          opts[:Logger] = WEBrick::Log.new($stdout, level)
+        end
+
+        # Add SSL to the stack if the user triggers --enable-ssl and they
+        # provide both types of certificates commonly needed.  Raise if they
+        # forget to add one of the certificates.
+
+        private
+        def enable_ssl(opts)
+          return if !opts[:BuntoOptions]["ssl_cert"] && !opts[:BuntoOptions]["ssl_key"]
+          if !opts[:BuntoOptions]["ssl_cert"] || !opts[:BuntoOptions]["ssl_key"]
+            raise RuntimeError, "--ssl-cert or --ssl-key missing."
+          end
+
+          require "openssl"
+          require "webrick/https"
+          source_key = Bunto.sanitized_path(opts[:BuntoOptions]["source"], opts[:BuntoOptions]["ssl_key" ])
+          source_certificate = Bunto.sanitized_path(opts[:BuntoOptions]["source"], opts[:BuntoOptions]["ssl_cert"])
+          opts[:SSLCertificate] = OpenSSL::X509::Certificate.new(File.read(source_certificate))
+          opts[:SSLPrivateKey ] = OpenSSL::PKey::RSA.new(File.read(source_key))
+          opts[:EnableSSL] = true
+        end
+
+        private
+        def start_callback(detached)
+          unless detached
+            proc do
+              Bunto.logger.info("Server running...", "press ctrl-c to stop.")
+            end
+          end
+        end
+
+        private
+        def mime_types
+          file = File.expand_path('../mime.types', File.dirname(__FILE__))
+          WEBrick::HTTPUtils.load_mime_types(file)
+        end
+      end
+    end
+  end
+end