db_mod 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f148df036e59a1e23b2faa43b407b9493d54671a
-  data.tar.gz: c0ab239586891d8b91a5a82d79a17f4e19777f48
+  metadata.gz: 5547dcc1f21c6ca964d25c097abb813e77713161
+  data.tar.gz: 2214d888e4d39fb545e65e2c8539fdeadc48b145
 SHA512:
-  metadata.gz: 199028216fcaf755e20a67d607ad5f7ac3399c0c26ea3cee37f151dc5786c3e87b57245a9c4d42bbe5807bb6e3a1e6814e2ae9495ed15030e6d94c85f9071ea1
-  data.tar.gz: 7930c834d9705cfdb2e57556e9a478db09c0967ac16339d5728893561178431d09520fb98f7dc688ee7d331b683ffe8014ccfe9e25c7efaa7348427afe5d0158
+  metadata.gz: 6e5bd968a9b47e6d55972444b55bb7bf0434938711c71d0c6955b6d6d048c25a7bfb0e78bffec87bc70dbe3c58aec5766513530e63104c24a2a1089ba99a91c0
+  data.tar.gz: 28d48191ba234d83a0dc52dc5c9224923712834d8b8411e4e67d081bc36ab45f062f5476e7e0d17f2eb0222cb89065bdb5f657d84230c765bc2f1208ce26a0dc

data/README.md

@@ -8,6 +8,12 @@ The `db_mod` gem is a simple framework that helps you organise your
 database access functions into modular libraries that can be included
 in your projects to give them selective access to facets of your data.
 
+For the moment `db_mod` only supports PostgreSQL databases via the
+`pg` gem. This gem is still in the early stages of development and no
+guarantees will be made about backwards compatibility until v0.1.0.
+
+Issues, pull requests, comments and feedback all welcomed.
+
 ## Usage
 
 ### The database connection
@@ -53,7 +59,7 @@ get_stuff.each do |thing|
 end
 ```
 
-#### `create`: Module instances
+#### Module instances: `DbMod.create`
 
 Each module also comes with its own `create` function,
 which instantiates an object exposing all of the module's functions.
@@ -69,7 +75,7 @@ db = MyFunctions.create PGconn.connect # ...
 db.get_stuff
 ```
 
-#### `@conn`: The connection object
+#### The connection object: `@conn`
 
 The connection created by `db_connect` or `create` will be stored
 in the instance variable `@conn`. This instance variable may be
@@ -104,7 +110,9 @@ db = DbAccess.create db: 'mydb'
 db.things_n_stuff
 ```
 
-### `def_prepared`: Declaring SQL statements
+### Declaring SQL statements
+
+#### Prepared statement methods: `DbMod.def_prepared`
 
 Modules which include `DbMod` can declare prepared statements
 using the module function `def_prepared`. These statements will
@@ -168,3 +176,10 @@ modules on the given connection.
 db = Db::ComplicatedStuff.create my_conn
 Db::ComplicatedStuff.prepare_all_statements my_conn
 ```
+
+#### Saved statement methods: `DbMod.def_statement`
+
+`def_statement` works in just the same way as `def_prepared`, except that
+the SQL queries are saved in memory rather than being sent to the database
+at connection time. This is useful for queries that will only be run once
+or twice during a program's execution.

data/db_mod.gemspec

@@ -5,14 +5,16 @@ Gem::Specification.new do |s|
   s.name        = 'db_mod'
   s.version     = DbMod::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Doug Hammond']
+  s.author      = 'Doug Hammond'
   s.email       = ['d.lakehammond@gmail.com']
-  s.summary     = 'Ruby framework for building modular db-access libs.'
-  s.description = 'Organize your database-intensive batch scripts with db_mod.'
+  s.homepage    = 'https://github.com/dslh/db_mod'
+  s.summary     = 'Declarative, modular database library framework.'
+  s.description = 'Framework for building modular database libraries.'
   s.license     = 'MIT'
 
+  s.required_ruby_version = '>= 1.9.3'
+
   s.add_runtime_dependency 'pg'
-  s.add_runtime_dependency 'docile'
 
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'rspec'

data/lib/db_mod.rb

@@ -17,7 +17,7 @@ module DbMod
   # class-level functions specific to the module.
   def self.included(mod)
     DbMod::Create.setup(mod)
-    DbMod::Statements::Prepared.setup(mod)
+    DbMod::Statements.setup(mod)
   end
 
   protected

data/lib/db_mod/statements.rb

@@ -9,5 +9,11 @@ module DbMod
   # See {DbMod::Statements::Statement} for details on +def_statement+
   # and {DbMod::Statements::Prepared} for details on +def_prepared+.
   module Statements
+    # Called when a module includes {DbMod},
+    # defines module-level +def_statement+ and +def_prepared+ dsl methods.
+    def self.setup(mod)
+      DbMod::Statements::Prepared.setup(mod)
+      DbMod::Statements::Statement.setup(mod)
+    end
   end
 end

data/lib/db_mod/statements/{params.rb → parameters.rb}

@@ -2,36 +2,41 @@ module DbMod
   module Statements
     # Parsing and validation of query parameters
     # for prepared SQL statements
-    module Params
+    module Parameters
+      # Called when a {DbMod} dynamically defined method is called.
       # Assert that the named arguments given for the prepared statement
-      # with the given name satisfy expectations.
+      # with the given name satisfy expectations. Returns a parameter array
+      # as per {Parameters.parameter_array}.
       #
       # @param expected [Array<Symbol>] the parameters expected to be present
-      # @param args [Hash] given parameters
+      # @param args [Array<Hash<Symbol>>] arguments given to the method being
+      #   executed. The method should only be called with an options hash that
+      #   contains exactly the parameter names given when the method was
+      #   defined.
       # @return [Array] values to be passed to the prepared statement
       def self.valid_named_args!(expected, args)
-        unless args.is_a? Hash
-          fail ArgumentError, "invalid argument: #{args.inspect}"
-        end
+        wrapped_hash! args
 
+        args = args.first
         if args.size != expected.size
           fail ArgumentError, "#{args.size} args given, #{expected.size} needed"
         end
 
-        expected.map do |arg|
-          args[arg] || fail(ArgumentError, "missing arg #{arg}")
-        end
+        parameter_array(expected, args)
       end
 
-      # Regex matching a numbered parameter
-      NUMBERED_PARAM = /\$\d+/
-
-      # Regex matching a named parameter
-      NAMED_PARAM = /\$[a-z]+(?:_[a-z]+)*/
-
-      # For validation, named or numbered parameter
-      NAMED_OR_NUMBERED = /^\$(?:\d+|[a-z]+(?:_[a-z]+)*)$/
+      # Called when a {DbMod} dynamically defined method is called.
+      # Assert that the correct number of arguments has been provided.
+      #
+      # @param count [Fixnum] arity of the method being called.
+      # @param args [Array] list of arguments given.
+      def self.valid_fixed_args!(count, args)
+        unless args.size == count
+          fail ArgumentError, "#{args.size} args given, #{count} expected"
+        end
+      end
 
+      # Called when a {DbMod} dynamically defined method is declared.
       # Parses parameters, named or numbered, from an SQL
       # statement. See the {Prepared} module documentation
       # for more. This method may modify the sql statement
@@ -47,15 +52,56 @@ module DbMod
       # @return [Fixnum,Array<Symbol>] description of
       #   prepared statement's parameters
       def self.parse_params!(sql)
-        Params.valid_sql_params! sql
+        Parameters.valid_sql_params! sql
         numbered = sql.scan NUMBERED_PARAM
         named = sql.scan NAMED_PARAM
 
         if numbered.any?
           fail ArgumentError, 'mixed named and numbered params' if named.any?
-          Params.parse_numbered_params! numbered
+          Parameters.parse_numbered_params! numbered
         else
-          Params.parse_named_params! sql, named
+          Parameters.parse_named_params! sql, named
+        end
+      end
+
+      # Regex matching a numbered parameter
+      NUMBERED_PARAM = /\$\d+/
+
+      # Regex matching a named parameter
+      NAMED_PARAM = /\$[a-z]+(?:_[a-z]+)*/
+
+      # For validation, named or numbered parameter
+      NAMED_OR_NUMBERED = /^\$(?:\d+|[a-z]+(?:_[a-z]+)*)$/
+
+      private
+
+      # Assert that the given parameter list is an array
+      # containing a single hash of named parameter values.
+      #
+      # Raises {ArgumentError} otherwise.
+      #
+      # @param args [Array<Hash<Symbol>>] method arguments being validated
+      def self.wrapped_hash!(args)
+        unless args.size == 1
+          fail ArgumentError, "unexpected arguments: #{args.inspect}"
+        end
+
+        unless args.first.is_a? Hash
+          fail ArgumentError, "invalid argument: #{args.first.inspect}"
+        end
+      end
+
+      # Convert the given named parameter hash into
+      # an array containing the parameter values in
+      # the order required to be supplied to the
+      # SQL statement being executed.
+      #
+      # @param expected [Array<Symbol>] the parameters expected to be present
+      # @param args [Hash] given parameters
+      # @return [Array] values to be passed to the prepared statement
+      def self.parameter_array(expected, args)
+        expected.map do |arg|
+          args[arg] || fail(ArgumentError, "missing arg #{arg}")
         end
       end
 
@@ -63,7 +109,7 @@ module DbMod
       # in the expected format. They must either be
       # lower_case_a_to_z or digits only.
       def self.valid_sql_params!(sql)
-        sql.scan(/\$\S+/) do |param|
+        sql.scan(/\$[A-Za-z0-9_]+/) do |param|
           unless param =~ NAMED_OR_NUMBERED
             fail ArgumentError, "Invalid parameter #{param}"
           end

data/lib/db_mod/statements/prepared.rb

@@ -1,4 +1,4 @@
-require_relative 'params'
+require_relative 'parameters'
 
 module DbMod
   module Statements
@@ -48,8 +48,6 @@ module DbMod
     #  my_prepared(1,2)
     #  my_named_prepared(a: 1, b: 2)
     module Prepared
-      include Params
-
       # Defines a module-specific +def_prepared+ function
       # for a module that has just had {DbMod} included.
       #
@@ -63,24 +61,6 @@ module DbMod
 
       private
 
-      # Merge the prepared statements from a module
-      # into a given hash. Fails if there are any
-      # duplicates.
-      #
-      # @param statements [Hash] named list of prepared statements
-      # @param klass [Class,Module] ancestor (hopefully a DbMod module)
-      #   to collect prepared statements from
-      def self.merge_statements(statements, klass)
-        return unless klass.respond_to? :prepared_statements
-        return if klass.prepared_statements.nil?
-
-        klass.prepared_statements.each do |name, sql|
-          fail DbMod::Exceptions::DuplicateStatementName if statements.key? name
-
-          statements[name] = sql
-        end
-      end
-
       # Add a +def_prepared+ method definition to a module.
       # This method allows modules to declare named SQL statements
       # that will be prepared when the database connection is
@@ -94,7 +74,7 @@ module DbMod
             sql = sql.dup
             name = name.to_sym
 
-            params = Params.parse_params! sql
+            params = Parameters.parse_params! sql
             prepared_statements[name] = sql
             Prepared.define_prepared_method(mod, name, params)
           end
@@ -117,18 +97,34 @@ module DbMod
         end
       end
 
-      # Define a method in the module with the given name
+      # Merge the prepared statements from a module
+      # into a given hash. Fails if there are any
+      # duplicates.
+      #
+      # @param statements [Hash] named list of prepared statements
+      # @param klass [Class,Module] ancestor (hopefully a DbMod module)
+      #   to collect prepared statements from
+      def self.merge_statements(statements, klass)
+        return unless klass.respond_to? :prepared_statements
+        return if klass.prepared_statements.nil?
+
+        klass.prepared_statements.each do |name, sql|
+          fail DbMod::Exceptions::DuplicateStatementName if statements.key? name
+
+          statements[name] = sql
+        end
+      end
+
+      # Define a method in the given module with the given name
       # and parameters, that will call the prepared statement
       # with the same name.
       #
-      # @param mod [Module] module declaring the metho
+      # @param mod [Module] module declaring the method
       # @param name [Symbol] method name
       # @param params [Fixnum,Array<Symbol>]
       #   expected parameter count, or a list of argument names.
       #   An empty array produces a no-argument method.
       def self.define_prepared_method(mod, name, params)
-        mod.expected_prepared_statement_parameters[name] = params
-
         if params.is_a?(Array)
           if params.empty?
             define_no_args_prepared_method(mod, name)
@@ -165,10 +161,7 @@ module DbMod
       # @param params [Array<Symbol>] list of parameter names
       def self.define_named_args_prepared_method(mod, name, params)
         method = lambda do |*args|
-          unless args.size == 1
-            fail ArgumentError, "unexpected arguments: #{args.inspect}"
-          end
-          args = Params.valid_named_args! params, args.first
+          args = Parameters.valid_named_args! params, args
           conn.exec_prepared(name.to_s, args)
         end
 
@@ -188,9 +181,7 @@ module DbMod
       #   requires
       def self.define_fixed_args_prepared_method(mod, name, count)
         method = lambda do |*args|
-          unless args.size == count
-            fail ArgumentError, "#{args.size} args given, #{count} expected"
-          end
+          Parameters.valid_fixed_args!(count, args)
 
           conn.exec_prepared(name.to_s, args)
         end
@@ -208,10 +199,6 @@ module DbMod
           define_method(:prepared_statements) do
             @prepared_statements ||= {}
           end
-
-          define_method(:expected_prepared_statement_parameters) do
-            @expected_prepared_statement_parameters ||= {}
-          end
         end
       end
 

data/lib/db_mod/statements/statement.rb

@@ -1,3 +1,5 @@
+require_relative 'parameters'
+
 module DbMod
   module Statements
     # Provides the +def_statement+ function which allows
@@ -23,7 +25,102 @@ module DbMod
     #   can then be passed parameters that will be used to fill
     #   in the statement before execution.
     module Statement
-      # Not yet implemented.
+      # Defines a module-specific +def_statement+ function
+      # for a module that has just had {DbMod} included.
+      #
+      # @param mod [Module]
+      def self.setup(mod)
+        Statement.define_def_statement(mod)
+      end
+
+      private
+
+      # Add a +def_statement+ method definition to a module.
+      # This method allows modules to declare SQL statements
+      # that can be accessed via an instance method with
+      # arbitrary name.
+      #
+      # @param mod [Module] a module with {DbMod} included
+      def self.define_def_statement(mod)
+        mod.class.instance_eval do
+          define_method(:def_statement) do |name, sql|
+            sql = sql.dup
+            name = name.to_sym
+
+            params = Parameters.parse_params! sql
+            Statement.define_statement_method(mod, name, params, sql)
+          end
+        end
+      end
+
+      # Define a method in the given module with the given name
+      # and parameters, that will call the given sql statement
+      # and return the results.
+      #
+      # @param mod [Module] module declaring the method
+      # @param name [Symbol] method name
+      # @param params [Fixnum,Array<Symbol>]
+      #   expected parameter count, or a list of argument names.
+      #   An empty array produces a no-argument method.
+      def self.define_statement_method(mod, name, params, sql)
+        if params.is_a?(Array)
+          if params.empty?
+            define_no_args_statement_method(mod, name, sql)
+          else
+            define_named_args_statement_method(mod, name, params, sql)
+          end
+        else
+          define_fixed_args_statement_method(mod, name, params, sql)
+        end
+      end
+
+      # Define a no-argument method with the given name
+      # that will execute the given sql statement and return
+      # the result.
+      #
+      # @param mod [Module] {DbMod} enabled module
+      #   where the method will be defined
+      # @param name [Symbol] name of the method to be defined
+      # @param sql [String] parameterless SQL statement to execute
+      def self.define_no_args_statement_method(mod, name, sql)
+        mod.instance_eval do
+          define_method name, ->() { query(sql) }
+        end
+      end
+
+      # Define a method with the given name, that accepts the
+      # given set of named parameters that will be used to execute
+      # the given SQL query.
+      #
+      # @param mod [Module] {DbMod} enabled module
+      # @param name [Symbol] name of the method to be defined
+      # @param params [Array<Symbol>] parameter names and order
+      def self.define_named_args_statement_method(mod, name, params, sql)
+        method = lambda do |*args|
+          args = Parameters.valid_named_args! params, args
+          conn.exec_params(sql, args)
+        end
+
+        mod.instance_eval { define_method(name, method) }
+      end
+
+      # Define a method with the given name that accepts a fixed number
+      # of arguments, that will be used to execute the given SQL query.
+      #
+      # @param mod [Module] {DbMod} enabled module where the method
+      #   will be defined
+      # @param name [Symbol] name of the method to be defined
+      # @param count [Fixnum] arity of the defined method,
+      #   the number of parameters that the SQL statement requires
+      def self.define_fixed_args_statement_method(mod, name, count, sql)
+        method = lambda do |*args|
+          Parameters.valid_fixed_args!(count, args)
+
+          conn.exec_params(sql, args)
+        end
+
+        mod.instance_eval { define_method(name, method) }
+      end
     end
   end
 end

data/lib/db_mod/version.rb

@@ -1,5 +1,5 @@
 # Version information
 module DbMod
   # The current version of db_mod.
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/db_mod/statements/prepared_spec.rb

@@ -108,6 +108,29 @@ describe DbMod::Statements::Prepared do
     end.not_to raise_exception
   end
 
+  it 'handles complicated parameter usage' do
+    mod = Module.new do
+      include DbMod
+
+      def_prepared(
+        :params_test,
+        'INSERT INTO foo (a,b,c,d) VALUES ($a-1,$b::integer,$c*2,$b)'
+      )
+    end
+
+    expect(@conn).to receive(:prepare).with(
+      'params_test',
+      'INSERT INTO foo (a,b,c,d) VALUES ($1-1,$2::integer,$3*2,$2)'
+    )
+    db = mod.create(db: 'testdb')
+
+    expect(@conn).to receive(:exec_prepared).with(
+      'params_test',
+      [1, 2, 3]
+    )
+    db.params_test(a: 1, b: 2, c: 3)
+  end
+
   it 'does not allow invalid parameters' do
     %w(CAPITALS numb3rs_and_l3tt3rs).each do |param|
       expect do

data/spec/db_mod/statements/statement_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe DbMod::Statements::Statement do
+  subject do
+    Module.new do
+      include DbMod
+
+      def_statement(
+        :one,
+        'SELECT * FROM foo WHERE a = $1 AND b = $2 AND c = $1'
+      )
+
+      def_statement(
+        :two,
+        'SELECT * FROM foo WHERE a = $a AND b = $b AND c = $a'
+      )
+    end.create db: 'testdb'
+  end
+
+  before do
+    @conn = instance_double 'PGconn'
+    allow(PGconn).to receive(:connect).and_return(@conn)
+  end
+
+  it 'executes statements with numbered params' do
+    expect(@conn).to receive(:exec_params).with(
+      'SELECT * FROM foo WHERE a = $1 AND b = $2 AND c = $1',
+      [1, 'two']
+    )
+    subject.one(1, 'two')
+
+    expect { subject.one 'not enough args' }.to raise_exception ArgumentError
+
+    expect do
+      subject.one('too', 'many', 'args')
+    end.to raise_exception ArgumentError
+  end
+
+  it 'executes statements with named params' do
+    expect(@conn).to receive(:exec_params).with(
+      'SELECT * FROM foo WHERE a = $1 AND b = $2 AND c = $1',
+      [1, 'two']
+    )
+    subject.two(a: 1, b: 'two')
+
+    expect do
+      subject.two bad: 'arg', b: 1, a: 1
+    end.to raise_exception ArgumentError
+    expect { subject.two b: 'a missing' }.to raise_exception ArgumentError
+    expect { subject.two 1, 2 }.to raise_exception ArgumentError
+    expect { subject.two 1 }.to raise_exception ArgumentError
+  end
+
+  it 'allows statements with no parameters' do
+    expect do
+      mod = Module.new do
+        include DbMod
+
+        def_statement :no_params, 'SELECT 1'
+      end
+
+      expect(@conn).to receive(:query).with('SELECT 1')
+      db = mod.create db: 'testdb'
+
+      expect { db.no_params }.not_to raise_exception
+      expect { db.no_params(1) }.to raise_exception ArgumentError
+    end.not_to raise_exception
+  end
+
+  it 'does not allow mixed parameter types' do
+    expect do
+      Module.new do
+        include DbMod
+
+        def_statement :numbers_and_names, <<-SQL
+          SELECT *
+            FROM foo
+           WHERE this = $1 AND wont = $work
+        SQL
+      end
+    end.to raise_exception ArgumentError
+  end
+
+  it 'handles complicated parameter usage' do
+    db = Module.new do
+      include DbMod
+
+      def_statement(
+        :params_test,
+        'INSERT INTO foo (a,b,c,d) VALUES ($a-1,$b::integer,$c*2,$b)'
+      )
+    end.create(db: 'testdb')
+
+    expect(@conn).to receive(:exec_params).with(
+      'INSERT INTO foo (a,b,c,d) VALUES ($1-1,$2::integer,$3*2,$2)',
+      [1, 2, 3]
+    )
+    db.params_test(a: 1, b: 2, c: 3)
+  end
+
+  it 'does not allow invalid parameters' do
+    %w(CAPITALS numb3s_and_l3tt3rs).each do |param|
+      expect do
+        Module.new do
+          include DbMod
+
+          def_statement :bad_params, %(
+            SELECT * FROM foo WHERE bad = $#{param}
+          )
+        end
+      end.to raise_exception ArgumentError
+    end
+  end
+
+  it 'validates numbered arguments' do
+    [
+      'a = $1 and b = $2 and c = $2 and c = $4',
+      'a = $2 and b = $2 and c = $3',
+      'a = $1 and b = $2 and c = $4'
+    ].each do |params|
+      expect do
+        Module.new do
+          include DbMod
+
+          def_statement :bad_params, "SELECT * FROM foo WHERE #{params}"
+        end
+      end.to raise_exception ArgumentError
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_mod
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Doug Hammond
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-11 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: docile
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +94,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Organize your database-intensive batch scripts with db_mod.
+description: Framework for building modular database libraries.
 email:
 - d.lakehammond@gmail.com
 executables: []
@@ -134,17 +120,18 @@ files:
 - lib/db_mod/exceptions/connection_not_set.rb
 - lib/db_mod/exceptions/duplicate_statement_name.rb
 - lib/db_mod/statements.rb
-- lib/db_mod/statements/params.rb
+- lib/db_mod/statements/parameters.rb
 - lib/db_mod/statements/prepared.rb
 - lib/db_mod/statements/statement.rb
 - lib/db_mod/transaction.rb
 - lib/db_mod/version.rb
 - spec/db_mod/create_spec.rb
 - spec/db_mod/statements/prepared_spec.rb
+- spec/db_mod/statements/statement_spec.rb
 - spec/db_mod/transaction_spec.rb
 - spec/db_mod_spec.rb
 - spec/spec_helper.rb
-homepage: 
+homepage: https://github.com/dslh/db_mod
 licenses:
 - MIT
 metadata: {}
@@ -156,7 +143,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -167,10 +154,11 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: Ruby framework for building modular db-access libs.
+summary: Declarative, modular database library framework.
 test_files:
 - spec/db_mod/create_spec.rb
 - spec/db_mod/statements/prepared_spec.rb
+- spec/db_mod/statements/statement_spec.rb
 - spec/db_mod/transaction_spec.rb
 - spec/db_mod_spec.rb
 - spec/spec_helper.rb