ant-mapper 0.0.2

data/lib/ant_support.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/ant_support/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "ant_support/#{filename}"
+end

data/lib/ant_support/callbacks.rb

@@ -0,0 +1,303 @@
+module AntSupport
+  # Callbacks are hooks into the lifecycle of an object that allow you to trigger logic
+  # before or after an alteration of the object state.
+  #
+  # Mixing in this module allows you to define callbacks in your class.
+  #
+  # Example:
+  #   class Storage
+  #     include AntSupport::Callbacks
+  #
+  #     define_callbacks :before_save, :after_save
+  #   end
+  #
+  #   class ConfigStorage < Storage
+  #     before_save :saving_message
+  #     def saving_message
+  #       puts "saving..."
+  #     end
+  #
+  #     after_save do |object|
+  #       puts "saved"
+  #     end
+  #
+  #     def save
+  #       run_callbacks(:before_save)
+  #       puts "- save"
+  #       run_callbacks(:after_save)
+  #     end
+  #   end
+  #
+  #   config = ConfigStorage.new
+  #   config.save
+  #
+  # Output:
+  #   saving...
+  #   - save
+  #   saved
+  #
+  # Callbacks from parent classes are inherited.
+  #
+  # Example:
+  #   class Storage
+  #     include AntSupport::Callbacks
+  #
+  #     define_callbacks :before_save, :after_save
+  #
+  #     before_save :prepare
+  #     def prepare
+  #       puts "preparing save"
+  #     end
+  #   end
+  #
+  #   class ConfigStorage < Storage
+  #     before_save :saving_message
+  #     def saving_message
+  #       puts "saving..."
+  #     end
+  #
+  #     after_save do |object|
+  #       puts "saved"
+  #     end
+  #
+  #     def save
+  #       run_callbacks(:before_save)
+  #       puts "- save"
+  #       run_callbacks(:after_save)
+  #     end
+  #   end
+  #
+  #   config = ConfigStorage.new
+  #   config.save
+  #
+  # Output:
+  #   preparing save
+  #   saving...
+  #   - save
+  #   saved
+  module Callbacks
+    class CallbackChain < Array
+      def self.build(kind, *methods, &block)
+        methods, options = extract_options(*methods, &block)
+        methods.map! { |method| Callback.new(kind, method, options) }
+        new(methods)
+      end
+
+      def run(object, options = {}, &terminator)
+        enumerator = options[:enumerator] || :each
+
+        unless block_given?
+          send(enumerator) { |callback| callback.call(object) }
+        else
+          send(enumerator) do |callback|
+            result = callback.call(object)
+            break result if terminator.call(result, object)
+          end
+        end
+      end
+
+      # TODO: Decompose into more Array like behavior
+      def replace_or_append!(chain)
+        if index = index(chain)
+          self[index] = chain
+        else
+          self << chain
+        end
+        self
+      end
+
+      def find(callback, &block)
+        select { |c| c == callback && (!block_given? || yield(c)) }.first
+      end
+
+      def delete(callback)
+        super(callback.is_a?(Callback) ? callback : find(callback))
+      end
+
+      private
+        def self.extract_options(*methods, &block)
+          methods.flatten!
+          options = methods.extract_options!
+          methods << block if block_given?
+          return methods, options
+        end
+
+        def extract_options(*methods, &block)
+          self.class.extract_options(*methods, &block)
+        end
+    end
+
+    class Callback
+      attr_reader :kind, :method, :identifier, :options
+
+      def initialize(kind, method, options = {})
+        @kind       = kind
+        @method     = method
+        @identifier = options[:identifier]
+        @options    = options
+      end
+
+      def ==(other)
+        case other
+        when Callback
+          (self.identifier && self.identifier == other.identifier) || self.method == other.method
+        else
+          (self.identifier && self.identifier == other) || self.method == other
+        end
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def dup
+        self.class.new(@kind, @method, @options.dup)
+      end
+
+      def hash
+        if @identifier
+          @identifier.hash
+        else
+          @method.hash
+        end
+      end
+
+      def call(*args, &block)
+        evaluate_method(method, *args, &block) if should_run_callback?(*args)
+      rescue LocalJumpError
+        raise ArgumentError,
+          "Cannot yield from a Proc type filter. The Proc must take two " +
+          "arguments and execute #call on the second argument."
+      end
+
+      private
+        def evaluate_method(method, *args, &block)
+          case method
+            when Symbol
+              object = args.shift
+              object.send(method, *args, &block)
+            when String
+              eval(method, args.first.instance_eval { binding })
+            when Proc, Method
+              method.call(*args, &block)
+            else
+              if method.respond_to?(kind)
+                method.send(kind, *args, &block)
+              else
+                raise ArgumentError,
+                  "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                  "a block to be invoked, or an object responding to the callback method."
+              end
+          end
+        end
+
+        def should_run_callback?(*args)
+          if options[:if]
+            evaluate_method(options[:if], *args)
+          elsif options[:unless]
+            !evaluate_method(options[:unless], *args)
+          else
+            true
+          end
+        end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+    	# 定义回调
+    	#
+    	# 例如:
+    	#   callbacks = %w(before_save)
+    	#   base.define_callbacks *callbacks
+    	# 等价于
+    	#   class << base
+    	#     def before_save(*methods,&block)
+    	#       callbacks= CallbackChain.build(:before_save,*methods,&block)
+    	#       (@before_save_callbacks ||= CallbackChain.new).concat callbacks
+    	#     end
+    	#
+    	#     def before_save_callback_chain
+    	#       @before_save_callbacks ||= CallbackChain.new
+    	#       if superclass.respond_to?(:before_save_callback_chain)
+    	#         CallbackChain.new(superclass.before_save_callback_chain+@before_save_callbacks)
+    	#       else
+    	#         @before_save_callbacks
+      #       end
+    	#     end
+    	#   end
+      def define_callbacks(*callbacks)
+        callbacks.each do |callback|
+          class_eval <<-"end_eval"
+            def self.#{callback}(*methods, &block)
+              callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+              (@#{callback}_callbacks ||= CallbackChain.new).concat callbacks
+            end
+
+            def self.#{callback}_callback_chain
+              @#{callback}_callbacks ||= CallbackChain.new
+
+              if superclass.respond_to?(:#{callback}_callback_chain)
+                CallbackChain.new(superclass.#{callback}_callback_chain + @#{callback}_callbacks)
+              else
+                @#{callback}_callbacks
+              end
+            end
+          end_eval
+        end
+      end
+    end
+
+    # Runs all the callbacks defined for the given options.
+    #
+    # If a block is given it will be called after each callback receiving as arguments:
+    #
+    #  * the result from the callback
+    #  * the object which has the callback
+    #
+    # If the result from the block evaluates to false, the callback chain is stopped.
+    #
+    # Example:
+    #   class Storage
+    #     include AntSupport::Callbacks
+    #
+    #     define_callbacks :before_save, :after_save
+    #   end
+    #
+    #   class ConfigStorage < Storage
+    #     before_save :pass
+    #     before_save :pass
+    #     before_save :stop
+    #     before_save :pass
+    #
+    #     def pass
+    #       puts "pass"
+    #     end
+    #
+    #     def stop
+    #       puts "stop"
+    #       return false
+    #     end
+    #
+    #     def save
+    #       result = run_callbacks(:before_save) { |result, object| result == false }
+    #       puts "- save" if result
+    #     end
+    #   end
+    #
+    #   config = ConfigStorage.new
+    #   config.save
+    #
+    # Output:
+    #   pass
+    #   pass
+    #   stop
+    def run_callbacks(kind, options = {}, &block)
+      # self.class.send("#{kind}_callback_chain")
+      #
+      self.class.send("#{kind}_callback_chain").run(self, options, &block)
+    end
+  end
+end

data/lib/ant_support/core_ext.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "ant_support/core_ext/#{filename}"
+end

data/lib/ant_support/core_ext/array.rb

@@ -0,0 +1,5 @@
+require 'ant_support/core_ext/array/extract_options'
+
+class Array #:nodoc:
+  include AntSupport::CoreExtensions::Array::ExtractOptions
+end

data/lib/ant_support/core_ext/array/extract_options.rb

@@ -0,0 +1,20 @@
+module AntSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module ExtractOptions
+        # Extracts options from a set of arguments. Removes and returns the last
+        # element in the array if it's a hash, otherwise returns a blank hash.
+        #
+        #   def options(*args)
+        #     args.extract_options!
+        #   end
+        #
+        #   options(1, 2)           # => {}
+        #   options(1, 2, :a => :b) # => {:a=>:b}
+        def extract_options!
+          last.is_a?(::Hash) ? pop : {}
+        end
+      end
+    end
+  end
+end

data/lib/ant_support/core_ext/blank.rb

@@ -0,0 +1,58 @@
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # to
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+    
+  # An object is present if it's not blank.
+  def present?
+    !blank?
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/ant_support/core_ext/class.rb

@@ -0,0 +1,3 @@
+require 'ant_support/core_ext/class/attribute_accessors'
+require 'ant_support/core_ext/class/inheritable_attributes'
+require 'ant_support/core_ext/class/removal'

data/lib/ant_support/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,54 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+#
+#  class Person
+#    cattr_accessor :hair_colors
+#  end
+#
+#  Person.hair_colors = [:brown, :black, :blonde, :red]
+class Class
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end