ruby_ext 0.5.10 → 4.0.0

data/Rakefile

@@ -7,6 +7,7 @@ project \
   name: "ruby_ext",
   gem: true,
   summary: "Ruby Extensions",
+  version: '4.0.0',
 
   author: "Alexey Petrushin",
   homepage: "http://github.com/alexeypetrushin/ruby_ext"

data/lib/ruby_ext/core.rb

@@ -11,7 +11,6 @@ raise 'ruby 1.9.2 or higher required!' if RUBY_VERSION < '1.9.2'
   not_defined
   string
   symbol
-  must
   deep_clone
   time
   multiple_inheritance

data/lib/ruby_ext/core/basic_object.rb

@@ -1,5 +1,5 @@
 BasicObject.class_eval do
-  protected :==, :equal?, :!, :!=
+  protected :==, :equal?, :!, :!=, :instance_eval, :instance_exec
 
   protected
     def raise *args

data/lib/ruby_ext/core/hash.rb

@@ -29,12 +29,12 @@ Hash.class_eval do
 
   # Haml relies on :inspect default format and it brokes haml, but I prefer new hash notation,
   # disable it if You use Haml.
-  unless $dont_extend_hash_inspect
-    def inspect
-      "{" + collect{|k, v| "#{k}: #{v}"}.join(', ') + "}"
-    end
-    alias_method :to_s, :inspect
-  end
+  # unless $dont_extend_hash_inspect
+  #   def inspect
+  #     "{" + collect{|k, v| "#{k}: #{v}"}.join(', ') + "}"
+  #   end
+  #   alias_method :to_s, :inspect
+  # end
 
   alias_method :blank?, :empty?
 

data/lib/ruby_ext/core/module.rb

@@ -1,8 +1,8 @@
 Module.class_eval do
   def alias name = nil
     if name
-      name.must_be.a String
-      name.must_not_be.blank
+      name.must.be_a String
+      name.must.be_present
       @alias = name.to_s
     else
       @alias ||= self.name.split('::').last
@@ -36,6 +36,14 @@ Module.class_eval do
     @namespace_for_cache[class_name]
   end
 
+  def metaclass
+    class << self; self end
+  end
+
+  def metaclass_eval &block
+    metaclass.class_eval &block
+  end
+
   def inheritable_accessor attribute_name, default_value
     raise "Can be used only for Class and Module" unless self.class.is? Module
 

data/lib/ruby_ext/core/string.rb

@@ -39,14 +39,8 @@ class String
   end
 
   def constantize
-    names = self.split('::')
-    names.shift if names.empty? || names.first.empty?
-
-    constant = Object
-    names.each do |name|
-      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-    end
-    constant
+    names = sub(/^::/, '').split '::'
+    names.reduce(Object){|memo, name| memo.const_get name, false}
   end
 
   def substitute(*args)

data/lib/ruby_ext/more.rb

@@ -1,9 +1,13 @@
 require 'ruby_ext/core'
 
+require 'ruby_ext/more/must'
+
 require 'set'
 
+# Lazy loading.
+autoload :UserError, 'ruby_ext/more/user_error'
 module RubyExt
-  %w(Callbacks DeclarativeCache Observable OpenConstructor Tuple).each do |const|
+  %w(Callbacks CallbacksProxy DeclarativeCache Observable OpenConstructor Tuple).each do |const|
     autoload const, "ruby_ext/more/#{const.underscore}"
   end
 end

data/lib/ruby_ext/more/callbacks.rb

@@ -2,7 +2,7 @@ module RubyExt::Callbacks
   class AbstractCallback
     attr_reader :executor
     def executor= executor
-      @executor = executor.must_be.a Symbol, Proc
+      @executor = executor.must.be_a Symbol, Proc
     end
 
     attr_reader :conditions
@@ -21,15 +21,15 @@ module RubyExt::Callbacks
       @conditions
     end
 
-    def run? target, data
+    def run? target, method, data
       if cond = conditions[:if]
         evaluate_if(cond, target, data)
       elsif cond = conditions[:unless]
         !evaluate_if(cond, target, data)
       elsif cond = conditions[:only]
-        evaluate_only(cond, data)
+        evaluate_only(cond, method, data)
       elsif cond = conditions[:except]
-        !evaluate_only(cond, data)
+        !evaluate_only(cond, method, data)
       else
         true
       end
@@ -44,19 +44,18 @@ module RubyExt::Callbacks
         elsif cond.is_a? Proc
           cond.call target, data
         else
-          must_be.never_called
+          must.be_never_called
         end
       end
 
-      def evaluate_only cond, data
-        method = data[:method]
-        method.must_be.a Symbol if method
+      def evaluate_only cond, method, data
+        method.must.be_a Symbol if method
         if cond.is_a? Symbol
           cond == method
         elsif cond.is_a? Array
           cond.include? method
         else
-          must_be.never_called
+          must.be_never_called
         end
       end
   end
@@ -64,9 +63,9 @@ module RubyExt::Callbacks
   class BeforeCallback < AbstractCallback
     attr_accessor :terminator
 
-    def build_block target, data, &block
+    def build_block target, method, data, &block
       -> do
-        if run? target, data
+        if run? target, method, data
           block.call if run target, data
         else
           block.call
@@ -80,7 +79,7 @@ module RubyExt::Callbacks
       elsif executor.is_a? Proc
         executor.call target
       else
-        must_be.never_called
+        must.be_never_called
       end
 
       !terminate?(target, callback_result)
@@ -101,9 +100,9 @@ module RubyExt::Callbacks
   end
 
   class AfterCallback < AbstractCallback
-    def build_block target, data, &block
+    def build_block target, method, data, &block
       -> do
-        if run? target, data
+        if run? target, method, data
           result = block.call
           run target, data
           result
@@ -119,15 +118,15 @@ module RubyExt::Callbacks
       elsif executor.is_a? Proc
         executor.call target
       else
-        must_be.never_called
+        must.be_never_called
       end
     end
   end
 
   class AroundCallback < AbstractCallback
-    def build_block target, data, &block
+    def build_block target, method, data, &block
       -> do
-        if run? target, data
+        if run? target, method, data
           run target, data, &block
         else
           block.call
@@ -141,62 +140,67 @@ module RubyExt::Callbacks
       elsif executor.is_a? Proc
         executor.call target, block
       else
-        must_be.never_called
+        must.be_never_called
       end
     end
   end
 
-  def run_before_callbacks callback_name, data = {}
-    callback_name.must_be.a Symbol
-    self.class.callbacks[callback_name].try :each do |callback|
-      if callback.is_a? BeforeCallback
-        return false unless callback.run self, data
+  def run_before_callbacks name, method, data = {}
+    name.must.be_a Symbol
+    self.class.callbacks[name].try :each do |callback|
+      if callback.is_a?(BeforeCallback) and callback.run?(self, method, data)
+        return false unless callback.run(self, data)
       end
     end
     true
   end
 
-  def run_after_callbacks callback_name, data = {}
-    callback_name.must_be.a Symbol
-    self.class.callbacks[callback_name].try :each do |callback|
-      callback.run self, data if callback.is_a? AfterCallback
+  def run_after_callbacks name, method, data = {}
+    name.must.be_a Symbol
+    self.class.callbacks[name].try :each do |callback|
+      if callback.is_a?(AfterCallback) and callback.run?(self, method, data)
+        callback.run(self, data)
+      end
     end
   end
 
-  def run_callbacks callback_name, data = {}, &block
-    callback_name.must_be.a Symbol
-    if callbacks = self.class.callbacks[callback_name]
-      chain = block || -> {}
-      chain = callbacks.reverse.reduce chain do |chain, callback|
-        callback.build_block self, data, &chain
+  def run_callbacks name, method, data = {}, &block
+    name.must.be_a Symbol
+    run_callbacks_once name, method, block do
+      if callbacks = self.class.callbacks[name]
+        chain = block || -> {}
+        chain = callbacks.reverse.reduce chain do |chain, callback|
+          callback.build_block self, method, data, &chain
+        end
+        chain.call
+      else
+        block.call if block
       end
-      chain.call
-    else
-      block.call if block
     end
   end
 
-  # We need to prevent callback from rinning multiple times if nested
-  # (need this for wrapping methods with callbacks to correctly call super).
-  def run_callbacks_only_once callback_name, data = {}, &block
-    set = Thread.current[callback_name] ||= {}
-    if set.include? object_id
-      block.call if block
+  # We need to prevent callback from rinning multiple times if nested.
+  def run_callbacks_once name, method, block_without_callbacks, &block
+    set = Thread.current[:callbacks] ||= {}
+    id = "#{object_id}/#{name}/#{method}"
+    if set.include? id
+      block_without_callbacks.call if block_without_callbacks
     else
       begin
-        set[object_id] = true
-        run_callbacks callback_name, data, &block
+        set[id] = true
+        block.call
       ensure
-        set.delete object_id
+        set.delete id
       end
     end
   end
+  protected :run_callbacks_once
 
   module ClassMethods
     inheritable_accessor :callbacks, {}
 
-    def set_callback callback_name, type, *executor_or_options, &block
-      callback_name.must_be.a Symbol
+    def set_callback name, type, *executor_or_options, &block
+      name.must.be_a Symbol
       type = type.to_sym
 
       # Parsing arguments.
@@ -204,8 +208,8 @@ module RubyExt::Callbacks
       "You can't provide both method name and block for filter!" if block and !executor_or_options.empty?
       executor = block || executor_or_options.first
 
-      type.must_be.in [:before, :around, :after]
-      executor.must_be.defined
+      type.must.be_in [:before, :around, :after]
+      executor.must.be_defined
 
       # Creating callback.
       callback = AbstractCallback.new
@@ -219,7 +223,7 @@ module RubyExt::Callbacks
       callback.terminator = opt.delete :terminator if type == :before
       callback.conditions = opt
 
-      (self.callbacks[callback_name] ||= []) << callback
+      (self.callbacks[name] ||= []) << callback
     end
 
     def wrap_method_with_callbacks method, callback
@@ -232,7 +236,7 @@ module RubyExt::Callbacks
       define_method method do |*args, &block|
         # We can't use run_callbacks, because in case of the `super`
         # call it will be runned twice.
-        run_callbacks_only_once callback do
+        run_callbacks callback, method do
           send method_without_callback, *args, &block
         end
       end

data/lib/ruby_ext/more/callbacks_proxy.rb

@@ -0,0 +1,18 @@
+class RubyExt::CallbacksProxy < BasicObject
+  attr_reader :object
+
+  def initialize object, callback_name
+    @object, @callback_name = object, callback_name
+  end
+
+  def callback_proxy?
+    true
+  end
+
+  protected
+    def method_missing m, *args, &block
+      object.run_callbacks @callback_name, m do
+        object.public_send m, *args, &block
+      end
+    end
+end

data/lib/ruby_ext/more/must.rb

@@ -0,0 +1,139 @@
+Object.class_eval do
+  def must
+    ::Must::PositiveExpectation.new self
+  end
+
+  def must_not
+    ::Must::NegativeExpectation.new self
+  end
+end
+
+class AssertionError < RuntimeError; end
+
+module Must
+  class Expectation < BasicObject
+    def initialize object
+      @object = object
+    end
+
+    def to_s; inspect end
+
+    # Special case, shortcut to write `a.must.be b` instead of `a.must.be_equal_to b`.
+    def be *args
+      if args.size == 1
+        be_equal_to args.first
+      elsif args.empty?
+        self
+      else
+        raise ArgumentError, "invalid usage!"
+      end
+    end
+
+    protected
+      attr_reader :object
+
+      def method_missing method, *args, &block
+        original_method = method
+        method, prefix, human_method = if method =~ /^be_/
+          [:"#{method.to_s[3..-1]}?", :be, :"#{method.to_s[3..-1]}"]
+        elsif method =~ /^have_/
+          [:"#{method.to_s[5..-1]}?", :have, :"#{method.to_s[5..-1]}"]
+        elsif method =~ /^[a-z_0-9]+$/
+          [:"#{method}?", nil, method]
+        else
+          [method, nil, method]
+        end
+        special_method = :"_#{method}"
+
+        # Defining method, to make it faster for future calls.
+        instance_methods = ::Must::Expectation.instance_methods false
+        if instance_methods.include? special_method
+          define_special_method original_method, special_method, human_method, prefix
+        else
+          define_method original_method, method, human_method, prefix
+        end
+
+        __send__ original_method, *args, &block
+      end
+
+      # Special expectations.
+
+      def _never_called?; false end
+      def _nil?; object.equal? nil end
+      def _defined?; !_nil? end
+      def _equal_to? o; object == o end
+      def _true?; !!object end
+      def _false?; !object end
+      def _a? *args; args.any?{|klass| object.is_a?(klass)} end
+      # def _include o; object.include? o end
+      # def _respond_to o; object.respond_to? o end
+      alias_method :_an?, :_a?
+
+      def _in? *args;
+        list = (args.size == 1 and args.first.respond_to?(:include?)) ? args.first : args
+        list.include? object
+      end
+
+      def p *args; ::Kernel.send :p, *args end
+
+      def fail_expectation positive, human_method, prefix, *args, &block
+        stack = ::Object.send(:caller).sfilter '/must.rb'
+
+        msg =  "    ASSERTION FAILED (#{stack.first}):\n"
+        msg << "    #{object.inspect[0..100]} must"
+        msg << " not" unless positive
+        msg << " #{prefix}" if prefix
+        msg << " #{human_method}"
+        msg << " #{args.collect(&:inspect).join(', ')}" unless args.empty?
+        msg << " &..." if block
+
+        ::Object.send :raise, ::AssertionError, msg, stack
+      end
+  end
+
+  class PositiveExpectation < Expectation
+    def inspect; "<#Must::PositiveExpectation #{object.inspect}>" end
+
+    protected
+      def define_special_method original_method, special_method, human_method, prefix
+        ::Must::PositiveExpectation.define_method original_method do |*args, &block|
+          unless self.__send__ special_method, *args, &block
+            fail_expectation true, human_method, prefix, *args, &block
+          end
+          object
+        end
+      end
+
+      def define_method original_method, method, human_method, prefix
+        ::Must::PositiveExpectation.define_method original_method do |*args, &block|
+          unless object.send method, *args, &block
+            fail_expectation true, human_method, prefix, *args, &block
+          end
+          object
+        end
+      end
+  end
+
+  class NegativeExpectation < Expectation
+    def inspect; "<#Must::NegativeExpectation #{object.inspect}>" end
+
+    protected
+      def define_special_method original_method, special_method, human_method, prefix
+        ::Must::NegativeExpectation.define_method original_method do |*args, &block|
+          if self.__send__ special_method, *args, &block
+            fail_expectation false, human_method, prefix, *args, &block
+          end
+          object
+        end
+      end
+
+      def define_method original_method, method, human_method, prefix
+        ::Must::NegativeExpectation.define_method original_method do |*args, &block|
+          if object.send method, *args, &block
+            fail_expectation false, human_method, prefix, *args, &block
+          end
+          object
+        end
+      end
+  end
+end

data/lib/ruby_ext/more/user_error.rb

@@ -0,0 +1,2 @@
+class UserError < StandardError
+end

data/readme.md

@@ -2,17 +2,24 @@ Collection of various utility classes and standard library extensions for Ruby l
 
 ## must - assertion tool, kind of RSpec assertions in runtime code
 
+Expectations are generated dynamically, so it will be also available and have the same form 
+for any of Your custom methods.
+
+It also doesn't pollute core Ruby classes very much, there are only 2 methods `must`, `must_not` added to
+the `Object` class.
+
 ``` ruby
-1.must_be.in 1..2
-"a".must_be.in 'a', 'b', 'c'
-key.must_be.a String
-value.must_not_be.nil
-must_be.never_called
-a.must_be == b
+1.must.be_in 1..2
+'a'.must.be_in 'a', 'b', 'c'
+'a'.must.be_a String
+'value'.must_not.be_nil
+2.must.be > 1
+[].must.be_empty
+[1, 2, 3].must_not.have_any{|v| v == 4}
 ```
 
-## inherit - combines include & extend in one
-Do you remember this *def self.included(base) ... end* hack? You don't need it anymore.
+## inherit - multiple inheritance in Ruby
+Do you remember this `def self.included(base) ... end` You don't need it anymore.
 
 ``` ruby
 module Feature
@@ -52,9 +59,9 @@ o.a => 'a'
 o.to_hash => {a: 'a', b: 'b'}
 ```
 
-## More
+## Callbacks
 
-These are just a small part of all handy methods and extensions, for more details please go to specs.
+[TODO add desctiption]
 
 # Usage
 

data/spec/more/callbacks_spec.rb

@@ -1,37 +1,53 @@
 require 'spec_helper'
 
 describe "Callbacks" do
-  before do
-    class ABase
-      inherit RubyExt::Callbacks
+  after{remove_constants :SomeClass, :AnotherClass}
 
-      set_callback :save, :before, :before_save
-      set_callback :save, :around, :around_save
-      set_callback :save, :after, :after_save
+  describe 'basic' do
+    before do
+      class SomeClass
+        inherit RubyExt::Callbacks
 
-      protected
-        def around_save
-          around_save_called
-          yield
-        end
+        set_callback :save, :before, :before_save
+        set_callback :save, :around, :around_save
+        set_callback :save, :after, :after_save
+
+        protected
+          def around_save
+            around_save_called
+            yield
+          end
+      end
     end
-  end
-  after{remove_constants :ABase, :SomeClass, :AnotherClass}
 
-  it "basic" do
-    o = ABase.new
-    o.should_receive :before_save
-    o.should_receive :around_save_called
-    o.should_receive :after_save
-    o.run_callbacks(:save){"result"}.should == "result"
-  end
+    it "basic" do
+      o = SomeClass.new
+      o.should_receive :before_save
+      o.should_receive :around_save_called
+      o.should_receive :after_save
+      o.run_callbacks(:save, :some_method){"result"}.should == "result"
+    end
 
-  it "should be possible to call before & after separatelly (in this mode :around is not available)" do
-    o = ABase.new
-    o.should_receive :before_save
-    o.run_before_callbacks(:save)
-    o.should_receive :after_save
-    o.run_after_callbacks(:save)
+    it "should be possible to call before & after separatelly (in this mode :around is not available)" do
+      o = SomeClass.new
+      o.should_receive :before_save
+      o.run_before_callbacks :save, :some_method
+      o.should_receive :after_save
+      o.run_after_callbacks :save, :some_method
+    end
+
+    it "inheritance" do
+      class AnotherClass < SomeClass
+        set_callback :save, :before, :before_save2
+      end
+
+      o = AnotherClass.new
+      o.should_receive :before_save
+      o.should_receive :before_save2
+      o.should_receive :around_save_called
+      o.should_receive :after_save
+      o.run_callbacks(:save, :some_method){"result"}.should == "result"
+    end
   end
 
   it "blocks" do
@@ -55,7 +71,7 @@ describe "Callbacks" do
     end
 
     o = SomeClass.new
-    o.run_callbacks(:save){"result"}.should == "result"
+    o.run_callbacks(:save, :some_method){"result"}.should == "result"
     o.result.should == [:before, :around_begin, :after, :around_end]
   end
 
@@ -81,20 +97,7 @@ describe "Callbacks" do
     o.should_receive(:around1_called).ordered.once
     o.should_receive(:before2).ordered.once
     o.should_receive(:after1).ordered.once
-    o.run_callbacks :save
-  end
-
-  it "inheritance" do
-    class SomeClass < ABase
-      set_callback :save, :before, :before_save2
-    end
-
-    o = SomeClass.new
-    o.should_receive :before_save
-    o.should_receive :before_save2
-    o.should_receive :around_save_called
-    o.should_receive :after_save
-    o.run_callbacks(:save){"result"}.should == "result"
+    o.run_callbacks :save, :some_method
   end
 
   it 'terminator' do
@@ -105,7 +108,7 @@ describe "Callbacks" do
       set_callback :save, :before, :before_save2
 
       def method
-        run_callbacks :save do
+        run_callbacks :save, :some_method do
           "result"
         end
       end
@@ -118,7 +121,7 @@ describe "Callbacks" do
 
     o = SomeClass.new
     o.should_not_receive :before_save2
-    o.run_callbacks(:save){"result"}.should_not == "result"
+    o.run_callbacks(:save, :some_method){"result"}.should_not == "result"
   end
 
   it 'conditions' do
@@ -130,44 +133,44 @@ describe "Callbacks" do
 
     o = SomeClass.new
     o.should_not_receive :before_save
-    o.run_callbacks(:save, method: :method){"result"}.should == 'result'
+    o.run_callbacks(:save, :some_method){"result"}.should == 'result'
 
     o = SomeClass.new
     o.should_receive :before_save
-    o.run_callbacks(:save, method: :another_method){"result"}.should == 'result'
+    o.run_callbacks(:save, :another_method){"result"}.should == 'result'
   end
 
   it "if, unless conditions" do
     c = RubyExt::Callbacks::AbstractCallback.new
     c.conditions = {if: lambda{|target, inf| true}}
-    c.run?(nil, {}).should be_true
+    c.run?(nil, :some_method, {}).should be_true
 
     c.conditions = {if: lambda{|target, inf| false}}
-    c.run?(nil, {}).should be_false
+    c.run?(nil, :some_method, {}).should be_false
 
     c.conditions = {unless: lambda{|target, inf| true}}
-    c.run?(nil, {}).should be_false
+    c.run?(nil, :some_method, {}).should be_false
 
     c.conditions = {unless: lambda{|target, inf| false}}
-    c.run?(nil, {}).should be_true
+    c.run?(nil, :some_method, {}).should be_true
   end
 
   it "only, except conditions" do
     c = RubyExt::Callbacks::AbstractCallback.new
     c.conditions = {only: :a}
-    c.run?(nil, {method: :a}).should be_true
+    c.run?(nil, :a, {}).should be_true
 
     c.conditions = {only: :b}
-    c.run?(nil, {method: :a}).should be_false
+    c.run?(nil, :a, {}).should be_false
 
     c.conditions = {except: :a}
-    c.run?(nil, {method: :a}).should be_false
+    c.run?(nil, :a, {}).should be_false
 
     c.conditions = {except: :b}
-    c.run?(nil, {method: :a}).should be_true
+    c.run?(nil, :a, {}).should be_true
 
     c.conditions = {only: :a}
-    c.run?(nil, {method: :a}).should be_true
+    c.run?(nil, :a, {}).should be_true
   end
 
 
@@ -184,7 +187,7 @@ describe "Callbacks" do
     end
 
     o = SomeClass.new
-    o.run_callbacks(:save){"result"}.should == 'another result'
+    o.run_callbacks(:save, :some_method){"result"}.should == 'another result'
   end
 
   describe "wrapping methods in callbacks" do
@@ -241,7 +244,7 @@ describe "Callbacks" do
       o.update.should == 'ok2'
     end
 
-    it "run_callbacks_only_once" do
+    it "callbacks should be runned only once" do
       class SomeClass
         inherit RubyExt::Callbacks
 
@@ -250,8 +253,8 @@ describe "Callbacks" do
 
       o = SomeClass.new
       o.should_receive(:before_save).once
-      (o.run_callbacks_only_once :save do
-        o.run_callbacks_only_once :save do
+      (o.run_callbacks :save, :some_method do
+        o.run_callbacks :save, :some_method do
           'result'
         end
       end).should == 'result'

data/spec/more/must_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe 'Assert' do
+  it 'misc' do
+    -> {must.be_never_called}.should raise_error(/must be never_called/)
+    -> {nil.must_not.be_nil}.should raise_error(/must not be nil/)
+    1.must_not.be_nil
+
+    1.must.be_in 1, 2
+    1.must.be_in [1, 2]
+    0.must.be_in 0..1
+
+    "".must.be_a String
+    "".must.be_a String, Symbol
+
+    2.must > 1
+    2.must.be > 1
+
+    1.must.be_defined
+    -> {nil.must.be_defined}.should raise_error(/must be defined/)
+
+    [1, 2].must.include 1
+  end
+
+  it "equality" do
+    1.must.be_equal_to 1
+    -> {1.must.be_equal_to 2}.should raise_error(/1 must be equal_to 2/)
+    1.must.be 1
+    -> {1.must.be 2}.should raise_error(/1 must be equal_to 2/)
+  end
+
+  it 'must & must_not' do
+    [].must.be_empty
+    [''].must_not.be_empty
+
+    -> {[''].must.be_empty}.should raise_error(/must be/)
+    -> {[].must_not.be_empty}.should raise_error(/must not be/)
+  end
+
+  it "should return result" do
+    [].must.be_empty.should == []
+  end
+
+  it "have", focus: true do
+    [1, 2, 3].must_not.have_any{|v| v == 4}
+    -> {[1, 2, 3].must_not.have_any{|v| v == 2}}.should raise_error(/[1, 2, 3] must not have any/)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_ext
 version: !ruby/object:Gem::Version
-  version: 0.5.10
+  version: 4.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-30 00:00:00.000000000Z
+date: 2011-11-01 00:00:00.000000000Z
 dependencies: []
 description: 
 email: 
@@ -31,7 +31,6 @@ files:
 - lib/ruby_ext/core/hash.rb
 - lib/ruby_ext/core/module.rb
 - lib/ruby_ext/core/multiple_inheritance.rb
-- lib/ruby_ext/core/must.rb
 - lib/ruby_ext/core/nil_class.rb
 - lib/ruby_ext/core/not_defined.rb
 - lib/ruby_ext/core/object.rb
@@ -42,10 +41,13 @@ files:
 - lib/ruby_ext/core/true_class.rb
 - lib/ruby_ext/core.rb
 - lib/ruby_ext/more/callbacks.rb
+- lib/ruby_ext/more/callbacks_proxy.rb
 - lib/ruby_ext/more/declarative_cache.rb
+- lib/ruby_ext/more/must.rb
 - lib/ruby_ext/more/observable.rb
 - lib/ruby_ext/more/open_constructor.rb
 - lib/ruby_ext/more/tuple.rb
+- lib/ruby_ext/more/user_error.rb
 - lib/ruby_ext/more.rb
 - lib/ruby_ext.rb
 - lib/yaml_fix.rb
@@ -54,11 +56,11 @@ files:
 - spec/core/enumerable.rb
 - spec/core/module_spec.rb
 - spec/core/multiple_inheritance_spec.rb
-- spec/core/must_spec.rb
 - spec/core/object_spec.rb
 - spec/core/open_object_spec.rb
 - spec/more/callbacks_spec.rb
 - spec/more/declarative_cache_spec.rb
+- spec/more/must_spec.rb
 - spec/more/observable_spec.rb
 - spec/more/open_constructor_spec.rb
 - spec/spec_helper.rb

data/lib/ruby_ext/core/must.rb

@@ -1,179 +0,0 @@
-class AssertionError < RuntimeError; end
-
-class MustAssertions < BasicObject
-  attr_reader :obj
-
-  def initialize obj
-    @obj = obj
-  end
-
-  def == o
-    @obj == o
-  end
-
-  def =~ o
-    @obj =~ o
-  end
-
-  def never_called
-    false
-  end
-
-  def nil
-    @obj.equal? nil
-  end
-
-  def defined
-    @obj != nil
-  end
-
-  def respond_to method
-    @obj.respond_to? method
-  end
-
-  def a *args
-    if args.class == ::Array
-      args.any?{|k| @obj.is_a? k}
-    else
-      @obj.is_a? args
-    end
-  end
-  alias_method :an, :a
-
-  def include o
-    @obj.include? o
-  end
-
-  def in *args
-    if args.size == 1
-      obj = args.first
-      if obj.is_a?(::Array) or obj.is_a?(::Range)
-        obj.include? @obj
-      else
-        args.include? @obj
-      end
-    else
-      args.include? @obj
-    end
-  end
-
-  def true
-    !!@obj
-  end
-
-  def false
-    !@obj
-  end
-
-  def empty
-    @obj.empty?
-  end
-
-  def blank
-    @obj.blank?
-  end
-
-  def present
-    !@obj.blank?
-  end
-
-  def > o
-    @obj > o
-  end
-
-  def < o
-    @obj < o
-  end
-
-  def >= o
-    @obj >= o
-  end
-
-  def <= o
-    @obj <= o
-  end
-
-  def exist *args
-    @obj.exist? *args
-  end
-
-  def be
-    @prefix = 'be'
-    self
-  end
-
-  def have
-    @prefix = 'have'
-    self
-  end
-
-  def self.assertions
-    special = [:be, :have]
-    public_instance_methods.select{|m| m !~ /^__/ and !special.include?(m)}
-  end
-
-  protected
-    # def method_missing m, *args, &b
-    #   raise ::RuntimeError, "Assertion '#{m}' is unknown!", caller[1..-1]
-    # end
-
-    def failed method, negative, *args
-      stack = ::Object.send(:caller).sfilter('must.rb')
-
-      unless args.empty?
-        ::Object.send :raise, ::AssertionError, "
-  ASSERTION FAILED (#{stack.first}):
-  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method} #{args.collect{|a| a.inspect}.join(', ')}
-        ", stack
-      else
-        ::Object.send :raise, ::AssertionError, "
-  ASSERTION FAILED (#{stack.first}):
-  #{@obj.inspect} must #{'not ' if negative}#{"#{@prefix} " if @prefix}#{method}
-        ", stack
-      end
-    end
-end
-
-class Must < MustAssertions
-  assertions.each do |m|
-    desition = "_#{m}"
-    alias_method desition, m
-    define_method m do |*args|
-      failed m, false, *args unless __send__(desition, *args)
-      @obj
-    end
-  end
-
-  def inspect
-    "<#Must>"
-  end
-end
-
-class MustNot < MustAssertions
-  assertions.each do |m|
-    desition = "_#{m}".to_sym
-    alias_method desition, m
-    define_method m do |*args|
-      failed m, true, *args if __send__(desition, *args)
-      @obj
-    end
-  end
-end
-
-Object.class_eval do
-  def must
-    Must.new(self)
-  end
-
-  def must_not
-    MustNot.new(self)
-  end
-
-  def must_be
-    must.be
-  end
-
-  def must_not_be
-    must_not.be
-  end
-end

data/spec/core/must_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-describe 'Assert' do
-  it 'must & must_not' do
-    -> {must_be.never_called}.should raise_error(/ever/)
-    -> {nil.must_not_be.nil}.should raise_error(/nil/)
-    1.must_not_be.nil
-    1.must_be.== 1
-    -> {1.must_be.== 2}.should raise_error(%r{==})
-    1.must_be.in 1, 2
-    1.must_be.in [1, 2]
-    0.must_be.in 0..1
-    "".must_be.a String
-    "".must_be.a String, Symbol
-    1.must_be.< 2
-
-    1.must_be.defined
-    -> {nil.must_be.defined}.should raise_error(/must be defined/)
-  end
-
-  it 'must_be & must_not_be' do
-    [].must_be.empty
-    [''].must_not_be.empty
-
-    -> {[''].must_be.empty}.should raise_error(/must be/)
-    -> {[].must_not_be.empty}.should raise_error(/must not be/)
-  end
-
-  it "should return result" do
-    [].must_be.empty.should == []
-  end
-end