octopress-ink 1.0.0.rc.48 → 1.0.0.rc.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6ba7aa056db45f2f28d8b70afaf07a0401b11e5
-  data.tar.gz: ee19501a664e330bc5674982382f8b0025686be6
+  metadata.gz: a4858b7de639dfc2e080960481b60d2e3b35c809
+  data.tar.gz: 748629f2f8af0d24a45fe78025106eb9c6cd4b57
 SHA512:
-  metadata.gz: d9b3d41581565613c6757e42581bbe398d1463ceea58a3fc85a651b3ba064ad3bfe826e37f2c072fe29540142534903528af59162ea619c2f764ee8d93a96c68
-  data.tar.gz: 7165df6396ecf13537da89780ef11e1b94862bfa7bf1f1a6309f27ff4a9aa5383c5f7165858fcb7d667cdcbcb5543759ae6be81eac77118761393ea49092230c
+  metadata.gz: 71f5e690c1ca468c8e14f8ab3770cc53b0fb2cfecf7379ca4be5ca11106de7a61acc46172571e69bfcc9bdc5e14b98427f236e198d91f19d92355b69f84c360b
+  data.tar.gz: 329f7932850c832ced252c2fd5103c45c9965c78528d4aee906bb303f919b9858b58c350c53407bc2c86375bc9328160fa0b5e500f6ca448dc7ba10011ac1acf

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Changelog
 
-### 1.0.0 RC47 - 2015-02-18
+### 1.0.0 RC49 - 2015-03-02
+
+- New: Plugin bootstrap allows plugins to work with templates for post indexes and RSS feeds. Each with automatic support for multilingual sites.
+
+Plugins can add pages and templates for:
+- A post index
+- A post archive
+- A post RSS feed
+- A link posts RSS feed (with octopress-linkblog)
+- An articles RSS feed (with octopress-linkblog)
+- A post RSS feed
+- Category index pages
+- Tag index pages
+- Category RSS feeds
+- Tag RSS feeds
+
+The plugin bootstrap will automatically handle page titles, permalinks and generating multiple pages for each tag and category.
+If a user installs octopress-multilingual, all pages will be replicated and filtered for each language.
+
+### 1.0.0 RC48 - 2015-02-18
 - Minor: Improved template asset info when listed with `octopress ink list [plugin]` command.
 
 ### 1.0.0 RC47 - 2015-02-18

data/lib/octopress-ink.rb

@@ -15,17 +15,18 @@ require 'octopress-ink/cache'
 
 module Octopress
   module Ink
+    extend self
 
     autoload :Utils,                'octopress-ink/utils'
     autoload :Assets,               'octopress-ink/assets'
     autoload :Convertible,          'octopress-ink/jekyll/convertible'
     autoload :Page,                 'octopress-ink/jekyll/page'
-    autoload :TemplatePage,         'octopress-ink/jekyll/template_page'
     autoload :Layout,               'octopress-ink/jekyll/layout'
     autoload :StaticFile,           'octopress-ink/jekyll/static_file'
     autoload :StaticFileContent,    'octopress-ink/jekyll/static_file_content'
     autoload :Plugins,              'octopress-ink/plugins'
     autoload :Plugin,               'octopress-ink/plugin'
+    autoload :Bootstrap,            'octopress-ink/plugin/bootstrap'
     autoload :PluginAssetPipeline,  'octopress-ink/plugin_asset_pipeline'
     autoload :Tags,                 'octopress-ink/tags'
 
@@ -38,7 +39,7 @@ module Octopress
 
     Plugins.reset
 
-    def self.version
+    def version
       version = "Jekyll v#{Jekyll::VERSION}, "
       if defined? Octopress::VERSION
         version << "Octopress v#{Octopress::VERSION} "
@@ -46,7 +47,7 @@ module Octopress
       version << "Octopress Ink v#{Octopress::Ink::VERSION}"
     end
 
-    def self.payload(lang=nil)
+    def payload(lang=nil)
       config = Plugins.config(lang)
       ink_payload = {
         'plugins'   => config['plugins'],
@@ -59,11 +60,11 @@ module Octopress
       ink_payload
     end
 
-    def self.enabled?
+    def enabled?
       @load_plugin_assets
     end
 
-    def self.load_plugin_assets=(setting)
+    def load_plugin_assets=(setting)
       @load_plguin_assets = setting
     end
 
@@ -71,7 +72,12 @@ module Octopress
     # 
     # plugin - A subclass of Plugin
     #
-    def self.register_plugin(plugin, options={})
+    def register_plugin(plugin, options={})
+      Plugins.register_plugin(plugin, options)
+    end
+
+    def register_theme(plugin, options={})
+      options['type'] = 'theme'
       Plugins.register_plugin(plugin, options)
     end
 
@@ -79,23 +85,27 @@ module Octopress
     # 
     # options - A hash of configuration options.
     #
-    def self.add_plugin(options={})
-      Plugins.register_plugin Plugin, options
+    def add_plugin(options={})
+      register_plugin Plugin, options
+    end
+
+    def add_theme(options={})
+      register_theme Plugin, options
     end
 
-    def self.add_docs(options={})
+    def add_docs(options={})
       Docs.register_docs options
     end
 
-    def self.config
+    def config
       @config ||= Configuration.config
     end
 
-    def self.plugins
+    def plugins
       Plugins.plugins
     end
 
-    def self.plugin(name)
+    def plugin(name)
       begin
         Plugins.plugin(name)
       rescue
@@ -112,7 +122,7 @@ module Octopress
     #   but no assets, i.e. 'minimal' info.
     #
     #
-    def self.list(options={})
+    def list(options={})
       site = Octopress.site(options)
       Plugins.register
       options = {'minimal'=>true} if options.empty?
@@ -128,7 +138,7 @@ module Octopress
       puts message
     end
 
-    def self.plugin_list(name, options)
+    def plugin_list(name, options)
       config = options.delete('config') # Jekyll conflicts with this option
       Octopress.site(options)
       Octopress.site.read
@@ -142,7 +152,7 @@ module Octopress
       end
     end
 
-    def self.copy_plugin_assets(name, options)
+    def copy_plugin_assets(name, options)
       config = options.delete('config') # Jekyll conflicts with this option
       Octopress.site(options)
       Plugins.register
@@ -162,7 +172,7 @@ module Octopress
       end
     end
 
-    def self.copy_path(name, options)
+    def copy_path(name, options)
       if path = options.delete('path')
         full_path = File.join(Dir.pwd, path)
         if !Dir["#{full_path}/*"].empty? && options['force'].nil?
@@ -175,7 +185,7 @@ module Octopress
       full_path
     end
 
-    def self.list_plugins(options={})
+    def list_plugins(options={})
       Octopress.site(options)
       Plugins.register
       puts "\nCurrently installed plugins:"
@@ -186,7 +196,7 @@ module Octopress
       end
     end
 
-    def self.gem_dir(*subdirs)
+    def gem_dir(*subdirs)
       File.expand_path(File.join(File.dirname(__FILE__), '../', *subdirs))
     end
 
@@ -196,7 +206,7 @@ module Octopress
     # Usage: In rakefile require 'octopress-ink'
     #        then add task calling Octopress::Ink.copy_doc for each file
     #
-    def self.copy_doc(source, dest, permalink=nil)
+    def copy_doc(source, dest, permalink=nil)
       contents = File.open(source).read
 
       # Convert H1 to title and add permalink in YAML front-matter
@@ -210,12 +220,12 @@ module Octopress
 
     private
 
-    def self.not_found(plugin)
+    def not_found(plugin)
       puts "Plugin '#{plugin}' not found."
       list_plugins
     end
 
-    def self.doc_yaml(title, permalink)
+    def doc_yaml(title, permalink)
       yaml  = "---\n"
       yaml += "title: \"#{title.strip}\"\n"
       yaml += "permalink: #{permalink.strip}\n" if permalink
@@ -226,6 +236,12 @@ end
 
 Liquid::Template.register_tag('css_asset_tag', Octopress::Ink::Tags::StylesheetTag)
 Liquid::Template.register_tag('js_asset_tag', Octopress::Ink::Tags::JavascriptTag)
+Liquid::Template.register_tag('categories', Octopress::Ink::Tags::CategoryTag)
+Liquid::Template.register_tag('category_list', Octopress::Ink::Tags::CategoryTag)
+Liquid::Template.register_tag('tags', Octopress::Ink::Tags::CategoryTag)
+Liquid::Template.register_tag('tag_list', Octopress::Ink::Tags::CategoryTag)
+Liquid::Template.register_tag('feeds', Octopress::Ink::Tags::FeedsTag)
+Liquid::Template.register_tag('feed_updated', Octopress::Ink::Tags::FeedUpdatedTag)
 
 Octopress::Docs.add({
   name:        "Octopress Ink",

data/lib/octopress-ink/assets/asset.rb

@@ -2,10 +2,11 @@ module Octopress
   module Ink
     module Assets
       class Asset
-        attr_reader :plugin, :dir, :base, :root, :file
+        attr_reader :plugin, :dir, :base, :root, :file, :overridden
         attr_accessor :exists
 
         FRONT_MATTER = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+        @overridden = false
 
         def initialize(plugin, base, file)
           @file = file
@@ -19,13 +20,13 @@ module Octopress
 
         def info
           message = filename.ljust(35)
-          if disabled?
+          if @overridden
+            message += "-overridden by #{@overridden}-"
+          elsif disabled?
             message += "-disabled-"
-          elsif self.respond_to?(:url_info)
-            message += url_info
           elsif path.to_s != plugin_path
             shortpath = File.join(Plugins.custom_dir.sub(Dir.pwd,''), dir).sub('/','')
-            message += "from: #{shortpath}/#{filename}"
+            message += "from: #{File.join(shortpath,filename).sub('/./', '/')}"
           end
           "  - #{message}"
         end
@@ -35,7 +36,7 @@ module Octopress
         end
 
         def disabled?
-          is_disabled(base, filename)
+          is_disabled(base, filename) || @overridden
         end
 
         def is_disabled(base, file)
@@ -43,6 +44,10 @@ module Octopress
           config.include?(base) || config.include?(File.join(base, filename))
         end
 
+        def override(plugin)
+          @overridden = plugin.name
+        end
+
         def path
           if @found_file
             @found_file

data/lib/octopress-ink/assets/page.rb

@@ -6,7 +6,7 @@ module Octopress
     module Assets
       class PageAsset < Asset
         attr_reader :filename
-        attr_accessor :data, :permalink_name
+        attr_accessor :data, :permalink_name, :cloned, :clone_of
 
         def initialize(plugin, base, file)
           @root = plugin.assets_path
@@ -27,20 +27,24 @@ module Octopress
           if page.url && !find_page(page)
             Octopress.site.pages << page
             plugin.config['permalinks'] ||= {}
-            plugin.config['permalinks'][@permalink_name] ||= page.url
+            permalink_config ||= page.url
           end
         end
 
-        def clone(permalink, permalink_name=nil)
+        def clone(data={})
+          self.cloned = true
           p = PageAsset.new(plugin, base, file)
-          p.permalink_name = permalink_name
-          p.permalink ||= permalink
+          p.clone_of = self
+          p.data = data
           p
         end
 
         def merge_data(data={})
-          self.data.merge!(data)
-          self
+          page.data.merge!(data)
+        end
+
+        def deep_merge(data={})
+          Jekyll::Utils.deep_merge_hashes(page.data, data)
         end
 
         def find_page(page)
@@ -55,25 +59,59 @@ module Octopress
 
         def page
           @page ||= begin
-            page = Page.new(Octopress.site, source_dir, page_dir, file, self)
+            page = Page.new(Octopress.site, source_dir, page_dir, file)
+
+            if permalink_config
+              page.data['permalink'] = permalink_config
+            else
+              permalink = page.data['permalink']
+            end
+
             page.data.merge!(@data)
+
             page
           end
         end
 
         def info
           message = super
-          name = permalink_name << page.ext
-          message.sub!(/#{filename}\s*/, name.ljust(35))
-          message.ljust(25) << (permalink || page.permalink || '')
+          return message if disabled?
+
+          if clone_of
+            "     #{permalink}"
+          elsif cloned
+            message << "\n     #{permalink}"
+          else
+            name = permalink_name << page.ext
+            message.sub!(/#{filename}\s*/, name.ljust(35))
+            message.ljust(25) << permalink
+          end
         end
 
         def permalink
-          @permalink ||= plugin.config['permalinks'][permalink_name]
+          page.url
+        end
+        
+        def url; permalink; end
+
+        def lang
+          data['lang']
         end
 
         def permalink=(url)
-          @permalink = url
+          page.data['permalink'] = url
+          permalink_config = url
+        end
+
+        def permalink_config
+          if Octopress.multilingual? && lang
+            plugin.config(lang)['permalinks'][permalink_name]
+          else
+            plugin.config['permalinks'][permalink_name]
+          end
+        end
+
+        def permalink_config=(url)
           if permalink_name
             plugin.config['permalinks'][permalink_name] = url
           end

data/lib/octopress-ink/assets/template.rb

@@ -24,30 +24,20 @@ module Octopress
           message = "  - #{message}\n"
 
           self.pages.each do |page|
-            message << "     /#{page.path.sub('index.html', '')}\n"
+            message << "     #{page.url}\n"
           end
           message
         end
 
-        def new_page(permalink, data={})
+        def new_page(data={})
           return if disabled?
-
-          dir = File.dirname(permalink)
-          name = File.basename(permalink)
-
-          page = Ink::TemplatePage.new(Octopress.site, File.dirname(self.path), '.', File.basename(self.path))
-
+          page = Ink::Page.new(Octopress.site, File.dirname(self.path), '.', File.basename(self.path))
           page.data.merge!(data)
 
-          page.dir = dir
-          page.name = name
-          page.process(name)
-
           self.pages << page
 
           page
         end
-
       end
     end
   end

data/lib/octopress-ink/commands/helpers.rb

@@ -7,6 +7,7 @@ module Octopress
           c.option "layouts", "--layouts", "#{action} only layouts"
           c.option "includes", "--includes", "#{action} only includes"
           c.option "pages", "--pages", "#{action} only pages"
+          c.option "templates", "--templates", "#{action} only pages"
           c.option "stylesheets", "--stylesheets", "#{action} only Stylesheets (.css, .scss, .sass)"
           c.option "css", "--css", "#{action} only CSS files (.css)"
           c.option "sass", "--sass", "#{action} only Sass files (.scss, .sass)"

data/lib/octopress-ink/jekyll/page.rb

@@ -2,27 +2,7 @@ module Octopress
   module Ink
     class Page < Jekyll::Page
       include Ink::Convertible
-      attr_reader :asset, :plugin
-
-      # Purpose: Configs can override a page's permalink
-      #
-      # url - Path relative to destination directory.
-      #       examples: 
-      #         - '/' for the _site/index.html page
-      #         - '/archive/' for the _site/archive/index.html page
-      #
-      def initialize(site, base, dir, name, asset)
-        @asset = asset
-        @plugin = asset.plugin
-        super(site, base, dir, name)
-      end
-
-      def destination(dest)
-        unless @dest
-          @dest = File.join(dest, self.url)
-        end
-        @dest
-      end
+      attr_accessor :dir, :name
 
       def relative_asset_path
         site_source = Pathname.new Octopress.site.source
@@ -34,9 +14,6 @@ module Octopress
       #
       def url
         @url ||= begin
-          @asset.permalink ||= self.data['permalink']
-          @url = @asset.permalink
-
           super
 
           if @url && @url =~ /\/$/

data/lib/octopress-ink/plugin.rb

@@ -4,11 +4,14 @@ module Octopress
   module Ink
     class Plugin
 
+      include Bootstrap
+
       DEFAULT_CONFIG = {
-        type: 'plugin'
+        type: 'plugin',
+        bootstrap: true
       }
 
-      attr_reader   :name, :type, :path, :assets_path, :local, :website, :description, :gem, :version, :source_url, :website,
+      attr_reader   :name, :type, :path, :assets_path, :local, :website, :description, :gem, :version, :source_url, :website, :bootstrap,
                     :layouts_dir, :stylesheets_dir, :javascripts_dir, :files_dir, :includes_dir, :images_dir, :templates_dir,
                     :layouts, :includes, :images, :fonts, :files, :pages, :templates, :docs
 
@@ -62,11 +65,12 @@ module Octopress
             add_includes
             add_layouts
             add_javascripts
+            add_stylesheets
             add_fonts
             add_files
             add_pages
             add_templates
-            add_stylesheets
+            bootstrap_plugin if @bootstrap
           end
         end
       end
@@ -149,15 +153,17 @@ module Octopress
       # returns: Hash of merged user and default config.yml files
       #
       def config(lang=nil)
-        @config ||= configs.first.read
-
         if lang
-          lang_config_hash[lang] || @config
+          lang_config_hash[lang] || read_config
         else
-          @config
+          read_config
         end
       end
 
+      def read_config
+        @config ||= configs.first.read
+      end
+
       # Language configurations
       #
       # returns: Hash of configs for files matching: conifg_[lang].yml
@@ -291,9 +297,11 @@ module Octopress
           case name
           when 'pages'
             header = "pages:".ljust(36) + "urls"
-            message << asset_list(assets, header)
+            message << asset_list(assets.sort_by(&:file), header)
           when 'config-file'
-            message << asset_list(assets, 'config')
+            message << " config:\n"
+            message << Ink::Utils.pretty_print_yaml(@config)
+            message << "\n"
 
             lang_config_hash.keys.each do |lang|
               message << "\n"
@@ -450,16 +458,19 @@ module Octopress
         add_template_pages
       end
 
-      def add_template_page(template, permalink, data={})
-        template = @templates.find { |t| t.filename == template }
-
-        unless template.nil? || template.disabled?
-          page = template.new_page(permalink, data)
+      def add_template_page(template, data={})
+        template = find_template(template) if template.is_a? String
+        unless template.nil?
+          page = template.new_page(data)
           Octopress.site.pages << page
           page
         end
       end
 
+      def find_template(file)
+        @templates.find { |t| t.filename == file }
+      end
+
       def add_docs
         Octopress::Docs.add_plugin_docs(self)
       end

data/lib/octopress-ink/plugin/bootstrap.rb

@@ -0,0 +1,507 @@
+module Octopress
+  module Ink
+    module Bootstrap
+      attr_reader :post_index, :post_archive, :category_index, :tag_index, :main_feed, :category_feed, :tag_feed, :articles_feed, :links_feed
+
+      # This module gives Plugins the ability to easily offer
+      # Index pages, archives, RSS feeds, Category and Tag indexes
+      # All with multilingual support.
+      #
+
+      def self.reset
+        @pages      = {}
+        @categories = {}
+        @tags       = {}
+        @feeds      = {}
+      end
+
+      def self.pages
+        @pages
+      end
+
+      def self.categories
+        @categories
+      end
+
+      def self.tags
+        @tags
+      end
+
+      def self.feeds
+        @feeds
+      end
+
+      def self.page(lang, type, key)
+        @pages[type][key]
+      end
+
+      def self.category(category, lang)
+        category = "#{category}_#{page.lang}" if Octopress.multilingual? && page.lang 
+        @categories[category]
+      end
+
+      def self.tag(category, lang)
+        tag = "#{tag}_#{page.lang}" if Octopress.multilingual? && page.lang 
+        @tags[tag]
+      end
+
+      def self.add_page(page, key=nil)
+        if @pages[page.url].nil?
+          @pages[page.url] = page
+
+          url = page.url.sub(/index.(xml|html)/, '')
+
+          if key == 'feeds'
+            @feeds[url] = page.data['title']
+          elsif key == 'tag'
+            tag = page.data[key]
+            tag = "#{tag}_#{page.lang}" if Octopress.multilingual? && page.lang 
+            @tags[tag] = url
+          elsif key == 'category'
+            category = page.data[key]
+            category = "#{category}_#{page.lang}" if Octopress.multilingual? && page.lang 
+            @categories[category] = url
+          end
+          page
+        end
+      end
+
+      # Generate site pages from bootstrappable pages and templates
+      #
+      def bootstrap_plugin
+        register_templates
+        inject_configs
+        add_page_metadata
+
+        # Add pages for other languages
+        if Octopress.multilingual?
+          Octopress::Multilingual.languages.each { |lang| inject_pages(lang) }
+        else
+          inject_pages
+        end
+      end
+
+      def register_templates
+        # Find pages and templates
+
+        @post_index       = pages.find     { |p| p.filename == 'post_index.html' }
+        @post_archive     = pages.find     { |p| p.filename == 'post_archive.html' }
+        @main_feed        = templates.find { |p| p.filename == 'main_feed.xml' }
+        @articles_feed    = templates.find { |p| p.filename == 'articles_feed.xml' }
+        @links_feed       = templates.find { |p| p.filename == 'links_feed.xml' }
+        @category_index   = templates.find { |t| t.filename == 'category_index.html' }
+        @tag_index        = templates.find { |t| t.filename == 'tag_index.html' }
+        @category_feed    = templates.find { |t| t.filename == 'category_feed.xml' }
+        @tag_feed         = templates.find { |t| t.filename == 'tag_feed.xml' }
+      end
+
+      # Merge optional configurations with plugin configuration
+      # Plugin configs overrides optional configs
+      #
+      def inject_configs
+        optional_configs.each do |opt_config|
+          @config = Jekyll::Utils.deep_merge_hashes(YAML.load(opt_config), @config)
+        end
+      end
+      
+      # Add default configurations based on matching pages and templates
+      #
+      def optional_configs
+        opt_config = []
+        opt_config << post_index_config      if post_index
+        opt_config << post_archive_config    if post_archive
+        opt_config << main_feed_config       if main_feed
+        opt_config << links_feed_config      if links_feed
+        opt_config << articles_feed_config   if articles_feed
+        opt_config << category_index_config  if category_index
+        opt_config << tag_index_config       if tag_index
+        opt_config << category_feed_config   if category_feed
+        opt_config << tag_feed_config        if tag_feed
+
+        # Add shared configurations for tags and categories
+        #
+        opt_config << category_config_defaults if category_index || category_feed
+        opt_config << tag_config_defaults      if tag_index || tag_feed
+
+        # Add feed defaults if plugin has any feed pages
+        #
+        if main_feed || links_feed || articles_feed || category_feed || tag_feed
+          opt_config << feed_config_defaults
+        end
+
+        opt_config
+      end
+
+      def add_page_metadata
+        [post_index, post_archive].compact.each do |page|
+          page.page.data['title'] ||= page_title(page.page, config)
+          if Octopress.multilingual?
+            page.page.data['lang'] = Octopress.site.config['lang']
+          end
+
+          unless Bootstrap.add_page(page)
+            page.override Bootstrap.pages[page.url].plugin
+          end
+        end
+      end
+
+      # Automatically clone pages or generate templates
+      #
+      # This will only occur if:
+      #   - Site configuration warrants it
+      #   - Plugin assets are present
+      #
+      # For example:
+      #   - Index pages are cloned only for additonal languages on multilingual sites
+      #   - Link-blogging feeds are only generated if the octopress-linkblog plugin is present
+      #   - Category and tag indexes and feeds depend on post metadata and configuration
+      #
+      def inject_pages(lang=nil)
+        config = self.config(lang)
+
+        # Only clone these pages for additional languages
+        #
+        if Octopress.multilingual? && Octopress.site.config['lang'] != lang
+          add_indexes(config, lang, post_index)
+          add_indexes(config, lang, post_archive)
+        end
+
+        add_feeds(config, lang, main_feed)
+
+        if defined? Octopress::Linkblog
+          add_feeds(config, lang, links_feed)
+          add_feeds(config, lang, articles_feed)
+        end
+
+        add_meta_indexes(config, lang, 'category', 'categories')
+        add_meta_indexes(config, lang, 'tag', 'tags')
+      end
+
+      def add_indexes(config, lang, page)
+        if new_page = clone_page(page, lang)
+          if Bootstrap.add_page(new_page)
+            @pages << new_page
+          end
+        end
+      end
+
+      def add_feeds(config, lang, feed_template)
+        if feed_template
+          type = feed_type(feed_template)
+          if page = feed_template.new_page({
+              'lang'      => lang,
+              'feed_type' => type,
+              'permalink' => lang_permalink(lang, config['permalinks']["#{type}_feed"]),
+              'plugin'    => self
+            })
+
+            page.data['title'] = page_title(page, config)
+
+            if Bootstrap.add_page(page, "feeds")
+              Octopress.site.pages << page
+            else
+              feed_template.pages.delete(page)
+            end
+          end
+        end
+      end
+
+      # Generates tag or category index or feed pages for each category and language
+      # Unless configuration lists specific categories
+      #
+      def add_meta_indexes(config, lang, type, types)
+
+        # Get page/feed template for category or tag
+        page_template = self.send("#{type}_index")
+        feed_template = self.send("#{type}_feed")
+
+        # Don't continue if this plugin doesn't have templates for this
+        return unless page_template || feed_template
+
+        collection = if lang
+          Octopress::Multilingual.send("#{types}_by_language")[lang].keys
+        else
+          Octopress.site.send("#{types}").keys
+        end
+
+        # User configured categories or tags
+        configured = Array(config[types]).map(&:downcase)
+
+        # If configuration specifices tags or categories, only generate indexes for those
+        if !configured.empty?
+          collection.delete_if { |i| !configured.include?(i) }
+        end
+
+        collection.each do |item|
+          item = item.downcase
+
+          # Only add pages if plugin has a feed template for this item
+          # and it hasn't been disabled in the configuration
+          #
+          if page_template && config["#{type}_indexes"] != false
+            permalink = lang_permalink(lang, config['permalinks']["#{type}_index"]).sub(":#{type}", item)
+
+            page = page_template.new_page({
+              'lang'      => lang,
+              "#{type}"   => item,
+              'permalink' => permalink,
+              'plugin'    => self
+            })
+
+            page.data['title'] = page_title(page, config)
+            if Bootstrap.add_page(page, type)
+              Octopress.site.pages << page
+            else
+              page_template.pages.delete(page)
+            end
+          end
+
+          # Only add feeds if plugin has a feed template for this item
+          # and it hasn't been disabled in the configuration
+          #
+          if feed_template && config["#{type}_feeds"] != false
+            permalink = lang_permalink(lang, config['permalinks']["#{type}_feed"]).sub(":#{type}", item)
+
+            page = feed_template.new_page({
+              'lang'      => lang,
+              "#{type}"   => item,
+              'feed_type' => type,
+              'permalink' => permalink,
+              'plugin'    => self
+            })
+
+            page.data['title'] = page_title(page, config)
+            if Bootstrap.add_page(page, 'feeds')
+              Octopress.site.pages << page
+            else
+              feed_template.delete(page)
+            end
+          end
+        end
+      end
+
+      # Creates a copy of an Ink Page asset
+      # configuring lang and permalink accordingly
+      #
+      def clone_page(page, lang)
+        return if page.nil?
+        new_page = page.clone({
+          'lang'      => lang,
+          'permalink' => page_permalink(page, lang)
+        })
+
+        new_page.page.data['title'] = page_title(new_page.page, config(lang))
+        new_page.permalink_name = nil
+        new_page
+      end
+
+      # Ensure cloned pages have language in their permalinks
+      # Since pages are only cloned for multilingual sites
+      #
+      def page_permalink(page, lang)
+        permalink = config(lang)['permalinks'][page.permalink_name]
+
+        if permalink.include?(":lang")
+          permalink.sub(":lang", lang)
+        else
+          File.join("/#{lang}", permalink)
+        end
+      end
+
+      # Ensure language is set in permalink if language is defined
+      #
+      def lang_permalink(lang, permalink)
+        if lang
+          permalink.sub(":lang", lang)
+        else
+          permalink.sub("/:lang/", '/')
+        end
+      end
+
+      
+      # Discern feed type based on filename
+      #
+      def feed_type(page)
+        if page.path.include? 'articles'
+          'articles'
+        elsif page.path.include? 'links'
+          'links'
+        elsif page.path.include? 'category'
+          'category'
+        elsif page.path.include? 'tag'
+          'tag'
+        else
+          'main'
+        end
+      end
+
+      def page_type(page)
+        if page.path.include? 'feed'
+          "#{feed_type(page)}_feed"
+        elsif page.path.include? 'post_index'
+          "post_index"
+        elsif page.path.include? 'post_archive'
+          "post_archive"
+        elsif page.path.include? 'category_index'
+          "category_index"
+        elsif page.path.include? 'tag_index'
+          "tag_index"
+        end
+      end
+
+      def generic_title(type, config, lang=nil)
+        title = config['titles'][type]
+        title = title.sub(':site_name', Octopress.site.config['name'] || '')
+        if lang && Octopress.multilingual?
+          title = title.sub(':lang_name', Octopress::Multilingual.language_name(lang))
+        end
+        title
+      end
+
+      def page_title(page, config)
+        type = page_type(page)
+        title = generic_title(type, config, page.lang)
+
+        if type.match(/(category|tag)/)
+          key = type.sub(/_index|_feed/, '')
+          label = tag_or_category_label(page, key, config)
+          title = title.sub(":#{key}", label)
+        end
+
+        title
+      end
+
+      def tag_or_category_label(page, type, config)
+        label = page.data[type].capitalize
+
+        if labels = config["#{type}_labels"]
+          label = labels[type] || label
+        end
+
+        label
+      end
+
+      def site_name
+        Octopress.site.config['name'] ? '- :site_name' : ''
+      end
+
+
+      # Default configuration settings
+      # Plugin authors can use or override these settings
+      #
+      def post_index_config
+<<-CONFIG
+titles:
+  post_index: Posts #{site_name}
+
+permalinks:
+  post_index: /
+CONFIG
+      end
+
+      def post_archive_config
+<<-CONFIG
+titles:
+  post_archive: Archive #{site_name}
+
+permalinks:
+  post_archive: /archive/
+CONFIG
+      end
+
+      def category_index_config
+<<-CONFIG
+titles:
+  category_index: Posts in :category #{site_name}
+
+permalinks:
+  category_index: #{"/:lang" if Octopress.multilingual?}/categories/:category/
+CONFIG
+      end
+
+      def tag_index_config
+<<-CONFIG
+titles:
+  tag_index: Posts tagged with :tag #{site_name}
+
+permalinks:
+  tag_index: #{"/:lang" if Octopress.multilingual?}/tags/:tag/
+CONFIG
+      end
+
+      def main_feed_config
+<<-CONFIG
+titles:
+  main_feed: Posts #{site_name} #{"(:lang_name)" if Octopress.multilingual?}
+
+permalinks:
+  main_feed: #{"/:lang" if Octopress.multilingual?}/feed/
+CONFIG
+      end
+
+      def links_feed_config
+<<-CONFIG
+titles:
+  links_feed: Links #{site_name} #{"(:lang_name)" if Octopress.multilingual?}
+
+permalinks:
+  links_feed: #{"/:lang" if Octopress.multilingual?}/feed/links/
+CONFIG
+      end
+
+      def articles_feed_config
+<<-CONFIG
+titles:
+  articles_feed: Articles #{site_name} #{"(:lang_name)" if Octopress.multilingual?}
+
+permalinks:
+  articles_feed: #{"/:lang" if Octopress.multilingual?}/feed/articles/
+CONFIG
+      end
+
+      def category_feed_config
+<<-CONFIG
+titles:
+  category_feed: Posts in :category #{site_name} #{"(:lang_name)" if Octopress.multilingual?}
+
+permalinks:
+  category_feed: #{"/:lang" if Octopress.multilingual?}/feed/categories/:category/
+CONFIG
+      end
+
+      def tag_feed_config
+<<-CONFIG
+titles:
+  tag_feed: Posts tagged with :tag #{site_name} #{"(:lang_name)" if Octopress.multilingual?}
+
+permalinks:
+  tag_feed: #{"/:lang" if Octopress.multilingual?}/feed/tags/:tag/
+CONFIG
+      end
+
+      def category_config_defaults
+<<-CONFIG
+#{"category_indexes: false" if category_index }
+#{"category_feeds: false" if category_feed }
+categories: []
+CONFIG
+      end
+
+      def tag_config_defaults
+<<-CONFIG
+#{"tag_indexes: false" if tag_index }
+#{"tag_feeds: false" if tag_feed }
+tags: []
+CONFIG
+      end
+
+      def feed_config_defaults
+<<-CONFIG
+feed_count: 20         # Number of items in feeds
+feed_excerpts: false   # Use post excerpts in feeds
+#{"posts_link_out: true" if links_feed }
+CONFIG
+      end
+    end
+  end
+end

data/lib/octopress-ink/plugins.rb

@@ -47,6 +47,7 @@ module Octopress
         @registered = false
         @css_tags = []
         @js_tags = []
+        Bootstrap.reset
       end
 
       def register

data/lib/octopress-ink/tags.rb

@@ -3,6 +3,9 @@ module Octopress
     module Tags
       autoload :JavascriptTag,        'octopress-ink/tags/javascript'
       autoload :StylesheetTag,        'octopress-ink/tags/stylesheet'
+      autoload :CategoryTag,          'octopress-ink/tags/category_tag'
+      autoload :FeedsTag,             'octopress-ink/tags/feeds_tag'
+      autoload :FeedUpdatedTag,       'octopress-ink/tags/feed_updated_tag'
     end
   end
 end

data/lib/octopress-ink/tags/category_tag.rb

@@ -0,0 +1,64 @@
+module Octopress
+  module Ink
+    module Tags
+      class CategoryTag < Liquid::Tag
+        def initialize(tag, input, tokens)
+          super
+          @tag    = tag
+          if !input.nil?
+            @input  = input.strip
+          end
+        end
+
+        def render(context)
+          @context = context
+
+
+          # If no input is passed, render in context of current page
+          # This allows the tag to be used without input on post templates
+          # But in a page loop it should be told passed the post item
+          #
+
+          page = context[@input] || context['page']
+          items = page[item_name_plural]
+
+          return '' if items.nil? || items.empty?
+
+          items = items.sort.map do |item|
+            link = item_link(page, item)
+
+            if item_list?
+              link = "<li class='#{item_type}-list-item'>#{link}</li>"
+            end
+
+            link
+          end
+
+          if item_list?
+            "<ul class='#{item_name}-list'>#{items.join}</ul>"
+          else
+            "<span class='#{item_name}-links'>#{items.join(', ')}</span>"
+          end
+        end
+
+        def item_list?
+          @tag.end_with? '_list'
+        end
+
+        def item_name
+          @tag.match('tag') ? 'tag' : 'category'
+        end
+
+        def item_name_plural
+          @tag.match('tag') ? 'tags' : 'categories'
+        end
+
+        def item_link(page, item)
+          dir = Bootstrap.send(item_name, item, page['lang'])
+          path = File.join(@context['site']['baseurl'], dir)
+          "<a class='#{item_name}-link' href='#{path}'>#{item.capitalize}</a>"
+        end
+      end
+    end
+  end
+end

data/lib/octopress-ink/tags/feed_updated_tag.rb

@@ -0,0 +1,26 @@
+module Octopress
+  module Ink
+    module Tags
+      class FeedUpdatedTag < Liquid::Tag
+        def render(context)
+          feed = context['page.feed_type']
+          site = context['site']
+
+          if feed == 'category'
+            posts = site['categories'][context['page.category']]
+          else
+            posts = site[feed] || site['posts']
+          end
+
+          if posts && !posts.empty?
+            post = posts.sort_by do |p|
+              p.data['date_updated'] || p.date
+            end.last
+
+            post.data['date_updated_xml'] || post.data['date_xml']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/octopress-ink/tags/feeds_tag.rb

@@ -0,0 +1,19 @@
+module Octopress
+  module Ink
+    module Tags
+      class FeedsTag < Liquid::Tag
+        def render(context)
+          tags = []
+          Bootstrap.feeds.each do |url, title|
+            tags << tag(url, title)
+          end
+          tags.join("\n")
+        end
+
+        def tag(url, title)
+          "<link href='#{url.sub('index.xml', '')}' title='#{title}' rel='alternate' type='application/atom+xml'>"
+        end
+      end
+    end
+  end
+end

data/lib/octopress-ink/utils.rb

@@ -16,6 +16,7 @@ module Octopress
           .gsub(/,$/,'')            # remove commas from end of lines
           .gsub(/{\n/,"\n")         # remove keys with empty hashes
           .gsub(/^\s+}\n/,'')       # remove keys with empty hashes
+          .gsub(/\[\s+\]/,'[]')       # remove whitespace in empty arrays
       end
     end
   end

data/lib/octopress-ink/version.rb

@@ -1,5 +1,5 @@
 module Octopress
   module Ink
-    VERSION = "1.0.0.rc.48"
+    VERSION = "1.0.0.rc.49"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: octopress-ink
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc.48
+  version: 1.0.0.rc.49
 platform: ruby
 authors:
 - Brandon Mathis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-20 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: octopress-date-format
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: octopress
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: octopress-linkblog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -151,7 +179,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: octopress-debugger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -207,11 +235,14 @@ files:
 - lib/octopress-ink/jekyll/page.rb
 - lib/octopress-ink/jekyll/static_file.rb
 - lib/octopress-ink/jekyll/static_file_content.rb
-- lib/octopress-ink/jekyll/template_page.rb
 - lib/octopress-ink/plugin.rb
+- lib/octopress-ink/plugin/bootstrap.rb
 - lib/octopress-ink/plugin_asset_pipeline.rb
 - lib/octopress-ink/plugins.rb
 - lib/octopress-ink/tags.rb
+- lib/octopress-ink/tags/category_tag.rb
+- lib/octopress-ink/tags/feed_updated_tag.rb
+- lib/octopress-ink/tags/feeds_tag.rb
 - lib/octopress-ink/tags/javascript.rb
 - lib/octopress-ink/tags/set_lang.rb
 - lib/octopress-ink/tags/stylesheet.rb

data/lib/octopress-ink/jekyll/template_page.rb

@@ -1,14 +0,0 @@
-module Octopress
-  module Ink
-    class TemplatePage < Jekyll::Page
-      attr_accessor :dir, :name
-      include Ink::Convertible
-      
-      def relative_asset_path
-        site_source = Pathname.new Octopress.site.source
-        page_source = Pathname.new @base
-        page_source.relative_path_from(site_source).to_s
-      end
-    end
-  end
-end