jekyll_ext 0.1.0

data/README.textile

@@ -0,0 +1,16 @@
+h1. jekyll_ext
+
+<em>jekyll_ext</em> allows you to extend the Jekyll static blog generator without forking and modifying it's codebase.
+With this code, not only do your extensions live in your blog directory, but they can also be shared and reutilized.
+
+More information can be found here: "Jekyll Extensions -= Pain":http://rfelix.com/2010/01/19/jekyll-extensions-minus-equal-pain/
+
+h2. Installation
+
+<code>gem install jekyll_ext</code>
+
+Now you just need to create the directory <em>_extensions</em> in your blog where all your extensions will live. Any <em>.rb</em> file in that directory or subdirectory will automatically be loaded by <em>jekyll_ext</em>.
+
+IMPORTANT: Instead of using the <code>jekyll</code> command, you should now use <code>ejekyll</code> instead (which is just a jekyll wrapper that loads your extensions).
+
+To get you started, take a look at my own <em>_extensions</em> directory: "my_jekyll_extensions":http://github.com/rfelix/my_jekyll_extensions

data/Rakefile

@@ -0,0 +1,5 @@
+require "rake"
+require "rake/clean"
+require "mg"
+
+MG.new("jekyll_ext.gemspec")

data/bin/ejekyll

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+# Code based on gist supplied by Alban Peignier (http://gist.github.com/379361)
+
+require 'rubygems'
+require 'jekyll'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'aop.rb')
+
+module Jekyll
+
+  class << self
+    alias_method :configuration_without_extensions, :configuration
+    def configuration_with_extensions(options)
+      options = configuration_without_extensions(options)
+      Dir["_extensions/*.rb", "_extensions/*/*.rb"].each do |f|
+        puts "Loading Extension: #{File.basename(f)}"
+        load f
+      end
+      options
+    end
+    alias_method :configuration, :configuration_with_extensions 
+    
+    alias_method :original_version, :version
+    def version
+      original_version + " (Extended)"
+    end
+    
+  end
+
+end
+
+original_jekyll = ENV['PATH'].split(':').collect { |d| "#{d}/jekyll" }.find{ |p| File.exists?(p) }
+load original_jekyll

data/lib/aop.rb

@@ -0,0 +1,107 @@
+if RUBY_VERSION >= "1.9"
+  require 'continuation'
+end
+
+module AOP
+  extend self  
+
+  # Intercept the +meth_name+ method of +klass+ and execute +block+ before the
+  # original method.
+  #   +klass+ Class that method to be intercepted belongs to
+  #   +meth_name+ Name of method to be intercepted
+  #   +block+ Code to executed before method, and can receive as parameters:
+  #     1. the instance that has been intercepted
+  #     2. the arguments passed to the original method
+  #
+  def before(klass, meth_name, &block)
+    intercept(klass, meth_name, :before, &block)
+  end
+  
+  # Intercept the +meth_name+ method of +klass+ and execute +block+ after the
+  # original method
+  #   +klass+ Class that method to be intercepted belongs to
+  #   +meth_name+ Name of method to be intercepted
+  #   +block+ Code to executed before method, and can receive as parameters:
+  #     1. the instance that has been intercepted
+  #     2. the arguments passed to the original method
+  #
+  def after(klass, meth_name, &block)
+    intercept(klass, meth_name, :after, &block)
+  end
+  
+  # Intercept the +meth_name+ method of +klass+ and execute +block+ before and
+  # after the original method, but needs explicit calling of a Ruby proc/lambda.
+  #   +klass+ Class that method to be intercepted belongs to
+  #   +meth_name+ Name of method to be intercepted
+  #   +block+ Code to executed before method, and can receive as parameters:
+  #     1. the instance that has been intercepted
+  #     2. the arguments passed to the original method
+  #     3. the proc that, if called, will proceed with the execution of the method
+  #     4. the proc that, if called, will abort the execution of the method returning
+  #        whatever was passed as arguments to the block
+  #
+  def around(klass, meth_name, &block)
+    intercept(klass, meth_name, :around, &block)
+  end
+  
+private
+  
+  # Use Ruby metaprogramming capabilities to intercept the method only once, making
+  # it execute the blocks defined for before, after, and around at the correct
+  # time before, after, or around the calling of the original method.
+  #   +klass+ Class that method to be intercepted belongs to
+  #   +meth_name+ Name of method to be intercepted
+  #   +type+ Type of interception to be made (before, after, or around)
+  #   +block+ Code to executed before/after/around method
+  # 
+  def intercept(klass, meth_name, type, &block)
+    orig_name = "aop_orig_#{meth_name}".to_sym
+    meth_name = meth_name.to_sym
+    @intercepted_methods ||= Hash.new do |h,k| 
+      # h[class_name] = hash
+      h[k] = Hash.new do |h,k|
+        # h[class_name][method_name] = hash
+        h[k] = Hash.new do |h,k| 
+          # h[class_name][method_name][interception_type] = array
+          h[k] = []
+        end
+      end
+    end
+    
+    make_interception = !@intercepted_methods[klass].has_key?(meth_name)
+    @intercepted_methods[klass][meth_name][type] << block
+    method_chain = @intercepted_methods[klass][meth_name]
+    
+    if make_interception
+      klass.class_eval do
+        alias_method orig_name, meth_name
+        define_method(meth_name) do |*args|
+          method_chain[:before].each { |m| m.call(self, args) }
+          # The result of the callcc block will either be the last line in the actual
+          # ruby block, or it will be whatever is passed as arguments when calling the 
+          # +abort_continuation+ proc
+          callcc do |abort_continuation|
+            # First lambda in chain is the call to the original method
+            call_lambda = lambda { send(orig_name, *args) }
+            method_chain[:around].each do |m|
+              # Make a chain of lambdas that calls the previouly defined
+              # lambda, thus creating a chain of around blocks that will
+              # all finally reach the original method block
+              prev_call_lambda = call_lambda
+              call_lambda = lambda {
+                # If +prev_call_lambda+ is called, the next around block in
+                # chain until the last one which corresponds to the original method call
+                # if +abort_continuation+ is called, then this loop is aborted and the
+                # callcc block returns whatever was passed as an argument to the proc call
+                m.call(self, args, prev_call_lambda, abort_continuation)
+              }
+            end
+            result = call_lambda.call
+            method_chain[:after].each { |m| m.call(self, result, args) }
+            result
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: jekyll_ext
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Raoul Felix
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-21 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mg
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: "      jekyll_ext allows you to extend the Jekyll static blog generator without forking\n      and modifying it's codebase. With this code, not only do your extensions live in\n      your blog directory, but they can also be shared and reutilized.\n"
+email: gems@rfelix.com
+executables: 
+- ejekyll
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/aop.rb
+- bin/ejekyll
+- Rakefile
+- README.textile
+has_rdoc: true
+homepage: http://rfelix.com/2010/01/19/jekyll-extensions-minus-equal-pain/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Create Jekyll extensions that are local to your blog and that can be shared with others
+test_files: []
+