dao 8.0.0 → 8.0.1

data/coerce-0.0.8/coerce.gemspec

@@ -1,31 +0,0 @@
-## coerce.gemspec
-#
-
-Gem::Specification::new do |spec|
-  spec.name = "coerce"
-  spec.version = "0.0.8"
-  spec.platform = Gem::Platform::RUBY
-  spec.summary = "coerce"
-  spec.description = "description: coerce kicks the ass"
-  spec.license = "same as ruby's"
-
-  spec.files =
-["README", "Rakefile", "coerce.gemspec", "lib", "lib/coerce.rb"]
-
-  spec.executables = []
-  
-  spec.require_path = "lib"
-
-  spec.test_files = nil
-
-  
-    spec.add_dependency(*["chronic", ">= 0.6.2"])
-  
-
-  spec.extensions.push(*[])
-
-  spec.rubyforge_project = "codeforpeople"
-  spec.author = "Ara T. Howard"
-  spec.email = "ara.t.howard@gmail.com"
-  spec.homepage = "https://github.com/ahoward/coerce"
-end

data/coerce-0.0.8/lib/coerce.rb

@@ -1,210 +0,0 @@
-module Coerce
-## built-in
-#
-  require 'uri'
-  require 'time'
-  require 'date'
-  require 'pathname'
-  require 'chronic'
-
-## version
-#
-  Coerce::Version = '0.0.8'
-
-  def self.version
-    Coerce::Version
-  end
-
-## dependencies
-#
-  def self.dependencies
-    {
-      'chronic'   =>  [ 'chronic'   , '>= 0.6.2' ]
-    }
-  end
-
-  begin
-    require 'rubygems'
-  rescue LoadError
-    nil
-  end
-
-  if defined?(gem)
-    self.dependencies.each do |lib, dependency|
-      gem(*dependency)
-      require(lib)
-    end
-  end
-
-##
-#
-  def self.export m
-    module_function m
-    public m
-  end
-
-  List = []
-
-  def self.coerce m, &b
-    define_method m, &b
-    export m
-    List << m.to_s
-  end
-
-  coerce :boolean do |obj|
-    case obj.to_s
-      when %r/^(true|t|1|yes|y|on)$/i
-        true
-      when %r/^(false|f|0|no|n|off)$/i
-        false
-      else
-        !!obj
-    end
-  end
-
-  coerce :integer do |obj|
-    Float(obj).to_i
-  end
-
-  coerce :float do |obj|
-    Float obj
-  end
-
-  coerce :number do |obj|
-    Float obj rescue Integer obj
-  end
-
-  coerce :string do |obj|
-    String obj
-  end
-
-  coerce :symbol do |obj|
-    String(obj).to_sym
-  end
-
-  coerce :uri do |obj|
-    ::URI.parse obj.to_s
-  end
-
-  coerce :url do |obj|
-    ::URI.parse(obj.to_s).to_s
-  end
-
-  coerce :time do |obj|
-    ::Chronic.parse(obj.to_s)
-  end
-
-  coerce :date do |obj|
-    begin
-      ::Date.parse(::Chronic.parse(obj.to_s).to_s)
-    rescue
-      ::Date.parse(obj.to_s)
-    end
-  end
-
-  coerce :pathname do |obj|
-    Pathname.new(obj.to_s)
-  end
-
-  coerce :path do |obj|
-    File.expand_path(obj.to_s)
-  end
-
-  coerce :input do |obj|
-    case obj.to_s
-      when '-'
-        io = STDIN.dup
-        io.fattr(:path){ '/dev/stdin' }
-        io
-      else
-        io = open(obj.to_s, 'r+')
-        at_exit{ io.close }
-        io
-    end
-  end
-
-  coerce :output do |obj|
-    case obj.to_s
-      when '-'
-        io = STDOUT.dup
-        io.fattr(:path){ '/dev/stdout' }
-        io
-      else
-        io = open(obj.to_s, 'w+')
-        at_exit{ io.close }
-        io
-    end
-  end
-
-  coerce :slug do |obj|
-    string = [obj].flatten.compact.join('-')
-    words = string.to_s.scan(%r/\w+/)
-    words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
-    words.delete_if{|word| word.nil? or word.strip.empty?}
-    String(words.join('-').downcase)
-  end
-
-  coerce :list do |*objs|
-    [*objs].flatten.join(',').split(/[\n,]/).map{|item| item.strip}.delete_if{|item| item.strip.empty?}
-  end
-
-  coerce :array do |*objs|
-    [*objs].flatten.join(',').split(/[\n,]/).map{|item| item.strip}.delete_if{|item| item.strip.empty?}
-  end
-
-  coerce :hash do |*objs|
-    list = Coerce.list(*objs)
-    hash = Hash.new
-    list.each do |pair|
-      k, v = pair.split(/[=:]+/, 2)
-      key = k.to_s.strip
-      val = v.to_s.strip
-      hash[key] = val
-    end
-    hash
-  end
-
-# add list_of_xxx methods
-#
-  List.dup.each do |type|
-    next if type.to_s =~ %r/list/ 
-    %W" list_of_#{ type } list_of_#{ type }s ".each do |m|
-      define_method m do |*objs|
-        list(*objs).map{|obj| send type, obj}
-      end
-      export m 
-      List << m
-    end
-  end
-
-# add list_of_xxx_from_file
-#
-  List.dup.each do |type|
-    next if type.to_s =~ %r/list/ 
-    %W" list_of_#{ type }_from_file list_of_#{ type }s_from_file ".each do |m|
-      define_method m do |*args|
-        buf = nil
-        if args.size == 1 and args.first.respond_to?(:read)
-          buf = args.first.read
-        else
-          open(*args){|io| buf = io.read}
-        end
-        send(m.sub(/_from_file/, ''), buf)
-      end
-      export m
-      List << m
-    end
-  end
-
-  def self.[] sym
-    prefix = sym.to_s.downcase.to_sym
-    candidates = List.select{|m| m =~ %r/^#{ prefix }/i}
-    m = candidates.shift
-    raise ArgumentError, "unsupported coercion: #{ sym.inspect } (#{ List.join ',' })" unless
-      m
-    raise ArgumentError, "ambiguous coercion: #{ sym.inspect } (#{ List.join ',' })" unless
-      candidates.empty? or m.to_s == sym.to_s
-    this = self
-    lambda{|obj| method(m).call obj}
-  end
-end

data/wrap-1.5.2/README

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

data/wrap-1.5.2/Rakefile

@@ -1,394 +0,0 @@
-This.rubyforge_project = 'codeforpeople'
-This.author = "Ara T. Howard"
-This.email = "ara.t.howard@gmail.com"
-This.homepage = "https://github.com/ahoward/#{ This.lib }"
-
-task :license do
-  open('LICENSE', 'w'){|fd| fd.puts "same as ruby's"}
-end
-
-task :default do
-  puts((Rake::Task.tasks.map{|task| task.name.gsub(/::/,':')} - ['default']).sort)
-end
-
-task :test do
-  run_tests!
-end
-
-namespace :test do
-  task(:unit){ run_tests!(:unit) }
-  task(:functional){ run_tests!(:functional) }
-  task(:integration){ run_tests!(:integration) }
-end
-
-def run_tests!(which = nil)
-  which ||= '**'
-  test_dir = File.join(This.dir, "test")
-  test_glob ||= File.join(test_dir, "#{ which }/**_test.rb")
-  test_rbs = Dir.glob(test_glob).sort
-        
-  div = ('=' * 119)
-  line = ('-' * 119)
-
-  test_rbs.each_with_index do |test_rb, index|
-    testno = index + 1
-    command = "#{ This.ruby } -w -I ./lib -I ./test/lib #{ test_rb }"
-
-    puts
-    say(div, :color => :cyan, :bold => true)
-    say("@#{ testno } => ", :bold => true, :method => :print)
-    say(command, :color => :cyan, :bold => true)
-    say(line, :color => :cyan, :bold => true)
-
-    system(command)
-
-    say(line, :color => :cyan, :bold => true)
-
-    status = $?.exitstatus
-
-    if status.zero? 
-      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
-      say("SUCCESS", :color => :green, :bold => true)
-    else
-      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
-      say("FAILURE", :color => :red, :bold => true)
-    end
-    say(line, :color => :cyan, :bold => true)
-
-    exit(status) unless status.zero?
-  end
-end
-
-
-task :gemspec do
-  ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
-  ignore_directories = ['pkg']
-  ignore_files = ['test/log']
-
-  shiteless = 
-    lambda do |list|
-      list.delete_if do |entry|
-        next unless test(?e, entry)
-        extension = File.basename(entry).split(%r/[.]/).last
-        ignore_extensions.any?{|ext| ext === extension}
-      end
-      list.delete_if do |entry|
-        next unless test(?d, entry)
-        dirname = File.expand_path(entry)
-        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
-      end
-      list.delete_if do |entry|
-        next unless test(?f, entry)
-        filename = File.expand_path(entry)
-        ignore_files.any?{|file| File.expand_path(file) == filename}
-      end
-    end
-
-  lib         = This.lib
-  object      = This.object
-  version     = This.version
-  files       = shiteless[Dir::glob("**/**")]
-  executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
-  #has_rdoc    = true #File.exist?('doc')
-  test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
-  summary     = object.respond_to?(:summary) ? object.summary : "summary: #{ lib } kicks the ass"
-  description = object.respond_to?(:description) ? object.description : "description: #{ lib } kicks the ass"
-  license     = object.respond_to?(:license) ? object.license : "same as ruby's"
-
-  if This.extensions.nil?
-    This.extensions = []
-    extensions = This.extensions
-    %w( Makefile configure extconf.rb ).each do |ext|
-      extensions << ext if File.exists?(ext)
-    end
-  end
-  extensions = [extensions].flatten.compact
-
-  if This.dependencies.nil?
-    dependencies = []
-  else
-    case This.dependencies
-      when Hash
-        dependencies = This.dependencies.values
-      when Array
-        dependencies = This.dependencies
-    end
-  end
-
-  template = 
-    if test(?e, 'gemspec.erb')
-      Template{ IO.read('gemspec.erb') }
-    else
-      Template {
-        <<-__
-          ## <%= lib %>.gemspec
-          #
-
-          Gem::Specification::new do |spec|
-            spec.name = <%= lib.inspect %>
-            spec.version = <%= version.inspect %>
-            spec.platform = Gem::Platform::RUBY
-            spec.summary = <%= lib.inspect %>
-            spec.description = <%= description.inspect %>
-            spec.license = <%= license.inspect %>
-
-            spec.files =\n<%= files.sort.pretty_inspect %>
-            spec.executables = <%= executables.inspect %>
-            
-            spec.require_path = "lib"
-
-            spec.test_files = <%= test_files.inspect %>
-
-            <% dependencies.each do |lib_version| %>
-              spec.add_dependency(*<%= Array(lib_version).flatten.inspect %>)
-            <% end %>
-
-            spec.extensions.push(*<%= extensions.inspect %>)
-
-            spec.rubyforge_project = <%= This.rubyforge_project.inspect %>
-            spec.author = <%= This.author.inspect %>
-            spec.email = <%= This.email.inspect %>
-            spec.homepage = <%= This.homepage.inspect %>
-          end
-        __
-      }
-    end
-
-  Fu.mkdir_p(This.pkgdir)
-  gemspec = "#{ lib }.gemspec"
-  open(gemspec, "w"){|fd| fd.puts(template)}
-  This.gemspec = gemspec
-end
-
-task :gem => [:clean, :gemspec] do
-  Fu.mkdir_p(This.pkgdir)
-  before = Dir['*.gem']
-  cmd = "gem build #{ This.gemspec }"
-  `#{ cmd }`
-  after = Dir['*.gem']
-  gem = ((after - before).first || after.first) or abort('no gem!')
-  Fu.mv(gem, This.pkgdir)
-  This.gem = File.join(This.pkgdir, File.basename(gem))
-end
-
-task :readme do
-  samples = ''
-  prompt = '~ > '
-  lib = This.lib
-  version = This.version
-
-  Dir['sample*/*'].sort.each do |sample|
-    samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
-
-    cmd = "cat #{ sample }"
-    samples << Util.indent(prompt + cmd, 2) << "\n\n"
-    samples << Util.indent(`#{ cmd }`, 4) << "\n"
-
-    cmd = "ruby #{ sample }"
-    samples << Util.indent(prompt + cmd, 2) << "\n\n"
-
-    cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -I ./lib #{ sample })'"
-    samples << Util.indent(`#{ cmd } 2>&1`, 4) << "\n"
-  end
-
-  template = 
-    if test(?e, 'README.erb')
-      Template{ IO.read('README.erb') }
-    else
-      Template {
-        <<-__
-          NAME
-            #{ lib }
-
-          DESCRIPTION
-
-          INSTALL
-            gem install #{ lib }
-
-          SAMPLES
-            #{ samples }
-        __
-      }
-    end
-
-  open("README", "w"){|fd| fd.puts template}
-end
-
-
-task :clean do
-  Dir[File.join(This.pkgdir, '**/**')].each{|entry| Fu.rm_rf(entry)}
-end
-
-
-task :release => [:clean, :gemspec, :gem] do
-  gems = Dir[File.join(This.pkgdir, '*.gem')].flatten
-  raise "which one? : #{ gems.inspect }" if gems.size > 1
-  raise "no gems?" if gems.size < 1
-
-  cmd = "gem push #{ This.gem }"
-  puts cmd
-  puts
-  system(cmd)
-  abort("cmd(#{ cmd }) failed with (#{ $?.inspect })") unless $?.exitstatus.zero?
-
-  cmd = "rubyforge login && rubyforge add_release #{ This.rubyforge_project } #{ This.lib } #{ This.version } #{ This.gem }"
-  puts cmd
-  puts
-  system(cmd)
-  abort("cmd(#{ cmd }) failed with (#{ $?.inspect })") unless $?.exitstatus.zero?
-end
-
-
-
-
-
-BEGIN {
-# support for this rakefile
-#
-  $VERBOSE = nil
-
-  require 'ostruct'
-  require 'erb'
-  require 'fileutils'
-  require 'rbconfig'
-  require 'pp'
-
-# fu shortcut
-#
-  Fu = FileUtils
-
-# cache a bunch of stuff about this rakefile/environment
-#
-  This = OpenStruct.new
-
-  This.file = File.expand_path(__FILE__)
-  This.dir = File.dirname(This.file)
-  This.pkgdir = File.join(This.dir, 'pkg')
-
-# grok lib
-#
-  lib = ENV['LIB']
-  unless lib
-    lib = File.basename(Dir.pwd).sub(/[-].*$/, '')
-  end
-  This.lib = lib
-
-# grok version
-#
-  version = ENV['VERSION']
-  unless version
-    require "./lib/#{ This.lib }"
-    This.name = lib.capitalize
-    This.object = eval(This.name)
-    version = This.object.send(:version)
-  end
-  This.version = version
-
-# see if dependencies are export by the module
-#
-  if This.object.respond_to?(:dependencies)
-    This.dependencies = This.object.dependencies
-  end
-
-# we need to know the name of the lib an it's version
-#
-  abort('no lib') unless This.lib
-  abort('no version') unless This.version
-
-# discover full path to this ruby executable
-#
-  c = Config::CONFIG
-  bindir = c["bindir"] || c['BINDIR']
-  ruby_install_name = c['ruby_install_name'] || c['RUBY_INSTALL_NAME'] || 'ruby'
-  ruby_ext = c['EXEEXT'] || ''
-  ruby = File.join(bindir, (ruby_install_name + ruby_ext))
-  This.ruby = ruby
-
-# some utils
-#
-  module Util
-    def indent(s, n = 2)
-      s = unindent(s)
-      ws = ' ' * n
-      s.gsub(%r/^/, ws)
-    end
-
-    def unindent(s)
-      indent = nil
-      s.each_line do |line|
-      next if line =~ %r/^\s*$/
-      indent = line[%r/^\s*/] and break
-    end
-    indent ? s.gsub(%r/^#{ indent }/, "") : s
-  end
-    extend self
-  end
-
-# template support
-#
-  class Template
-    def initialize(&block)
-      @block = block
-      @template = block.call.to_s
-    end
-    def expand(b=nil)
-      ERB.new(Util.unindent(@template)).result((b||@block).binding)
-    end
-    alias_method 'to_s', 'expand'
-  end
-  def Template(*args, &block) Template.new(*args, &block) end
-
-# colored console output support
-#
-  This.ansi = {
-    :clear      => "\e[0m",
-    :reset      => "\e[0m",
-    :erase_line => "\e[K",
-    :erase_char => "\e[P",
-    :bold       => "\e[1m",
-    :dark       => "\e[2m",
-    :underline  => "\e[4m",
-    :underscore => "\e[4m",
-    :blink      => "\e[5m",
-    :reverse    => "\e[7m",
-    :concealed  => "\e[8m",
-    :black      => "\e[30m",
-    :red        => "\e[31m",
-    :green      => "\e[32m",
-    :yellow     => "\e[33m",
-    :blue       => "\e[34m",
-    :magenta    => "\e[35m",
-    :cyan       => "\e[36m",
-    :white      => "\e[37m",
-    :on_black   => "\e[40m",
-    :on_red     => "\e[41m",
-    :on_green   => "\e[42m",
-    :on_yellow  => "\e[43m",
-    :on_blue    => "\e[44m",
-    :on_magenta => "\e[45m",
-    :on_cyan    => "\e[46m",
-    :on_white   => "\e[47m"
-  }
-  def say(phrase, *args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    options[:color] = args.shift.to_s.to_sym unless args.empty?
-    keys = options.keys
-    keys.each{|key| options[key.to_s.to_sym] = options.delete(key)}
-
-    color = options[:color]
-    bold = options.has_key?(:bold)
-
-    parts = [phrase]
-    parts.unshift(This.ansi[color]) if color
-    parts.unshift(This.ansi[:bold]) if bold
-    parts.push(This.ansi[:clear]) if parts.size > 1
-
-    method = options[:method] || :puts
-
-    Kernel.send(method, parts.join)
-  end
-
-# always run out of the project dir
-#
-  Dir.chdir(This.dir)
-}