octopress 3.0.0.alpha2 → 3.0.0.alpha3

data/lib/octopress/commands/scaffold.rb

@@ -1,102 +0,0 @@
-module Octopress
-  module Commands
-    class Scaffold < Command
-      SCAFFOLD_DIR = File.join(Octopress.lib_root, "scaffold")
-      
-      SCAFFOLD_DIRS = %w[
-        configs
-        includes
-        layouts
-        lib
-        lib/rake
-        javascripts
-        javascripts/lib
-        javascripts/modules
-        source
-        stylesheets
-        plugins
-      ]
-
-      class << self
-        def process(args, options)
-          type, plugin_name = process_args(args)
-
-          create_scaffold(type, plugin_name)
-        end
-
-        ####################
-        # Scaffolding
-        ####################
-        
-        def create_scaffold(type, plugin_name)
-          Octopress.logger.info "Scaffolding a new Octopress #{type} in ./#{plugin_name}..."
-          FileUtils.mkdir(plugin_name)
-          Dir.chdir(plugin_name) do
-            FileUtils.mkdir(SCAFFOLD_DIRS)
-            FileUtils.mkdir("lib/#{ruby_name(plugin_name)}")
-            FileUtils.cp(scaffold_file("Rakefile"), "Rakefile")
-            FileUtils.cp(scaffold_file("plugin-name.gemspec"), "#{plugin_name}.gemspec")
-            File.open("MANIFEST.yml", "w") { |f| f.write(plugin_yaml(plugin_name, type)) }
-            File.open("lib/#{ruby_name(plugin_name)}.rb", "w") do |f|
-              f.puts "require 'octopress'"
-              f.puts
-              f.puts "class #{plugin_class(plugin_name)} < Octopress::Plugin"
-              f.puts "  ROOT = File.expand_path('../../', __FILE__)"
-              f.puts "end"
-            end
-            File.open("Gemfile", "w") do |f|
-              f.puts "source 'https://rubygems.org'"
-              f.puts
-              f.puts "gemspec"
-            end
-          end
-        end
-
-        def ruby_name(plugin_name)
-          plugin_name.gsub(/-/, '_')
-        end
-
-        def plugin_yaml(plugin_name, type)
-          plugin_data = {
-            "name" => plugin_name,
-            "slug" => plugin_name,
-            "type" => type,
-            "version" => "0.0.1",
-            "description" => "TODO- Add your description",
-            "summary" => "TODO- Add your summary",
-            "homepage" => "TODO- Add your plugin's homepage",
-            "authors" => ["YOUR NAME"],
-            "emails"  => ["YOUREMAIL@EXAMPLE.COM"]
-          }.to_yaml
-        end
-
-        def plugin_class(plugin_name)
-          plugin_name.split("-").map{ |n| n.capitalize }.join("")
-        end
-
-        def scaffold_file(*args)
-          File.join(SCAFFOLD_DIR, *args)
-        end
-
-        ####################
-        # Arguments
-        ####################
-
-        def process_args(args)
-          validate_args(args)
-          type        = args.shift.downcase
-          plugin_name = args.join(" ").downcase.gsub(/[\ \-_]+/, '-')
-          [type, plugin_name]
-        end
-
-        def validate_args(args)
-          if args.size < 2 || !%w[plugin theme].include?(args.first)
-            Octopress.logger.error "Invalid arguments: type must be one of 'plugin'," +
-                                   "'theme', and a plugin name must follow."
-            raise ArgumentError
-          end
-        end
-      end
-    end
-  end
-end

data/lib/octopress/commands/serve.rb

@@ -1,25 +0,0 @@
-module Octopress
-  module Commands
-    class Serve < Command
-      class << self
-        def process(args, options)
-          Octopress::Commands::Build.process(args, options)
-          serve(args, options)
-        end
-
-        def serve(args, options)
-          guardPid = Process.spawn("guard --guardfile #{Octopress.lib_root}/octopress/guardfile")
-          puts "Starting Rack, serving to http://#{Octopress.configuration[:server_host]}:#{Octopress.configuration[:port]}"
-          rackupPid = Process.spawn("rackup --host #{Octopress.configuration[:server_host]} --port #{Octopress.configuration[:port]}")
-
-          trap("INT") {
-            [guardPid, rackupPid].each { |pid| Process.kill(3, pid) rescue Errno::ESRCH }
-            exit 0
-          }
-
-          [guardPid, rackupPid].each { |pid| Process.wait(pid) }
-        end
-      end
-    end
-  end
-end

data/lib/octopress/configuration.rb

@@ -1,237 +0,0 @@
-require 'yaml'
-
-module Octopress
-  class Configuration
-    DEFAULT_CONFIG_DIR = File.join(Octopress.root, 'config')
-    attr_accessor :config_directory
-
-    def initialize(config_dir = DEFAULT_CONFIG_DIR)
-      self.config_directory = config_dir
-    end
-
-    def config_dir(*subdirs)
-      File.expand_path(File.join(*subdirs), self.config_directory)
-    end
-
-    # Static: Reads the configuration of the specified file
-    #
-    # path - the String path to the configuration file, relative to ./_config
-    #
-    # Returns a Hash of the items in the configuration file (symbol keys)
-    def read_config(path)
-      full_path = self.config_dir(path)
-      if File.exists? full_path
-        begin
-          configs = YAML.load(File.open(full_path))
-          if configs.nil?
-            Hash.new
-          else
-            configs.to_symbol_keys
-          end
-        rescue => e
-          puts "Error reading configuration file '#{full_path}':"
-          puts e.message, e.backtrace
-          exit(-1)
-        end
-      else
-        raise ArgumentError, "File at '#{full_path}' does not exist."
-      end
-    end
-
-    # Static: Concatenates javacript lib instead of merging (the default behavior for other configs)
-    # 
-    # current - current configuration hash
-    # new     - hash which hasn't yet been merged
-    #
-    # Returns a concatenated array of javascript lib configurations
-
-    def add_js_lib(current, new)
-      begin
-        new_lib = new[:require_js][:lib]
-        new_lib = [new_lib] unless new_lib.kind_of?(Array)
-        new[:require_js][:lib] = current[:require_js][:lib].concat new_lib
-      rescue
-      end
-      new
-    end
-
-    # Static: Writes the contents of a set of configurations to a path in the config directory
-    #
-    # path - the String path to the configuration file, relative to ./_config
-    # obj  - the object to be dumped into the specified file in YAML form
-    #
-    # Returns the Hash for the configuration file.
-    def write_config(path, obj)
-      YAML.dump(obj.to_string_keys, File.open(self.config_dir(path), 'w'))
-    end
-
-    # Static: Reads all the configuration files into one hash
-    #
-    # Returns a Hash of all the configuration files, with each key being a symbol
-    def read_configuration
-      configs = DEFAULTS.dup
-      Dir.glob(self.config_dir('defaults', '**', '*.yml')) do |filename|
-        file_yaml = read_config(filename)
-        unless file_yaml.nil?
-          file_yaml = add_js_lib(configs, file_yaml)
-          configs = configs.deep_merge(file_yaml)
-        end
-      end
-      Dir.glob(self.config_dir('*.yml')) do |filename|
-        file_yaml = read_config(filename)
-        unless file_yaml.nil?
-          file_yaml = add_js_lib(configs, file_yaml)
-          configs = configs.deep_merge(file_yaml)
-        end
-      end
-
-      configs.to_symbol_keys
-    end
-
-    # Static: Writes configuration files necessary for generation of the Jekyll site
-    #
-    # Returns a Hash of the items which were written to the Jekyll configuration file
-    def write_configs_for_generation
-      jekyll_configs = {}
-
-      Dir.chdir(Octopress.root) do
-        File.open("_config.yml", "w") do |f|
-          jekyll_configs = Octopress.configuration.to_string_keys.to_yaml :canonical => false
-          f.write(jekyll_configs)
-        end
-      end
-
-      jekyll_configs
-    end
-
-    # Static: Removes configuration files required for site generation
-    #
-    # Returns the number of files deleted
-    def remove_configs_for_generation
-      Dir.chdir(Octopress.root) do
-        File.unlink("_config.yml")
-      end
-    end
-
-    PostTemplate = YAML.load <<-YAML
-      extension: markdown
-      layout: post
-      title: true
-      date: true
-      categories:
-    YAML
-
-    LinkPostTemplate = YAML.load <<-YAML
-      extension: markdown
-      layout: post
-      title: true
-      date: true
-      external-url:
-      categories:
-    YAML
-
-    PageTemplate = YAML.load <<-YAML
-      extension: html
-      layout: page
-      title: true
-      date: false
-    YAML
-
-    DEFAULTS = {
-      url: 'http://yoursite.com',
-      title: 'My Octopress Blog',
-      subtitle: 'A blogging framework for hackers.',
-      author: 'Your Name',
-      description: '',
-
-      # If publishing to a subdirectory as in http://site.com/project set 'root: /project'
-      root:         '/',
-      permalink:    '/:year/:month/:day/:title/',
-      source:       'source',          # source file directory
-      destination:  'public',          # compiled site directory
-      plugins:      [
-        "#{Octopress.lib_root}/octopress/liquid_helpers",
-        "#{Octopress.lib_root}/octopress/filters",
-        "#{Octopress.lib_root}/octopress/tags",
-        "#{Octopress.lib_root}/octopress/generators",
-        "plugins"
-      ],
-      code_dir:     'downloads/code',
-      category_dir: 'categories',
-      include: ['.htaccess'],
-
-      markdown:     'redcarpet',
-      redcarpet: {
-        extensions: [
-          'no_intra_emphasis',
-          'strikethrough',
-          'autolink',
-          'superscript',
-          'smart',
-          'footnotes',
-        ]
-      },
-
-      # Default date format is "ordinal" (resulting in "July 22nd 2007")
-      # You can customize the format as defined in
-      # http://www.ruby-doc.org/core-1.9.2/Time.html#method-i-strftime
-      # Additionally, %o will give you the ordinal representation of the day
-
-      date_format:    'ordinal',
-      env:            'production',    # affects asset compilation
-      post_index_dir: 'source',        # directory for your posts index page (if you put your index in source/blog/index.html, set this to 'source/blog')
-      stash_dir:      '_stash',        # directory to stash posts for speedy generation
-      posts_dir:      '_posts',        # directory for blog files
-      deploy_dir:     '_deploy',       # directory whose contents are to be deployed
-      new_post_ext:   'markdown',      # default new post file extension when using the new_post task
-      new_page_ext:   'markdown',      # default new page file extension when using the new_page task
-      titlecase:      true,            # Converts page and post titles to titlecase
-      server_host:    '0.0.0.0',       # host ip address for preview server
-      port:           4000,            # port for preview server eg. localhost:4000
-      timezone:       'local',         # default time and date used to local timezone. Vew supported timezones (under TZ column): http://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-      #paginate_path: page/:num,       # default path for pagination, eg. page/2/
-      paginate:       10,              # Posts per page on the blog index
-
-      # Templates - these can be overridden in site.yml and themes can ship with their own default templates.
-
-      templates: {
-        post: PostTemplate,
-        linkpost: LinkPostTemplate,
-        page: PageTemplate,
-      },
-
-
-      # Feed settings
-
-      feed: {
-        limit:        20,            # Maximum number of posts to include in the feed
-        url:          '/feed/',      # Link to templates feed
-        email_url:    false,         # Link to email subscription page (if you offer it)
-        categories:   false,         # Generate individual feeds for each post category (potential performance hit)
-        author_email: false,         # Author email address to the feed
-      },
-
-      # Asset configuration
-
-      # Asset configuration
-
-      # Javascript assets stored in javascripts/lib and javascripts/modules
-      # Are wrapped with CommonJS functions, combined, uglified and fingerprinted
-      # Supported files: .js, .coffee, .mustache, .eco, .tmpl
-
-      # Dependiences from lib are added first as globals
-      require_js: {
-
-        # Dependiences are added first as globals
-        lib: ['jquery-1.9.1.js', 'jquery.cookie.js'],
-
-        # Modules are wrapped with CommonJS functions and must be
-        # Example:
-        #   for file: assets/javascripts/modules/some-plugin/awesome.js
-        #   require like: var awesome = require('some-plugin/awesome')
-        modules: ['modules']
-      }
-    }
-  end
-end
-

data/lib/octopress/dependency_installer.rb

@@ -1,287 +0,0 @@
-require 'uri'
-require 'open3'
-require 'fileutils'
-
-module Octopress
-  class DependencyInstaller
-
-    # Static: installs a list of plugins
-    #
-    # plugins - an Array of plugin names
-    #
-    # Returns nothing
-    def self.install_all(plugins)
-      if plugins.is_a?(String)
-        plugins = [plugins]
-      end
-      installer = DependencyInstaller.new
-      plugins.each do |plugin|
-        installer.install plugin
-      end
-    end
-
-    CACHE_DIR             = File.join(Octopress.root, ".plugins")
-    USERNAME_REPO_REGEXP  = /^([a-z0-9\-_]+)\/([a-z0-9\-_]+)$/
-    OCTOPRESS_REPO_REGEXP = /^[a-z0-9\-_]+$/
-    GIT_REPO_REGEXP       = /^(git:\/\/|https:\/\/|git@)([a-z0-9.]+)(\/|:)([a-z0-9\-_]+)\/([a-z0-9\-_]+)\.git/
-
-    # Public: Create a new DependencyInstaller and initialize instance variables
-    #
-    # Returns nothing
-    def initialize(plugins = [])
-      @plugins = Set.new.merge(plugins)
-    end
-
-    # Public: constructs full git URL for a plugin
-    #
-    # plugin - the plugin name
-    #
-    # Returns full git URL for a plugin
-    def git_url(plugin)
-      if OCTOPRESS_REPO_REGEXP.match(plugin)
-        "git://github.com/octopress/#{plugin}.git"
-      elsif USERNAME_REPO_REGEXP.match(plugin)
-        "git://github.com/#{plugin}.git"
-      else
-        plugin
-      end
-    end
-
-    # Public: Gets the directory for local storage
-    #
-    # Returns the directory for the plugin
-    def namespace(plugin)
-      if manifest(plugin)["type"].to_s == "theme"
-        "theme"
-      else
-        manifest(plugin)["slug"]
-      end
-    end
-
-    # Public: builds full installation directory path for plugin
-    #
-    # plugin - the plugin name
-    #
-    # Returns the full path of the installation directory
-    def cache_dir(plugin)
-      FileUtils.mkdir_p(CACHE_DIR) unless File.exists?(CACHE_DIR)
-      File.join(CACHE_DIR, File.basename(plugin).gsub(/\.git$/, ''))
-    end
-
-    # Public: clones the remote repository to the plugin install directory
-    #
-    # plugin - the plugin name
-    #
-    # Returns the file path to where the plugin was installed
-    def clone(plugin)
-      if File.directory?(cache_dir(plugin))
-        Open3.popen3("cd #{cache_dir(plugin)} && git pull origin master") do |stdin, stdout, stderr, wait_thr|
-          exit_status = wait_thr.value
-          raise RuntimeError, "Error updating #{plugin}".red unless exit_status.exitstatus == 0
-        end
-      else
-        Open3.popen3("git clone #{git_url(plugin)} #{cache_dir(plugin)}") do |stdin, stdout, stderr, wait_thr|
-          exit_status = wait_thr.value
-          raise RuntimeError, "Error cloning #{plugin}".red unless exit_status.exitstatus == 0
-        end
-      end
-      cache_dir(plugin)
-    end
-
-    # Public: fetches the contents of the manifest file as a Hash
-    #
-    # plugin - the plugin name
-    #
-    # Returns a Hash of the contents of the manifest file
-    def manifest(plugin)
-      @manifests = {} if @manifests.nil?
-      if @manifests.has_key?(plugin)
-        @manifests[plugin]
-      else
-        @manifests[plugin] = YAML.load_file(File.join(cache_dir(plugin), "manifest.yml"))
-      end
-    end
-
-    # Public: build dependency tree for a plugin
-    #
-    # plugin - the plugin name
-    #
-    # Returns an array of plugin names that are dependencies of the one specified
-    def build_dependencies_tree(plugin)
-      unless @plugins.include?(plugin)
-        clone(plugin)
-        manifest_yml = manifest(plugin)
-        Octopress.logger.debug manifest_yml.to_s
-        return [plugin] if !manifest_yml.has_key?("dependencies") || manifest_yml["dependencies"].size == 0
-        manifest_yml["dependencies"].each do |dep|
-          build_dependencies_tree(dep)
-        end
-      else
-        Octopress.logger.warn "Already installed #{plugin}."
-      end
-    end
-
-    # Public: copy files from the plugin clone to the user's source directory
-    #
-    # plugin - the plugin name
-    #
-    # Returns an Array of file paths which were copied
-    def copy_files(plugin)
-      manifest_yml = manifest(plugin)
-      %w[javascripts stylesheets plugins config source includes].each do |type|
-        Octopress.logger.debug "Copying #{type} files for #{plugin}..."
-        send("copy_#{type}_files", plugin)
-      end
-    end
-
-    # Public: install a plugin and its dependencies
-    #
-    # plugin - the plugin name
-    #
-    # Returns the Array of all plugins installed so far
-    def install(plugin)
-      @plugins.merge(build_dependencies_tree(plugin))
-      @plugins.each do |plugin|
-        copy_files(plugin)
-      end
-
-      @plugins
-    end
-
-    private
-    # Private: Copy file to Octopress installation
-    #
-    # files       - a list of files
-    # destination - the directory in which the files should be copied
-    #
-    # Returns nothing
-    def copy_file_list(files, destination)
-      if files.size > 0
-        FileUtils.mkdir_p(destination, verbose: false) unless File.directory?(destination)
-        if files.is_a?(String) && File.directory?(files)
-          Octopress.logger.debug "Copying #{files}/. to #{destination} ..."
-          FileUtils.cp_r "#{files}/.", destination, verbose: false
-        else
-          Octopress.logger.debug "Copying #{files.join(", ")} to #{destination} ..."
-          FileUtils.cp files, destination, verbose: false
-        end
-      end
-    end
-
-    # Private: Fetch list of files in a file recursively
-    #
-    # plugin   - plugin name
-    # *subdirs - a
-    def globbed_filelist(plugin, *subdirs)
-      Dir.glob(File.join(cache_dir(plugin), *subdirs, "**", "*")).select do |filename|
-        File.file?(filename)
-      end
-    end
-
-    # Private: Copy source files to local Octopress installation
-    #
-    # plugin - plugin name
-    #
-    # Returns nothing
-    def copy_source_files(plugin)
-      source      = File.join(cache_dir(plugin), "source")
-      destination = File.join(Octopress.root, Octopress.configuration[:source])
-      destination = File.join(destination, namespace(plugin)) if manifest(plugin)["type"] != "theme"
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    # Private: Copy includes files to local Octopress installation
-    #
-    # plugin - plugin name
-    #
-    # Returns nothing
-    def copy_includes_files(plugin)
-      source      = File.join(cache_dir(plugin), "includes")
-      destination = File.join(Octopress.root, Octopress.configuration[:source], "_includes", namespace(plugin))
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    # Private: Copy javascript files to local Octopress installation
-    #
-    # plugin - plugin name
-    # files - the filenames of the stylesheet files for this plugin relative to
-    #         the stylesheets dir in the plugin's install dir
-    #
-    # Returns nothing
-    def copy_config_files(plugin)
-      source      = File.join(cache_dir(plugin), "configs")
-      destination = File.join(Octopress.root, "config", "defaults", namespace(plugin))
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    def config_files(plugin)
-      globbed_filelist(plugin, "configs")
-    end
-
-    # Private: Copy javascript files to local Octopress installation
-    #
-    # plugin - plugin name
-    #
-    # Returns nothing
-    def copy_javascripts_files(plugin)
-      source      = File.join(cache_dir(plugin), "javascripts", "lib")
-      destination = File.join(Octopress.root, "javascripts", "lib", namespace(plugin))
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-      source      = File.join(cache_dir(plugin), "javascripts", "modules")
-      destination = File.join(Octopress.root, "javascripts", "modules", namespace(plugin))
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    # Private: Copy javascript files to local Octopress installation
-    #
-    # plugin - plugin name
-    # files - the filenames of the stylesheet files for this plugin relative to
-    #         the stylesheets dir in the plugin's install dir
-    #
-    # Returns nothing
-    def copy_stylesheets_files(plugin)
-      source      = File.join(cache_dir(plugin), "stylesheets")
-      sass_dir    = File.join(Octopress.root, "stylesheets")
-      namespace   = namespace(plugin)
-
-      if namespace == 'theme'
-        destination = File.join(sass_dir, namespace(plugin))
-      else
-        destination = File.join(sass_dir, 'plugins', namespace(plugin))
-      end
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    # Private: Copy javascript files to local Octopress installation
-    #
-    # plugin - plugin name
-    # files - the filenames of the Jekyll plugin files for this plugin relative
-    #         to the plugin dir in the plugin's install dir
-    #
-    # Returns nothing
-    def copy_plugins_files(plugin)
-      source      = File.join(cache_dir(plugin), "plugins")
-      install_dir = Octopress.configuration[:plugins].is_a?(Array) ? Octopress.configuration[:plugins].last : Octopress.configuration[:plugins]
-      destination = File.join(Octopress.root, install_dir, namespace(plugin))
-      if File.directory?(source)
-        copy_file_list(source, destination)
-      end
-    end
-
-    def plugin_files(plugin)
-      globbed_filelist(plugin, "plugins")
-    end
-  end
-end