dao 3.3.0 → 4.2.1

data/lib/dao/validations/validator.rb

@@ -0,0 +1,219 @@
+module Dao
+  module Validations
+    class Validator
+      NotBlank = lambda{|value| !value.to_s.strip.empty?} unless defined?(NotBlank)
+      Cleared = 'Cleared'.freeze unless defined?(Cleared)
+
+      class << Validator
+        def for(*args, &block)
+          new(*args, &block)
+        end
+      end
+
+      attr_accessor :object
+      attr_accessor :validations
+      attr_accessor :errors
+      attr_accessor :status
+
+      def initialize(object)
+        @object = object
+        @validations = Map.new
+        @errors = Errors.new
+        @status = Status.new
+      end
+
+      fattr(:attributes) do
+        attributes =
+          catch(:attributes) do
+            if @object.respond_to?(:attributes)
+              throw :attributes, @object.attributes
+            end
+            if @object.instance_variable_defined?('@attributes')
+              throw :attributes, @object.instance_variable_get('@attributes')
+            end
+            if @object.is_a?(Map)
+              throw :attributes, @object
+            end
+            if @object.respond_to?(:to_map)
+              throw :attributes, Map.new(@object.to_map)
+            end
+            if @object.is_a?(Hash)
+              throw :attributes, Map.new(@object)
+            end
+            if @object.respond_to?(:to_hash)
+              throw :attributes, Map.new(@object.to_hash)
+            end
+            raise ArgumentError.new("found no attributes on #{ @object.inspect }(#{ @object.class.name })")
+          end
+
+        case attributes
+          when Map
+            attributes
+          when Hash
+            Map.new(attributes)
+          else
+            raise(ArgumentError.new("#{ attributes.inspect } (#{ attributes.class })"))
+        end
+      end
+
+      def add(*args, &block)
+        options = Map.options_for!(args)
+        block = args.pop if args.last.respond_to?(:call)
+        block ||= NotBlank
+        callback = Callback.new(options, &block)
+        validations.set(args => Callback::Chain.new) unless validations.has?(args)
+        validations.get(args).add(callback)
+        callback
+      end
+      alias_method('validates', 'add')
+
+      def run_validations!(*args)
+        run_validations(*args)
+      ensure
+        validated!
+      end
+
+      def validations_search_path
+        @validations_search_path ||= (
+          list = [
+            object,
+            object.class.ancestors.map{|ancestor| ancestor.respond_to?(:validator) ? ancestor : nil}
+          ]
+          list.flatten!
+          list.compact!
+          list.reverse!
+          list
+        )
+      end
+
+      def validations_list
+        validations_search_path.map{|object| object.validator.validations}
+      end
+
+      def run_validations(*args)
+        object = args.first || @object
+
+        attributes.extend(InstanceExec) unless attributes.respond_to?(:instance_exec)
+
+        previous_errors = []
+        new_errors = []
+
+        errors.each_message do |keys, message|
+          previous_errors.push([keys, message])
+        end
+        errors.clear!
+        status.ok!
+
+        list = validations_list
+
+        list.each do |validations|
+          validations.depth_first_each do |keys, chain|
+            chain.each do |callback|
+              next unless callback and callback.respond_to?(:to_proc)
+
+              number_of_errors = errors.size
+              value = attributes.get(keys)
+
+              returned =
+                catch(:validation) do
+                  args = [value, attributes].slice(0, callback.arity)
+                  attributes.instance_exec(*args, &callback)
+                end
+
+              case returned
+                when Hash
+                  map = Map(returned)
+                  valid = map[:valid]
+                  message = map[:message]
+
+                when TrueClass, FalseClass
+                  valid = returned
+                  message = nil
+
+                else
+                  any_errors_added = errors.size > number_of_errors
+                  valid = !any_errors_added
+                  message = nil
+              end
+
+              message ||= callback.options[:message]
+              message ||= (value.to_s.strip.empty? ? 'is blank' : 'is invalid')
+
+              unless valid
+                new_errors.push([keys, message])
+              else
+                new_errors.push([keys, Cleared])
+              end
+            end
+          end
+        end
+
+        previous_errors.each do |keys, message|
+          errors.add(keys, message) unless new_errors.assoc(keys)
+        end
+
+        new_errors.each do |keys, value|
+          next if value == Cleared
+          message = value
+          errors.add(keys, message)
+        end
+
+        if status.ok? and !errors.empty?
+          status.update(412)
+        end
+
+        errors
+      end
+
+      def validated?
+        @validated = false unless defined?(@validated)
+        @validated
+      end
+
+      def validated!(boolean = true)
+        @validated = !!boolean
+      end
+
+      def validate
+        run_validations
+      end
+
+      def validate!
+        raise Error.new("#{ object.class.name } is invalid!") unless valid?
+        object
+      end
+
+      def valid!
+        @forcing_validity = true
+      end
+
+      def forcing_validity?
+        defined?(@forcing_validity) and @forcing_validity
+      end
+
+      def forcing_validity!(boolean = true)
+        @forcing_validity = !!boolean
+      end
+
+      def valid?(*args)
+        if forcing_validity?
+          true
+        else
+          options = Map.options_for!(args)
+          validate #if(options[:validate] or !validated?)
+          errors.empty? and status.ok?
+        end
+      end
+
+      def reset
+        errors.clear!
+        status.update(:ok)
+        forcing_validity!(false)
+        validated!(false)
+        self
+      end
+    end
+  end
+
+  Validator = Validations::Validator
+end

data/test/active_model_conducer_lint_test.rb

@@ -0,0 +1,19 @@
+class LintTest < ActiveModel::TestCase
+  include ActiveModel::Lint::Tests
+
+  class LintConducer < Dao::Conducer; end
+        
+  def setup
+    @model = LintConducer.new
+  end
+end
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+
+  require File.join(libdir, 'dao')
+  require File.join(testdir, 'testing')
+}

data/test/api_test.rb

@@ -0,0 +1,261 @@
+
+
+Testing Dao do
+## api
+#
+  testing 'that an api class for your application can be built using a simple dsl' do
+    assert{
+      api_class =
+        Dao.api do
+          ### dsl
+        end
+    }
+  end
+
+  testing 'that apis can have callable endpoints added to them which accept params and return results' do
+    captured = []
+
+    api_class =
+      assert{
+        Dao.api do
+          endpoint(:foo) do |params, result|
+            captured.push(params, result)
+          end
+        end
+      }
+    api = assert{ api_class.new }
+    result = assert{ api.call(:foo, {}) }
+    assert{ result.is_a?(Hash) }
+  end
+
+  testing 'that endpoints are automatically called according to arity' do
+    api = assert{ Class.new(Dao.api) }
+    assert{ api.class_eval{ endpoint(:zero){|| result.update :args => [] } } }
+    assert{ api.class_eval{ endpoint(:one){|a| result.update :args => [a]} } }
+    assert{ api.class_eval{ endpoint(:two){|a,b| result.update :args => [a,b]} } }
+
+    assert{ api.new.call(:zero).args.size == 0 }
+    assert{ api.new.call(:one).args.size == 1 }
+    assert{ api.new.call(:two).args.size == 2 }
+  end
+
+  testing 'that endpoints have an auto-vivifying params/result' do
+    api = assert{ Class.new(Dao.api) }
+    assert{ api.class_eval{ endpoint(:foo){ params; result; } } }
+    result = assert{ api.new.call(:foo) }
+    assert{ result.path.to_s =~ /foo/ }
+  end
+
+  testing 'that an api can be called with different modes' do
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.modes = []
+
+            Dao::Mode.list.each do |mode|
+              send(mode){ data.modes.push(mode) }
+            end
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode.list.each do |mode|
+      result = api.mode(mode).call(:foo)
+      assert{ result.data.modes.include?(mode) }
+    end
+  end
+
+  testing 'that options/head/get are considered read modes' do
+    read_mode = assert{ Dao::Mode.read }
+
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            read { data.modes.push(read_mode) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode::Read.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [read_mode] }
+    end
+  end
+
+  testing 'that post/put/delete/trace/connect are considered write modes' do
+    write_mode = assert{ Dao::Mode.write }
+
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            write { data.modes.push(write_mode) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    Dao::Mode::Write.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [write_mode] }
+    end
+  end
+
+  testing 'that the first, most specific, mode block encountered fires first' do
+    api_class =
+      assert{
+        Dao.api do
+          call(:foo) do
+            data.update :modes => []
+            Dao::Mode::Read.each do |mode|
+              send(mode){ data.modes.push(mode) }
+            end
+            read { data.modes.push(Dao::Mode.read) }
+          end
+        end
+      }
+    api = assert{ api_class.new }
+
+    read = Dao::Mode.read
+    result = assert{ api.mode(read).call(:foo) }
+    assert{ result.data.modes == [read] }
+
+    Dao::Mode::Read.each do |mode|
+      result = assert{ api.mode(mode).call(:foo) }
+      assert{ result.data.modes == [mode] }
+    end
+  end
+
+## results
+#
+  testing 'that results can be created' do
+    result = assert{ Dao::Result.new }
+    assert{ result.path }
+    assert{ result.status }
+    assert{ result.errors }
+    assert{ result.params }
+    assert{ result.data }
+  end
+
+  testing 'that results can be created with a path' do
+    result = assert{ Dao::Result.new('/api/foo/bar') }
+    assert{ result.path == '/api/foo/bar' }
+  end
+
+## paths
+#
+  testing 'that simple paths can be contstructed/compiled' do
+    path = assert{ Dao::Path.for('./api/../foo/bar')  }
+    assert{ path =~ %r|^/| }
+    assert{ path !~ %r|[.]| }
+    assert{ path.params.is_a?(Hash) }
+    assert{ path.keys.is_a?(Array) }
+    assert{ path.pattern.is_a?(Regexp) }
+  end
+
+## routes
+#
+  testing 'that an api has a list of routes' do
+    api_class =
+      assert{
+        Dao.api do
+        end
+      }
+    assert{ api_class.routes.is_a?(Array) }
+  end
+
+  testing 'that routed endpoints call be declared' do
+    api_class =
+      assert{
+        Dao.api do
+          call('/users/:user_id/comments/:comment_id') do
+            data.update(params)
+          end
+        end
+      }
+    api = api_class.new
+  end
+
+  testing 'that routed methods can be called with embedded params' do
+    api_class =
+      assert{
+        Dao.api do
+          call('/users/:user_id/comments/:comment_id') do 
+            data.update(params)
+          end
+        end
+      }
+    api = api_class.new
+
+    {
+      '/users/4/comments/2' => {},
+      '/users/:user_id/comments/:comment_id' => {:user_id => 4, :comment_id => 2},
+    }.each do |path, params|
+      result = assert{ api.call(path, params) }
+      assert{ result.data.user_id.to_s =~ /4/ }
+      assert{ result.data.comment_id.to_s =~ /2/ }
+      assert{ result.path == '/users/4/comments/2' }
+      assert{ result.route == '/users/:user_id/comments/:comment_id' }
+    end
+  end
+
+## doc
+#
+  testing 'that apis can be documented via the api' do
+    api_class =
+      assert {
+        Dao.api {
+          description 'foobar'
+          doc 'signature' => {'read' => '...', 'write' => '...'} 
+          endpoint('/barfoo'){}
+        }
+      }
+    api_class_index = assert{ api_class.index.is_a?(Hash) }
+    api = assert{ api_class.new }
+    api_index = assert{ api.index.is_a?(Hash) }
+    assert{ api_class_index==api_index }
+  end
+
+# aliases
+#
+  testing 'that apis can alias methods' do
+    api_class =
+      assert {
+        Dao.api {
+          call('/barfoo'){ data.update(:k => :v) }
+          call('/foobar', :alias => '/barfoo')
+        }
+      }
+    api = assert{ api_class.new }
+    assert{ api.call('/barfoo').data.k == :v }
+    assert{ api.call('/foobar').data.k == :v }
+  end
+
+protected
+  def hash_equal(a, b)
+    array = lambda{|h| h.to_a.map{|k,v| [k.to_s, v]}.sort}
+    array[a] == array[b]
+  end
+
+  def api(&block)
+    api_class = assert{ Dao.api(&block) }
+    api = assert{ api_class.new }
+  end
+end
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+
+  require File.join(libdir, 'dao')
+  require File.join(testdir, 'testing')
+  require File.join(testdir, 'helper')
+}