datoki 2.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8ba5eae546ee0b466bbb634b3b05203ad3cfef1
-  data.tar.gz: c5fca1d1cc64342d30538e9850b16c2995d55dd2
+  metadata.gz: 43a52b61961fb85e568c481ec205a0367f13a50b
+  data.tar.gz: 9b9064f20a24ebe7b141ea54f9e201ce447fa1d7
 SHA512:
-  metadata.gz: f356726aa8abe2b29ec6bfd0ff86594d81621e8bdbde5276d60aec70dc85aab1288c13893a6505f053f14d1c8d57f049707c39fdb93ce1db1fbfc51c33f90d7c
-  data.tar.gz: 49c0f8bbbd20b2785c2be44bea06f650e76cc01a8b30783c524fc2ab278ff3a4ae94010a74bf3b467ee1d3aeab341647a958aaedd9573565ea3c653d4a2d09a2
+  metadata.gz: 389d463817cdad3695f0355216e3e6eba492ed092c63ffe18a7c391351f9a66305121b7242d4076c74fdb5cd64ff68195e980caba5298fc3149771c9a8e3a591
+  data.tar.gz: b23b19e80b655b8020bd5f57ef71772093c5b351c7a47026dbe08490e5074223e29653ae532afb649c895a9c5efa85ae55d9f3ec3b5cd0520c7b5ffe09ba49a4

data/README.md

@@ -1,7 +1,8 @@
 
 # Datoki
 
-A Ruby gem for managing validation and records using PostgreSQL.
+A Ruby gem that is part abstraction layer, part validator...
+for managing data in PostgreSQL.
 
 ## Installation
 
@@ -39,3 +40,7 @@ A Ruby gem for managing validation and records using PostgreSQL.
   end # === class
 ```
 
+## NOTE:
+
+1) Raises an error if a mismatch between field definition and schema.
+Example: `:allow_null != field[:allow][:null]`

data/VERSION

@@ -1 +1 @@
-2.0.1
+3.1.0

data/lib/datoki.rb

@@ -11,7 +11,7 @@ module Datoki
   Schema_Conflict = Class.new RuntimeError
 
   Actions       = [:all, :create, :read, :update, :update_or_create, :trash, :delete]
-  Char_Types    = [:varchar, :text]
+  Char_Types    = [:varchar, :text, :string_ish]
   Numeric_Types = [:smallint, :integer, :bigint, :decimal, :numeric]
   Types         = Char_Types + Numeric_Types + [:datetime]
 
@@ -51,7 +51,6 @@ module Datoki
     attr_reader :ons, :fields, :fields_as_required
 
     def initialize_def_field
-      @on_doc             = []
       @ons                = {}
       @fields             = {} # Ex: {:name=>{}, :age=>{}}
       @fields_as_required = {} # Ex: {:name!=>:name}
@@ -59,8 +58,6 @@ module Datoki
       @schema             = {}
       @schema_match       = false
       @table_name         = nil
-      name = self.to_s.downcase.to_sym
-      table(name) if Datoki.db.tables.include?(name)
     end
 
     def schema_match?
@@ -68,6 +65,7 @@ module Datoki
     end
 
     def table name
+      fail ArgumentError, "Table name must be a Symbol: #{name.inspect}" unless name.is_a?(Symbol)
       if !@schema.empty? || @table_name
         fail "Schema/table already defined: #{@table_name.inspect}"
       end
@@ -75,10 +73,11 @@ module Datoki
       db_schema = Datoki.db.schema(name)
 
       if !db_schema
-        fail "Schema not found for: #{name.inspect}"
+        fail ArgumentError, "Schema not found for: #{name.inspect}"
       end
 
       @table_name = name
+      self.const_set(:TABLE, DB[@table_name])
 
       db_schema.each { |pair|
         @schema[pair.first] = pair.last
@@ -130,15 +129,25 @@ module Datoki
       end
     end
 
-    def field? *args
-      inspect_field?(:type, field[:name], *args)
+    def pseudo
+      fields[@current_field][:pseudo] = true
     end
 
     def allow sym
       fields[@current_field][:allow][sym] = true;
     end
 
+    def field? *args
+      inspect_field?(:type, field[:name], *args)
+    end
+
     def field *args
+      # === Setup a default table if none specified:
+      if !@table_name
+        t_name = self.to_s.downcase.to_sym
+        table(name) if Datoki.db.tables.include?(t_name)
+      end
+
       return fields[@current_field] if args.empty?
       return fields[args.first] unless block_given?
 
@@ -214,11 +223,9 @@ module Datoki
       name      = @current_field
       db_schema = schema[@current_field]
 
-      if db_schema && !field && db_schema[:type] != :datetime
-        fail Schema_Conflict, "#{name}: #{name.inspect} has not been defined."
-      end
-
-      return true if field[:schema_match]
+      return true if db_schema && !field
+      return true if field[:schema_has_been_matched]
+      return true if field[:pseudo]
 
       if db_schema[:allow_null] != field[:allow][:null]
         fail Schema_Conflict, "#{name}: :allow_null: #{db_schema[:allow_null].inspect} != #{field[:allow][:null].inspect}"
@@ -245,10 +252,12 @@ module Datoki
       end
 
       # === match :type
-      db_type = Datoki.db_type_to_ruby db_schema[:db_type], db_schema[:type]
-      type    = field[:type]
-      if db_type != type
-        fail Schema_Conflict, "#{name}: :type: #{db_type.inspect} != #{type.inspect}"
+      if field[:type] != :string_ish
+        db_type = Datoki.db_type_to_ruby db_schema[:db_type], db_schema[:type]
+        type    = field[:type]
+        if db_type != type
+          fail Schema_Conflict, "#{name}: :type: #{db_type.inspect} != #{type.inspect}"
+        end
       end
 
       # === match :max_length
@@ -270,14 +279,7 @@ module Datoki
         fail Schema_Conflict, "#{name}: :allow_null: #{db_schema[:allow_null].inspect} != #{field[:allow][:null].inspect}"
       end
 
-      field[:schema_match] = true
-    end
-
-    attr_reader :on_doc
-    def on *args
-      return(field_on *args) if !block_given?
-      @on_doc << [args, Proc.new]
-      self
+      field[:schema_has_been_matched] = true
     end
 
     def field_on action, meth_name_sym
@@ -373,6 +375,14 @@ module Datoki
       when [Fixnum, Fixnum]
         field[:min], field[:max] = args
 
+      when [Proc], [Regexp]
+        matches *args
+
+      when [Fixnum, Fixnum, Proc], [Fixnum, Fixnum, Regexp]
+        field[:min] = args.shift
+        field[:max] = args.shift
+        matches *args
+
       else
         fail "Unknown args: #{args.inspect}"
 
@@ -380,6 +390,15 @@ module Datoki
 
     end # === def
 
+    [:mis_match, :small, :big].each { |name|
+      eval <<-EOF
+        def #{name} msg
+          field[:error_msgs] ||= {}
+          field[:error_msgs][:#{name}] = msg
+        end
+      EOF
+    }
+
     def enable *props
       props.each { |prop|
         case prop
@@ -404,9 +423,9 @@ module Datoki
       }
     end
 
-    def set_to *args
+    def set_to v = :blok
       field[:cleaners][:set_to] ||= []
-      field[:cleaners][:set_to].concat args
+      field[:cleaners][:set_to] << (v == :blok ? Proc.new : v)
     end
 
     def equal_to *args
@@ -432,17 +451,10 @@ module Datoki
       EOF
     }
 
-    def match *args
+    def matches v = :blok
       fail "Not allowed for #{field[:type].inspect}" unless field?(:chars)
       field[:cleaners][:match] ||= []
-      field[:cleaners][:match] << args
-    end
-
-    def not_match *args
-      fail "Not allowed for #{field[:type].inspect}" unless field?(:chars)
-      field[:cleaners][:not_match] ||= []
-      field[:cleaners][:not_match] << args
-      self
+      field[:cleaners][:match] << (v == :blok ? Proc.new : v)
     end
 
     def create raw
@@ -454,13 +466,14 @@ module Datoki
 
   # ================= Instance Methods ===============
 
-  attr_reader :error
+  attr_reader :error, :data
   def initialize unknown = nil
     @data       = nil
     @field_name = nil
     @clean      = nil
     @error      = nil
     @skips      = {}
+    @db_ops     = {} # Ex: :db_insert=>true, :db_update=>true
 
     if unknown
       if unknown.keys.all? { |f| self.class.fields.has_key?(f) }
@@ -472,56 +485,62 @@ module Datoki
     end
 
     if @raw
-      self.class.on_doc.each { |raw_arr|
-
-        conds = raw_arr.first
-        func  = raw_arr.last
-        instance_eval(&func) if conds.all? { |cond|
-          case cond
-          when Symbol
-            send(cond)
-          when Proc
-            cond.arity == 1 ? cond.call(@raw) : instance_eval(&cond)
-          when TrueClass, FalseClass
-            cond
-          else
-            fail ArgumentError, "Unknown: #{cond.inspect}"
-          end
-        }
 
-      } # === on_doc.each
+      schema = self.class.schema
+
+      case
+      when create? && respond_to?(:create)
+        create
+      when update? && respond_to?(:update)
+        update
+      when delete? && respond_to?(:delete)
+        delete
+      end
 
-      if !@clean
-        @raw.each { |k, v|
-          clean(k) if self.class.fields.has_key?(k)
+      if @clean
+        @clean.each { |k, v|
+          # === Delete nil value if schema has a default value:
+          @clean.delete(k) if @clean[k].nil? && schema[k] && schema[k][:default]
         }
       end
 
-      schema = self.class.schema
-      if create?
-        # === Did the programmer forget to set the value?:
-        self.class.fields.each { |k, meta|
-          has_default = schema[k] && schema[k][:default]
-          if clean[k].nil? && !meta[:allow][:null] && !meta[:primary_key] && !has_default
-            fail ArgumentError, "#{k.inspect} is not set."
+      fail "No clean values found." if (!@clean || @clean.empty?)
+
+      if !@skips[:db] && !self.class.schema.empty?
+
+        final = db_clean
+        begin
+          case
+
+          when create?
+            db_insert
+
+          when update?
+
+            DB[self.class.table].
+              where(primary_key[:name] => final.delete(primary_key[:name])).
+              update(final)
+
+          when delete?
+            DB[self.class.table].
+              where(primary_key[:name] => final.delete(primary_key[:name])).
+              delete
+
           end
 
-          # === Should we let the DB set the value?
-          @clean.delete(k) if @clean[k].nil? && has_default
-        }
-      end
+        rescue Sequel::UniqueConstraintViolation => e
 
-      case
-      when create?
-        insert_into_table unless !respond_to?(:insert_into_table)
-      when update?
-        alter_record unless !respond_to?(:alter_record)
-      when delete?
-        delete_from_table unless !respond_to?(:delete_from_table)
-      end unless @skips[:db]
-    end # === if @raw
+          self.class.fields.each { |f|
+            if e.message["'\"#{f}_"]
+              field_name f
+              fail! :unique, "{{English name}} already taken: #{final[f]}"
+            end
+          }
+          raise e
 
-    self.class.schema_match(:all)
+        end # === begin/rescue
+      end # === if !@skips[:db]
+    end # === if @raw
   end
 
   def skip name
@@ -532,6 +551,22 @@ module Datoki
     @error && !@error.empty?
   end
 
+  def db_clean
+    @clean.select { |k, v|
+      !self.class.fields[k][:pseudo]
+    }
+  end
+
+  def clean! *args
+    args.each { |name|
+      if @raw[name].nil? && (!@clean || @clean[name].nil?)
+        fail ArgumentError, "#{name.inspect} is not set."
+      else
+        clean name
+      end
+    }
+  end
+
   def clean *args
     @clean ||= {}
 
@@ -546,10 +581,8 @@ module Datoki
 
     name = args.first
 
-    if (real_name = self.class.fields_as_required[name]) && @raw[real_name].nil? && @clean[real_name].nil?
-      fail ArgumentError, "#{real_name.inspect} is not set."
-    else
-      name = real_name || name
+    if (real_name = self.class.fields_as_required[name])
+      return(clean! real_name) 
     end
 
     @clean[name] = @raw[name] if !clean.has_key?(name) && @raw.has_key?(name)
@@ -572,14 +605,14 @@ module Datoki
     if field?(:numeric) && clean[name].is_a?(String)
       clean_val = Integer(clean[name]) rescue String
       if clean_val == String
-        fail! "!English_name must be numeric."
+        fail! :wrong_type, "{{English name}} must be numeric."
       else
         clean[name] = clean_val
       end
     end
 
     if field?(:text) && clean[name].is_a?(String) && clean[name].empty? && field[:min].to_i > 0
-      fail! "!English_name is required."
+      fail! :required, "{{English name}} is required."
     end
     # ================================
 
@@ -593,25 +626,30 @@ module Datoki
       when [NilClass, Fixnum]
         case
         when clean[name].is_a?(String) && clean[name].size > field[:max]
-          fail! "!English_name can't be longer than !max characters."
+          fail! :big, "{{English name}} can't be longer than {{max}} characters."
         when clean[name].is_a?(Numeric) && clean[name] > field[:max]
-          fail! "!English_name can't be higher than !max."
+          fail! :big, "{{English name}} can't be higher than {{max}}."
         end
 
       when [Fixnum, NilClass]
         case
         when clean[name].is_a?(String) && clean[name].size < field[:min]
-          fail! "!English_name can't be shorter than !min characters."
+          fail! :short, "{{English name}} can't be shorter than {{min}} characters."
         when clean[name].is_a?(Numeric) && clean[name] < field[:min]
-          fail! "!English_name can't be less than !min."
+          fail! :short, "{{English name}} can't be less than {{min}."
         end
 
       when [Fixnum, Fixnum]
         case
-        when clean[name].is_a?(String) && (clean[name].size < field[:min] || clean[name].size > field[:max])
-          fail! "!English_name must be between !min and !max characters."
-        when clean[name].is_a?(Numeric) && (clean[name] < field[:min] || clean[name] > field[:max])
-          fail! "!English_name must be between !min and !max."
+        when field?(:chars) && clean[name].size > field[:max]
+          fail! :big, "{{English name}} must be between {{min}} and {{max}} characters."
+        when field?(:chars) && clean[name].size < field[:min]
+          fail! :small, "{{English name}} must be between {{min}} and {{max}} characters."
+
+        when field?(:numeric) && clean[name] > field[:max]
+          fail! :big, "{{English name}} must be between {{min}} and {{max}}."
+        when field?(:numeric) && clean[name] < field[:min]
+          fail! :small, "{{English name}} must be between {{min}} and {{max}}."
         end
 
       else
@@ -637,7 +675,7 @@ module Datoki
     # === Is value in options? =======
     if field[:options]
       if !field[:options].include?(clean[name])
-        fail! "!English_name can only be: #{field[:options].map(&:inspect).join ', '}"
+        fail! :mis_match, "{{English name}} can only be: #{field[:options].map(&:inspect).join ', '}"
       end
     end
     # ================================
@@ -650,53 +688,55 @@ module Datoki
         when :type
           case
           when field?(:numeric) && !clean[name].is_a?(Integer)
-            fail! "!English_name needs to be an integer."
+            fail! :wrong_type, "{{English name}} needs to be an integer."
           when field?(:chars) && !clean[name].is_a?(String)
-            fail! "!English_name needs to be a String."
+            fail! :wrong_type, "{{English name}} needs to be a String."
           end
 
         when :exact_size
           if clean[name].size != field[:exact_size]
             case
             when field?(:chars) || clean[name].is_a?(String)
-              fail! "!English_name needs to be !exact_size in length."
+              fail! :mis_match, "{{English name}} needs to be {{exact_size}} in length."
             else
-              fail! "!English_name can only be !exact_size in size."
+              fail! :mis_match, "{{English name}} can only be {{exact_size}} in size."
             end
           end
 
         when :set_to
           args.each { |meth|
-            clean[name] = send(meth)
+            clean[name] = (meth.is_a?(Symbol) ? send(meth) : meth.call(self, clean[name]))
           }
 
         when :equal_to
           args.each { |pair|
             meth, msg, other = pair
             target = send(meth)
-            fail!(msg || "!English_name must be equal to: #{target.inspect}") unless clean[name] == target
+            fail!(msg || "{{English name}} must be equal to: #{target.inspect}") unless clean[name] == target
           }
 
         when :included_in
           arr, msg, other = args
-          fail!(msg || "!English_name must be one of these: #{arr.join ', '}") unless arr.include?(clean[name])
+          fail!(msg || "{{English name}} must be one of these: #{arr.join ', '}") unless arr.include?(clean[name])
 
         when :upcase
           clean[name] = clean[name].upcase
 
         when :match
-          args.each { |pair|
-            regex, msg, other = pair
-            if clean[name] !~ regex
-              fail!(msg || "!English_name must match #{regex.inspect}")
-            end
-          }
+          args.each { |regex|
+            case regex
+            when Regexp
+              if clean[name] !~ regex
+                fail!(:mis_match, "{{English name}} is invalid.")
+              end
+
+            when Proc
+              if !regex.call(self, clean[name])
+                fail!(:mis_match, "{{English name}} is invalid.")
+              end
 
-        when :not_match
-          args.each { |pair|
-            regex, msg, other = pair
-            if clean[name] =~ regex
-              fail!(msg || "!English_name must not match #{regex.inspect}")
+            else
+              fail ArgumentError, "Unknown matcher: #{regex.inspect}"
             end
           }
 
@@ -706,34 +746,31 @@ module Datoki
     } # === field[:cleaners].each
   end # === def clean
 
-  def new_data
-    @new_data ||= {}
+  def error_msg type
+    field[:error_msgs] && field[:error_msgs][type]
   end
 
-  def on *args
-    fail ArgumentError, "No conditions." if args.empty?
-    yield if args.all? { |cond|
-      case cond
-      when Symbol
-        send(cond)
-      when TrueClass, FalseClass
-        cond
-      else
-        fail ArgumentError, "Unknown value: #{cond.inspect}"
-      end
-    }
-  end
+  def fail! *args
+    case args.size
+    when 1
+      msg = args.shift
+    when 2
+      msg = error_msg(args.shift) || args.shift
+    else
+      fail ArgumentError, "Unknown args: #{args.inspect}"
+    end
 
-  def fail! msg
-    err_msg = msg.gsub(/!([a-z\_\-]+)/i) { |raw|
+    err_msg = msg.gsub(/\{\{([a-z\_\-\ ]+)\}\}/i) { |raw|
       name = $1
       case name
-      when "English_name"
+      when "English name"
         self.class.fields[field_name][:english_name].capitalize.gsub('_', ' ')
-      when "ENGLISH_NAME"
+      when "ENGLISH NAME"
         self.class.fields[field_name][:english_name].upcase.gsub('_', ' ')
       when "max", "min", "exact_size"
         self.class.fields[field_name][name.downcase.to_sym]
+      when "val"
+        clean[field_name]
       else
         fail "Unknown value: #{name}"
       end
@@ -771,24 +808,16 @@ module Datoki
     self.class.inspect_field? :type, field_name, *args
   end
 
-  def create new_data
-    @new_data = new_data
-    run :create
-    self
-  end
-
-  def update new_data
-    @new_data = new_data
-    run :update
-    self
-  end
-
   def primary_key
     arr = self.class.fields.detect { |k, v| v[:primary_key] }
     fail "Primary key not found." unless arr
     arr.last
   end
 
+  def new?
+    !@data
+  end
+
   def create?
     (@raw.has_key?(:create) && @raw[:create]) ||
     @raw.has_key?(primary_key[:name]) && !@raw[primary_key[:name]]
@@ -806,6 +835,18 @@ module Datoki
     !!(@raw.has_key?(:delete) && !@raw[:delete])
   end
 
+  def TABLE
+    self.class::TABLE
+  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)
+    @db_ops[k] = true
+  end
+
 end # === module Datoki ===
 
 

data/specs/0010-Datoki.db.rb

@@ -14,13 +14,29 @@ describe "Datoki.db" do
 
     @klass = Class.new {
       include Datoki
-      table "datoki_test"
+      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
     }
   }
 
+  it "allows an undefined field that exists in the db schema" do
+    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'}
+  end
+
   it 'raises Schema_Conflict if a field is found that allows null, but not specifed to do so' do
     should.raise(Datoki::Schema_Conflict) {
       Class.new {
@@ -30,13 +46,13 @@ describe "Datoki.db" do
         field(:title) { varchar 1, 123 }
         field(:body) { text 1, 123 }
       }
-    }.message.should.match /:allow_null: true != false/
+    }.message.should.match /body: :allow_null: true != false/
   end
 
   it "requires field if value = null and :allow_null = false" do
-    should.raise(ArgumentError) {
+    should.raise(Sequel::NotNullConstraintViolation) {
       @klass.create :title=>nil, :body=>"hiya"
-    }.message.should.match /:title is not set/
+    }.message.should.match /null value in column "title" violates not-null constraint/
   end
 
   it "requires a value if: :text field, value = (empty string), min = 1, allow null" do

data/specs/0010-Numeric.rb

@@ -7,6 +7,9 @@ describe Numeric do
                                   include Datoki
                                   field(:id)  { primary_key }
                                   field(:age) { smallint 1, 150 }
+                                  def create
+                                    clean :age
+                                  end
                                 }
                               end
   }
@@ -31,8 +34,11 @@ describe Numeric do
       include Datoki
       field(:id) { primary_key }
       field(:age) { smallint nil, 1, 99 }
+      def create
+        clean :age
+      end
     }.create(:age=>nil).
-    clean[:age].should == nil
+    clean.should == {:age=>nil}
   end
 
   it "allows nil in an array" do
@@ -40,8 +46,11 @@ describe Numeric do
       include Datoki
       field(:id) { primary_key }
       field(:age) { smallint [nil, 1,2,3,4] }
+      def create
+        clean :age
+      end
     }.create(:age=>nil).
-    clean[:age].should == nil
+    clean.should == {:age=>nil}
   end
 
   it "allows to specify an Array of possible values" do
@@ -49,6 +58,9 @@ describe Numeric do
       include Datoki
       field(:id) { primary_key }
       field(:age) { smallint [1,2,3,4] }
+      def create
+        clean :age
+      end
     }.create(:age=>2).
     clean[:age].should == 2
   end
@@ -59,8 +71,41 @@ describe Numeric do
         include Datoki
         field(:id) { primary_key }
         field(:num) { smallint [1,2,3,4] }
+        def create
+          clean :num
+        end
       }.create :num=>0
     }.error[:msg].should.match /Num can only be: 1, 2, 3, 4/
   end
 
+  it "uses :big error msg" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        field(:squirrels) {
+          smallint 10, 10
+          big '{{val}} is too big.'
+        }
+        def create
+          clean :squirrels
+        end
+      }.create :squirrels=>50
+    }.error[:msg].should == "50 is too big."
+  end # === it uses :big error msg
+
+  it "uses :small error msg" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        field(:squirrels) {
+          smallint 10, 10
+          small '{{val}} is too small.'
+        }
+        def create
+          clean :squirrels
+        end
+      }.create :squirrels=>5
+    }.error[:msg].should == "5 is too small."
+  end # === it uses :small error msg
+
 end # === describe Numeric

data/specs/0010-Numeric_db.rb

@@ -17,7 +17,7 @@ describe 'Datoki.db number' do
   it "does not set :min = 1" do
     Class.new {
       include Datoki
-      table "datoki_test"
+      table :datoki_test
       field(:parent_id) { smallint }
     }.
     fields[:parent_id][:min].should == nil

data/specs/0010-varchar.rb

@@ -1,20 +1,14 @@
 
 describe :varchar do # ================================================
 
-  it "requires field by default during :create" do
-    should.raise(ArgumentError) {
-      Class.new {
-        include Datoki
-        field(:title) { varchar }
-      }.create({})
-    }.message.should.match /:title is not set/
-  end
-
   it "raises RuntimeError if allow :null and :min = 0" do
     should.raise(RuntimeError) {
       Class.new {
         include Datoki
         field(:name) { varchar nil, 0, 50 }
+        def create
+          clean :name
+        end
       }
     }.message.should.match /varchar can't be both: allow :null && :min = 0/
   end
@@ -24,6 +18,9 @@ describe :varchar do # ================================================
       Class.new {
         include Datoki
         field(:title) { varchar 3, 255 }
+        def create
+          clean :title
+        end
       }.create :title => '1'
     }.error[:msg].should.match /Title must be between 3 and 255 characters/i
   end
@@ -33,6 +30,9 @@ describe :varchar do # ================================================
       Class.new {
         include Datoki
         field(:title) { varchar 0, 5 }
+        def create
+          clean :title
+        end
       }.create :title => '123456'
     }.error[:msg].should.match /Title must be between 0 and 5 characters/
   end
@@ -42,8 +42,11 @@ describe :varchar do # ================================================
       Class.new {
         include Datoki
         field :title do
-          varchar
-          match /\A[a-zA-Z0-9]+\z/i, "Title must be only: alphanumeric"
+          varchar /\A[a-zA-Z0-9]+\z/i
+          mis_match "Title must be only: alphanumeric"
+        end
+        def create
+          clean :title
         end
       }.create :title => '$! title'
     }.error[:msg].should.match /Title must be only: alphanumeric/
@@ -52,10 +55,12 @@ describe :varchar do # ================================================
   it "allows varchar to be nil" do
     r = Class.new {
       include Datoki
-      field(:title) {
-        varchar nil, 1, 123
-      }
-    }.create({})
+      field(:title) { varchar nil, 1, 123 }
+      field(:body) { varchar nil, 1, 123 }
+      def create
+        clean :title, :body
+      end
+    }.create({:body=>'yo'})
     r.clean.has_key?(:title).should == false
   end
 
@@ -69,6 +74,9 @@ describe :varchar do # ================================================
           'Custom title'
         end
       }
+      def create
+        clean :title
+      end
     }.
     create(:title => 'My Title').
     clean[:title].should.match /Custom title/
@@ -78,6 +86,9 @@ describe :varchar do # ================================================
     Class.new {
       include Datoki
       field(:title) { varchar }
+      def create
+        clean :title
+      end
     }.
     create(:title => ' my title ').
     clean[:title].should == 'my title'
@@ -90,6 +101,9 @@ describe :varchar do # ================================================
         varchar
         disable :strip
       }
+      def create
+        clean :title
+      end
     }.
     create(:title => ' my title ').
     clean[:title].should == ' my title '

data/specs/0010-varchar_db.rb

@@ -11,7 +11,7 @@ describe "Datoki.db :varchar" do
     EOF
     @klass = Class.new {
       include Datoki
-      table "datoki_test"
+      table :datoki_test
       field(:id) { primary_key }
       field(:title) { varchar 1, 123 }
       field(:body) { text nil, 1, 3000 }

data/specs/0011-string_ish.rb

@@ -0,0 +1,60 @@
+
+describe :string do
+
+  before {
+    CACHE[:datoki_string] ||= begin
+                                reset_db <<-EOF
+                                  CREATE TABLE "datoki_test" (
+                                    id serial NOT NULL PRIMARY KEY,
+                                    ip inet   NOT NULL
+                                  );
+                                EOF
+                              end
+  }
+
+  it "treats special PG types as a string" do
+    Class.new {
+      include Datoki
+      table :datoki_test
+      field(:ip) {
+        string_ish 5, 50, /\A[0-9\:\.]+\Z/
+        mis_match "Invalid format for ip: !val"
+      }
+      def create
+        clean :ip
+      end
+    }.create(:ip=>'127.0.0.2')
+    DB[:datoki_test].all.should == [{:id=>1, :ip=>'127.0.0.2'}]
+  end # === it treats special PG types as a string
+
+  it "uses :big error msg" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        field(:note) {
+          string_ish 1,5
+          big '{{English name}} can\'t be bigger than {{max}}.'
+        }
+        def create
+          clean :note
+        end
+      }.create :note=>"1234567"
+    }.error[:msg].should == "Note can\'t be bigger than 5."
+  end # === it uses :big error msg
+
+  it "uses :small error msg" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        field(:note) {
+          string_ish 2,5
+          small '{{English name}} can\'t be smaller than {{min}}.'
+        }
+        def create
+          clean :note
+        end
+      }.create :note=>"1"
+    }.error[:msg].should == "Note can\'t be smaller than 2."
+  end # === it uses :small error msg
+
+end # === describe :string

data/specs/0012-pseudo.rb

@@ -0,0 +1,34 @@
+
+describe :pseudo do
+
+  before {
+    CACHE[:datoki_pseudo] ||= begin
+                                reset_db <<-EOF
+                                  CREATE TABLE "datoki_test" (
+                                    id serial NOT NULL PRIMARY KEY,
+                                    title varchar(15) NOT NULL,
+                                    body  text NOT NULL
+                                  );
+                                EOF
+                              end
+  }
+
+  it "does not save values to database" do
+    Class.new {
+      include Datoki
+      table :datoki_test
+      field(:title) { varchar 5, 15 }
+      field(:body) { text 5, 15 }
+      field(:password) {
+        string_ish 5, 10, /\A[a-z0-9\ ]+\Z/
+        pseudo
+      }
+      def create
+        clean :title, :body, :password
+      end
+    }.create(:title=>'Yo yo yo', :body=>'The body',:password=>'11111111')
+
+    DB[:datoki_test].all.should == [{:id=>1,:title=>'Yo yo yo', :body=>'The body'}]
+  end # === it does not save values to database
+
+end # === describe :pseudo

data/specs/0020-clean!.rb

@@ -0,0 +1,19 @@
+
+describe :clean! do
+
+  it "fails w/ArgumentError if field is undefined" do
+    c = Class.new {
+      include Datoki
+
+      field(:name) { varchar }
+      def create
+        clean! :name, :nick
+      end
+    }
+
+    should.raise(ArgumentError) {
+      c.create(:nick=>'Bob')
+    }.message.should.match /:name is not set/
+  end # === it fails w/ArgumentError if underfined
+
+end # === describe :clean!

data/specs/0020-clean.rb

@@ -6,7 +6,10 @@ describe :clean do
       include Datoki
 
       field(:nick_name) { varchar 1,50 }
-      on(:happy?) { clean :nick_name }
+      def create
+        clean :nick_name
+        skip :db
+      end
 
       def happy?
         true
@@ -24,12 +27,9 @@ describe :clean do
       field(:nick_name) { varchar 3, 255 }
       field(:age) { smallint; allow :null }
 
-      on :happy? do
+      def create
         clean :nick_name, :age
-      end
-
-      def happy?
-        true
+        skip :db
       end
     }
     c.create(:nick_name=>'Wiley').
@@ -41,17 +41,13 @@ describe :clean do
       include Datoki
 
       field(:name) { varchar }
-      on :happy? do
+      def create
         clean :name!
       end
-
-      def happy?
-        true
-      end
     }
 
     should.raise(ArgumentError) {
-      c.new(:happy=>true, :nick=>'Bob')
+      c.create(:nick=>'Bob')
     }.message.should.match /:name is not set/
   end # === it fails w/ArgumentError if underfined
 

data/specs/0030-matching.rb

@@ -0,0 +1,93 @@
+
+describe :matching do
+
+  before {
+    CACHE[:datoki_matching] ||= begin
+                                  reset_db <<-EOF
+                                  CREATE TABLE "datoki_test" (
+                                    id serial NOT NULL PRIMARY KEY,
+                                    title varchar(15) NOT NULL,
+                                    body  text NOT NULL,
+                                    age   smallint NOT NULL
+                                  );
+                                  EOF
+                                end
+  }
+
+  it "uses error message from :mis_match" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:title) { varchar 5, 15, lambda { |r, val| false }; mis_match "Title is bad." }
+        field(:body) { text 5, 10 }
+        field(:age) { smallint }
+        def create
+          clean :title, :body, :age
+        end
+      }.create(:title=>'title', :body=>'body', :age=>50)
+    }.error[:msg].should.match /Title is bad/
+  end # === it uses error message from :mis_match
+
+  it "inserts data into db if match w/Regexp matcher" do
+    Class.new {
+      include Datoki
+      table :datoki_test
+      field(:title) { varchar 5, 15, /title 4/ }
+      field(:body) { text 5, 10 }
+      field(:age) { smallint }
+      def create
+        clean :title, :body, :age
+      end
+    }.create(:title=>'title 4', :body=>'body 4', :age=>50)
+
+    DB[:datoki_test].all.last.should == {:id=>1, :title=>'title 4', :body=>'body 4', :age=>50}
+  end # === it inserts data into db if matcher returns true
+
+  it "inserts data into db if lambda matcher returns true" do
+    Class.new {
+      include Datoki
+      table :datoki_test
+      field(:title) { varchar 5, 15, lambda { |r, val| true } }
+      field(:body) { text 5, 10 }
+      field(:age) { smallint }
+      def create
+        clean :title, :body, :age
+      end
+    }.create(:title=>'title 5', :body=>'body 5', :age=>50)
+
+    DB[:datoki_test].all.last.should == {:id=>2, :title=>'title 5', :body=>'body 5', :age=>50}
+  end # === it inserts data into db if matcher returns true
+
+  it "throws :invalid if mis-match w/Regexp matcher" do
+    catch(:invalid) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:title) { varchar 5, 15, /\Agood\Z/; mis_match "Title is really bad." }
+        field(:body) { text 5, 10 }
+        field(:age) { smallint }
+        def create
+          clean :title, :body, :age
+        end
+      }.create(:title=>'baddd', :body=>'body', :age=>50)
+    }.error[:msg].should.match /Title is really bad/
+  end # === it accepts a Regexp as a matcher
+
+  it "throws :invalid if lambda matcher returns false" do
+    r = catch(:invalid) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:title) { varchar 5, 15, lambda { |r, v| false } }
+        field(:body) { text 5, 10 }
+        field(:age) { smallint }
+        def create
+          clean :title, :body, :age
+        end
+      }.create(:title=>'title', :body=>'body', :age=>50)
+    }
+    r.error[:msg].should.match /Title is invalid/
+  end # === it throws :invalid if matcher returns false
+
+end # === describe :matching

data/specs/0031-set_to.rb

@@ -0,0 +1,32 @@
+
+describe :set_to do
+
+  it "sets val to block" do
+    Class.new {
+      include Datoki
+      field(:age) {
+        smallint
+        set_to { |raw, val| val + 50 }
+      }
+      def create
+        clean :age
+      end
+    }.create(:age=>20).
+    clean.should == {:age=>70}
+  end # === it sets val to lambda
+
+  it "sets val to lambda" do
+    Class.new {
+      include Datoki
+      field(:age) {
+        smallint
+        set_to(lambda { |raw, val| val + 10 })
+      }
+      def create
+        clean :age
+      end
+    }.create(:age=>20).
+    clean.should == {:age=>30}
+  end # === it sets val to lambda
+
+end # === describe :set_to

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datoki
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - da99
@@ -108,7 +108,6 @@ files:
 - VERSION
 - datoki.gemspec
 - lib/datoki.rb
-- specs/0010-Datoki.db.new.rb
 - specs/0010-Datoki.db.rb
 - specs/0010-Numeric.rb
 - specs/0010-Numeric_db.rb
@@ -118,8 +117,12 @@ files:
 - specs/0010-schema_conflict.rb
 - specs/0010-varchar.rb
 - specs/0010-varchar_db.rb
+- specs/0011-string_ish.rb
+- specs/0012-pseudo.rb
+- specs/0020-clean!.rb
 - specs/0020-clean.rb
-- specs/0020-on.rb
+- specs/0030-matching.rb
+- specs/0031-set_to.rb
 - specs/lib/helpers.rb
 homepage: https://github.com/da99/datoki
 licenses:

data/specs/0010-Datoki.db.new.rb

@@ -1,31 +0,0 @@
-
-describe 'Datoki.db :new' do
-
-  before {
-    CACHE[:datoki_db_new] ||= begin
-                                reset_db <<-EOF
-                                  CREATE TABLE "datoki_test" (
-                                    id serial NOT NULL PRIMARY KEY,
-                                    parent_id smallint NOT NULL,
-                                    title varchar(123) NOT NULL,
-                                    body  text
-                                  );
-                                EOF
-                              end
-  }
-
-  it "raises Schema_Conflict if field has not been defined, but exists in the db schema" do
-    should.raise(Datoki::Schema_Conflict) {
-      Class.new {
-        include Datoki
-        table :datoki_test
-        field(:id) { primary_key }
-        field(:parent_id) { smallint }
-        field(:body) { text nil, 1, 222 }
-      }.new
-    }.message.should.match /:title has not been defined/
-  end
-
-end # === describe Datoki.db :new
-
-

data/specs/0020-on.rb

@@ -1,64 +0,0 @@
-
-describe :on do
-
-  it "executes proc if condition is true" do
-    c = Class.new {
-      include Datoki
-
-      on :happy? do
-        @result = :happy
-      end
-
-      on :sad? do
-        @result= :happy
-      end
-
-      attr_reader :result
-
-      def happy?
-        @raw[:state] == :happy
-      end
-
-      def sad?
-        @raw[:state] == :sad
-      end
-    }
-
-    c.create(:state => :happy).
-      result.should == :happy
-  end # === it executes proc if condition is true
-
-  it "executes nested :on if condition matches" do
-    c = Class.new {
-      include Datoki
-
-      RESULT = []
-
-      attr_reader :result
-
-      on :true? do
-        on :filled? do
-          @result ||= []
-          @result << :found
-        end
-        on :false? do
-          fail
-        end
-      end
-
-      def false?
-        false
-      end
-
-      def filled?
-        true
-      end
-
-      def true?
-        true
-      end
-    }
-    c.create({}).result.should == [:found]
-  end # === it executes nested :on if condition matches
-
-end # === describe :on