octopress 3.0.0.alpha1

data/lib/octopress/command.rb

@@ -0,0 +1,9 @@
+module Octopress
+  class Command
+    class << self
+      def process(args = nil, options = nil)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/octopress/commands.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__))
+
+module Octopress
+  module Commands
+    autoload :Build,            'commands/build'
+    autoload :BuildJekyll,      'commands/build_jekyll'
+    autoload :BuildJavascripts, 'commands/build_javascripts'
+    autoload :BuildStylesheets, 'commands/build_stylesheets'
+    autoload :Install,          'commands/install'
+    autoload :New,              'commands/new'
+    autoload :Scaffold,         'commands/scaffold'
+    autoload :Serve,            'commands/serve'
+  end
+end

data/lib/octopress/commands/build.rb

@@ -0,0 +1,17 @@
+module Octopress
+  module Commands
+    class Build < Command
+      class << self
+        def process(args, options)
+          if Octopress.configuration[:source].nil? || !File.directory?(Octopress.configuration[:source])
+            Octopress.logger.error "### You haven't set anything up yet. First run `octopress install <theme-name>` to set up an Octopress theme."
+            raise SiteNotFoundError
+          end
+          BuildJavascripts.process(args, options)
+          BuildStylesheets.process(args, options)
+          BuildJekyll.process(args, options)
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/build_javascripts.rb

@@ -0,0 +1,11 @@
+module Octopress
+  module Commands
+    class BuildJavascripts < Command
+      class << self
+        def process(args, options)
+          puts Octopress::JSAssetsManager.new.compile if Dir.exists?("javascripts")
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/build_jekyll.rb

@@ -0,0 +1,25 @@
+module Octopress
+  module Commands
+    class BuildJekyll < Command
+      class << self
+        def process(args, options)
+          Octopress.configurator.write_configs_for_generation
+          puts "## Generating Site with Jekyll - ENV: #{Octopress.env}"
+          system "jekyll build #{jekyll_flags}"
+          puts unpublished unless unpublished.empty?
+          Octopress.configurator.remove_configs_for_generation
+        end
+
+        def unpublished
+          posts   = Dir.glob("#{Octopress.configuration[:source]}/#{Octopress.configuration[:posts_dir]}/*.*")
+          options = {env: Octopress.env, message: "\nThese posts were not generated:"}
+          @unpublished ||= get_unpublished(posts, options)
+        end
+
+        def jekyll_flags
+          Octopress.env.production? ? "" : "--drafts --trace"
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/build_stylesheets.rb

@@ -0,0 +1,13 @@
+module Octopress
+  module Commands
+    class Build < Command
+      class << self
+        def process(args, options)
+          if Dir.exists?("stylesheets")
+            system "compass compile --css-dir #{Octopress.configuration[:source]}/stylesheets"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/install.rb

@@ -0,0 +1,45 @@
+module Octopress
+  module Commands
+    class Install < Command
+      class << self
+        def process(args = nil, options = nil)
+          raise "Please specify at least one plugin to install." if args.nil? || args.empty?
+
+          plugin_name = args[0]
+          require_plugin(plugin_name)
+
+          # Essentially doing: 'Adn::Installer.new.install':
+          Object.const_get(classify(plugin_name))::Installer.new.install
+        end
+
+        def require_plugin(plugin_name)
+          require "#{plugin_name}"
+        rescue LoadError
+          begin
+            if File.read("#{Octopress.root}/Gemfile").match(/gem ["']#{plugin_name}["']/)
+              Octopress.logger.warn("Oops! Looks like you haven't installed the gem but you have it in your Gemfile. Running 'bundle install'...")
+              `bundle install`
+              require "#{plugin_name}"
+            else
+              raise LoadError, "Cannot load #{plugin_name}"
+            end
+          rescue LoadError
+            Octopress.logger.error("We could couldn't find the plugin '#{plugin_name}'.")
+            Octopress.logger.error("Make sure you add this to your Gemfile:\n")
+            Octopress.logger.error("gem '#{plugin_name}'\n")
+            Octopress.logger.error("Then run 'bundle install' and retry the installation.")
+            raise LoadError, "Cannot load #{plugin_name}"
+          end
+        end
+
+        def classify(plugin_name)
+          rubyify(plugin_name).split("_").map(&:capitalize).join("")
+        end
+
+        def rubyify(plugin_name)
+          plugin_name.to_s.gsub(/-/, '_')
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/new.rb

@@ -0,0 +1,21 @@
+module Octopress
+  module Commands
+    class New < Command
+      class << self
+        def process(args = nil, options = nil)
+          source = File.join(Octopress.root, 'lib/octopress/scaffold/site')
+          destination = process_args(args)
+          FileUtils.cp_r "#{source}/.", "#{destination}/"
+        end
+
+        def process_args(args)
+          if args.nil? || args.empty?
+            Octopress.logger.error "You must specify a destination for your new site."
+            raise ArgumentError
+          end
+          args.first
+        end
+      end
+    end
+  end
+end

data/lib/octopress/commands/scaffold.rb

@@ -0,0 +1,101 @@
+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)) }
+            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)
+          plugin_data = {
+            "name" => plugin_name,
+            "slug" => plugin_name,
+            "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

@@ -0,0 +1,25 @@
+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.root}/lib/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

@@ -0,0 +1,231 @@
+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:      ['lib/octopress/liquid_helpers', 'lib/octopress/filters', 'lib/octopress/tags', 'lib/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
+