merb_active_record 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 YOUR NAME
+
+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

@@ -0,0 +1,4 @@
+merb_active_record
+=================
+
+A plugin for the Merb framework that provides ....

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+PLUGIN = "merb_active_record"
+NAME = "merb_active_record"
+VERSION = "0.0.1"
+AUTHOR = "Duane Johnson"
+EMAIL = "canadaduane@gmail.com"
+HOMEPAGE = "http://merb-plugins.rubyforge.org/merb_active_record/"
+SUMMARY = "Merb plugin that provides ActiveRecord support for Merb"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.requirements << 'merb'
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_active_record.rb
+Add your Merb rake tasks to lib/merb_active_record/merbtasks.rb

data/lib/merb/orms/active_record/connection.rb

@@ -0,0 +1,56 @@
+require 'fileutils'
+require 'active_record'
+
+module Merb
+  module Orms
+    module ActiveRecord
+      class << self
+        def config_file() MERB_ROOT / "config" / "database.yml" end
+        def sample_dest() MERB_ROOT / "config" / "database.sample.yml" end
+        def sample_source() File.dirname(__FILE__) / "database.sample.yml" end
+      
+        def copy_sample_config
+          FileUtils.cp sample_source, sample_dest unless File.exists?(sample_dest)
+        end
+      
+        def config
+          @config ||=
+            begin
+              # Convert string keys to symbols
+              full_config = Erubis.load_yaml_file(config_file)
+              config = (Merb::Plugins.config[:merb_active_record] = {})
+              (full_config[MERB_ENV.to_sym] || full_config[MERB_ENV]).each { |k, v| config[k.to_sym] = v }
+               ::ActiveRecord::Base.configurations= full_config
+              config
+            end
+        end
+
+        # Database connects as soon as the gem is loaded
+        def connect
+          if File.exists?(config_file)
+            puts "Connecting to database..."
+
+            Thread.new{ loop{ sleep(60*60); ::ActiveRecord::Base.verify_active_connections! } }.priority = -10
+
+            ::ActiveRecord::Base.verification_timeout = 14400
+            ::ActiveRecord::Base.logger = MERB_LOGGER
+            ::ActiveRecord::Base.establish_connection config
+          else
+            copy_sample_config
+            puts "No database.yml file found in #{MERB_ROOT}/config."
+            puts "A sample file was created called database.sample.yml for you to copy and edit."
+            exit(1)
+          end
+        end
+        
+        # Registering this ORM lets the user choose active_record as a session
+        # in merb.yml's session_store: option.
+        def register_session_type
+          Merb::Server.register_session_type("active_record",
+            "merb/session/active_record_session",
+            "Using ActiveRecord database sessions")
+        end
+      end
+    end
+  end
+end

data/lib/merb/orms/active_record/database.sample.yml

@@ -0,0 +1,17 @@
+---
+# This is a sample database file for the Sequel ORM
+:development: &defaults
+  :adapter: mysql
+  :database: sample_development
+  :username: teh_user
+  :password: secrets
+  :host: localhost
+  :socket: /tmp/mysql.sock
+
+:test:
+  <<: *defaults
+  :database: sample_test
+
+:production:
+  <<: *defaults
+  :database: sample_production

data/lib/merb/orms/active_record/tasks/databases.rb

@@ -0,0 +1,287 @@
+task :environment do
+ MERB_ENV = ( ENV['MERB_ENV'] || MERB_ENV ).to_sym
+end
+
+namespace :db do
+  namespace :create do
+    desc 'Create all the local databases defined in config/database.yml'
+    task :all => :environment do
+      ActiveRecord::Base.configurations.each_value do |config|
+        create_local_database(config)
+      end
+    end
+  end
+
+  desc 'Create the local database defined in config/database.yml for the current MERB_ENV'
+  task :create => :environment do
+    p ActiveRecord::Base.configurations
+    p MERB_ENV
+    create_local_database(ActiveRecord::Base.configurations[MERB_ENV])
+  end
+
+  def create_local_database(config)
+    # Only connect to local databases
+    if config[:host] == 'localhost' || config[:host].blank?
+      begin
+        ActiveRecord::Base.establish_connection(config)
+        ActiveRecord::Base.connection
+      rescue
+        case config[:adapter]
+        when 'mysql'
+          #~ @charset   = ENV['CHARSET']   || 'utf8'
+          #~ @collation = ENV['COLLATION'] || 'utf8_general_ci'
+          begin
+            ActiveRecord::Base.establish_connection(config.merge({:database => nil}))
+            ActiveRecord::Base.connection.create_database(config[:database]) #, {:charset => @charset, :collation => @collation})
+            ActiveRecord::Base.establish_connection(config)
+            p "MySQL #{config[:database]} database succesfully created"
+          rescue
+            $stderr.puts "Couldn't create database for #{config.inspect}"
+          end
+        when 'postgresql'
+          `createdb "#{config[:database]}" -E utf8`
+        when 'sqlite'
+          `sqlite "#{config[:database]}"`
+        when 'sqlite3'
+          `sqlite3 "#{config[:database]}"`
+        end
+      else
+        p "#{config[:database]} already exists"
+      end
+    else
+      p "This task only creates local databases. #{config[:database]} is on a remote host."
+    end
+  end
+
+  desc 'Drops the database for the current environment'
+  task :drop => :environment do
+    config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+    p config
+    case config[:adapter]
+    when 'mysql'
+      ActiveRecord::Base.connection.drop_database config[:database]
+    when /^sqlite/
+      FileUtils.rm_f File.join(MERB_ROOT, config[:database])
+    when 'postgresql'
+      `dropdb "#{config[:database]}"`
+    end
+  end
+
+  desc "Migrate the database through scripts in schema/migrations. Target specific version with VERSION=x"
+  task :migrate => :environment do
+    ActiveRecord::Migrator.migrate("schema/migrations/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  desc 'Drops, creates and then migrates the database for the current environment. Target specific version with VERSION=x'
+  task :reset => ['db:drop', 'db:create', 'db:migrate']
+
+  # desc "Retrieves the charset for the current environment's database"
+  # task :charset => :environment do
+  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   case config[:adapter]
+  #   when 'mysql'
+  #     ActiveRecord::Base.establish_connection(config)
+  #     puts ActiveRecord::Base.connection.charset
+  #   else
+  #     puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+  #   end
+  # end
+
+  # desc "Retrieves the collation for the current environment's database"
+  # task :collation => :environment do
+  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   case config[:adapter]
+  #   when 'mysql'
+  #     ActiveRecord::Base.establish_connection(config)
+  #     puts ActiveRecord::Base.connection.collation
+  #   else
+  #     puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+  #   end
+  # end
+
+  desc "Retrieves the current schema version number"
+  task :version => :environment do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+    task :load => :environment do
+      require 'active_record/fixtures'
+      ActiveRecord::Base.establish_connection(MERB_ENV.to_sym)
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(MERB_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+        Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
+      end
+    end
+  end
+
+  namespace :schema do
+    desc "Create a schema/schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :environment do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "schema/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+
+    desc "Load a schema.rb file into the database"
+    task :load => :environment do
+      file = ENV['SCHEMA'] || "schema/schema.rb"
+      load(file)
+    end
+  end
+
+  namespace :structure do
+    desc "Dump the database structure to a SQL file"
+    task :dump => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs[MERB_ENV][:adapter]
+      when "mysql", "oci", "oracle"
+        ActiveRecord::Base.establish_connection(abcs[MERB_ENV])
+        File.open("schema/#{MERB_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+      when "postgresql"
+        ENV['PGHOST']     = abcs[MERB_ENV]["host"] if abcs[MERB_ENV]["host"]
+        ENV['PGPORT']     = abcs[MERB_ENV]["port"].to_s if abcs[MERB_ENV]["port"]
+        ENV['PGPASSWORD'] = abcs[MERB_ENV]["password"].to_s if abcs[MERB_ENV]["password"]
+        search_path = abcs[MERB_ENV]["schema_search_path"]
+        search_path = "--schema=#{search_path}" if search_path
+        `pg_dump -i -U "#{abcs[MERB_ENV]["username"]}" -s -x -O -f schema/#{MERB_ENV}_structure.sql #{search_path} #{abcs[MERB_ENV]["database"]}`
+        raise "Error dumping database" if $?.exitstatus == 1
+      when "sqlite", "sqlite3"
+        dbfile = abcs[MERB_ENV]["database"] || abcs[MERB_ENV]["dbfile"]
+        `#{abcs[MERB_ENV]["adapter"]} #{dbfile} .schema > schema/#{MERB_ENV}_structure.sql`
+      when "sqlserver"
+        `scptxfr /s #{abcs[MERB_ENV]["host"]} /d #{abcs[MERB_ENV]["database"]} /I /f db\\#{MERB_ENV}_structure.sql /q /A /r`
+        `scptxfr /s #{abcs[MERB_ENV]["host"]} /d #{abcs[MERB_ENV]["database"]} /I /F db\ /q /A /r`
+      when "firebird"
+        set_firebird_env(abcs[MERB_ENV])
+        db_string = firebird_db_string(abcs[MERB_ENV])
+        sh "isql -a #{db_string} > schema/#{MERB_ENV}_structure.sql"
+      else
+        raise "Task not supported by '#{abcs[MERB_ENV][:adapter]}'"
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open("schema/#{MERB_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      end
+    end
+  end
+
+  namespace :test do
+    desc "Recreate the test database from the current environment's database schema"
+    task :clone => %w(db:schema:dump db:test:purge) do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Schema.verbose = false
+      Rake::Task["db:schema:load"].invoke
+    end
+
+
+    desc "Recreate the test databases from the development structure"
+    task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+      when "mysql"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+        IO.readlines("schema/#{MERB_ENV}_structure.sql").join.split("\n\n").each do |table|
+          ActiveRecord::Base.connection.execute(table)
+        end
+      when "postgresql"
+        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        `psql -U "#{abcs["test"]["username"]}" -f schema/#{MERB_ENV}_structure.sql #{abcs["test"]["database"]}`
+      when "sqlite", "sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        `#{abcs["test"]["adapter"]} #{dbfile} < schema/#{MERB_ENV}_structure.sql`
+      when "sqlserver"
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{MERB_ENV}_structure.sql`
+      when "oci", "oracle"
+        ActiveRecord::Base.establish_connection(:test)
+        IO.readlines("schema/#{MERB_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
+          ActiveRecord::Base.connection.execute(ddl)
+        end
+      when "firebird"
+        set_firebird_env(abcs["test"])
+        db_string = firebird_db_string(abcs["test"])
+        sh "isql -i schema/#{MERB_ENV}_structure.sql #{db_string}"
+      else
+        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    desc "Empty the test database"
+    task :purge => :environment do
+      abcs = ActiveRecord::Base.configurations
+      case abcs["test"]["adapter"]
+      when "mysql"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
+      when "postgresql"
+        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+        enc_option = "-E #{abcs["test"]["encoding"]}" if abcs["test"]["encoding"]
+
+        ActiveRecord::Base.clear_active_connections!
+        `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+        `createdb #{enc_option} -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
+      when "sqlite","sqlite3"
+        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+        File.delete(dbfile) if File.exist?(dbfile)
+      when "sqlserver"
+        dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{MERB_ENV}_structure.sql`
+      when "oci", "oracle"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+          ActiveRecord::Base.connection.execute(ddl)
+        end
+      when "firebird"
+        ActiveRecord::Base.establish_connection(:test)
+        ActiveRecord::Base.connection.recreate_database!
+      else
+        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      end
+    end
+
+    desc 'Prepare the test database and load the schema'
+    task :prepare => :environment do
+      if defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+        Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:clone" }[ActiveRecord::Base.schema_format]].invoke
+      end
+    end
+  end
+
+  namespace :sessions do
+  #  desc "Creates a sessions migration for use with CGI::Session::ActiveRecordStore"
+  #  task :create => :environment do
+  #    raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+  #    require 'rails_generator'
+  #    require 'rails_generator/scripts/generate'
+  #    Rails::Generator::Scripts::Generate.new.run(["session_migration", ENV["MIGRATION"] || "AddSessions"])
+  #  end
+
+    desc "Clear the sessions table"
+    task :clear => :environment do
+      session_table = 'session'
+      session_table = Inflector.pluralize(session_table) if ActiveRecord::Base.pluralize_table_names
+      ActiveRecord::Base.connection.execute "DELETE FROM #{session_table}"
+    end
+  end
+end
+
+def session_table_name
+  ActiveRecord::Base.pluralize_table_names ? :sessions : :session
+end
+
+def set_firebird_env(config)
+  ENV["ISC_USER"]     = config["username"].to_s if config["username"]
+  ENV["ISC_PASSWORD"] = config["password"].to_s if config["password"]
+end
+
+def firebird_db_string(config)
+  FireRuby::Database.db_string_for(config.symbolize_keys)
+end

data/lib/merb/session/active_record_session.rb

@@ -0,0 +1,128 @@
+require 'active_record'
+
+module Merb
+  module SessionMixin
+    def setup_session
+      MERB_LOGGER.info("Setting up session")
+      before = cookies[_session_id_key]
+      @_session, cookies[_session_id_key] = Merb::ActiveRecordSession.persist(cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(@_session.data).hash
+      @_new_cookie = cookies[_session_id_key] != before
+    end
+
+    def finalize_session
+      MERB_LOGGER.info("Finalize session")
+      @_session.save if @_fingerprint != Marshal.dump(@_session.data).hash
+      set_cookie(_session_id_key, @_session.session_id, _session_expiry) if (@_new_cookie || @_session.needs_new_cookie)
+    end
+  end # ActiveRecordMixin
+
+  class ActiveRecordSession < ::ActiveRecord::Base
+    set_table_name 'sessions'
+    # Customizable data column name.  Defaults to 'data'.
+    cattr_accessor :data_column_name
+    self.data_column_name = 'data'
+    before_save :marshal_data!
+    before_save :raise_on_session_data_overflow!
+    attr_accessor :needs_new_cookie
+
+    class << self
+      # Generates a new session ID and creates a row for the new session in the database.
+      def generate
+        create(:session_id => Merb::SessionMixin::rand_uuid, :data => {})
+      end
+
+      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
+      # If none is found, generates a new session.
+      def persist(session_id)
+        if session_id
+          session = find_by_session_id(session_id)
+        end
+        unless session
+          session = generate
+        end
+        [session, session.session_id]
+      end
+    
+      # Don't try to reload ARStore::Session in dev mode.
+      def reloadable? #:nodoc:
+        false
+      end
+
+      def data_column_size_limit
+        @data_column_size_limit ||= columns_hash[@@data_column_name].limit
+      end
+
+      def marshal(data)   Base64.encode64(Marshal.dump(data)) if data end
+      def unmarshal(data) Marshal.load(Base64.decode64(data)) if data end
+
+      def create_table!
+        connection.execute <<-end_sql
+          CREATE TABLE #{table_name} (
+            id INTEGER PRIMARY KEY,
+            #{connection.quote_column_name('session_id')} TEXT UNIQUE,
+            #{connection.quote_column_name(@@data_column_name)} TEXT(255)
+          )
+        end_sql
+      end
+
+      def drop_table!
+        connection.execute "DROP TABLE #{table_name}"
+      end
+    end
+  
+    # Regenerate the Session ID
+    def regenerate
+      update_attributes(:session_id => Merb::SessionMixin::rand_uuid)
+      self.needs_new_cookie = true
+    end 
+   
+    # Recreates the cookie with the default expiration time 
+    # Useful during log in for pushing back the expiration date 
+    def refresh_expiration
+      self.needs_new_cookie = true
+    end 
+  
+    # Lazy-delete of session data 
+    def delete
+      self.data = {}
+    end
+  
+    def [](key)
+      data[key]
+    end
+  
+    def []=(key, val)
+      data[key] = val
+    end
+    
+    # Lazy-unmarshal session state.
+    def data
+      @data ||= self.class.unmarshal(read_attribute(@@data_column_name)) || {}
+    end
+
+    # Has the session been loaded yet?
+    def loaded?
+      !! @data
+    end
+
+    private
+      attr_writer :data
+
+      def marshal_data!
+        return false if !loaded?
+        write_attribute(@@data_column_name, self.class.marshal(self.data))
+      end
+
+      # Ensures that the data about to be stored in the database is not
+      # larger than the data storage column. Raises
+      # ActionController::SessionOverflowError.
+      def raise_on_session_data_overflow!
+        return false if !loaded?
+        limit = self.class.data_column_size_limit
+        if loaded? and limit and read_attribute(@@data_column_name).size > limit
+          raise MerbController::SessionOverflowError
+        end
+      end
+  end # ActiveRecordSessionMixin
+end # Merb

data/lib/merb_active_record.rb

@@ -0,0 +1,11 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  if Merb::Server.app_loaded?
+    puts "Warning: The merb_active_record gem must be loaded before the application"
+  else
+    require "merb/orms/active_record/connection"
+    Merb::Orms::ActiveRecord.connect
+    Merb::Orms::ActiveRecord.register_session_type
+  end
+  Merb::Plugins.add_rakefiles "merb/orms/active_record/tasks/databases"
+end

data/specs/merb_active_record_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "merb_active_record" do
+  it "should do nothing" do
+    true.should == true
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,2 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.1
+specification_version: 1
+name: merb_active_record
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-09-24 00:00:00 -07:00
+summary: Merb plugin that provides ActiveRecord support for Merb
+require_paths: 
+- lib
+email: canadaduane@gmail.com
+homepage: http://merb-plugins.rubyforge.org/merb_active_record/
+rubyforge_project: 
+description: Merb plugin that provides ActiveRecord support for Merb
+autorequire: merb_active_record
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Duane Johnson
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb
+- lib/merb_active_record.rb
+- lib/merb/orms
+- lib/merb/session
+- lib/merb/orms/active_record
+- lib/merb/orms/active_record/connection.rb
+- lib/merb/orms/active_record/database.sample.yml
+- lib/merb/orms/active_record/tasks
+- lib/merb/orms/active_record/tasks/databases.rb
+- lib/merb/session/active_record_session.rb
+- specs/merb_active_record_spec.rb
+- specs/spec_helper.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+executables: []
+
+extensions: []
+
+requirements: 
+- merb
+dependencies: []
+