dao 5.5.1 → 8.0.1

data/lib/dao/upload.rb

@@ -173,7 +173,6 @@ class Upload < ::Map
   attr_accessor :basename
   attr_accessor :io
   attr_accessor :tmpdir
-  attr_accessor :placeholder
 
   IOs = {}
 

data/lib/dao/validations/common.rb

@@ -364,9 +364,9 @@ module Dao
         options = Map.options_for!(args)
         list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
 
-        list.each do |args|
+        list.each do |_args|
           candidates = list.dup
-          candidates.delete(args)
+          candidates.delete(_args)
 
           message = options[:message] || "(or #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
           allow_nil = options[:allow_nil]
@@ -424,7 +424,7 @@ module Dao
 
               m
             end
-          validates(*args, &block)
+          validates(*_args, &block)
         end
       end
 
@@ -432,9 +432,9 @@ module Dao
         options = Map.options_for!(args)
         list = args + Array(options.delete(:keys)) + Array(options.delete(:or))
 
-        list.each do |args|
+        list.each do |_args|
           candidates = list.dup
-          candidates.delete(args)
+          candidates.delete(_args)
 
           message = options[:message] || "(and #{ candidates.map{|candidate| Array(candidate).join('.')}.join(', ') } ) is blank or missing"
           allow_nil = options[:allow_nil]
@@ -492,7 +492,7 @@ module Dao
 
               m
             end
-          validates(*args, &block)
+          validates(*_args, &block)
         end
       end
 

data/lib/dao/validations/validator.rb

@@ -101,7 +101,7 @@ module Dao
         block = args.pop if args.last.respond_to?(:call)
         block ||= NotBlank
         callback = Callback.new(options, &block)
-        options = Map.options_for!(args)
+        Map.options_for!(args)
         key = key_for(args)
         validations = stack.validations.last || self.validations
         validations[key] ||= Callback::Chain.new
@@ -112,7 +112,7 @@ module Dao
 
       def validates_each(*args, &block)
         options = Map.options_for!(args)
-        key = key_for(args)
+        key_for(args)
 
         args.push(options)
 
@@ -299,7 +299,7 @@ module Dao
         if forcing_validity?
           true
         else
-          options = Map.options_for!(args)
+          Map.options_for!(args)
           run_validations
           errors.empty? and status.ok?
         end

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/tasks/default.rake

@@ -0,0 +1,207 @@
+# vim: syntax=ruby
+require 'rake/clean'
+require 'digest'
+#------------------------------------------------------------------------------
+# If you want to Develop on this project just run 'rake develop' and you'll
+# have all you need to get going. If you want to use bundler for development,
+# then run 'rake develop:using_bundler'
+#------------------------------------------------------------------------------
+namespace :develop do
+
+  # Install all the development and runtime dependencies of this gem using the
+  # gemspec.
+  task :default => 'Gemfile' do
+    require 'rubygems/dependency_installer'
+    installer = ::Gem::DependencyInstaller.new
+    puts "Installing bundler..."
+    installer.install 'bundler'
+    sh 'bundle install'
+    puts "\n\nNow run 'rake test'"
+  end
+
+  # Create a Gemfile that just references the gemspec
+  file 'Gemfile' => :gemspec do
+    File.open( "Gemfile", "w+" ) do |f|
+      f.puts "# DO NOT EDIT - This file is automatically generated"
+      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+      f.puts 'source "https://rubygems.org/"'
+      f.puts 'gemspec'
+    end
+  end
+end
+desc "Boostrap development"
+task :develop => "develop:default"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.libs         = %w[ lib spec test ]
+    t.pattern      = "{test,spec}/**/{test_*,*_spec,*_test}.rb"
+  end
+
+  task :test_requirements
+  task :test => :test_requirements
+  task :default => :test
+rescue LoadError
+  This.task_warning( 'test' )
+end
+
+#------------------------------------------------------------------------------
+# Manifest - We want an explicit list of thos files that are to be packaged in
+#            the gem. Most of this is from Hoe.
+#------------------------------------------------------------------------------
+namespace 'manifest' do
+  desc "Check the manifest"
+  task :check => :clean do
+    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
+    files = files.select{ |f| File.file?( f ) }
+
+    tmp = "Manifest.tmp"
+    File.open( tmp, 'w' ) do |f|
+      f.puts files.join("\n")
+    end
+
+    begin
+      sh "diff -du Manifest.txt #{tmp}"
+    ensure
+      rm tmp
+    end
+    puts "Manifest looks good"
+  end
+
+  desc "Generate the manifest"
+  task :generate => :clean do
+    files = %x[ git ls-files ].split("\n").sort
+    files.reject! { |f| f =~ This.exclude_from_manifest }
+    File.open( "Manifest.txt", "w" ) do |f|
+      f.puts files.join("\n")
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Fixme - look for fixmes and report them
+#------------------------------------------------------------------------------
+namespace :fixme do
+  task :default => 'manifest:check' do
+    This.manifest.each do |file|
+      next if file == __FILE__
+      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
+      puts "FIXME: Rename #{file}" if file =~ /fixme/i
+      IO.readlines( file ).each_with_index do |line, idx|
+        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
+        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
+      end
+    end
+  end
+
+  def fixme_project_root
+    This.project_path( '../fixme' )
+  end
+
+  def fixme_project_path( subtree )
+    fixme_project_root.join( subtree )
+  end
+
+  def local_fixme_files
+    This.manifest.select { |p| p =~ %r|^tasks/| }
+  end
+
+  def outdated_fixme_files
+    local_fixme_files.select do |local|
+      upstream     = fixme_project_path( local )
+      upstream.exist? &&
+        ( Digest::SHA256.file( local ) != Digest::SHA256.file( upstream ) )
+    end
+  end
+
+  def fixme_up_to_date?
+    outdated_fixme_files.empty?
+  end
+
+  desc "See if the fixme tools are outdated"
+  task :outdated => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are up to date."
+    else
+      outdated_fixme_files.each do |f|
+        puts "#{f} is outdated"
+      end
+    end
+  end
+
+  desc "Update outdated fixme files"
+  task :update => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are already up to date."
+    else
+      puts "Updating fixme files:"
+      outdated_fixme_files.each do |local|
+        upstream = fixme_project_path( local )
+        puts "  * #{local}"
+        FileUtils.cp( upstream, local )
+      end
+      puts "Use your git commands as appropriate."
+    end
+  end
+end
+desc "Look for fixmes and report them"
+task :fixme => "fixme:default"
+
+#------------------------------------------------------------------------------
+# Gem Specification
+#------------------------------------------------------------------------------
+# Really this is only here to support those who use bundler
+desc "Build the #{This.name}.gemspec file"
+task :gemspec do
+  File.open( This.gemspec_file, "wb+" ) do |f|
+    f.puts "# DO NOT EDIT - This file is automatically generated"
+    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+    f.write This.platform_gemspec.to_ruby
+  end
+end
+
+# .rbc files from ruby 2.0
+CLOBBER << FileList["**/*.rbc"]
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+::Gem::PackageTask.new( This.platform_gemspec ) do
+  # nothing
+end
+
+#------------------------------------------------------------------------------
+# Release - the steps we go through to do a final release, this is pulled from
+#           a compbination of mojombo's rakegem, hoe and hoe-git
+#
+# 1) make sure we are on the master branch
+# 2) make sure there are no uncommitted items
+# 3) check the manifest and make sure all looks good
+# 4) build the gem
+# 5) do an empty commit to have the commit message of the version
+# 6) tag that commit as the version
+# 7) push master
+# 8) push the tag
+# 7) pus the gem
+#------------------------------------------------------------------------------
+task :release_check do
+  unless `git branch` =~ /^\* master$/
+    abort "You must be on the master branch to release!"
+  end
+  unless `git status` =~ /^nothing to commit/m
+    abort "Nope, sorry, you have unfinished business"
+  end
+end
+
+desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
+task :release => [ :release_check, 'manifest:check', :gem ] do
+  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
+  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
+  sh "git push origin master"
+  sh "git push origin v#{This.version}"
+  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
+end
+