dao 7.0.0 → 8.0.0

data/lib/dao/conducer.rb

@@ -86,14 +86,10 @@ module Dao
   # instance methods
   #
     %w[
-      attributes
-      form
       params
-      errors
       messages
       models
       model
-      conduces
     ].each{|attr| fattr(attr)}
 
   # ctors
@@ -323,6 +319,10 @@ module Dao
       update_attributes(attributes)
     end
 
+    def attributes
+      @attributes
+    end
+
     def set(*args, &block)
       update_attributes(*args, &block)
     end
@@ -399,10 +399,10 @@ module Dao
     end
 
     def id_for(object)
-      model?(object) ? object.id : object
+      modelish?(object) ? object.id : object
     end
 
-    def model?(object)
+    def modelish?(object)
       object.respond_to?(:persisted?)
     end
 
@@ -478,10 +478,6 @@ module Dao
       Dao.key_for(key)
     end
 
-    def errors
-      validator.errors
-    end
-
     def model_name
       self.class.model_name
     end

data/lib/dao/errors2html.rb

@@ -71,7 +71,7 @@ module Dao
         when Map
           hash = Hash.new
           hashlike.depth_first_each do |key, value|
-            index = key.pop if key.last.is_a?(Integer)
+            _ = key.pop if key.last.is_a?(Integer)
             (hash[key] ||= []).push(value)
           end
           hash

data/lib/dao/support.rb

@@ -183,11 +183,12 @@ module Dao
   def json_for(object, options = {})
     object = object.as_json if object.respond_to?(:as_json)
 
-    options = options.empty? ? Map.for(options) : options
-    options[:pretty] = json_pretty?  unless options.has_key?(:pretty)
+    pretty = (options.delete(:pretty) || json_pretty?)
+
+    generate = pretty ? :pretty_generate : :generate
 
     begin
-      MultiJson.dump(object, options)
+      JSON.send(generate, object, options)
     rescue Object => _
       YAML.load( object.to_yaml ).to_json
     end
@@ -231,21 +232,9 @@ module Dao
     end
   end
 
-
-  {
-    'ffi-uuid'  => proc{|*args| FFI::UUID.generate_time.to_s},
-    'uuidtools' => proc{|*args| UUIDTools::UUID.timestamp_create.to_s},
-    'uuid'      => proc{|*args| UUID.generate.to_s},
-  }.each do |lib, implementation|
-    begin
-      require(lib)
-      define_method(:uuid, &implementation)
-      break
-    rescue LoadError
-      nil
-    end
+  def uuid
+    SecureRandom.uuid
   end
-  abort 'no suitable uuid generation library detected' unless method_defined?(:uuid)
 
   def ensure_interface!(object, *interface)
     interface.flatten.compact.each do |method|

data/lib/dao/wrap.rb

@@ -0,0 +1,259 @@
+module Dao
+  module Wrap
+    def Wrap.included(other)
+      super
+    ensure
+      other.send(:instance_eval, &ClassMethods)
+      other.send(:class_eval, &InstanceMethods)
+    end
+
+    def Wrap.code_for(method)
+      name = method.name.to_s
+      arity = method.arity
+
+      case
+        when arity == 0
+          signature = <<-__.strip
+            def #{ name }(&block)
+              args = []
+          __
+
+        when arity < 0
+          argv = Array.new(arity.abs - 1){|i| "arg#{ i }"}
+          argv.push('*args')
+          argv = argv.join(', ')
+
+          signature = <<-__.strip
+            def #{ name }(#{ argv }, &block)
+              args = [#{ argv }]
+          __
+
+        when arity > 0
+          argv = Array.new(arity){|i| "arg#{ i }"}
+          argv = argv.join(', ')
+
+          signature = <<-__.strip
+            def #{ name }(#{ argv }, &block)
+              args = [#{ argv }]
+          __
+      end
+
+      code =
+        <<-__
+          #{ signature.strip }
+           
+            if running_callbacks?(#{ name.inspect })
+              return wrapped_#{ name }(*args, &block)
+            end
+
+            running_callbacks(#{ name.inspect }) do
+              catch(:halt) do
+                return false if run_callbacks(:before, #{ name.inspect }, args)==false
+
+                begin
+                  result = wrapped_#{ name }(*args, &block)
+                ensure
+                  run_callbacks(:after, #{ name.inspect }, [result]) unless $!
+                end
+              end
+            end
+          end
+        __
+
+      return code
+    end
+
+    ClassMethods = proc do
+      def method_added(name)
+        return super if wrapping?
+        begin
+          super
+        ensure
+          wrap!(name) if wrapped?(name)
+        end
+      end
+
+      def include(other)
+        super
+      ensure
+        other.instance_methods.each do |name|
+          if wrapped?(name)
+            begin
+              remove_method(name)
+            rescue NameError
+              nil
+            end
+            wrap!(name)
+          end
+        end
+      end
+
+      def wrap(name, *args, &block)
+        wrapped!(name)
+
+        wrap!(name) if
+          begin
+            instance_method(name)
+            true
+          rescue NameError
+            false
+          end
+      end
+
+      def wrapped!(name)
+        name = name.to_s
+        wrapped.push(name) unless wrapped.include?(name)
+        name
+      end
+
+      def wrapped
+        @wrapped ||= []
+      end
+
+      def wrapped?(name)
+        ancestors.any?{|ancestor| ancestor.respond_to?(:wrapped) and ancestor.wrapped.include?(name.to_s)}
+      end
+
+      def wrap!(name)
+        name = name.to_s
+        method = instance_method(name)
+
+        wrapping! name do
+          name = name.to_s
+          wrapped_name = "wrapped_#{ name }"
+
+          begin
+            remove_method(wrapped_name)
+          rescue NameError
+            nil
+          end
+
+          alias_method(wrapped_name, name)
+
+          module_eval(Wrap.code_for(method))
+        end
+      end
+
+      def wrapping!(name, &block)
+        name = name.to_s
+        @wrapping ||= []
+
+        return if @wrapping.last == name
+
+        @wrapping.push(name)
+
+        begin
+          block.call
+        ensure
+          @wrapping.pop
+        end
+      end
+
+      def wrapping?(*name)
+        @wrapping ||= []
+
+        if name.empty?
+          !@wrapping.empty?
+        else
+          @wrapping.last == name.last.to_s
+        end
+      end
+
+      def callbacks
+        @callbacks ||= Map.new
+      end
+
+      def initialize_callbacks!(name)
+        callbacks[name] ||= Map[ :before, [], :after, [] ]
+        callbacks[name]
+      end
+
+      def before(name, *args, &block)
+        wrap(name) unless wrapped?(name)
+        name = wrap_expand_aliases(name)
+        cb = initialize_callbacks!(name)
+        cb.before.push(args.shift || block)
+      end
+
+      def after(name, *args, &block)
+        wrap(name) unless wrapped?(name)
+        name = wrap_expand_aliases(name)
+        cb = initialize_callbacks!(name)
+        cb.after.push(args.shift || block)
+      end
+
+      def wrap_aliases
+        @@wrap_aliases ||= Hash.new
+      end
+
+      def wrap_alias(dst, src)
+        wrap_aliases[dst.to_s] = src.to_s
+      end
+
+      def wrap_expand_aliases(name)
+        name = name.to_s
+        loop do
+          break unless wrap_aliases.has_key?(name)
+          name = wrap_aliases[name]
+        end
+        name
+      end
+    end
+
+    InstanceMethods = proc do
+      def running_callbacks(name, &block)
+        name = name.to_s
+        @running_callbacks ||= []
+        return block.call() if @running_callbacks.last == name
+
+        @running_callbacks.push(name)
+
+        begin
+          block.call()
+        ensure
+          @running_callbacks.pop
+        end
+      end
+
+      def running_callbacks?(*name)
+        @running_callbacks ||= []
+
+        if name.empty?
+          @running_callbacks.last
+        else
+          @running_callbacks.last == name.last.to_s
+        end
+      end
+
+      def run_callbacks(which, name, argv)
+        which = which.to_s.to_sym
+        name = name.to_s
+        list = []
+
+        self.class.ancestors.each do |ancestor|
+          next unless ancestor.respond_to?(:callbacks)
+
+          if ancestor.callbacks.is_a?(Map) and ancestor.callbacks[name].is_a?(Map)
+            callbacks = ancestor.callbacks[name][which]
+            accumulate = (which == :before ? :unshift : :push)
+            list.send(accumulate, *callbacks) if callbacks.is_a?(Array)
+          end
+        end
+
+        list.each do |callback|
+          block = callback.respond_to?(:call) ? callback : proc{ send(callback.to_s.to_sym) }
+          args = argv.slice(0 .. (block.arity > 0 ? block.arity : -1))
+          result = instance_exec(*args, &block)
+          return false if result == false
+        end
+
+        true
+      end
+
+      def halt!(*args)
+        value = args.size == 0 ? false : args.shift
+        throw(:halt, value)
+      end
+    end
+  end
+end

data/test/conducer_test.rb

@@ -498,7 +498,7 @@ $pry=true
 
       path = File.join(File.dirname(__FILE__), 'data/han-solo.jpg') 
       assert{ test(?s, path) }
-      up = Upload.new(path)
+      _up = Upload.new(path)
       comment = Comment.new
 
       c = conducer_class.new( comment, :up => {:file => Upload.new(path)} ) 
@@ -512,8 +512,8 @@ $pry=true
 
       assert{ c.save }
 
-      value_was_relayed = assert{ comment.attributes[:up] == upload._value }
-      value_was_cleared = assert{ !test(?f, upload.path) }
+      _value_was_relayed = assert{ comment.attributes[:up] == upload._value }
+      _value_was_cleared = assert{ !test(?f, upload.path) }
 
       assert{ test(?s, path) }
 ensure
@@ -705,7 +705,7 @@ protected
 
     def method_missing(method, *args, &block)
       re = /^([^=!?]+)([=!?])?$/imox
-      matched, key, suffix = re.match(method.to_s).to_a
+      _matched, key, suffix = re.match(method.to_s).to_a
       
       case suffix
         when '=' then attributes.set(key, args.first)

data/test/form_test.rb

@@ -2,8 +2,8 @@
 require_relative 'test_helper'
 class DaoFormTest < ::Dao::TestCase
   test '.new' do
-    form = new_form() 
-    form = new_named_form() 
+    _ = new_form() 
+    _ = new_named_form() 
   end
 
   test 'name_for' do

data/test/validations_test.rb

@@ -111,8 +111,9 @@ class DaoValidationsTest < ::Dao::TestCase
   end
 
   test 'simple validates_confirmation_of' do
+=begin
     return :pending
-
+=end
     api_class =
       Dao.api do
         endpoint('/foobar'){
@@ -136,7 +137,6 @@ class DaoValidationsTest < ::Dao::TestCase
 #
   test 'that validations clear only that which they know about' do
     params = Dao::Params.new
-    errors = params.errors
 
     assert{ params.validates(:email){|email| email.to_s.split(/@/).size == 2} }
     assert{ params.validates(:password){|password| password == 'pa$$w0rd'} }

data/wrap-1.5.2/README

@@ -0,0 +1,57 @@
+NAME
+  wrap
+
+SYNOPSIS
+  non-sucking :before and :after filters for any ruby class
+
+DESCRIPTION
+  yes yes, active_support does this.  but crapily.  with active_support you'll
+  need to do this
+
+
+    class Record
+      include ActiveSupport::Callbacks
+      define_callbacks :save
+
+      def save
+        run_callbacks :save do
+          puts "- save"
+        end
+      end
+    end
+
+  but hey, if a subclass forgets to call 'super' or doesn't manually run
+  'run_callbacks' the codez are *screwed*.  that sux.  why not this?
+
+
+    class Record
+      include Wrap
+
+      wrap :save
+    end
+
+
+  yes, it's that simple.  you can now do
+
+    class SubRecord < Record
+      before :save do
+        special_sauce
+      end
+      
+      def save
+        no_special_sauce
+      end
+    end
+
+  did you get that?  the :before and :after hooks will be called no matter
+  what the subclass does.  the method will be wrapped, period.  no special
+  work required.  of course, if the sublcass messes with 'method_added' their
+  will be hell to pay.  that's the price for simplicity.
+
+  the callbacks are very close, but not identical to active_supports.  you can
+  return 'false' to halt the chain, but you can also simply call 'halt!'.
+  another neat trick is that :before callbacks will be called with the
+  arguments to the wrapped method itself iff possible and :after callbacks
+  will be called with the result of the wrapped method, iff possible.
+
+  the test suite reads pretty damn clean.  have a go.