dumbo 0.0.1 → 0.0.3

data/lib/dumbo/enum_type.rb

@@ -2,7 +2,6 @@ module Dumbo
   class EnumType < Type
     attr_accessor :labels
 
-
     def load_attributes
       super
 
@@ -12,11 +11,11 @@ module Dumbo
           WHERE enumtypid = #{oid}
           ORDER by enumsortorder
         SQL
-        @labels = res.to_a.map{|r| r['enumlabel']}
+      @labels = res.to_a.map { |r| r['enumlabel'] }
     end
 
     def to_sql
-      lbl_str = labels.map{|l| "'"+l+"'"}.join(",\n  ")
+      lbl_str = labels.map { |l| "'" + l + "'" }.join(",\n  ")
 
       <<-SQL.gsub(/^ {6}/, '')
       CREATE TYPE #{name} AS ENUM (
@@ -25,4 +24,4 @@ module Dumbo
       SQL
   end
   end
-end
+end

data/lib/dumbo/extension.rb

@@ -1,35 +1,80 @@
 module Dumbo
-  class Extension
-    attr_reader :name, :version
-    def initialize(name = nil, version = nil)
-      @name = name || File.read('Makefile')[/EXTENSION *= *([^\s]*)/,1]
-      @version = version || File.read("#{self.name}.control")[/default_version *= *'([^']*)'/,1]
+  class Extension < Struct.new(:name, :version)
+    class << self
+      def name
+        @_name ||= File.read(makefile)[/EXTENSION\s*=\s*([^\s]*)/, 1]
+      end
+
+      def version
+        @_version ||= File.read(control_file)[/default_version\s*=\s*'([^']*)'/, 1]
+      end
+
+      def versions
+        new.versions
+      end
+
+      def version!(string)
+        content = File.read(control_file)
+        new_content = content.gsub(version, new_version)
+        File.open(control_file, 'w') { |file| file.puts new_content }
+      end
+
+      def file_name
+        "#{name}--#{version}.sql"
+      end
+
+      private
+
+      def makefile
+        'Makefile'
+      end
+
+      def control_file
+        "#{name}.control"
+      end
+    end
+
+    def name
+      self[:name] ||= Extension.name
+    end
+
+    def version
+      self[:version] ||= Extension.version
     end
 
     # main releases without migrations
     def releases
-      Dir.glob("#{name}--*.sql").reject{|f| f=~/\d--\d/}
+      Dir.glob("#{name}--*.sql").reject { |f| f =~ /\d--\d/ }
     end
 
-    def available_versions
-      versions = releases.map{|f| ExtensionVersion.new f[/#{name}--([\d\.]*?)\.sql/,1] }
-      versions.sort
+    def versions
+      releases.map do |file_name|
+        if version_string = file_name[/([\d+\.]+)\.sql$/, 1]
+          ExtensionVersion.new_from_string(version_string)
+        else
+          nil
+        end
+      end.compact.sort
     end
 
-    def install
+    def create
       execute "DROP EXTENSION IF EXISTS #{name}"
-      execute "CREATE EXTENSION #{name} VERSION '#{version}'"
+
+      create_sql = "CREATE EXTENSION #{name}"
+      create_sql = "#{create_sql} VERSION '#{version}'" unless version.nil?
+
+      execute create_sql
       self
     end
 
     def obj_id
       @obj_id ||= begin
-        result = execute <<-sql
+        result = execute <<-SQL
           SELECT e.extname, e.oid
           FROM pg_catalog.pg_extension e
           WHERE e.extname ~ '^(#{name})$'
           ORDER BY 1;
-        sql
+        SQL
         result.first['oid']
       end
     end
@@ -43,24 +88,24 @@ module Dumbo
           ORDER BY 1;
         SQL
 
-        result.map{|r| PgObject.new(r['objid']).get(r['classid'])}
+        result.map { |r| PgObject.new(r['objid']).get(r['classid']) }
       end
     end
 
     def types
-      objects.select{|o| o.kind_of?(Type)}
+      objects.select { |o| o.kind_of?(Type) }
     end
 
     def functions
-      objects.select{|o| o.kind_of?(Function)}
+      objects.select { |o| o.kind_of?(Function) }
     end
 
     def casts
-      objects.select{|o| o.kind_of?(Cast)}
+      objects.select { |o| o.kind_of?(Cast) }
     end
 
     def operators
-      objects.select{|o| o.kind_of?(Operator)}
+      objects.select { |o| o.kind_of?(Operator) }
     end
 
     private
@@ -68,6 +113,5 @@ module Dumbo
     def execute(sql)
       ActiveRecord::Base.connection.execute sql
     end
-
   end
-end
+end

data/lib/dumbo/extension_migrator.rb

@@ -5,31 +5,31 @@ module Dumbo
 
     def initialize(name, old_version, new_version)
       @name = name
-      @old_version = Extension.new(name, old_version).install
+      @old_version = Extension.new(name, old_version).create
       @old_version.objects
-      @new_version = Extension.new(name, new_version).install
+      @new_version = Extension.new(name, new_version).create
       @new_version.objects
     end
 
     def create
-      File.open("#{name}--#{old_version.version}--#{new_version.version}.sql",'w') do |f|
+      File.open("#{name}--#{old_version.version}--#{new_version.version}.sql", 'w') do |f|
         f.puts upgrade
       end
-      File.open("#{name}--#{new_version.version}--#{old_version.version}.sql",'w') do |f|
+      File.open("#{name}--#{new_version.version}--#{old_version.version}.sql", 'w') do |f|
         f.puts downgrade
       end
     end
 
     def upgrade
       TYPES.map do |type|
-        diff = object_diff(type,:upgrade)
+        diff = object_diff(type, :upgrade)
         "----#{type}----\n" + diff if diff.present?
       end.compact.join("\n")
     end
 
     def downgrade
       TYPES.map do |type|
-        diff = object_diff(type,:downgrade)
+        diff = object_diff(type, :downgrade)
         "----#{type}----\n" + diff if diff.present?
       end.compact.join("\n")
     end
@@ -46,12 +46,12 @@ module Dumbo
       ids = @old_version.public_send(type).map(&:identify) | @new_version.public_send(type).map(&:identify)
 
       sqls = ids.map do |id|
-        n = @new_version.public_send(type).find{|n| n.identify == id }
-        o = @old_version.public_send(type).find{|n| n.identify == id }
+        n = @new_version.public_send(type).find { |n| n.identify == id }
+        o = @old_version.public_send(type).find { |n| n.identify == id }
         if n
-          n.public_send(dir,o)
+          n.public_send(dir, o)
         elsif o
-          o.public_send(dir,o)
+          o.public_send(dir, o)
         end
       end
 
@@ -63,4 +63,4 @@ module Dumbo
       ActiveRecord::Base.connection.execute sql
     end
   end
-end
+end

data/lib/dumbo/extension_version.rb

@@ -1,25 +1,43 @@
 module Dumbo
-  class ExtensionVersion
+  class ExtensionVersion < Struct.new(:major, :minor, :patch)
     include Comparable
 
-    attr_reader :major, :minor, :patch
+    class << self
+      def new_from_string(version)
+        ExtensionVersion.new(*version.split('.').map(&:to_i))
+      end
 
-    def initialize(version="")
-      @major, @minor, @patch = version.split(".").map(&:to_i)
+      def sort
+        sort! { |a, b| a <=> b }
+      end
     end
 
     def <=>(other)
-      return major <=> other.major if ((major <=> other.major) != 0)
-      return minor <=> other.minor if ((minor <=> other.minor) != 0)
-      return patch <=> other.patch if ((patch <=> other.patch) != 0)
+      return major <=> other.major if (major <=> other.major) != 0
+      return minor <=> other.minor if (minor <=> other.minor) != 0
+      return patch <=> other.patch if (patch <=> other.patch) != 0
     end
 
-    def self.sort
-      self.sort!{|a,b| a <=> b}
+    def bump(level)
+      send("bump_#{level}")
     end
 
     def to_s
-      [major,minor,patch].join('.')
+      to_a.compact.join('.')
+    end
+
+    private
+
+    def bump_major
+      ExtensionVersion.new(major + 1, 0, 0)
+    end
+
+    def bump_minor
+      ExtensionVersion.new(major, minor.to_i + 1, 0)
+    end
+
+    def bump_patch
+      ExtensionVersion.new(major, minor, patch.to_i + 1)
     end
   end
-end
+end

data/lib/dumbo/function.rb

@@ -17,40 +17,40 @@ module Dumbo
     end
 
     def drop
-      "DROP FUNCTION #{name} #{arg_types}"
+      "DROP FUNCTION #{name}(#{arg_types});"
     end
 
     def upgrade(other)
-      return self.to_sql if other.nil?
+      return to_sql if other.nil?
 
-      if other.identify != self.identify
-        raise "Not the Same Objects!"
+      if other.identify != identify
+        fail 'Not the Same Objects!'
       end
 
-      return nil if other.to_sql == self.to_sql
+      return nil if other.to_sql == to_sql
 
-      if other.result_type != self.result_type
-         <<-SQL.gsub(/^ {8}/, '')
-        #{self.drop}
-        #{self.to_sql}
+      if other.result_type != result_type
+        <<-SQL.gsub(/^ {8}/, '')
+        #{drop}
+        #{to_sql}
         SQL
       else
-        self.to_sql
+        to_sql
       end
     end
 
     def downgrade(other)
-      return self.to_sql if other.nil?
+      return to_sql if other.nil?
 
-      if other.identify != self.identify
-        raise "Not the Same Objects!"
+      if other.identify != identify
+        fail 'Not the Same Objects!'
       end
 
-      return nil if other.to_sql == self.to_sql
+      return nil if other.to_sql == to_sql
 
-      if other.result_type != self.result_type
-         <<-SQL.gsub(/^ {8}/, '')
-        #{self.drop}
+      if other.result_type != result_type
+        <<-SQL.gsub(/^ {8}/, '')
+        #{drop}
         #{other.to_sql}
         SQL
       else
@@ -87,15 +87,15 @@ module Dumbo
           AND p.oid = #{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
-      definition.gsub("public.#{name}",name)
+      definition.gsub("public.#{name}", name)
     end
   end
-end
+end

data/lib/dumbo/operator.rb

@@ -16,7 +16,6 @@ module Dumbo
     identfied_by :name, :leftarg, :rightarg
 
     def load_attributes
-
       result = execute <<-SQL
         SELECT
          op.oprname AS name,
@@ -42,16 +41,15 @@ module Dumbo
         WHERE op.oid = #{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
-      attrs = [:leftarg, :rightarg, :commutator, :negator, :restrict, :join].inject([]) do |mem, attr|
+      attrs = [:leftarg, :rightarg, :commutator, :negator, :restrict, :join].reduce([]) do |mem, attr|
         mem << "#{attr.to_s.upcase} = #{public_send(attr)}" if public_send(attr)
         mem
       end
@@ -71,4 +69,4 @@ module Dumbo
       "DROP OPERATOR #{name};"
     end
   end
-end
+end

data/lib/dumbo/pg_object.rb

@@ -17,10 +17,10 @@ module Dumbo
     end
 
     def identify
-       identifier.map{|a| public_send a}
+      identifier.map { |a| public_send a }
     end
 
-    def get(type=nil)
+    def get(type = nil)
       case type
       when 'function', 'pg_proc'
         Function.new(oid).get
@@ -31,42 +31,39 @@ module Dumbo
       when 'type', 'pg_type'
         Type.new(oid).get
       else
-        self.load_attributes
+        load_attributes
         self
       end
     end
 
     def load_attributes
-
     end
 
     def upgrade(other)
-      return self.to_sql if other.nil?
+      return to_sql if other.nil?
 
-      if other.identify != self.identify
-        raise "Not the Same Objects!"
+      if other.identify != identify
+        fail 'Not the Same Objects!'
       end
 
-      if other.to_sql != self.to_sql
-         <<-SQL.gsub(/^ {8}/, '')
-        #{self.drop}
-        #{self.to_sql}
+      if other.to_sql != to_sql
+        <<-SQL.gsub(/^ {8}/, '')
+        #{drop}
+        #{to_sql}
         SQL
       end
-
-
     end
 
     def downgrade(other)
-      return self.drop if other.nil?
+      return drop if other.nil?
 
-      if other.identify != self.identify
-        raise "Not the Same Objects!"
+      if other.identify != identify
+        fail 'Not the Same Objects!'
       end
 
-      if other.to_sql != self.to_sql
-         <<-SQL.gsub(/^ {8}/, '')
-        #{self.drop}
+      if other.to_sql != to_sql
+        <<-SQL.gsub(/^ {8}/, '')
+        #{drop}
         #{other.to_sql}
         SQL
       end
@@ -75,6 +72,5 @@ module Dumbo
     def execute(sql)
       ActiveRecord::Base.connection.execute(sql)
     end
-
   end
-end
+end