dddbl 0.0.1.alpha

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+*.gem
+*~
+*#
+.bundle
+Gemfile.lock

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011, André Gawron
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, 
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+- The names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,188 @@
+= DDDBL - Definition Driven Database Layer
+
+== What?
+
+DDDBL is a library to simplify the use of (different) databases and splits up
+application's and database's (e.g: SQL queries) code through an easy
+and unified API. The SQL is defined in files outside of the application's source
+to easiliy port the SQL to diffrent applications - or even programming languages.
+Refering to the written queries using an alias makes it even more clearer and
+better to understand for newcomers, who then don't have to waste time figuring out
+what the query does.
+
+== Why?
+
+Many applications interacting with databases have the sql code directly written
+in the its source. Reading, reviewing and understanding that
+unfimiliar code can be hard, even more for non sql-pros. Most of the time -
+to optimize the queries and the database performance in general - DBAs are hired
+who are probably not familiar with the programming language used. So they have
+to dig into the code and try to optimize it without breaking anything.
+
+== Supported databases
+
+Common RDMS like MySQL, PostgreSQL and SQLite are supported. The DDDBL uses another
+gem called RDBI which simplifies the handling of several databases. For a full
+list please of supported drivers please check the RDBI's github page
+(https://github.com/RDBI/).
+
+== It's a port, isn't it?
+
+Yes. The DDDBL was orginally written in PHP and is a creation of Torsten Zühlsdorff.
+For more information on the PHP version, go to http://www.dddbl.de (German only).
+The ruby version will also be featured there in the near future.
+
+=== Any differences?
+
+Yes. As of writing, the ruby port does not include every functionality the
+PHP version offers. For example:
+
+* not as much freedom regarding manipulating query-parameter pre-execution besides
+  casting the binded parameters to any value extendable through TypeLib
+* caching of prepared statements
+
+== Dependecies
+
+The database handling and querying is handled by the RDBI library. For more
+information please see their README (https://github.com/RDBI/rdbi/blob/master/README.txt)
+or visit the project's page on https://github.com/RDBI/ .
+
+== Getting started
+
+=== Database definitions
+
+Every database the DDDBL should connect to has to be defined in a configuration
+file using the ini-format. Example:
+
+    [TEST-DB]
+    HOST = localhost
+    DBNAME = test
+    TYPE = PostgreSQL
+    USER = root
+    PASS =
+    DEFAULT = true
+
+* [TEST-DB]: alias of the database connection. It's used if the DDDBL shall
+  execute the query to another database
+* HOST: host of the database
+* DBNAME: database to select
+* TYPE: driver to use
+* USER: user who will be used to connect to the database
+* PASS: user's password
+* DEFAULT: normally, the DDDBL needs to know which database shall be used
+  to execute the query. If the DEFAULT flag is set to true, this connection
+  will be used at first - no explit connection selection needed. DEFAULT is optional.
+
+Now the file has to be added to the database pool:
+
+    DDDBL::Pool::DB << DDDBL::Config.parse_dbs('/path/to/db/definitions.def')
+
+The database has to be added before any queries. Adding a file with database
+definitions results in establishing a connection to every defined database.
+
+==== Selecting (another) database
+
+If only one connection is used, the following is just "good-to-know".
+To select (another) database but the default is done by calling
+
+    DDDBL::select_db('TEST-DB')
+
+Now every query executed after #select_db will be using the database connection
+defined through the alias 'TEST-DB'.
+
+=== Query definitions
+
+The query definition file also uses the ini-format and has to be configurated
+seperately from the application (that's what the DDDBL is all about, isn't it?)
+
+As for now, the query definitions of the PHP and ruby versions are interchangable:
+
+    [QUERY-ALIAS]
+    QUERY = "SELECT * FROM table"
+    HANDLER = MULTI
+
+    [QUERY-MULTILINE]
+    QUERY = "SELECT *
+             FROM table
+             WHERE foo = ?"
+    HANDLER = MULTI
+
+    [CREATE-TABLE]
+    QUERY = "CREATE TABLE foobar ( id SERIAL, name VARCHAR(50) )"
+
+* [QUERY-ALIAS]: as with the database definition, the alias is used to
+  refer to the query inside of the application.
+* QUERY: the sql query. It can be enclosed by " but it's optional as long
+  as the query fits into one line. ? is used to define parameters which will
+  be binded later on. No ; needed.
+* HANDLER: the handler is in charge of transforming the query's result set.
+  There's own section devoted to that topic. HANDLER is optional (since a
+  result set can be empty).
+
+As the database definitions, the query definitions also have to be added to the pool:
+
+    DDDBL::Pool << DDDBL::Config.parse_queries('/path/to/query/definitions.sql')
+
+==== Querying
+
+To execute a query which was be added to the pool is straight forward:
+
+    formated_result = DDDBL::get('QUERY-ALIAS')
+
+    # binds 'bar'
+    formated_result = DDDBL::get('QUERY-MULTILINE', 'bar')
+
+    # without a result set
+    DDDBL::get('CREATE-TABLE')
+
+=== Transactions
+
+DDDBL also supports transaction. More information on the implementation details
+has to be looked up in the RDBI::Database documentation
+
+    DDDBL::transaction do
+        DDDBL::get('CREATE-TABLE')
+
+        # will fail because QUERY-MULTILINE expects a parameter
+        DDDBL::get('QUERY-MULTILINE')
+    end
+
+Since the QUERY-MULTLINE will fail, the whole transaction will be rolled back
+and no table will be created.
+
+=== Creating your own result handler
+
+As you may know or guess by now, RDBI supports transforming the query's result
+set to any datastructure you want. It's as straight forward as adding a query
+file to the pool, just extend the RDBI's RDBI::Result::Driver class and
+implement at least #fetch. The name of the new result driver is then the name
+which has to be used in the query's HANDLER configuration field.
+
+It's also possible to pass a configuration to the result driver defined in the
+query definition:
+
+    [QUERY-ALIAS]
+    QUERY = "SELECT bar FROM foo;"
+    HANDLER = MULTI INT::bar
+
+MULTI, as in the other examples, is the name of the result driver. If there's
+a whitespace following with more text, this additional text will be passed to
+the result driver's constructor. The example definition will explitictly cast
+every row's bar-column value to an Integer.
+
+For more information on creating a result driver, please read the documentation
+of RDBI::Result::Driver. If you want to overwrite a default result driver,
+just override the class.
+
+== Bughunting was successful!
+
+Just report the bug through github's tracker: https://github.com/melkon/dddbl/issues
+
+== I'd like to patch and / or help maintain DDDBL. How can I?
+
+* Fork the project: http://github.com/melkon/dddbl
+* Make your feature addition or bug fix.
+
+== Copyright
+
+Copyright (c) 2011 André Gawron. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/dddbl.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "dddbl/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dddbl"
+  s.version     = DDDBL::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["André Gawron"]
+  s.email       = ["andre@ziemek.de"]
+  s.homepage    = "https://github.com/melkon/dddbl"
+  s.summary     = %q{A Definition Driven Database Layer}
+  s.description = %q{A Definition Driven Database Layer. First developed in php, see: http://www.dddbl.de}
+
+  s.rubyforge_project = "dddbl"
+
+  s.add_dependency "inifile", ">= 0.4.1"
+  s.add_dependency "rdbi"
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

data/example/dbdef.def

@@ -0,0 +1,9 @@
+[TEST-DB]
+HOST = localhost
+DBNAME = trackadev
+TYPE = PostgreSQL
+USER = trackadev
+PASS =
+BIND = true
+DEFAULT = true
+

data/example/demo.rb

@@ -0,0 +1,59 @@
+require 'rdbi'
+require 'rdbi-driver-postgresql'
+
+require 'inifile'
+require 'dddbl'
+
+class RDBI::Result::Driver::YAL < RDBI::Result::Driver
+  def initialize(result, *args)
+    super
+    RDBI::Util.optional_require('yaml')
+  end
+
+  def format_single_row(raw)
+    ::Hash[column_names.zip(raw)].to_yaml
+  end
+
+  def format_multiple_rows(raw_rows)
+    raw_rows.collect { |row| ::Hash[column_names.zip(row)] }.to_yaml
+  end
+
+  private
+  def column_names
+    @column_names ||= @result.schema.columns.map(&:name)
+  end
+end
+
+
+DDDBL::Pool::DB << DDDBL::Config.parse_dbs('dbdef.def')
+DDDBL::Pool     << DDDBL::Config.parse_queries('test.sql')
+
+DDDBL::get('TEST-QUERY')
+
+DDDBL::get('TEST-INSERT', 'andre')
+DDDBL::get('TEST-INSERT', 'melkon')
+
+before = DDDBL::get('TEST-SELECT') ; p before
+
+begin
+  DDDBL::transaction do
+
+    DDDBL::get('TEST-UPDATE', 'thorny', 2)
+
+    # raises an exception
+    # rollback initiated
+    # throws an exception
+    DDDBL::get('TEST-INSERT')
+
+end ; rescue => e ; end
+
+after =  DDDBL::get('TEST-SELECT') ; p after
+
+
+if before.to_s == after.to_s
+  p "transaction rollbacked"
+else
+  p "transaction commited"
+end
+
+DDDBL::get('TEST-DROP')

data/example/test.sql

@@ -0,0 +1,12 @@
+[TEST-QUERY]
+QUERY = "CREATE TABLE  muff (id SERIAL, name VARCHAR(255))"
+
+[TEST-INSERT]
+QUERY = "INSERT INTO muff (name) VALUES(?)"
+
+[TEST-SELECT]
+QUERY = "SELECT * FROM muff"
+HANDLER = YAML
+
+[TEST-DROP]
+QUERY = "DROP TABLE IF EXISTS muff"

data/lib/dddbl.rb

@@ -0,0 +1,152 @@
+#
+# DDDBL - Definition Driven Database Layer
+# Copyright (c) 2011 André Gawron. See LICENSE and README for details.
+#
+# @example Executing Query
+#   result = DDDBL::get('QUERY-ALIAS', 'foo', 'bar')
+#
+# @example Simple Transaction
+#   DDDBL::transaction do
+#     DDDBL::get('QUERY-ALIAS', 'foo', 'bar')
+#     DDDBL::get('CREATE-TABLE')
+#   end
+#
+# @example Select another database
+#   DDDBL::select_db('DATABASE-ALIAS')
+#
+class DDDBL
+
+  #
+  # a query can be associated with a specific
+  # database driver but if none is given, it will
+  # be safed in GLOBAL_POOL so every database connection
+  # can execute the defined query.
+  #
+  GLOBAL_POOL = :default
+  
+  class << self
+
+    #
+    # selects an database connection which will then 
+    # be used to execute queries. if the connection 
+    # is not yet established, it will be after calling 
+    # this method.
+    # 
+    # @param [String] database_name databse alias which was defined in the config file
+    #
+    def select_db(database_name)
+      if @dbh == nil || @database != database_name
+        @dbh = RDBI::pool(database_name).get_dbh
+      end
+    end
+
+    #
+    # executes a defined alias and returns its result set which is
+    # transformed by an optionally defined result hanlder before.
+    #
+    # #get uses the current database connection set by #select_db
+    # if none was explicity selected but a default database was set
+    # using the configuration files, the default connection
+    # will be used.
+    #
+    # @param [String] query_alias querie's alias defined in the config file
+    # @param [Array] *binds the parameters which shall be binded to the query
+    #
+    # @return the result set transformed by the defined handler
+    #
+    def get(query_alias, *binds)
+      query = DDDBL::Pool[@dbh.driver, query_alias]
+      res = @dbh.execute(query[:query], *binds)
+      res.as(query[:handler]).fetch(:all) if !query[:handler].empty?
+    end
+
+    #
+    # delegates method calls to RDBI::Database
+    # DDDBL::transaction is currently implemented this way.
+    # 
+    # @param [String] method valid RDBI::Database method
+    # @param [Array] *args RDBI::Database method's arguments
+    # @param [Proc] &block and finally the optional block
+    #
+    # @return everything that the RDBI::Datbase method calls will return
+    # @return [Boolean] false if no database connection is set
+    #
+    # @raise [ArgumentError] if RDBI::Database does not implement given method
+    #
+    def method_missing(method, *args, &block)
+      return false if !@dbh.is_a? RDBI::Database
+      raise ArgumentError, "RDBI::Database doesnt have #{method}" if !@dbh.respond_to?(method)
+
+      @dbh.send(method, *args, &block)
+    end
+
+  end
+
+end
+
+#
+# DDDBL::Utils provides methods for validation of queries
+# and database definitions. 
+# 
+# @see DDDBL::Pool for implementation examples
+# @see DDDBL::Pool::DB for implementation examples
+#
+module DDDBL::Utils
+
+  #
+  # sets the mandatory fiels of a configuration
+  # 
+  # @param [#each] fields which are mandatory, has to implement `#each`
+  #
+  # @raise [ArgumentError] if fields does not respond to #each
+  #
+  def mandatory(fields)
+    raise ArgumentError, 'parameter has to implement #each' if !fields.respond_to?('each')
+    
+    @mandatory = fields
+  end
+
+  #
+  # sets the optional fiels of a configuration
+  #
+  # @param [#each] fields which are optional, has to implement #each
+  #
+  # @raise [ArgumentError] if fields does not respond to #each
+  #
+  def optional(fields)
+    raise ArgumentError, 'parameter has to implement #each' if !fields.respond_to?('each')
+
+    @optional = fields
+  end
+
+  #
+  # checks check for the defined mandatory and optional values
+  # 
+  # @param [#each] check data structure which implements #each
+  # 
+  # @return [Boolean] true if validation was successful
+  # @return [Boolean] false if not
+  #
+  # @raise [ArgumentError] if check does not respond to #has_key?
+  # @raise [ArgumentError] if check does not respond to #empty?
+  #
+  def valid?(check)
+    raise ArgumentError, 'parameter has to implement has_key?' if !check.respond_to?('has_key?')
+    raise ArgumentError, 'parameter has to implement empty?' if !check.respond_to?('empty?')
+    
+    @mandatory.each do |key|
+      return false if !check.has_key?(key) || check[key].empty?
+    end
+
+    @optional.each do |key|
+      return false if !check.has_key?(key)
+    end
+  end
+
+end
+
+require 'dddbl/config'
+require 'dddbl/pool'
+
+# result handler
+require 'dddbl/results'

data/lib/dddbl/config.rb

@@ -0,0 +1,119 @@
+#
+# DDDBL - Definition Driven Database Layer
+# Copyright (c) 2011 André Gawron. See LICENSE and README for details.
+#
+# DDDBL::Config parses the configuration files for queries and databases.
+#
+# Feel free to implement another parser (for example YAML-based files)
+# and overwrite or extend DDDBL::Config. DDDBL::Config::Defaults
+# will give you reasonable default values.
+#
+# @example Parse database definitions
+#   db_defintions = DDDBL::Config.parse_dbs('/path/to/file')
+#
+# @example Parse query definitions
+#   query_definitions = DDDBL::Config.parse_queries('/path/to/file')
+#
+module DDDBL::Config
+
+  class << self
+
+    #
+    # Offers methods to get default values for a database 
+    # and query configuration.
+    #
+    module DDDBL::Config::Defaults
+
+      #
+      # returns the default values for a query configuration
+      # 
+      # @param [String] query_alias the query's alias
+      # 
+      # @return [Hash] the default values for a query configuration
+      # @option [String] :alias will contain the query_alias
+      # @option [String, Symbol] :type will contain DDDBL::GLOBAL_POOL
+      # @option [String] :handler will contain an empty string
+      #
+      def default_query(query_alias)
+        {
+          :alias   => query_alias,
+          :type    => DDDBL::GLOBAL_POOL,
+          :handler => ''
+        }
+      end
+
+      #
+      # returns the default values for a database configuration
+      # 
+      # @param [String] db_alias the database's alias
+      # 
+      # @return [Hash] the default values for a database configuration
+      # @option [String] :pool_name will contain the db_alias
+      # @option [Boolean] :default will contain false
+      # @option [String] :pass will contain the user's password
+      #
+      def default_db(db_alias)
+        {
+          :pool_name => db_alias,
+          :default   => false,
+          :pass      => ''
+        }
+      end
+      
+    end
+
+    include DDDBL::Config::Defaults
+    
+  end
+  
+  #
+  # parses the queries from given file
+  #
+  # @param [File] file containing query definitions in IniFile-format
+  #
+  # @return [Hash<Hash>] parsed queries
+  #
+  # @raise [ArgumentError] if file does not exist
+  #
+  # @see [IniFile] for more information on the syntax
+  #
+  def self.parse_queries(file)
+    raise ArgumentError, "#{file} does not exist" if !File.exists?(file)
+
+    queries = {}
+
+    IniFile.load(file).each do |query_alias, query_param, query_value|
+      queries[query_alias] ||= default_query(query_alias)
+      queries[query_alias][query_param.downcase.to_sym] = query_value
+    end
+    
+    queries
+
+  end
+
+  #
+  # parses the databases from given file
+  #
+  # @param [File] file containing database definitions in IniFile-format
+  #
+  # @return [Hash<Hash>] parsed databases
+  #
+  # @raise [ArgumentError] if file does not exist
+  #
+  # @see [IniFile] for more information on the syntax
+  #
+  def self.parse_dbs(file)
+    raise ArgumentError, "#{file} does not exist" if !File.exists?(file)
+
+    dbs = {}
+
+    IniFile.load(file).each do |db_alias, db_param, db_value|
+      dbs[db_alias] ||= default_db(db_alias)
+      dbs[db_alias][db_param.downcase.to_sym] = db_value
+    end
+
+    dbs
+
+  end
+
+end

data/lib/dddbl/pool.rb

@@ -0,0 +1,108 @@
+#
+# DDDBL - Definition Driven Database Layer
+# Copyright (c) 2011 André Gawron. See LICENSE and README for details.
+#
+# DDDBL::Pool contains the parsed queries
+#
+class DDDBL::Pool
+
+  class << self
+    include DDDBL::Utils
+  end
+
+  mandatory [:alias, :query, :type]
+  optional  [:handler]
+
+  #
+  # returns a stored query for given database driver
+  # if none is found, the method looks in the global "namespace"
+  # if there is also no query stored, it raises an exception.
+  # 
+  # @param [String] dbtype database's driver name (e.g. MySQL or PostgreSQL)
+  # @param [String] query_alias the query's alias
+  # 
+  # @return [Hash] the query configuration
+  # 
+  # @raise [StandardError] if no query is stored under given alias and driver
+  # 
+  # @see [DDDBL::Pool::[]=] for hash keys
+  # @see [DDDBL::GLOBAL_POOL] for global "namespace"
+  #
+  def self.[](dbtype, query_alias)
+    if @pool.has_key?(dbtype) && @pool[dbtype].has_key?(query_alias)
+      @pool[dbtype][query_alias]
+    elsif @pool.has_key?(DDDBL::GLOBAL_POOL) && @pool[DDDBL::GLOBAL_POOL].has_key?(query_alias)
+      @pool[DDDBL::GLOBAL_POOL][query_alias]
+    else
+      raise StandardError, "#{query_alias} not a saved query alias"
+    end
+  end
+
+  #
+  # sets a query configuration for given database pool
+  # optional keys have to be set but can be empty.
+  #
+  # @param [String] dbtype database's driver name (e.g. MySQL or PostgreSQL)
+  # @param [Hash] query_config a valid query configuration
+  #
+  # @raise [StandardError] if the query configuration is not valid
+  #
+  # @see #mandatory for mandatory query configration keys
+  # @see #optional for optional query configuration keys
+  #
+  def self.[]=(dbtype, query_config)
+    raise StandardError, 'query is not properly configured' if !valid?(query_config)
+
+    @pool ||= Hash.new(&(p=lambda{|h,k| h[k] = Hash.new(&p)}))
+    @pool[dbtype][query_config[:alias]] = query_config
+  end
+
+  #
+  # shortcut for an array (or hash) of query configurations
+  # adds the whole query_configs to their corresponding pools.
+  #
+  # @param [#each] query_configs a list of query_configs, has to respond to #each(key, query_config)
+  #
+  def self.<<(query_configs)
+    query_configs.each do |key, query_config|
+      DDDBL::Pool[query_config[:type]] = query_config
+    end
+  end
+
+end
+
+#
+# DDDBL - Definition Driven Database Layer
+# Copyright (c) 2011 André Gawron. See LICENSE and README for details.
+# 
+# DDDBL::Pool::DB contains the parsed database definitions
+#
+class DDDBL::Pool::DB
+
+  class << self
+    include DDDBL::Utils
+  end
+
+  mandatory [:type, :pool_name, :host, :dbname, :user]
+  optional  [:default, :pass]
+  
+  #
+  # adds the whole db_configs to the pool,
+  # establishs a connection to each of them,
+  # and selects the default database connection
+  # if no connection is already set.
+  #
+  # @param [#each] query_configs a list of query_configs, has to respond to #each(key, query_config)
+  #
+  # @raise [StandardError] if the configration file is not valid
+  #
+  def self.<<(db_configs)
+    db_configs.each do |key, db_config|
+      raise StandardError, 'db_config is not valid' if !valid?(db_config)
+      
+      RDBI::connect_cached(db_config[:type], db_config);
+      DDDBL::select_db(db_config[:pool_name]) if db_config[:default] && !DDDBL::connected?
+    end
+  end
+
+end

data/lib/dddbl/results.rb

@@ -0,0 +1,5 @@
+# the php-library makes use of MULTI as result handler
+# RDBI provides with Struct the same functionality
+# for portability reasons of the query config files
+# a MULTI handler is introduced which is an alias for Struct
+class RDBI::Result::Driver::MULTI < RDBI::Result::Driver::Struct ; end

data/lib/dddbl/version.rb

@@ -0,0 +1,3 @@
+class DDDBL
+  VERSION = "0.0.1.alpha"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: dddbl
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 0.0.1.alpha
+platform: ruby
+authors: 
+- "Andr\xC3\xA9 Gawron"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-31 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: inifile
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdbi
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: "A Definition Driven Database Layer. First developed in php, see: http://www.dddbl.de"
+email: 
+- andre@ziemek.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- dddbl.gemspec
+- example/dbdef.def
+- example/demo.rb
+- example/test.sql
+- lib/dddbl.rb
+- lib/dddbl/config.rb
+- lib/dddbl/pool.rb
+- lib/dddbl/results.rb
+- lib/dddbl/version.rb
+homepage: https://github.com/melkon/dddbl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: dddbl
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: A Definition Driven Database Layer
+test_files: []
+