datoki 3.1.0 → 3.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43a52b61961fb85e568c481ec205a0367f13a50b
-  data.tar.gz: 9b9064f20a24ebe7b141ea54f9e201ce447fa1d7
+  metadata.gz: c428125e9eb84488c728ccefe771cc2999661ad5
+  data.tar.gz: 73a3385af85fec918db78ac0dcf2e688b0650a09
 SHA512:
-  metadata.gz: 389d463817cdad3695f0355216e3e6eba492ed092c63ffe18a7c391351f9a66305121b7242d4076c74fdb5cd64ff68195e980caba5298fc3149771c9a8e3a591
-  data.tar.gz: b23b19e80b655b8020bd5f57ef71772093c5b351c7a47026dbe08490e5074223e29653ae532afb649c895a9c5efa85ae55d9f3ec3b5cd0520c7b5ffe09ba49a4
+  metadata.gz: 33c0f0d96d1c411211f50f36bf103d25d441ac1456ae19b765ba191df6379913bcb6d403b6b1a3470d0c5d8a97279022f60b13836b5539217303d48c05348d93
+  data.tar.gz: 59b1622720b9c1b909395fbaa1dbd1bd837384c9c7b6c4a0448c515c9baf76cd3e2410d09c720df1a940b10331cfc4b6d9fb1d8328ec8bb40ccd2072ed9e9662

data/README.md

@@ -11,6 +11,14 @@ for managing data in PostgreSQL.
 ## Usage
 
 ```ruby
+  # === Set it up: =======================
+  require 'datoki'
+  require 'sequel'
+  DB = Sequel.connect ENV['DATABASE_URL']
+  DB.cache_schema = false
+  Datoki.db DB
+  # ======================================
+
   class Computer
     include Datoki
 

data/VERSION

@@ -1 +1 @@
-3.1.0
+3.2.1

data/lib/datoki.rb

@@ -48,7 +48,7 @@ module Datoki
 
   module Def_Field
 
-    attr_reader :ons, :fields, :fields_as_required
+    attr_reader :ons, :fields, :table_name, :fields_as_required
 
     def initialize_def_field
       @ons                = {}
@@ -137,15 +137,35 @@ module Datoki
       fields[@current_field][:allow][sym] = true;
     end
 
+    #
+    # This method removes keys that
+    # are meant to be secret: e.g. encrypted passwords.
+    # This decreases the chance they end up in logs.
+    #
+    def returning_fields
+      return [] unless table_name
+      s = Datoki.db.schema(table_name)
+      return [] unless s
+      s.map { |pair|
+        name, meta = pair
+        field = fields[name]
+        if !field || !field[:secret]
+          name
+        else
+          nil
+        end
+      }.compact
+    end
+
     def field? *args
       inspect_field?(:type, field[:name], *args)
     end
 
     def field *args
       # === Setup a default table if none specified:
-      if !@table_name
+      if !@table_name && Datoki.db
         t_name = self.to_s.downcase.to_sym
-        table(name) if Datoki.db.tables.include?(t_name)
+        table(t_name) if Datoki.db.tables.include?(t_name)
       end
 
       return fields[@current_field] if args.empty?
@@ -294,6 +314,19 @@ module Datoki
       self
     end
 
+    def unique_index name, msg = nil
+      field[:unique_index] = name
+      if msg
+        field[:error_msgs] ||= {}
+        field[:error_msgs][:unique] = msg
+      end
+      self
+    end
+
+    def secret
+      field[:secret] = true
+    end
+
     def primary_key
       field[:primary_key] = true
       if field?(:unknown)
@@ -452,13 +485,17 @@ module Datoki
     }
 
     def matches v = :blok
-      fail "Not allowed for #{field[:type].inspect}" unless field?(:chars)
       field[:cleaners][:match] ||= []
       field[:cleaners][:match] << (v == :blok ? Proc.new : v)
     end
 
     def create raw
-      raw[:create] = self
+      raw[:create] = self.to_s
+      new raw
+    end
+
+    def update raw
+      raw[:update] = self.to_s
       new raw
     end
 
@@ -466,7 +503,7 @@ module Datoki
 
   # ================= Instance Methods ===============
 
-  attr_reader :error, :data
+  attr_reader :error, :raw
   def initialize unknown = nil
     @data       = nil
     @field_name = nil
@@ -476,12 +513,18 @@ module Datoki
     @db_ops     = {} # Ex: :db_insert=>true, :db_update=>true
 
     if unknown
-      if unknown.keys.all? { |f| self.class.fields.has_key?(f) }
+      is_record = unknown.keys.all? { |f|
+        self.class.fields.has_key?(f) ||
+          (self.class.schema && self.class.schema.has_key?(f)) 
+      }
+
+      if is_record
         @data = unknown
         @data.default_proc = Key_Not_Found
       else
         @raw = unknown
       end
+
     end
 
     if @raw
@@ -489,11 +532,12 @@ module Datoki
       schema = self.class.schema
 
       case
-      when create? && respond_to?(:create)
+      when create?
         create
-      when update? && respond_to?(:update)
+      when update?
+        clean primary_key[:name]
         update
-      when delete? && respond_to?(:delete)
+      when delete?
         delete
       end
 
@@ -508,7 +552,6 @@ module Datoki
 
       if !@skips[:db] && !self.class.schema.empty?
 
-        final = db_clean
         begin
           case
 
@@ -516,12 +559,10 @@ module Datoki
             db_insert
 
           when update?
-
-            DB[self.class.table].
-              where(primary_key[:name] => final.delete(primary_key[:name])).
-              update(final)
+            db_update
 
           when delete?
+            final = db_clean
             DB[self.class.table].
               where(primary_key[:name] => final.delete(primary_key[:name])).
               delete
@@ -530,10 +571,10 @@ module Datoki
 
         rescue Sequel::UniqueConstraintViolation => e
 
-          self.class.fields.each { |f|
-            if e.message["'\"#{f}_"]
+          self.class.fields.each { |f, meta|
+            if meta[:unique_index] && e.message[%^unique constraint "#{meta[:unique_index]}"^]
               field_name f
-              fail! :unique, "{{English name}} already taken: #{final[f]}"
+              fail! :unique, "{{English name}} already taken: #{meta[:name]}"
             end
           }
           raise e
@@ -543,6 +584,11 @@ module Datoki
     end # === if @raw
   end
 
+  def data
+    fail "Data not set." unless @data
+    @data
+  end
+
   def skip name
     @skips[name] = true
   end
@@ -553,7 +599,8 @@ module Datoki
 
   def db_clean
     @clean.select { |k, v|
-      !self.class.fields[k][:pseudo]
+      meta = self.class.fields[k]
+      !meta || !meta[:pseudo]
     }
   end
 
@@ -808,10 +855,17 @@ module Datoki
     self.class.inspect_field? :type, field_name, *args
   end
 
+  def id
+    d = data
+    pk = primary_key[:name]
+    fail "No primary key set yet." unless d.has_key?(pk)
+    d[pk]
+  end
+
   def primary_key
-    arr = self.class.fields.detect { |k, v| v[:primary_key] }
-    fail "Primary key not found." unless arr
-    arr.last
+    name, meta = self.class.fields.detect { |k, v| v[:primary_key] }
+    fail "Primary key not found." unless meta
+    meta
   end
 
   def new?
@@ -819,8 +873,7 @@ module Datoki
   end
 
   def create?
-    (@raw.has_key?(:create) && @raw[:create]) ||
-    @raw.has_key?(primary_key[:name]) && !@raw[primary_key[:name]]
+    !!(@raw.has_key?(:create) && @raw[:create])
   end
 
   def read?
@@ -839,14 +892,35 @@ module Datoki
     self.class::TABLE
   end
 
+  def returning_fields
+    self.class.returning_fields
+  end
+
   def db_insert
     k = :db_insert
-    final = db_clean
     fail "Already inserted." if @db_ops[k]
-    @data = (@data || {}).merge(TABLE().returning.insert(final).first)
+
+    final = db_clean
+    new_data = TABLE().returning(*returning_fields).insert(final).first
+    @data = (@data || {}).merge(new_data)
     @db_ops[k] = true
   end
 
+  def db_update
+    k = :db_update
+    fail "Already updated" if @db_ops[k]
+
+    final = db_clean
+    new_data = TABLE().
+      returning(*returning_fields).
+      where(primary_key[:name] => final.delete(primary_key[:name])).
+      update(final).
+      first
+
+    @data = (@data || {}).merge(new_data)
+    @db_ops[:db_update]  = true
+  end
+
 end # === module Datoki ===
 
 

data/specs/0010-Datoki.db.rb

@@ -1,9 +1,10 @@
 
+class Datoki_Test
+end
 
 describe "Datoki.db" do
 
   before {
-
     CACHE[:datoki_db_test] ||= reset_db <<-EOF
       CREATE TABLE "datoki_test" (
         id serial NOT NULL PRIMARY KEY,
@@ -23,18 +24,56 @@ describe "Datoki.db" do
         clean :title, :body
       end
     }
-  }
+  } # === before
 
-  it "allows an undefined field that exists in the db schema" do
+  it "sets :table_name to name of class" do
+    class Datoki_Test
+      include Datoki
+      field(:title) { varchar 1,123  }
+    end
+
+    Datoki_Test.table_name.should == :datoki_test
+  end # === it sets :table_name to name of class
+
+  it "does not return fields marked as :secret" do
+    c = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123; secret }
+
+      def create
+        clean :id, :title, :body
+      end
+    }
+    r = c.create(:title=>'test', :body=>'my body')
+    r.data.keys.should == [:id, :title]
+  end # === it does not return fields marked as :secret
+
+  it "allows to save undefined field to the db" do
     Class.new {
       include Datoki
       table :datoki_test
+
+      def create
+        clean[:title] = 'title 123'
+      end
+    }.create({})
+    DB[:datoki_test].all.last[:title].should == 'title 123'
+  end # === it allows to save undefined field to the db
+
+  it "allows an undefined field that exists in the db schema" do
+    r = Class.new {
+      include Datoki
+      table :datoki_test
       field(:id) { primary_key }
       field(:title) { varchar 1, 123 }
       def create
         clean :title
       end
-    }.create(:title=>'title').data.should == {:id=>1, :title=>'title', :body=>'hello'}
+    }.create(:title=>'title').data
+    r[:title].should == 'title'
+    r[:body].should == 'hello'
   end
 
   it 'raises Schema_Conflict if a field is found that allows null, but not specifed to do so' do

data/specs/0010-create.rb

@@ -0,0 +1,45 @@
+
+describe :create do
+
+  before {
+    CACHE[:datoki_db_test] ||= reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id serial NOT NULL PRIMARY KEY,
+        title varchar(123) NOT NULL,
+        body  text DEFAULT 'hello'
+      );
+    EOF
+
+    @klass = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { integer; primary_key }
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123 }
+
+      def create
+        clean :title, :body
+      end
+    }
+  } # === before
+
+  it "throws :invalid for a violation of a unique key constraint of a defined field" do
+    c = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { integer; primary_key; unique_index 'datoki_test_pkey' }
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123 }
+
+      def create
+        clean :id, :title, :body
+      end
+    }
+    r = @klass.create :title=>'the title', :body=>'yes yes yes'
+    catch(:invalid) {
+      c.create :id=>r.data[:id], :title=>r.data[:title], :body=>r.data[:body]
+    }.error[:msg].should.match /Id already taken/
+  end # === it
+
+
+end # === describe :create

data/specs/0010-update.rb

@@ -0,0 +1,39 @@
+
+describe :update do
+
+  before {
+    CACHE[:update] ||= reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id serial NOT NULL PRIMARY KEY,
+        title varchar(123) NOT NULL,
+        body  text DEFAULT 'hello'
+      );
+    EOF
+  } # === before
+
+  it "updates the record" do
+    c = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { integer; primary_key }
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123 }
+
+      def create
+        clean :title, :body
+      end
+
+      def update
+        clean :title, :body
+      end
+    }
+
+    r = c.create :title=>'My Old', :body=>'My Old'
+    c.update :id=>r.id, :title=>'My New Title', :body=>'My New Body'
+
+    record = DB[:datoki_test].where(:id=>r.id).first
+    record[:title].should == 'My New Title'
+    record[:body].should  == 'My New Body'
+  end # === it updates the record
+
+end # === describe :update

data/specs/0011-new.rb

@@ -0,0 +1,37 @@
+
+describe :new do
+
+  before {
+    CACHE[:datoki_db_test] ||= reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id serial NOT NULL PRIMARY KEY,
+        title varchar(123) NOT NULL,
+        body  text DEFAULT 'hello'
+      );
+    EOF
+
+  } # === before
+
+  it "saves hash as data" do
+    klass = Class.new {
+      include Datoki
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123 }
+    }
+    r = klass.new(title: 'title1', body: 'body1')
+    r.data[:title].should == 'title1'
+  end # === it saves hash as data
+
+  it "saves hash even for undefined, yet schema, fields" do
+    klass = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:title) { varchar 1, 123 }
+    }
+    r = klass.new(id: 1, title: 'title1', body: 'body1')
+    r.data[:title].should == 'title1'
+  end # === it saves hash even for undefined, yet schema, fields
+
+end # === describe :new
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datoki
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.1
 platform: ruby
 authors:
 - da99
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2015-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -111,12 +111,15 @@ files:
 - specs/0010-Datoki.db.rb
 - specs/0010-Numeric.rb
 - specs/0010-Numeric_db.rb
+- specs/0010-create.rb
 - specs/0010-href.rb
 - specs/0010-html_escape.rb
 - specs/0010-no_type.rb
 - specs/0010-schema_conflict.rb
+- specs/0010-update.rb
 - specs/0010-varchar.rb
 - specs/0010-varchar_db.rb
+- specs/0011-new.rb
 - specs/0011-string_ish.rb
 - specs/0012-pseudo.rb
 - specs/0020-clean!.rb
@@ -144,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A gem to manage PGsql records.