datoki 1.0.1 → 2.0.0

data/lib/datoki.rb

@@ -15,6 +15,10 @@ module Datoki
   Numeric_Types = [:smallint, :integer, :bigint, :decimal, :numeric]
   Types         = Char_Types + Numeric_Types + [:datetime]
 
+  Key_Not_Found = lambda { |hash, key|
+    fail ArgumentError, "Key not found: #{key.inspect}"
+  }
+
   class << self
 
     def included klass
@@ -44,16 +48,17 @@ module Datoki
 
   module Def_Field
 
-    attr_reader :ons, :fields
+    attr_reader :ons, :fields, :fields_as_required
 
     def initialize_def_field
-      @record_errors = false
-      @ons           = {}
-      @fields        = {}
-      @current_field = nil
-      @schema        = {}
-      @schema_match  = false
-      @table_name    = nil
+      @on_doc             = []
+      @ons                = {}
+      @fields             = {} # Ex: {:name=>{}, :age=>{}}
+      @fields_as_required = {} # Ex: {:name!=>:name}
+      @current_field      = nil
+      @schema             = {}
+      @schema_match       = false
+      @table_name         = nil
       name = self.to_s.downcase.to_sym
       table(name) if Datoki.db.tables.include?(name)
     end
@@ -62,14 +67,6 @@ module Datoki
       @schema_match
     end
 
-    def record_errors?
-      @record_errors
-    end
-
-    def record_errors
-      @record_errors = true
-    end
-
     def table name
       if !@schema.empty? || @table_name
         fail "Schema/table already defined: #{@table_name.inspect}"
@@ -137,6 +134,10 @@ module Datoki
       inspect_field?(:type, field[:name], *args)
     end
 
+    def allow sym
+      fields[@current_field][:allow][sym] = true;
+    end
+
     def field *args
       return fields[@current_field] if args.empty?
       return fields[args.first] unless block_given?
@@ -144,6 +145,7 @@ module Datoki
       name = args.first
 
       fail "#{name.inspect} already defined." if fields[name]
+      fields_as_required[:"#{name}!"] = name
 
       fields[name] = {
         :name         => name,
@@ -271,7 +273,14 @@ module Datoki
       field[:schema_match] = true
     end
 
-    def on action, meth_name_sym
+    attr_reader :on_doc
+    def on *args
+      return(field_on *args) if !block_given?
+      @on_doc << [args, Proc.new]
+      self
+    end
+
+    def field_on action, meth_name_sym
       fail "Invalid action: #{action.inspect}" unless Actions.include? action
       if field
         field[:on][action] ||= {}
@@ -304,7 +313,7 @@ module Datoki
       field[:html_escape] = :href
       case args.map(&:class)
       when []
-        varchar 0, 255
+        varchar 1, 255
       when [NilClass]
         varchar nil, 1, (schema[field[:name]] ? schema[field[:name]][:max_length] : 255)
       else
@@ -436,48 +445,296 @@ module Datoki
       self
     end
 
-    def create h = {}
-      r = new
-      r.create h
+    def create raw
+      raw[:create] = self
+      new raw
     end
 
-  end # === Def_Field
+  end # === Def_Field =====================================================
 
   # ================= Instance Methods ===============
 
-  def initialize data = nil
+  attr_reader :error
+  def initialize unknown = nil
     @data       = nil
-    @new_data   = nil
     @field_name = nil
-    @clean_data = nil
-    @errors     = nil
+    @clean      = nil
+    @error      = nil
+    @skips      = {}
+
+    if unknown
+      if unknown.keys.all? { |f| self.class.fields.has_key?(f) }
+        @data = unknown
+        @data.default_proc = Key_Not_Found
+      else
+        @raw = unknown
+        @raw.default_proc = Key_Not_Found
+      end
+    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
+
+      if !@clean
+        @raw.each { |k, v|
+          clean(k) if self.class.fields.has_key?(k)
+        }
+      end
+
+      if create?
+        self.class.fields.each { |k, meta|
+          if !clean.has_key?(k) && !meta[:allow][:null] && !meta[:primary_key]
+            fail ArgumentError, "#{k.inspect} is not set."
+          end
+        }
+      end
+
+      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.schema_match(:all)
   end
 
-  def errors
-    @errors ||= {}
+  def skip name
+    @skips[name] = true
   end
 
-  def errors?
-    @errors && !@errors.empty?
+  def error?
+    @error && !@error.empty?
   end
 
-  def save_error msg
-    @errors ||= {}
-    @errors[field_name] ||= {}
-    @errors[field_name][:msg] = msg
-    @errors[field_name][:value] = val
-  end
+  def clean *args
+    if args.empty?
+      @clean ||= begin
+                   h = {}
+                   h.default_proc = Key_Not_Found
+                   h
+                 end
+      return @clean
+    end
 
-  def clean_data
-    @clean_data ||= {}
-  end
+    if args.size > 1
+      return args.each { |f| clean f }
+    end
+
+    name     = args.first
+    required = false
+
+    if self.class.fields_as_required[name]
+      name = self.class.fields_as_required[name]
+      required = true
+    end
+
+    field_name(name)
+    f_meta   = self.class.fields[name]
+    required = true if (!field[:allow][:null] && (!@raw.has_key?(name) || @raw[name] == nil))
+
+    # === Did the programmer forget to set the value?:
+    if required && (!@raw.has_key?(name) || @raw[name].nil?)
+      fail ArgumentError, "#{name.inspect} is not set."
+    end
+
+    # === Skip this if nothing is set and is null-able:
+    if !required && field[:allow][:null] && !@raw.has_key?(name) && !clean.has_key?(name)
+      return nil
+    end
+
+    clean[name] = @raw[name] unless clean.has_key?(name)
+
+    # === Should we let the DB set the value?
+    if self.class.schema[name] && self.class.schema[name][:default] && (!clean.has_key?(name) || !clean[name])
+      clean.delete name
+      return self.class.schema[name][:default]
+    end
+
+    # === Strip the value:
+    if clean[name].is_a?(String) && field[:allow][:strip]
+      clean[name].strip!
+    end
+
+    if field?(:chars) && !field.has_key?(:min) && clean[name].is_a?(String) && field[:allow][:null]
+      clean[name] = nil
+    end
+
+    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."
+      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."
+    end
+    # ================================
+
+    # === check min, max ======
+    if clean[name].is_a?(String) || clean[name].is_a?(Numeric)
+      case [field[:min], field[:max]].map(&:class)
+
+      when [NilClass, NilClass]
+        # do nothing
+
+      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."
+        when clean[name].is_a?(Numeric) && clean[name] > field[:max]
+          fail! "!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."
+        when clean[name].is_a?(Numeric) && clean[name] < field[:min]
+          fail! "!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."
+        end
+
+      else
+        fail "Unknown values for :min, :max: #{field[:min].inspect}, #{field[:max].inspect}"
+      end
+    end # === if
+    # ================================
+
+    # === to_i if necessary ==========
+    if field?(:numeric)
+      if clean[name].nil? && !field[:allow][:null]
+        clean[name] = clean[name].to_i
+      end
+    end
+    # ================================
+
+    # === :strip if necessary ========
+    if field?(:chars) && field[:allow][:strip] && clean[name].is_a?(String)
+      clean[name] = clean[name].strip
+    end
+    # ================================
+
+    # === Is value in options? =======
+    if field[:options]
+      if !field[:options].include?(clean[name])
+        fail! "!English_name can only be: #{field[:options].map(&:inspect).join ', '}"
+      end
+    end
+    # ================================
+
+    field[:cleaners].each { |cleaner, args|
+      next if args === false # === cleaner has been disabled.
+
+        case cleaner
+
+        when :type
+          case
+          when field?(:numeric) && !clean[name].is_a?(Integer)
+            fail! "!English_name needs to be an integer."
+          when field?(:chars) && !clean[name].is_a?(String)
+            fail! "!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."
+            else
+              fail! "!English_name can only be !exact_size in size."
+            end
+          end
+
+        when :set_to
+          args.each { |meth|
+            clean[name] = send(meth)
+          }
+
+        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
+          }
+
+        when :included_in
+          arr, msg, other = args
+          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
+          }
+
+        when :not_match
+          args.each { |pair|
+            regex, msg, other = pair
+            if clean[name] =~ regex
+              fail!(msg || "!English_name must not match #{regex.inspect}")
+            end
+          }
+
+        else
+          fail "Cleaner not implemented: #{cleaner.inspect}"
+        end # === case cleaner
+    } # === field[:cleaners].each
+  end # === def clean
 
   def new_data
     @new_data ||= {}
   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! msg
     err_msg = msg.gsub(/!([a-z\_\-]+)/i) { |raw|
       name = $1
@@ -493,12 +750,8 @@ module Datoki
       end
     }
 
-    if self.class.record_errors?
-      save_error err_msg
-      throw :error_saved
-    else
-      fail Invalid, err_msg
-    end
+    @error = {:field_name=>field_name, :msg=>err_msg, :value=>clean[field_name]}
+    throw :invalid, self
   end
 
   def field_name *args
@@ -507,24 +760,13 @@ module Datoki
       fail "Field name not set." unless @field_name
       @field_name
     when 1
+      fail ArgumentError, "Unknown field: #{args.first.inspect}" unless self.class.fields[args.first]
       @field_name = args.first
     else
       fail "Unknown args: #{args.inspect}"
     end
   end
 
-  def val
-    if clean_data.has_key?(field_name)
-      clean_data[field_name]
-    else
-      new_data[field_name]
-    end
-  end
-
-  def val! new_val
-    clean_data[field_name] = new_val
-  end
-
   def field *args
     case args.size
     when 0
@@ -540,196 +782,6 @@ module Datoki
     self.class.inspect_field? :type, field_name, *args
   end
 
-  def run action
-    self.class.fields.each { |f_name, f_meta|
-
-      field_name f_name
-      is_set    = new_data.has_key?(field_name)
-      is_update = action == :update
-      is_nil    = is_set && new_data[field_name].nil?
-
-      # === Should the field be skipped? ===============
-      next if !is_set && is_update
-      next if !is_set && field[:primary_key]
-      next if field[:allow][:null] && (!is_set || is_nil)
-
-      if is_set 
-        val! new_data[field_name]
-      elsif field.has_key?(:default)
-        val! field[:default]
-      end
-
-      if val.is_a?(String) && field[:allow][:strip]
-        val! val.strip
-      end
-
-      if field?(:chars) && !field.has_key?(:min) && val.is_a?(String) && field[:allow][:null]
-        val! nil
-      end
-
-      catch :error_saved do
-
-        if field?(:numeric) && val.is_a?(String)
-          clean_val = Integer(val) rescue String
-          if clean_val == String
-            fail! "!English_name must be numeric."
-          else
-            val! clean_val
-          end
-        end
-
-        # === check required. ============
-        if val.nil? && !field[:allow][:null]
-          fail! "!English_name is required."
-        end
-
-        if field?(:text) && val.is_a?(String) && val.empty? && field[:min].to_i > 0
-          fail! "!English_name is required."
-        end
-        # ================================
-
-        # === check min, max ======
-        if val.is_a?(String) || val.is_a?(Numeric)
-          case [field[:min], field[:max]].map(&:class)
-
-          when [NilClass, NilClass]
-            # do nothing
-
-          when [NilClass, Fixnum]
-            case
-            when val.is_a?(String) && val.size > field[:max]
-              fail! "!English_name can't be longer than !max characters."
-            when val.is_a?(Numeric) && val > field[:max]
-              fail! "!English_name can't be higher than !max."
-            end
-
-          when [Fixnum, NilClass]
-            case
-            when val.is_a?(String) && val.size < field[:min]
-              fail! "!English_name can't be shorter than !min characters."
-            when val.is_a?(Numeric) && val < field[:min]
-              fail! "!English_name can't be less than !min."
-            end
-
-          when [Fixnum, Fixnum]
-            case
-            when val.is_a?(String) && (val.size < field[:min] || val.size > field[:max])
-              fail! "!English_name must be between !min and !max characters."
-            when val.is_a?(Numeric) && (val < field[:min] || val > field[:max])
-              fail! "!English_name must be between !min and !max."
-            end
-
-          else
-            fail "Unknown values for :min, :max: #{field[:min].inspect}, #{field[:max].inspect}"
-          end
-        end # === if
-        # ================================
-
-        # === to_i if necessary ==========
-        if field?(:numeric)
-          val! val.to_i
-        end
-        # ================================
-
-        # === :strip if necessary ========
-        if field?(:chars) && field[:allow][:strip] && val.is_a?(String)
-          val! val.strip
-        end
-        # ================================
-
-        # === Is value in options? =======
-        if field[:options]
-          if !field[:options].include?(val)
-            fail! "!English_name can only be: #{field[:options].map(&:inspect).join ', '}"
-          end
-        end
-        # ================================
-
-        field[:cleaners].each { |cleaner, args|
-          next if args === false # === cleaner has been disabled.
-
-            case cleaner
-
-            when :type
-              case
-              when field?(:numeric) && !val.is_a?(Integer)
-                fail! "!English_name needs to be an integer."
-              when field?(:chars) && !val.is_a?(String)
-                fail! "!English_name needs to be a String."
-              end
-
-            when :exact_size
-              if val.size != field[:exact_size]
-                case
-                when field?(:chars) || val.is_a?(String)
-                  fail! "!English_name needs to be !exact_size in length."
-                else
-                  fail! "!English_name can only be !exact_size in size."
-                end
-              end
-
-            when :set_to
-              args.each { |meth|
-                val! send(meth)
-              }
-
-            when :equal_to
-              args.each { |pair|
-                meth, msg, other = pair
-                target = send(meth)
-                fail!(msg || "!English_name must be equal to: #{target.inspect}") unless val == target
-              }
-
-            when :included_in
-              arr, msg, other = args
-              fail!(msg || "!English_name must be one of these: #{arr.join ', '}") unless arr.include?(val)
-
-            when :upcase
-              val! val.upcase
-
-            when :match
-              args.each { |pair|
-                regex, msg, other = pair
-                if val !~ regex
-                  fail!(msg || "!English_name must match #{regex.inspect}")
-                end
-              }
-
-            when :not_match
-              args.each { |pair|
-                regex, msg, other = pair
-                if val =~ regex
-                  fail!(msg || "!English_name must not match #{regex.inspect}")
-                end
-              }
-
-            else
-              fail "Cleaner not implemented: #{cleaner.inspect}"
-            end # === case cleaner
-
-
-        } # === field[:cleaners].each
-
-        field[:on][action].each { |meth, is_enabled|
-          next unless is_enabled
-          send meth
-        } if field[:on][action]
-
-      end # === catch :error_saved
-    } # === field
-
-    return if errors?
-
-    self.class.ons.each { |action, meths|
-      meths.each { |meth, is_enabled|
-        next unless is_enabled
-        catch :error_saved do
-          send meth
-        end
-      }
-    }
-  end
-
   def create new_data
     @new_data = new_data
     run :create
@@ -742,6 +794,29 @@ module Datoki
     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 create?
+    (@raw.has_key?(:create) && @raw[:create]) ||
+    @raw.has_key?(primary_key[:name]) && !@raw[primary_key[:name]]
+  end
+
+  def read?
+    !!(@raw.has_key?(:read) && @raw[:read])
+  end
+
+  def update?
+    !!(@raw.has_key?(:update) && @raw[:update])
+  end
+
+  def delete?
+    !!(@raw.has_key?(:delete) && !@raw[:delete])
+  end
+
 end # === module Datoki ===
 
 

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

@@ -0,0 +1,31 @@
+
+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
+
+