dao 4.2.1 → 4.4.2

data/b.rb

@@ -1,38 +0,0 @@
-
-require 'dao'
-
-
-
-class C < ::Map
-  include Dao::Validations
-  validates_presence_of :foo
-end
-
-c = C.new
-
-p c.valid?
-p c.errors
-
-c.update(:foo => 42)
-
-p c.valid?
-p c.errors
-
-#p 'c.validator.attributes' => c.validator.attributes
-#p 'c' => c
-
-__END__
-
-p c.valid?
-
-
-p c
-
-p c.valid?
-
-#c.validator
-#p c.validator.object
-#p c.valid?
-#p c.errors
-#p c.status
-

data/lib/dao/conducer/crud.rb

@@ -1,70 +0,0 @@
-module Dao
-## CRUD support
-#
-  class Conducer
-    module CRUD
-      Code = proc do
-        class << self
-          def db
-            Db.instance
-          end
-
-          def collection
-            db[collection_name]
-          end
-
-          def all(*args)
-            hashes = collection.all()
-            hashes.map{|hash| new(hash)}
-          end
-
-          def find(id)
-            hash = collection.find(id)
-            new(hash) if hash
-          end
-        end
-
-        def save
-          run_callbacks :save do
-            return(false) unless valid?
-            id = self.class.collection.save(@attributes)
-            @attributes.set(:id => id)
-            true
-          end
-        ensure
-          @new_record = false
-        end
-
-        def destroy
-          id = self.id
-          if id
-            self.class.collection.destroy(id)
-            @attributes.rm(:id)
-          end
-          id
-        ensure
-          @destroyed = true
-        end
-      end
-
-      def CRUD.included(other)
-        super
-      ensure
-        other.module_eval(&Code)
-      end
-    end
-  end
-
-## dsl for auto-crud
-#
-  class Conducer
-    class << self
-      def crud
-        include(Conducer::CRUD)
-      end
-      alias_method('crud!', 'crud')
-      alias_method('autocrud!', 'crud')
-    end
-  end
-  #Conducer::send(:include, Conducer::CRUD)
-end

data/lib/dao/current.rb

@@ -1,66 +0,0 @@
-# FIXME - the redundancy in this file fucking kilz me... fix it.
-#
-module Dao::Current
-  Methods = proc do
-  end
-
-  ClassMethods = proc do
-    def current_controller
-      @current_controller ||= (
-        if defined?(@controller)
-          @controller
-        else
-          Dao.current_controller || Dao.mock_controller
-        end
-      )
-    end
-
-    %w( request response session ).each do |attr|
-      instance_eval <<-__, __FILE__, __LINE__
-        def current_#{ attr }
-          @current_#{ attr } ||= current_controller.instance_eval{ #{ attr } }
-        end
-      __
-    end
-
-    %w( current_user effective_user real_user ).each do |attr|
-      instance_eval <<-__, __FILE__, __LINE__
-        def #{ attr }
-          @#{ attr } ||= current_controller.instance_eval{ #{ attr } }
-        end
-        def #{ attr }=(value)
-          @#{ attr } = value
-        end
-      __
-    end
-  end
-
-  InstanceMethods = proc do
-    def current_controller
-      @current_controller ||= (
-        if defined?(@controller)
-          @controller
-        else
-          self.class.current_controller
-        end
-      )
-    end
-
-    %w( current_request current_response current_session current_user effective_user real_user ).each do |attr|
-      module_eval <<-__, __FILE__, __LINE__
-        def #{ attr }
-          @#{ attr } ||= self.class.send('#{ attr }')
-        end
-        def #{ attr }=(value)
-          @#{ attr } = value
-        end
-      __
-    end
-  end
-
-  def self.included(other)
-    other.send(:instance_eval, &ClassMethods)
-    other.send(:class_eval, &InstanceMethods)
-    super
-  end
-end

data/lib/dao/image_cache.rb

@@ -1,193 +0,0 @@
-module Dao
-  require 'uuidtools'
-  require 'fileutils'
-  require 'cgi'
-
-  class ImageCache
-    Version = '1.0.0'
-
-    class << ImageCache
-      def version
-        ImageCache::Version
-      end
-
-      def base
-        @base ||= 'images/cache'
-      end
-
-      def base=(base)
-        @base = base.to_s.sub(%r|^/+|, '')
-      end
-
-      def url
-        '/' + base
-      end
-
-      def root
-        @root ||= File.join(Rails.root, 'public', base)
-      end
-
-      def uuid(*args)
-        UUIDTools::UUID.timestamp_create.to_s
-      end
-
-      def tmpdir(&block)
-        tmpdir = File.join(root, uuid)
-
-        if block
-          FileUtils.mkdir_p(tmpdir)
-          block.call(tmpdir)
-        else
-          tmpdir
-        end
-      end
-
-      def cleanname(path)
-        basename = File.basename(path.to_s)
-        CGI.unescape(basename).gsub(%r/[^0-9a-zA-Z_@)(~.-]/, '_').gsub(%r/_+/,'_')
-      end
-
-      def cache_key_for(key)
-        "#{ key }__cache"
-      end
-
-      def for(params, key = :image)
-        image = params[key]
-        if image.respond_to?(:read)
-          tmpdir do |tmp|
-            basename = cleanname(image.original_path)
-
-            path = File.join(tmp, basename)
-            open(path, 'w'){|fd| fd.write(image.read)}
-            image_cache = new(key, path)
-            params[key] = image_cache.io
-            return image_cache
-          end
-        end
-
-        cache_key = cache_key_for(key)
-        image_cache = params[cache_key]
-        if image_cache
-          dirname, basename = File.split(image_cache)
-          path = root + '/' + File.join(File.basename(dirname), basename)
-          image_cache = new(key, path)
-          params[key] = image_cache.io
-          return image_cache
-        end
-
-        return new(key, path=nil)
-      end
-
-      def finalizer(object_id)
-        if fd = IOs[object_id]
-          IO.for_fd(fd).close
-          IOs.delete(object_id)
-        end
-      end
-
-      UUIDPattern = %r/^[a-zA-Z0-9-]+$/io
-      Age = 60 * 60 * 24
-
-      def clear!(options = {})
-        glob = File.join(root, '*')
-        age = Integer(options[:age] || options['age'] || Age)
-        since = options[:since] || options['since'] || Time.now
-
-        Dir.glob(glob) do |entry|
-          begin
-            next unless test(?d, entry)
-            next unless File.basename(entry) =~ UUIDPattern
-
-            files = Dir.glob(File.join(entry, '**/**'))
-
-            all_files_are_old =
-              files.all? do |file|
-                begin
-                  stat = File.stat(file)
-                  age = since - stat.atime
-                  age >= Age
-                rescue
-                  false
-                end
-              end
-
-            FileUtils.rm_rf(entry) if all_files_are_old
-          rescue
-            next
-          end
-        end
-      end
-    end
-
-    attr_accessor :key
-    attr_accessor :cache_key
-    attr_accessor :path
-    attr_accessor :dirname
-    attr_accessor :basename
-    attr_accessor :value
-    attr_accessor :io
-
-    IOs = {}
-
-    def initialize(key, path)
-      @key = key.to_s
-      @cache_key = ImageCache.cache_key_for(key)
-
-      if path
-        @path = path
-        @dirname, @basename = File.split(@path)
-        @value = File.join(File.basename(@dirname), @basename).strip
-        @io = open(@path)
-        IOs[object_id] = @io.fileno
-        ObjectSpace.define_finalizer(self, ImageCache.method(:finalizer).to_proc)
-      else
-        @path = nil
-        @value = nil
-      end
-    end
-
-    def hidden
-      raw("<input type='hidden' name='#{ @cache_key }' value='#{ @value }' />") if @value
-    end
-
-    def to_s
-      hidden.to_s
-    end
-
-    def url
-      File.join(ImageCache.url, @value) if @value
-    end
-
-    def raw(*args)
-      string = args.join
-      if string.respond_to?(:html_safe)
-        string.html_safe
-      else
-        string
-      end
-    end
-
-    def clear!
-      FileUtils.rm_rf(@dirname) if test(?d, @dirname)
-    rescue
-      nil
-    ensure
-      if @io
-        @io.close
-        IOs.delete(object_id)
-      end
-      Thread.new{ ImageCache.clear! }
-    end
-  end
-
-  Image_cache = ImageCache unless defined?(Image_cache)
-
-  if defined?(Rails.env)
-    unless Rails.env.production?
-      if defined?(unloadable)
-        unloadable(ImageCache)
-        unloadable(Image_cache)
-      end
-    end
-  end
-end

data/lib/dao/rails/lib/generators/dao/templates/conducer_controller.rb

@@ -1,79 +0,0 @@
-<%
-
-  conducer_class_name = @conducer_name.camelize
-  controller_class_name = @controller_name.camelize
-
--%>
-class PostsController < ApplicationController
-  Post = PostConducer
-
-  def index
-    @posts = Post.for_index(params)
-
-    respond_to do |format|
-      format.html # index.html.erb
-      format.json  { render :json => @posts }
-    end
-  end
-
-  def show
-    @post = Post.for_show(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.erb
-      format.json  { render :json => @post }
-    end
-  end
-
-  def new
-    @post = Post.for_new(params)
-
-    respond_to do |format|
-      format.html # new.html.erb
-      format.json  { render :json => @post }
-    end
-  end
-
-  def edit
-    @post = Post.find(params[:id])
-  end
-
-  def create
-    @post = Post.new(params[:post])
-
-    respond_to do |format|
-      if @post.save
-        format.html { redirect_to(@post, :notice => 'Post was successfully created.') }
-        format.json  { render :json => @post, :status => :created, :location => @post }
-      else
-        format.html { render :action => "new" }
-        format.json  { render :json => @post.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  def update
-    @post = Post.find(params[:id])
-
-    respond_to do |format|
-      if @post.update_attributes(params[:post])
-        format.html { redirect_to(@post, :notice => 'Post was successfully updated.') }
-        format.json  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.json  { render :json => @post.errors, :status => :unprocessable_entity }
-      end
-    end
-  end
-
-  def destroy
-    @post = Post.find(params[:id])
-    @post.destroy
-
-    respond_to do |format|
-      format.html { redirect_to(posts_url) }
-      format.json  { head :ok }
-    end
-  end
-end
-