Dex 0.1.3 → 0.2.0

data/lib/Dex.rb

@@ -3,62 +3,101 @@ require 'sequel'
 
 class Dex
 
-  def self.rack_dir
-    @rack_dir ||= File.join( File.dirname( __FILE__ ) , "/Dex/Rack_App" )
+  module DEFAULT
+    DB_NAME    = "/tmp/dex_exceptions.db" 
+    TABLE_NAME = :dex_exceptions
+    RACK_DIR   = File.join( File.dirname( __FILE__ ) , "/Dex/Rack" )
   end
 
-  def self.default_db
-    "/tmp/dex_exceptions.db"
-  end
-
-  def self.default_table
-    :dex_exceptions
+  def self.default k
+    eval "#{self}::DEFAULT::#{k.to_s.upcase}"
   end
 
   module DSL
     
-    def db_file f = :_R_
-      return @db_file if f == :_R_
-      @db_file = f
+    attr_reader :table
+
+    def default *args
+      Dex.default(*args)
     end
 
-    def keep_only n = 250
-      c = table.count
-      return false unless c > 250
-      table.filter( :id=> Dex.table.select(:id).limit( c-n ) ).delete
+    def db *args
+      return @db if args.empty? && instance_variable_defined?(:@db)
+        
+      case args.size
+        
+      when 0
+        name  = default :db_name
+        table = default :table_name
+        
+      when 1
+        name  = args[0]
+        table = default :table_name
+
+      when 2
+        name  = args[0]
+        table = args[1]
+        
+      else
+        args.shift
+        args.shift
+        raise ArgumentError, "Unknown arguments: #{args.inspect}"
+        
+      end # === case
+      
+      @db    = Sequel.sqlite(name)
+      @table = @db[table.to_sym]
+      
+      @db.create_table?(table_name) {
+
+        primary_key :id
+        String   :message
+        String   :exception
+        Text     :backtrace
+        Integer  :status
+        DateTime :created_at
+
+      }
+
+      @db
+    end # === def db
+
+    def db_name
+      db.opts[:database] || default(:db_name)
+    end
+    
+    def table_name
+      return nil unless table
+      table.opts[:from].first
     end
 
-    def db name = :_RETURN_
-      if name != :_RETURN_
-        @db = begin
-                db_file name
-                db = Sequel.sqlite db_file
-                db.create_table?(Dex.default_table) {
-
-                  primary_key :id
-                  String :message
-                  String :exception
-                  Text :backtrace
-                  Integer :status
-                  DateTime :created_at
-
-                }
-                db
-              end
-        @table = nil
-      end
+    def table_exists?
+      db.table_exists?(table_name)
+    end
 
-      @db ||= db(Dex.default_db)
+    def fields
+      db.schema(table_name).map(&:first)
     end
 
-    def table name = :_RETURN_
-      if name != :_RETURN_
-        @table = db[name]
-      end
-      @table ||= table(:dex_exceptions)
+    def keep_only n = 250
+      c = table.count
+      return false unless c > 250
+      table.filter( :id=> Dex.table.select(:id).limit( c-n ) ).delete
     end
 
-    def insert e
+    def insert e, other=Hash[]
+      unless other.keys.empty?
+        keys=other.keys.map(&:to_sym)
+        new_keys = keys - fields
+        unless new_keys.empty?
+          db.alter_table table_name do
+            new_keys.each { |k|
+              add_column k, :string
+            }
+          end
+        end
+      end
+      
       table.insert \
         :message   => e.message, \
         :exception => e.exception.class.name, \
@@ -67,6 +106,11 @@ class Dex
         :created_at => Time.now.utc
     end
 
+    def remove_field name
+      db.alter_table table_name do
+        drop_column name
+      end
+    end
     def recent n = 10
       ds = table.reverse_order(:created_at, :id).limit(n)
       if n < 2

data/lib/Dex/version.rb

@@ -1,3 +1,3 @@
 class Dex
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/Dex.rb

@@ -1,12 +1,18 @@
 
 describe "Dex :db" do
-  
-  it "resets :table to nil after specifying a new Database" do
+
+  behaves_like 'Test DB'
+
+  it "converts String table name to Symbol. (Sequel table name compatibility.)" do
+    t = new_dex
+    t.db "/tmp/db.test.1.db", "my_table"
+    t.table_name.should == "my_table".to_sym
+  end
+
+  it "sets table name to specified value" do
     t = new_dex
-    t.db "/tmp/db.test.1.db"
-    t.table.count
-    t.db "/tmp/db.test.2.db"
-    t.instance_eval { @table }.should.be == nil
+    t.db "/tmp/db.test.1.db", :my_new_table
+    t.table_name.should == :my_new_table
   end
 
   it "allows file names with underscores: my_log.db" do
@@ -36,102 +42,120 @@ describe "Dex :db" do
 end # === Dex :db
 
 describe "Dex :recent" do
-  
+
+  behaves_like 'Test DB'
+
   it "returns first result if n = 1" do
-    transact {
-      e = except "One"
-      Dex.insert e
-      Dex.recent( 1 )[:message].should == "One"
-    }
+    e = except "One"
+    Dex.insert e
+    Dex.recent( 1 )[:message].should == "One"
   end
 
   it "returns a dataset if n > 1" do
-    transact {
-      e1 = except "One"
-      e2 = except "Two"
-      Dex.insert e1
-      Dex.insert e2
-      r = Dex.recent
-      r.to_a.size.should == 2
-    }
+    e1 = except "One"
+    e2 = except "Two"
+    Dex.insert e1
+    Dex.insert e2
+    r = Dex.recent
+    r.to_a.size.should == 2
   end
-    
+
   it "returns results in reverse order" do
-    transact {
-      3.times do |i|
-        Dex.insert( except i.to_s )
-      end
-      Dex.recent.map { |d| d[:message] }.should == %w{ 2 1 0 }
-    }
+    3.times do |i|
+      Dex.insert( except i.to_s )
+    end
+    Dex.recent.map { |d| d[:message] }.should == %w{ 2 1 0 }
   end
 
 end # === Dex :recent
 
 
 describe "Dex :insert" do
-  
+
+  behaves_like 'Test DB'
+
   it "saves message of exception" do
-    transact {
-      e = except "My Name"
-      Dex.insert e
-      Dex.recent( 1 )[:message].should == e.message
-    }
+    e = except "My Name"
+    Dex.insert e
+    Dex.recent( 1 )[:message].should == e.message
   end
-  
+
   it "returns id of new record" do
-    transact {
-      e = except "My record"
-      id = Dex.insert(e)
-      Dex.filter(:id=>id).first[:message].should == "My record"
-    }
+    e = except "My record"
+    id = Dex.insert(e)
+    Dex.filter(:id=>id).first[:message].should == "My record"
   end
 
   it "sets :status to 0 by default" do
-    transact {
-      id = Dex.insert(except "Another record")
-      Dex.filter(:id=>id).first[:status].should == 0
+    id = Dex.insert(except "Another record")
+    Dex.filter(:id=>id).first[:status].should == 0
+  end
+
+  it "adds new fields to table" do
+    dex = new_dex "new_fields"
+    dex.db.transaction(:rollback=>:always) {
+      dex.insert( except("New fields"), :fd1=>"field 1", :fd2=>"field 2" )
+      fields = dex.db.schema(dex.table_name).map(&:first)
+      fields.should.include :fd1
+      fields.should.include :fd2
     }
   end
+
 end # === Dex :insert
 
 describe "Dex :keep_only" do
-  
+
+  behaves_like 'Test DB'
+
   it "deletes oldest records leaving most recent 250" do
-    transact {
-      300.times { |i| Dex.insert except(i.to_s) }
-      Dex.keep_only
-      Dex.count.should == 250
-      Dex.recent(1)[:message].should == '299'
-    }
+    300.times { |i| Dex.insert except(i.to_s) }
+    Dex.keep_only
+    Dex.count.should == 250
+    Dex.recent(1)[:message].should == '299'
   end
-  
+
   it "accepts a limit argument" do
-    transact {
-      300.times { |i| Dex.insert except(i.to_s) }
-      Dex.keep_only 12
-      Dex.table.count.should == 12
-    }
+    300.times { |i| Dex.insert except(i.to_s) }
+    Dex.keep_only 12
+    Dex.table.count.should == 12
   end
 
 end # === Dex :keep_only
 
-describe "Dex missing_method" do
-  
+describe "Dex :missing_method" do
+
+  behaves_like 'Test DB'
+
   it "sends message to :table if it responds to message" do
-    transact {
-      (rand 10).times { |i| Dex.insert except(i.to_s) }
-      Dex.count.should == Dex.table.count
-    }
+    (rand 10).times { |i| Dex.insert except(i.to_s) }
+    Dex.count.should == Dex.table.count
   end
 
   it "raises super :missing_method if :table does not respond to message" do
-    transact {
-      (rand 10).times { |i| Dex.insert except(i.to_s) }
-      should.raise(NoMethodError) {
-        Dex.xyz
-      }.message.should.match %r!undefined method `xyz' for Dex:Class!
-    }
+    (rand 10).times { |i| Dex.insert except(i.to_s) }
+    should.raise(NoMethodError) {
+      Dex.xyz
+    }.message.should.match %r!undefined method `xyz' for Dex:Class!
   end
-  
+
 end # === Dex missing_method
 
+describe "Dex :remove_field" do
+  
+  before {
+    @dex = new_dex(':memory:')
+    @dex.table.delete 
+  }
+
+  it "removes specified field" do
+    orig = @dex.fields
+    name = :my_field
+    @dex.insert except("remve field"), name => '---'
+    @dex.fields.should.include name
+    @dex.remove_field name
+    
+    @dex.fields.should.not.include name
+  end
+
+end # === Dex :remove_field
+

data/spec/libs/main.rb

@@ -18,21 +18,18 @@ Bacon.summary_on_exit
 require 'Bacon_Colored'
 require 'pry'
 require 'Exit_0'
-
 require 'Dex'
 
-Exit_0 "rm /tmp/dex.test.db" if File.exists?("/tmp/dex.test.db")
-Dex.db "/tmp/dex.test.db"
+Dex.db ":memory:"
 
-def transact 
-  Dex.db.transaction(:rollback=>:always) {
-    yield
-  }
-end
-
-def new_dex
+def new_dex db = nil
   @t ||= Class.new { include Dex::DSL }
-  @t.new
+  dex = @t.new
+  if db
+    dex.db(db[':'] ? db : File.join("/tmp", db) )
+  end
+
+  dex
 end
 
 def except name
@@ -46,6 +43,15 @@ def except name
 end
 
 
+shared "Test DB" do
+  
+  before {
+    Dex.table.delete
+  }
+  
+end
+
+
 # ======== Include the tests.
 if ARGV.size > 1 && ARGV[1, ARGV.size - 1].detect { |a| File.exists?(a) }
   # Do nothing. Bacon grabs the file.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Dex
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-04 00:00:00.000000000 Z
+date: 2012-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bacon
@@ -135,6 +135,7 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- db.db
 - lib/Dex.rb
 - lib/Dex/version.rb
 - spec/Dex.rb