pakada 0.0.0

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+group :pakada do
+  gem "pakada", :path => "."
+end
+
+group :testing do
+  gem "mocha"
+  gem "fakefs"
+  gem "fakefs-require"
+end
+

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Lars Gierth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1 @@
+= Drupal-like awesomeness on Ruby

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler"
+Bundler.setup(:pakada)
+
+require "pakada/tasks"

data/lib/pakada/application.rb

@@ -0,0 +1,23 @@
+class Pakada
+  class Application
+    class << self
+      attr_reader :request, :response
+      
+      def call(request_env)
+        Pakada.hook(:reset)
+        
+        request = Rack::Request.new(request_env)
+        response = Rack::Response.new
+        
+        @request, @response = request, response
+        Pakada.hook(:request)
+  
+        response.write("Hi, I'm Pakada!") if response.length == 0
+        
+        Pakada.hook(:response)
+        @request, @response = nil, nil
+        return response.finish
+      end
+    end
+  end
+end

data/lib/pakada/boot.rb

@@ -0,0 +1,7 @@
+require "pakada"
+
+env = (ENV["RACK_ENV"] ||= "development").to_sym
+Bundler.setup(:modules, :default, env)
+
+require "config/boot" if File.exist?("config/boot.rb")
+Pakada.boot(env)

data/lib/pakada/module.rb

@@ -0,0 +1,81 @@
+class Pakada
+  module Module
+    @descendants = Dictionary.new
+    
+    class << self
+      attr_reader :descendants
+      
+      def prepare
+        specs = []
+        Gem.loaded_specs.each do |name, spec|
+          next unless name =~ Regexp.new("^#{gem_prefix}")
+          i = $LOAD_PATH.find_index(spec.load_paths.first)
+          specs[i] = spec
+        end
+        specs.delete(nil)
+        
+        specs.reverse.each do |spec|
+          name = spec.name[gem_prefix.length..-1].to_sym
+          @descendants[name] = {
+            :gemspec => spec,
+            :klass => nil,
+            :path => spec.full_gem_path,
+          } unless @descendants[name]
+        end
+      end
+      
+      def load
+        prepare
+        
+        @descendants.each do |name, mod|
+          next if mod[:klass]
+          require(mod[:gemspec].full_gem_path + "/module")
+        end
+      end
+      
+      def gem_prefix
+        @gem_prefix ||= "pakada" + Pakada::VERSION.split(".")[0] + "-"
+      end
+      
+      def included(klass)
+        klass.class_eval { @hooks = {} }
+        klass.extend(ClassMethods)
+        
+        name = klass.to_s.underscore.split("_")[0..-2].join("_")
+        @descendants[name.to_sym][:klass] = klass
+      end
+    end
+    
+    def hook(name, *args)
+      hooks = self.class.class_eval { @hooks }
+      hooks[name].each {|h| instance_exec(*args, &h) } if hooks[name]
+    end
+    
+    def version
+      return self.class.version
+    end
+    
+    def path
+      return self.class.path
+    end
+    
+    module ClassMethods
+      def hook(name, &block)
+        @hooks[name] ||= []
+        @hooks[name] << block
+      end
+      
+      def name
+        return @name ||= Pakada::Module.descendants.find {|m| m[1][:klass] == self }[0]
+      end
+      
+      def version
+        return Pakada::Module.descendants[name][:gemspec].version.to_s
+      end
+      
+      def path
+        return Pakada::Module.descendants[name][:path]
+      end
+    end
+  end
+end

data/lib/pakada/support/aliasing.rb

@@ -0,0 +1,8 @@
+class Module
+  
+  def alias_method_chain(target, feature)
+    alias_method("#{target}_without_#{feature}", target)
+    alias_method(target, "#{target}_with_#{feature}")
+  end
+  
+end

data/lib/pakada/support/inflection.rb

@@ -0,0 +1,35 @@
+class String
+  
+  def classify()
+    Extlib::Inflection.classify(self)
+  end
+  
+  def camelize()
+    Extlib::Inflection.camelize(self)
+  end
+  
+  def underscore()
+    Extlib::Inflection.underscore(self)
+  end
+  
+  def humanize()
+    Extlib::Inflection.humanize(self)
+  end
+  
+  def demodulize()
+    Extlib::Inflection.demodulize(self)
+  end
+  
+  def tableize()
+    Extlib::Inflection.tableize(self)
+  end
+  
+  def foreign_key()
+    Extlib::Inflection.foreign_key(self)
+  end
+  
+  def constantize()
+    Extlib::Inflection.constantize(self)
+  end
+  
+end

data/lib/pakada/support/instance_exec.rb

@@ -0,0 +1,27 @@
+class Object
+
+  module InstanceExecHelper
+  end
+
+  include InstanceExecHelper
+  
+  # this leaks memory
+  # see http://eigenclass.org/hiki/bounded+space+instance_exec
+  def instance_exec(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname = "__instance_exec#{n}")
+      InstanceExecHelper.module_eval { define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    return ret
+  end
+  
+end

data/lib/pakada/support.rb

@@ -0,0 +1,9 @@
+require "yaml"
+
+require "extlib/dictionary"
+require "extlib/inflection"
+require "extlib/string"
+
+require "pakada/support/aliasing"
+require "pakada/support/inflection"
+require "pakada/support/instance_exec" if RUBY_VERSION < "1.9"

data/lib/pakada/tasks.rb

@@ -0,0 +1,22 @@
+require "pakada"
+
+dirs = []
+
+# core's tasks
+dirs << Gem.loaded_specs["pakada"].full_gem_path
+
+# modules' tasks
+ENV["RACK_ENV"] ||= "development"
+Bundler.setup(:modules, :default, ENV["RACK_ENV"].to_sym)
+Pakada::Module.load
+Pakada::Module.descendants.each do |name, mod|
+  dirs << mod[:gemspec].full_gem_path
+end
+
+# project's tasks
+dirs << Dir.pwd
+
+# load the tasks
+dirs.uniq.each do |dir|
+  Dir["#{dir}/tasks/*"].each {|f| require(f) }
+end

data/lib/pakada/test.rb

@@ -0,0 +1,14 @@
+ENV["RACK_ENV"] = "testing"
+require "bundler"
+Bundler.setup(:pakada, :modules, :default, ENV["RACK_ENV"].to_sym)
+
+require "pakada"
+
+require "test/unit"
+require "pakada/test_case"
+Test::Unit::TestCase.class_eval { include(Pakada::TestCase) }
+
+require "mocha"
+require "fakefs/safe"
+require "fakefs/require"
+require "rack"

data/lib/pakada/test_case.rb

@@ -0,0 +1,69 @@
+class Pakada
+  module TestCase
+    def create_files(files)
+      files.each do |name, content|
+        File.open(name, "w") do |f|
+          f.write(content)
+        end
+      end
+    end
+    
+    def stub_gemspecs(paths)
+      @stubbed_gemspecs ||= []
+      @load_path_diff ||= []
+      
+      old_load_path = $LOAD_PATH.dup
+
+      paths.each do |path|
+        spec = eval(File.read(path))
+        dir = File.expand_path(File.dirname(path))
+        
+        spec.stubs(:full_gem_path).returns(dir)
+        spec.stubs(:load_paths).returns([dir + "/lib"])
+        Gem.loaded_specs[spec.name] = spec
+        @stubbed_gemspecs << spec.name
+        
+        $LOAD_PATH.unshift(spec.load_paths.first)
+      end
+      
+      @load_path_diff += $LOAD_PATH - old_load_path
+    end
+    
+    def revert_gemspecs()
+      @stubbed_gemspecs.each {|name| Gem.loaded_specs.delete(name) }
+      @load_path_diff.each {|path| $LOAD_PATH.delete(path) }
+      
+      @stubbed_gemspecs = nil
+      @load_path_diff = nil
+    end
+    
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def setup(&block)
+        define_method(:setup, &block)
+      end
+      
+      def teardown(&block)
+        define_method(:teardown, &block)
+      end
+      
+      def test(name, &block)
+        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        
+        defined = instance_method(test_name) rescue false
+        raise "#{test_name} is already defined in #{self}" if defined
+        
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pakada/version.rb

@@ -0,0 +1,3 @@
+class Pakada
+  VERSION = Gem.loaded_specs["pakada"].version.to_s
+end

data/lib/pakada.rb

@@ -0,0 +1,113 @@
+require "rack"
+require "pakada/support"
+
+require "pakada/application"
+require "pakada/module"
+require "pakada/version"
+
+class Pakada
+  class << self
+    attr_reader :modules, :middleware
+    attr_writer :env
+    
+    def boot(env = nil)
+      @env = env.to_sym if env
+      
+      load_middleware 
+      load_modules if @modules.empty?
+      
+      hook(:boot) unless testing?
+    end
+    
+    def load_middleware
+      config = YAML.load_file("config/middleware.yml") rescue {}
+      @middleware = Rack::Builder.new
+      config[env].each do |klass|
+        args = []
+        klass, args = klass.to_a[0] if klass.is_a?(Hash)
+        if args.is_a?(Array)
+          @middleware.use(klass.constantize, *args)
+        else
+          @middleware.use(klass.constantize, args)
+        end
+      end if config[env]
+    end
+    
+    def load_modules
+      Module.load
+      @modules = Dictionary.new
+      @hooks = {}
+      Module.descendants.each do |name, mod|
+        @modules[name] = mod[:klass].new
+        @modules[name].hook(:activate) unless testing?
+      end
+    end
+    
+    def [](name)
+      return modules[name]
+    end
+    
+    def []=(name, mod)
+      modules[name] = mod
+    end
+    
+    def hook(name, *args)
+      catch(:halt) { @modules.each_value {|mod| mod.hook(name, *args) } }
+    end
+    
+    def hook_reverse(name, *args)
+      catch(:halt) { @modules.reverse.each_value {|mod| mod.hook(name, *args) } }
+    end
+    
+    def app
+      unless @app
+        @middleware.run(Application)
+        @app = @middleware.to_app
+      end
+      return @app
+    end
+    
+    def request
+      return Application.request
+    end
+    
+    def response
+      return Application.response
+    end
+    
+    def reset
+      @env = nil
+      @middleware = Rack::Builder.new
+      @modules = Dictionary.new
+      @app = nil
+    end
+    
+    def shutdown
+      hook_reverse(:shutdown) unless testing?
+      
+      reset
+    end
+    
+    def env
+      return @env ||= (ENV["RACK_ENV"] || :development).to_sym
+    end
+    
+    def development?
+      return env == :development
+    end
+    
+    def testing?
+      return env == :testing
+    end
+    
+    def staging?
+      return env == :staging
+    end
+    
+    def production?
+      return env == :production
+    end
+  end
+  
+  reset
+end

data/tasks/test.rb

@@ -0,0 +1,73 @@
+require "rake/testtask"
+
+desc " => rake test"
+task " " => :default
+task :default => :test
+
+desc "Test all modules as well as Pakada's core"
+task :test do
+  Rake::Task["test:*"].execute
+end
+
+namespace :test do
+  desc "Test the module 'my_module'"
+  task :"my_module"
+  
+  desc "Test the modules 'my_module' and 'another_module' as well as Pakada's core"
+  task :"my_module+another_module+core"
+end
+
+rule /^test(:.+)?$/ do |t|
+  arg = (t.name || "*").split(":").last
+  modules = []
+  
+  if arg == "*"
+    modules << "core"
+    modules += Pakada::Module.descendants.keys
+  else
+    modules = arg.split("+")
+  end
+  
+  modules.each do |mod|
+    puts "-----"
+    puts "Testing #{mod}"
+    
+    runner = "rake/rake_test_loader.rb"
+    $LOAD_PATH.each do |p|
+      path = File.join p, runner
+      if File.exist? path
+        runner = path
+        break
+      end
+    end
+    
+    dir = File.expand_path(if mod == "core"
+      File.dirname(__FILE__) + "/.."
+    else
+      Pakada::Module.descendants[mod.to_sym][:path] rescue raise("Unknown module: #{mod}")
+    end)
+    files = FileList[dir + "/test/**/*_test.rb"]
+
+    opts = []
+    opts << "-rubygems"
+    opts << "-C#{dir}"
+    opts << "-I#{Gem.loaded_specs["pakada"].full_gem_path}/lib"
+    
+    ["_", "PWD", "GEM_PATH", "GEM_HOME"].each {|k| ENV.delete(k) }
+    ENV["BUNDLE_GEMFILE"] = if File.exist?(dir + "/Gemfile")
+      dir + "/Gemfile"
+    else
+      File.expand_path("Gemfile")
+    end
+    
+    begin
+      cmd = FileUtils::RUBY + " " + [
+        opts.join(" "),
+        runner,
+        files.map{|f| %("#{f}") }.join(" "),
+      ].join(" ")
+      system(cmd)
+    rescue
+    end
+  end
+end

data/test/files.rb

@@ -0,0 +1,60 @@
+FILES = {
+
+  "config/middleware.yml" => <<-CODE,
+    :testing:
+        - Rack::ShowExceptions
+        - Rack::Static:
+            :urls:
+                - /images
+            :root: public
+  CODE
+  
+  "modules/foo/pakada0-foo.gemspec" => <<-CODE,
+    Gem::Specification.new do |s|
+      s.name        = "pakada0-foo"
+      s.version     = "0.1.0dev"
+      s.platform    = Gem::Platform::RUBY
+      s.authors     = ["Lars Gierth"]
+      s.email       = ["lgierth@entwickler.com"]
+      s.homepage    = "http://github.com/lgierth/pakada"
+      s.summary     = "nothing"
+      
+      s.add_dependency "pakada"
+      
+      s.files        = ["module.rb"]
+      s.require_path = "lib"
+      
+      s.required_rubygems_version = ">= 1.3.6"
+    end
+  CODE
+  "modules/foo/module.rb" => <<-CODE,
+    class FooModule
+      include Pakada::Module
+    end
+  CODE
+  
+  "modules/bar/pakada0-bar.gemspec" => <<-CODE,
+    Gem::Specification.new do |s|
+      s.name        = "pakada0-bar"
+      s.version     = "0.1.0dev"
+      s.platform    = Gem::Platform::RUBY
+      s.authors     = ["Lars Gierth"]
+      s.email       = ["lgierth@entwickler.com"]
+      s.homepage    = "http://github.com/lgierth/pakada"
+      s.summary     = "nothing"
+      
+      s.add_dependency "pakada"
+      
+      s.files        = ["module.rb"]
+      s.require_path = "lib"
+      
+      s.required_rubygems_version = ">= 1.3.6"
+    end
+  CODE
+  "modules/bar/module.rb" => <<-CODE,
+    class BarModule
+      include Pakada::Module
+    end
+  CODE
+
+}

data/test/helper.rb

@@ -0,0 +1 @@
+require "pakada/test"

data/test/module_test.rb

@@ -0,0 +1,81 @@
+require "test/helper"
+require "test/files"
+
+class ModuleTest < Test::Unit::TestCase
+  setup do
+    FakeFS.activate!
+    FakeFS::Require.activate!({
+      :fallback => true,
+      :load => true,
+      :autoload => true,
+    })
+    create_files(FILES)
+    
+    stub_gemspecs([
+      "modules/foo/pakada0-foo.gemspec",
+      "modules/bar/pakada0-bar.gemspec",
+    ])
+  end
+  
+  teardown do
+    revert_gemspecs
+    Mocha::Mockery.instance.teardown
+    
+    Pakada.shutdown
+    
+    FakeFS::FileSystem.clear
+    FakeFS::Require.deactivate!
+    FakeFS.deactivate!
+  end
+  
+  test "prepares modules" do
+    Pakada::Module.prepare
+    modules = Pakada::Module.descendants
+    
+    assert_equal 2, modules.length
+    assert_equal File.expand_path("modules/foo"), modules[:foo][:path]
+    assert_equal "pakada0-foo", modules[:foo][:gemspec].name
+  end
+  
+  test "loads modules" do
+    Pakada::Module.load
+    modules = Pakada::Module.descendants
+    
+    assert_equal 2, modules.length
+    assert_equal FooModule, modules[:foo][:klass]
+  end
+  
+  test "has hooks" do
+    Pakada::Module.load
+
+    FooModule.class_eval do
+      hook :asd do
+      end
+    end
+    
+    assert(FooModule.class_eval { @hooks[:asd] })
+    assert_equal 1, FooModule.class_eval { @hooks[:asd].length }
+  end
+  
+  test "executes hooks" do
+    Pakada.boot
+    
+    FooModule.class_eval do
+      hook :something do |state|
+        state.called = true
+      end
+    end
+    
+    state = Struct.new(:called).new
+    Pakada.hook :something, state
+    
+    assert state.called
+  end
+  
+  test "has a version" do
+    Pakada.boot
+    
+    version = Gem.loaded_specs["pakada0-foo"].version.to_s
+    assert_equal version, Pakada[:foo].version
+  end
+end

data/test/pakada_test.rb

@@ -0,0 +1,80 @@
+require "test/helper"
+require "test/files"
+
+class PakadaTest < Test::Unit::TestCase
+  setup do
+    FakeFS.activate!
+    FakeFS::Require.activate!({
+      :fallback => true,
+      :load => true,
+      :autoload => true,
+    })
+    create_files(FILES)
+    
+    stub_gemspecs([
+      "modules/foo/pakada0-foo.gemspec",
+      "modules/bar/pakada0-bar.gemspec",
+    ])
+  end
+  
+  teardown do
+    revert_gemspecs
+    Mocha::Mockery.instance.teardown
+    
+    Pakada.shutdown
+    
+    FakeFS::FileSystem.clear
+    FakeFS::Require.deactivate!
+    FakeFS.deactivate!
+  end
+  
+  test "maintains a Rack middleware stack" do
+    Rack::Builder.any_instance.expects(:use).with(Rack::ShowExceptions)
+    Rack::Builder.any_instance.expects(:use).with(Rack::Static, {
+      :urls => ["/images"],
+      :root => "public",
+    })
+    Pakada.boot
+  end
+  
+  test "executes modules' hooks" do
+    Pakada.boot
+    Pakada[:foo].class.class_eval do
+      hook(:foobar) do
+      end
+    end
+    
+    Pakada[:foo].expects(:hook).once.with(:foobar, 123)
+    Pakada.hook(:foobar, 123)
+  end
+  
+  test "cancels the execution of a hook when it catches :halt" do
+    Pakada.boot
+    Pakada[:foo].class.class_eval do
+      hook(:foobar) do |state|
+        throw :halt
+        state.after_throw = true
+      end
+    end
+    
+    state = Struct.new(:after_throw).new
+    Pakada.hook(:foobar, state)
+    
+    assert !state.after_throw
+  end
+  
+  test "provides a Rack application end-point" do
+    Rack::Builder.any_instance.expects(:run).with(Pakada::Application)
+    
+    Pakada.boot
+    assert_equal Rack::ShowExceptions, Pakada.app.class
+  end
+  
+  test "prints a greeting when the response would be empty" do
+    Pakada.boot
+    Pakada.stubs(:hook)
+    
+    resp = Pakada.app.call("PATH_INFO" => "/")
+    assert_equal "Hi, I'm Pakada!", resp[2].body.to_s
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification 
+name: pakada
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Lars Gierth
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: fakefs-require
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: 
+email: 
+- lgierth@entwickler.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pakada/version.rb
+- lib/pakada/support.rb
+- lib/pakada/boot.rb
+- lib/pakada/tasks.rb
+- lib/pakada/test.rb
+- lib/pakada/test_case.rb
+- lib/pakada/application.rb
+- lib/pakada/module.rb
+- lib/pakada/support/aliasing.rb
+- lib/pakada/support/instance_exec.rb
+- lib/pakada/support/inflection.rb
+- lib/pakada.rb
+- tasks/test.rb
+- test/pakada_test.rb
+- test/files.rb
+- test/module_test.rb
+- test/helper.rb
+- Gemfile
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/lgierth/pakada
+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: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Drupal-like awesomeness on Ruby
+test_files: []
+