octopress-ink 1.0.0.alpha.44 → 1.0.0.alpha.45

data/lib/octopress-ink/plugin.rb

@@ -12,8 +12,10 @@ module Octopress
                     :layouts_dir, :stylesheets_dir, :javascripts_dir, :files_dir, :includes_dir, :images_dir,
                     :layouts, :includes, :images, :fonts, :files, :pages, :docs
 
-      def initialize(options={})
-        DEFAULT_CONFIG.merge(options || configuration).each { |k,v| set_config(k,v) }
+      def initialize(options)
+        options = Jekyll::Utils.symbolize_hash_keys(options || configuration)
+
+        DEFAULT_CONFIG.merge(options).each { |k,v| set_config(k,v) }
 
         @layouts_dir       = 'layouts'
         @files_dir         = 'files'
@@ -28,7 +30,8 @@ module Octopress
         @layouts           = []
         @includes          = []
         @css               = []
-        @javascripts       = []
+        @js                = []
+        @coffee            = []
         @images            = []
         @sass              = []
         @docs              = []
@@ -38,17 +41,6 @@ module Octopress
         @slug            ||= @name
       end
 
-      def configuration; {}; end
-
-      def set_config(name,value)
-        instance_variable_set("@#{name}", value)
-        instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{name}
-            @#{name}
-          end
-        EOS
-      end
-
       def register
         unless @assets_path.nil?
           disable_assets
@@ -65,43 +57,25 @@ module Octopress
         end
       end
 
-      def add_assets; end
-
-      def stylesheets
-        css.clone.concat sass_without_partials
+      # Themes should always have the slug "theme"
+      #
+      def slug
+        Filters.sluggify @type == 'theme' ? 'theme' : @slug
       end
 
-      def config
-        @config ||= Assets::Config.new(self, @config_file).read
-      end
+      # Path where doc pages will be hosted
+      #
+      # - returns: String, eg: docs/plugins/plugin-slug
+      #
+      def docs_base_path
 
-      def disable_assets
-        disabled = []
-        config['disable'] ||= {}
-        config['disable'].each do |key,val| 
-          next unless can_disable.include? key
-          if !!val == val
-            disabled << key if val
-          elsif val.is_a? Array
-            val.each { |v| disabled << File.join(key, v) }
-          elsif val.is_a? String
-            disabled << File.join(key, val)
-          end
+        if @type == 'theme'
+          base = 'theme'
+        else
+          base = File.join('plugins', slug)
         end
-        config['disable'] = disabled
-      end
 
-      def disabled?(dir, file)
-        config['disable'].include?(dir) || config['disable'].include?(File.join(dir, file))
-      end
-
-      def slug
-        Filters.sluggify @type == 'theme' ? @type : @slug
-      end
-
-      def docs_base_path
-        type = @type == 'plugin' ? 'plugins' : @type
-        File.join('docs', type, slug)
+        File.join('docs', base)
       end
 
       # Docs pages for easy listing in an index
@@ -126,6 +100,94 @@ module Octopress
         end
       end
 
+      # List info about plugin's assets
+      #
+      # returs: String filled with asset info
+      #
+      def list(options={})
+        if options['minimal']
+          minimal_list
+        else
+          detailed_list(options)
+        end
+      end
+
+      # Add asset files which aren't disabled
+      #
+      def add_asset_files(options)
+        select_assets(options).each do |name, assets|
+          next if name == 'defaults'
+          assets.each {|file| file.add unless file.disabled? }
+        end
+      end
+
+      # Copy asset files to plugin override path
+      #
+      def copy_asset_files(path, options)
+        copied = []
+
+        select_assets(options).each do |name, assets|
+          next if name == 'docs'
+          assets.each { |a| copied << a.copy(path) }
+        end
+        copied
+      end
+
+      # stylesheets should include Sass and CSS
+      #
+      def stylesheets
+        css.clone.concat sass_without_partials
+      end
+
+      def javascripts
+        js.clone.concat coffee
+      end
+
+      # Plugin configuration
+      #
+      # returns: Hash of merged user and default config.yml files
+      #
+      def config
+        @config ||= defaults.read
+      end
+
+      # Remove files from Jekyll since they'll be proccessed by Ink instead
+      #
+      def remove_jekyll_assets(files)
+        files.each {|f| f.remove_jekyll_asset }
+      end
+
+      def include(file)
+        @includes.find{|i| i.filename == file }.path
+      end
+
+      private
+
+      def get_paths(files)
+        files.dup.map { |f| f.path }.compact
+      end
+
+      def disable_assets
+        disabled = []
+        config['disable'] ||= {}
+        config['disable'].each do |key,val| 
+          next unless can_disable.include? key
+          if !!val == val
+            disabled << key if val
+          elsif val.is_a? Array
+            val.each { |v| disabled << File.join(key, v) }
+          elsif val.is_a? String
+            disabled << File.join(key, val)
+          end
+        end
+        config['disable'] = disabled
+      end
+
+      def defaults
+        @defaults ||= Assets::Config.new(self, @config_file)
+      end
+
+
       def can_disable
         [ 
           'pages',
@@ -133,6 +195,8 @@ module Octopress
           'css',
           'stylesheets',
           'javascripts',
+          'js',
+          'coffee',
           'images',
           'fonts',
           'files'
@@ -147,22 +211,49 @@ module Octopress
           'pages'       => @pages, 
           'sass'        => @sass, 
           'css'         => @css,
-          'javascripts' => @javascripts, 
+          'js'          => @js, 
+          'coffee'      => @coffee, 
           'images'      => @images, 
           'fonts'       => @fonts, 
-          'files'       => @files
+          'files'       => @files,
+          'defaults'    => [@defaults]
         }
       end
+      
+      # Return information about each asset 
+      def assets_list(options)
+        message = ''
+        no_assets = []
 
-      def info(options={})
-        if options['minimal']
-          minimal_info
-        else
-          detailed_info(options)
+        select_assets(options).each do |name, assets|
+          next if assets.compact.size == 0
+
+          case name
+          when 'docs'
+            header = "documentation: /#{docs_base_path}/"
+            message += asset_list(assets, header)
+          when 'defaults'
+            message += asset_list(assets, 'default configuration')
+          else
+            message += asset_list(assets, name)
+          end
+
+          message += "\n"
         end
+
+        message
       end
 
-      def minimal_info
+      def asset_list(assets, heading)
+        list = " #{heading}:\n"
+        assets.each do |asset|
+          list += "#{asset.info}\n"
+        end
+
+        list
+      end
+
+      def minimal_list
         message = " #{@name}"
         message += " (#{slug})"
         message += " - v#{@version}" if @version
@@ -172,9 +263,9 @@ module Octopress
         message += "\n"
       end
 
-      def detailed_info(options)
-        asset_info = assets_info(options)
-        return '' if asset_info.empty?
+      def detailed_list(options)
+        list = assets_list(options)
+        return '' if list.empty?
 
         name = "Plugin: #{@name}"
         name += " (theme)" if @type == 'theme'
@@ -195,7 +286,7 @@ module Octopress
         80.times { lines += '=' }
 
         message = "\n#{message}\n#{lines}\n"
-        message += asset_info
+        message += list
         message += "\n"
       end
 
@@ -203,38 +294,6 @@ module Octopress
         line = "| #{line.ljust(76)} |"
       end
 
-      # Return information about each asset 
-      def assets_info(options)
-        message = ''
-        no_assets = []
-
-        if options['stylesheets']
-          options['css'] = true
-          options['sass'] = true
-          options.delete('stylesheets')
-        end
-
-        select_assets(options).each do |name, assets|
-          next if assets.size == 0
-          if name == 'docs'
-            message += " documentation: /#{docs_base_path}/\n"
-            if assets.size > 1
-              assets.each do |asset|
-                message += "  - #{asset.info}\n"
-              end
-            end
-          else
-            message += " #{name}:\n"
-            assets.each do |asset|
-              message += "  - #{asset.info}\n"
-            end
-          end
-          message += "\n"
-        end
-
-        message
-      end
-
       # Return selected assets
       #
       # input: options (an array ['type',...], hash {'type'=>true}
@@ -243,19 +302,43 @@ module Octopress
       # Output a hash of assets instances {'files' => @files }
       #
       def select_assets(asset_types)
-        # Accept options from the CLI (as a hash of asset: true)
+
+        # Accept options from the CLI (as a hash of asset_name: true)
         # Or from Ink modules as an array of asset names
         #
         if asset_types.is_a? Hash
+           
+          # Show Sass and CSS when 'stylesheets' is chosen
+          if asset_types['stylesheets']
+            asset_types['css'] = true
+            asset_types['sass'] = true
+            asset_types.delete('stylesheets')
+          end
+
+          if asset_types['javascripts']
+            asset_types['js'] = true
+            asset_types['coffee'] = true
+            asset_types.delete('javascripts')
+          end
+
           asset_types = asset_types.keys
         end
 
-        asset_types = [asset_types] if asset_types.is_a? String
+        # Args should allow a single asset as a string too
+        #
+        if asset_types.is_a? String
+          asset_types = [asset_types] 
+        end
         
-        # Remove options which don't belong
+        # Match asset_types against list of assets and
+        # remove asset_types which don't belong
         #
         asset_types.select!{|asset| assets.include?(asset)}
 
+        # If there are no asset_types, return all assets
+        # This will happen if list command is used with
+        # no filtering arguments
+        #
         if asset_types.nil? || asset_types.empty?
           assets
         else
@@ -298,7 +381,13 @@ module Octopress
       end
 
       def add_javascripts
-        @javascripts = add_new_assets(@javascripts_dir, Assets::Javascript)
+        find_assets(@javascripts_dir).each do |asset|
+          if File.extname(asset) =~ /\.js$/
+            @js << Assets::Javascript.new(self, @javascripts_dir, asset)
+          elsif File.extname(asset) =~ /\.coffee$/
+            @coffee << Assets::Coffeescript.new(self, @javascripts_dir, asset)
+          end
+        end
       end
 
       def add_fonts
@@ -327,95 +416,39 @@ module Octopress
         Find.find(dir).to_a.reject {|f| File.directory? f }
       end
 
-      #def add_css(file, media=nil)
-        #@css << Assets::Stylesheet.new(self, @stylesheets_dir, file, media)
-      #end
-
-      #def add_sass(file, media=nil)
-        #@sass << Assets::Sass.new(self, @sass_dir, file, media)
-      #end
-
-      #def add_css_files(files, media=nil)
-        #files.each { |f| add_css(f, media) }
-      #end
-
-      #def add_sass_files(files, media=nil)
-        #files.each { |f| add_sass(f, media) }
-      #end
-
-      def remove_jekyll_assets(files)
-        files.each {|f| f.remove_jekyll_asset }
-      end
-
-      def add_asset_files(options)
-        select_assets(options).each do |name, assets|
-          assets.each {|file| file.add unless file.disabled? }
-        end
-      end
-
-      def copy_asset_files(path, options)
-        copied = []
-
-        if options['stylesheets']
-          options['css'] = true
-          options['sass'] = true
-          options.delete('stylesheets')
-        end
-
-        select_assets(options).each do |name, assets|
-          next if name == 'docs'
-          assets.each { |a| copied << a.copy(path) }
-        end
-        copied
-      end
-
-      def stylesheet_paths
-        get_paths @css.reject{|f| f.disabled? }
-      end
-
-      def javascript_paths
-        get_paths @javascripts.reject{|f| f.disabled? }
-      end
-
-      def stylesheet_tags
-        get_tags @css.reject{|f| f.disabled? }
-      end
-
       def css
-        @css.reject{|f| f.disabled? }
+        @css.reject{|f| f.disabled? }.compact
       end
 
       def sass
-        @sass.reject{|f| f.disabled? }
+        @sass.reject{|f| f.disabled? }.compact
       end
 
       def sass_without_partials
         sass.reject{|f| f.file =~ /^_/ }
       end
 
-      def javascripts
-        @javascripts.reject{|f| f.disabled? }
+      def js
+        @js.reject{|f| f.disabled? }.compact
       end
 
-      def sass_tags
-        get_tags @sass
+      def coffee
+        @coffee.reject{|f| f.disabled? }.compact
       end
 
-      def javascript_tags
-        get_tags @javascripts
-      end
+      def configuration; {}; end
 
-      def get_paths(files)
-        files.dup.map { |f| f.path }.compact
+      def set_config(name, value)
+        instance_variable_set("@#{name}", value)
+        instance_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{name}
+            @#{name}
+          end
+        EOS
       end
 
-      def get_tags(files)
-        files.dup.map { |f| f.tag }
-      end
+      def add_assets; end
 
-      def include(file)
-        @includes.find{|i| i.filename == file }.path
-      end
     end
   end
 end

data/lib/octopress-ink/plugin_asset_pipeline.rb

@@ -0,0 +1,172 @@
+module Octopress
+  module Ink
+    module PluginAssetPipeline
+
+      # Compile CSS to take advantage of Sass's compression settings
+      #
+      def self.compile_css(content)
+        configs = sass_converter.sass_configs
+        configs[:syntax] = :scss
+
+        Sass.compile(content, configs)
+      end
+
+      def self.compile_sass(sass)
+        Sass.compile(sass.content, sass_configs(sass))
+      end
+
+      # Gets default Sass configuration hash from Jekyll
+      #
+      def self.sass_configs(sass)
+        configs = sass_converter.sass_configs
+
+        configs[:syntax] = sass.ext.sub(/^\./,'').to_sym
+
+        if sass.respond_to? :load_paths
+          configs[:load_paths] = sass.load_paths
+        end
+
+        configs
+      end
+      
+      # Access Jekyll's built in Sass converter
+      #
+      def self.sass_converter
+        if @sass_converter
+          @sass_converter
+        else
+          Ink.site.converters.each do |c|
+            @sass_converter = c if c.kind_of?(Jekyll::Converters::Sass) 
+          end
+          @sass_converter
+        end
+      end
+
+      # Return a link tag, for all plugins' stylesheets
+      #
+      def self.combined_stylesheet_tag
+        tags = ''
+        combine_stylesheets.keys.each do |media|
+          tags.concat "<link href='#{Filters.expand_url(combined_stylesheet_path(media))}' media='#{media}' rel='stylesheet' type='text/css'>"
+        end
+        tags
+      end
+
+      def self.combined_javascript_tag
+        unless combine_javascripts == ''
+          "<script src='#{Filters.expand_url(combined_javascript_path)}'></script>"
+        end
+      end
+
+
+      # Combine stylesheets from each plugin
+      #
+      # Returns a hash of stylesheets grouped by media types
+      #
+      #   output: { 'screen' => 'body { background... }' }
+      #
+      def self.combine_stylesheets
+        if @combined_stylesheets
+          @combined_stylesheets
+        else
+          combined = {}
+
+          stylesheets.clone.each do |media,files|
+            files.each do |file|
+              header = "/* #{file.plugin.type.capitalize}: #{file.plugin.name} */"
+              combined[media] ||= ''
+              combined[media] << "#{header}\n" unless combined[media] =~ /#{file.plugin.name}/
+              combined[media] << file.read
+            end
+          end
+
+          @combined_stylesheets = combined
+        end
+      end
+
+      def self.write_combined_stylesheet
+        css = combine_stylesheets
+        css.keys.each do |media|
+          contents = compile_css(css[media])
+          contents = AutoprefixerRails.process(contents)
+          write_files(contents, combined_stylesheet_path(media)) 
+        end
+      end
+
+      def self.combined_stylesheet_path(media)
+        File.join('stylesheets', "#{media}-#{stylesheet_fingerprint(media)}.css")
+      end
+
+      def self.stylesheet_fingerprint(media)
+        @stylesheet_fingerprint ||= {}
+        @stylesheet_fingerprint[media] ||=
+          fingerprint(stylesheets[media].clone.map {|f| f.path })
+      end
+
+      # Get all plugins stylesheets
+      #
+      # Returns a hash of assets grouped by media
+      #
+      #   output: { 'screen' => [Octopress::Ink::Assets::Stylesheet, ..]
+      #
+      def self.stylesheets
+        if @stylesheets
+          @stylesheets
+        else
+          files = {}
+          Plugins.plugins.clone.each do |plugin| 
+            plugin.stylesheets.each do |file|
+              files[file.media] ||= []
+              files[file.media] << file
+            end
+          end
+          @stylesheets = files
+        end
+      end
+
+      def self.javascripts
+        @javascripts ||=
+          Plugins.plugins.clone.map { |p| p.javascripts }.flatten
+      end
+
+      def self.javascript_fingerprint
+        @javascript_fingerprint ||=
+          fingerprint(javascripts.clone.map {|f| f.path })
+      end
+
+      def self.combine_javascripts
+        if @combined_javascript
+          @combined_javascript
+        else
+          js = ""
+          javascripts.clone.each do |f| 
+            unless js =~ /#{f.plugin.name}/
+              js += "/* #{f.plugin.type.capitalize}: #{f.plugin.name} */\n" 
+            end
+            js += f.read
+          end
+          @combined_javascript = js
+        end
+      end
+
+      def self.combined_javascript_path
+        File.join('javascripts', "all-#{javascript_fingerprint}.js")
+      end
+
+      def self.write_combined_javascript
+        js = combine_javascripts
+        write_files(js, combined_javascript_path) unless js == ''
+      end
+
+      def self.write_files(source, dest)
+        Plugins.static_files << StaticFileContent.new(source, dest)
+      end
+
+      def self.fingerprint(paths)
+        paths = [paths] unless paths.is_a? Array
+        Digest::MD5.hexdigest(paths.clone.map! { |path| "#{File.mtime(path).to_i}" }.join)
+      end
+      
+    end
+  end
+end