dumbo 0.0.1 → 0.0.3

data/lib/dumbo/rake_task.rb

@@ -1,24 +1,26 @@
-require "rake"
+require 'rake'
 require 'rake/tasklib'
-require "erubis"
-require "pathname"
+require 'erubis'
+require 'pathname'
 require 'yaml'
 require 'logger'
 require 'active_record'
-require "dumbo/extension"
-require "dumbo/dependency_resolver"
+require 'dumbo/extension'
+require 'dumbo/dependency_resolver'
+require 'rspec/core'
 
 module Dumbo
   class RakeTask < ::Rake::TaskLib
     attr_accessor :name
 
     def initialize(name = 'dumbo')
-
       @name = name
 
       namespace name do
+        Dumbo::DbTask.new(:db)
+
         desc 'creates and installs extension'
-        task :all => ["#{extension}--#{version}.sql", :install]
+        task all: [:src, Extension.file_name, :install]
 
         desc 'installs the extension'
         task :install do
@@ -26,69 +28,83 @@ module Dumbo
         end
 
         desc 'concatenates files'
-        file "#{extension}--#{version}.sql" => file_list do |t|
+        file Extension.file_name => file_list do |t|
           sql = t.prerequisites.map do |file|
-            ["--source file #{file}"] + get_sql(file) + [" "]
+            ["--source file #{file}"] + get_sql(file) + [' ']
           end.flatten
           concatenate sql, t.name
         end
 
+        desc 'prepare source files'
+        task :src do
+          Dir.glob('src/**/*.erb').each do |file|
+            src = convert_template(file)
+            out = Pathname.new(file).sub_ext('')
+            File.open(out.to_s, 'w') do |f|
+              f.puts src.join("\n")
+            end
+          end
+        end
+
         desc 'creates migration files for the last two versions'
         task :migrations do
-          old_version, new_version = Dumbo::Extension.new.available_versions.last(2).map(&:to_s)
+          old_version, new_version = Extension.versions.last(2).map(&:to_s)
+
           if new_version
-            Dumbo::ExtensionMigrator.new(Dumbo::Extension.new.name, old_version, new_version).create
+            ExtensionMigrator.new(Extension.name, old_version, new_version)
+            .create
           end
         end
 
-        desc 'release a new version'
+        desc 'upgrate .control file to a new version'
         task :new_version, :level do |t, args|
-          args.with_defaults(:level => 'patch')
-          v = version_bump args[:level]
-          set_version v
+          args.with_defaults(level: 'patch')
+
+          v = new_version(args[:level])
+          Extension.version!(v)
 
           Rake::Task["#{name}:all"].invoke
         end
-      end
-    end
-
-    def set_version(new_version)
-      content = File.read("#{extension}.control")
-      new_content = content.gsub(version, new_version)
-      File.open("#{extension}.control", "w") {|file| file.puts new_content}
-    end
 
-    def version_bump(level='patch')
-      levels = {'patch' => 2, 'minor' => 1, 'major' => 0}
-      parts = version.split('.').map(&:to_i)
-      l = levels[level]
-      parts[l] += 1
-      (l+1..2).each {|l| parts[l]=0}
-
-      parts.join('.')
-    end
-
-    def version
-      Dumbo::Extension.new.version
-    end
-
-    def extension
-      Dumbo::Extension.new.name
+        namespace :test do
+          desc 'creates regression tests from specs and runs them'
+          task regression: ['all', 'db:test:prepare'] do
+            ENV['DUMBO_REGRESSION'] = 'true'
+            RSpec::Core::RakeTask.new(:spec).run_task(false)
+
+            if $?.success?
+              test_files = Rake::FileList.new("test/sql/**/*.sql")
+              out_files  = test_files.pathmap("%{^test/sql/,test/expected/}X.out")
+              out_files.each{|f| FileUtils.touch(f)}
+              system('make installcheck &> /dev/null')
+
+              out_files.pathmap("%{^test/expected/,results/}p").each do |f|
+                FileUtils.cp(f,'test/expected/')
+                File.delete(f)
+              end
+
+              system('make installcheck')
+            else
+              Dir.glob('test/*').each{|f| File.delete(f)}
+            end
+          end
+        end
+      end
     end
 
-    def available_versions
-      Dumbo::Extension.new.name.available_versions
+    def new_version(level = :patch)
+      ExtensionVersion.new_from_string(Extension.version).bump(level).to_s
     end
 
-        # source sql file list
+    # source sql file list
     def file_list
-      Dumbo::DependencyResolver.new(Dir.glob("sql/**/*.{sql,erb}")).resolve
+      DependencyResolver.new(Dir.glob('sql/**/*.{sql,erb}')).resolve
     end
 
     def concatenate(lines, target)
-      File.open(target,'w') do |f|
+      File.open(target, 'w') do |f|
         lines.each do |line|
-          f.puts line unless line =~ Dumbo::DependencyResolver.depends_pattern
+          f.puts line unless line =~ DependencyResolver.depends_pattern
         end
       end
     end
@@ -109,13 +125,7 @@ module Dumbo
     end
 
     def get_bindings(file)
-      base = Pathname.new(file).sub_ext('.yml').basename
-      yaml = Pathname.new('config').join(base)
-      if yaml.exist?
-        YAML.load_file(yaml)
-      else
-        {}
-      end
+      BindingLoader.new(file).load
     end
   end
-end
+end

data/lib/dumbo/range_type.rb

@@ -1,7 +1,7 @@
 module Dumbo
   class RangeType < Type
     attr_accessor :subtype, :subtype_opclass, :collation,
-                  :canonical,:subtype_diff
+                  :canonical, :subtype_diff
 
     def load_attributes
       super
@@ -19,19 +19,16 @@ module Dumbo
         WHERE rngtypid=#{oid}
         SQL
 
-      result.first.each do |k,v|
-        send("#{k}=",v) rescue nil
+      result.first.each do |k, v|
+        send("#{k}=", v) rescue nil
       end
       result.first
     end
 
-
-
-
     def to_sql
-      attr_str = [:subtype, :subtype_opclass, :collation, :canonical,:subtype_diff].map do |a|
+      attr_str = [:subtype, :subtype_opclass, :collation, :canonical, :subtype_diff].map do |a|
         [a, public_send(a)]
-      end.select{|k,v| v && v != '-' }.map{|k,v| "#{k.upcase}=#{v}"}.join(",\n  ")
+      end.select { |k, v| v && v != '-' }.map { |k, v| "#{k.upcase}=#{v}" }.join(",\n  ")
 
       <<-SQL.gsub(/^ {6}/, '')
       CREATE TYPE #{name} AS RANGE (
@@ -40,4 +37,4 @@ module Dumbo
       SQL
     end
   end
-end
+end

data/lib/dumbo/test.rb

@@ -0,0 +1,8 @@
+require 'dumbo/test/fixture'
+require 'dumbo/test/helper'
+require 'dumbo/test/matchers'
+
+module Dumbo
+  module Test
+  end
+end

data/lib/dumbo/test/fixture.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+module Dumbo
+  module Test
+    class Fixture
+      include Singleton
+
+      attr_reader :fixtures
+
+      def self.fixtures
+        instance.fixtures
+      end
+
+      def initialize
+        @fixtures = {}
+      end
+
+      def eval_fixture(file,contents=nil)
+        contents ||= File.read(file.to_s)
+        instance_eval(contents)
+        @fixtures
+      rescue SyntaxError => e
+        syntax_msg = e.message.gsub("#{file}:", 'on line ')
+        raise "Fixture syntax error #{syntax_msg}"
+      rescue ScriptError, RegexpError, NameError, ArgumentError => e
+        e.backtrace[0] = "#{e.backtrace[0]}: #{e.message} (#{e.class})"
+        puts e.backtrace.join("\n       ")
+        raise "There was an error in your Fixture," \
+          + e.message
+      end
+
+      def fixture(name, *args)
+        opts = extract_options!(args)
+        table_name = args.first || name
+
+        @fixtures[name] = [table_name, opts]
+      end
+
+
+      private
+
+      def extract_options!(arr)
+        if arr.last.is_a? Hash
+          arr.pop
+        else
+          {}
+        end
+      end
+
+    end
+  end
+end

data/lib/dumbo/test/helper.rb

@@ -0,0 +1,64 @@
+require 'logger'
+require 'dumbo/test/fixture'
+module Dumbo
+  module Test
+    module Helper
+      class Fixture
+        def initialize(table_name, values)
+          @table_name, @values = table_name, values
+        end
+
+        def values
+          (read_fixture.last || {}).merge(@values)
+        end
+
+        def table_name
+          read_fixture.first || @table_name
+        end
+
+        private
+
+        def read_fixture
+          @fixtures ||= (Dumbo::Test::Fixture.fixtures[@table_name] || [])
+        end
+      end
+
+      class SqlLogger < Logger
+        def format_message(severity, timestamp, progname, msg)
+          "#{msg.gsub(/\e\[(\d+)m/, '').gsub(/.*?\(.*?ms\)/,'').gsub(/^ +/,'')};\n"
+        end
+
+        def add(*args)
+          return unless args.first == DEBUG
+          super
+        end
+      end
+
+
+      def install_extension
+        query "CREATE EXTENSION #{Dumbo::Extension.new.name}"
+      end
+
+      def query(sql)
+        ActiveRecord::Base.connection.select_all(sql, 'SQL', [])
+      end
+
+      def create(table_name, values)
+        fix = Fixture.new(table_name, values)
+        table_name, values = fix.table_name, fix.values
+
+         ActiveRecord::Base.connection.insert_fixture(values, table_name)
+      end
+
+      def create_list(num, table_name, &block)
+        num.times do |i|
+          block_val = block.call(i)
+          fix = Fixture.new(table_name, block_val)
+          table_name, values = fix.table_name, fix.values
+
+          ActiveRecord::Base.connection.insert_fixture(values, table_name)
+        end
+      end
+    end
+  end
+end

data/lib/dumbo/test/matchers.rb

@@ -0,0 +1,76 @@
+module Dumbo
+  module Matchers
+
+    # test a query result against an expectation
+    # e.g.
+    # query("SELECT COUNT(*) FROM users").should match '3'
+    # query("SELECT id, name FROM users").should match ['1', 'foo'] ,['2', 'bar'] ,['3', 'baz']
+    # query("SELECT id, name FROM users").should match_with_header ['id', 'name'], ['1', 'foo'] ,['2', 'bar'] ,['3', 'baz']
+    # query("SELECT id, name FROM users ORDER BY id").should match_ordered ['id', 'name'], ['1', 'foo'] ,['2', 'bar'] ,['3', 'baz']
+
+    def match(*expected)
+      return super if expected.first.is_a? Regexp
+      QueryMatcher.new(flat_expected(expected))
+    end
+
+    def match_with_header(*expected)
+      QueryMatcher.new(flat_expected(expected), header: true)
+    end
+
+    def match_ordered(*expected)
+      QueryMatcher.new(flat_expected(expected), ordered: true )
+    end
+
+    def flat_expected(expected)
+      expected.size == 1 ? expected.first.to_s : expected.map(&:to_s)
+    end
+
+    class QueryMatcher < RSpec::Matchers::BuiltIn::ContainExactly
+      attr_reader :actual, :expected, :options
+
+      def initialize(expected = UNDEFINED, options={})
+        @expected = expected unless UNDEFINED.equal?(expected)
+        @options = options
+      end
+
+      def matches?(actual)
+        @actual = actual
+        convert_actual
+        convert_expected
+        match = match(expected, self.actual)
+        options[:ordered] ? expected == self.actual : match
+      end
+
+      def failure_message_for_should
+        if @missing_items.empty? && @extra_items.empty?
+          message = "actual collection is in the wrong order\n"
+          message +=  "expected collection contained:  #{expected.inspect}\n"
+          message += "actual collection contained:    #{actual.inspect}\n"
+          message
+        else
+          super
+        end
+
+      end
+
+      def convert_expected
+        @expected = [expected] unless expected.is_a?(Array)
+      end
+
+      def convert_actual
+        @actual = if options[:header]
+          [actual.columns] + actual.rows
+        else
+          case actual.rows.size
+          when 0
+            []
+          when 1
+            actual.rows.first
+          else
+            actual.rows
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dumbo/test/regression_helper.rb

@@ -0,0 +1,20 @@
+RSpec.configure do |config|
+  config.before(:all) do |e|
+    path =  self.class.metadata[:file_path]
+    test_file = Pathname.new(path).basename.sub_ext('.sql').sub('_spec','')
+    test_path = test_file.realdirpath  File.expand_path('test/sql')
+    FileUtils.touch(test_path)
+
+    ActiveRecord::Base.logger = Dumbo::Test::Helper::SqlLogger.new(test_path)
+    ActiveRecord::Base.logger.level = 0
+  end
+
+  config.before(:suite) do |s|
+    FileUtils.rm_r Dir.glob('test/sql/*'), force: true
+  end
+
+  config.before(:each) do |example|
+    ActiveRecord::Base.logger.debug "-- " + example.metadata[:full_description]
+    ActiveRecord::Base.logger.debug "-- " + example.metadata[:location]
+  end
+end

data/lib/dumbo/test/silence_unknown_oid.rb

@@ -0,0 +1,12 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      module DatabaseStatements
+        def warn(msg)
+          return if msg =~ /^unknown OID/
+          super
+        end
+      end
+    end
+  end
+end