RubyGems - bitclust-core - Versions diffs - 0.5.3 → 0.5.4 - Mend

bitclust-core 0.5.3 → 0.5.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3171) hide show

data/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.3/vendor/bundle/ruby/1.9.1/gems/bitclust-core-0.5.1/vendor/bundle/ruby/1.9.1/gems/rr-1.0.4/lib/rr/double_definitions/child_double_definition_create.rb DELETED Viewed

@@ -1,27 +0,0 @@
-module RR
-  module DoubleDefinitions
-    class ChildDoubleDefinitionCreate < DoubleDefinitionCreate # :nodoc
-      attr_reader :parent_double_definition
-      def initialize(parent_double_definition)
-        @parent_double_definition = parent_double_definition
-        super()
-      end
-      def root_subject
-        parent_double_definition.root_subject
-      end
-      def instance_of(*args)
-        raise NoMethodError
-      end
-      protected
-      def add_strategy(subject, method_name, definition_eval_block, &block)
-        super do
-          block.call
-          parent_double_definition.implemented_by(lambda {|*args|subject})
-        end
-      end
-    end
-  end
-end

@@ -1,365 +0,0 @@
-module RR
-  module DoubleDefinitions
-    class DoubleDefinition #:nodoc:
-      ORIGINAL_METHOD = Object.new
-      attr_accessor(
-        :argument_expectation,
-        :times_matcher,
-        :implementation,
-        :after_call_proc,
-        :yields_value,
-        :double,
-        :double_definition_create
-      )
-      include Space::Reader
-      def initialize(double_definition_create)
-        @implementation = nil
-        @argument_expectation = nil
-        @times_matcher = nil
-        @after_call_proc = nil
-        @yields_value = nil
-        @double_definition_create = double_definition_create
-        @ordered = false
-        @verbose = false
-        @verify_method_signature = false
-      end
-      def subject
-        double_definition_create.subject
-      end
-      def root_subject
-        double_definition_create.root_subject
-      end
-      module ArgumentDefinitionConstructionMethods
-        # Double#with sets the expectation that the Double will receive
-        # the passed in arguments.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.with(1, 2) {:return_value}
-        def with(*args, &return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new(*args)
-          install_method_callback return_value_block
-          self
-        end
-        # Double#with_any_args sets the expectation that the Double can receive
-        # any arguments.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.with_any_args {:return_value}
-        def with_any_args(&return_value_block)
-          @argument_expectation = Expectations::AnyArgumentExpectation.new
-          install_method_callback return_value_block
-          self
-        end
-        # Double#with_no_args sets the expectation that the Double will receive
-        # no arguments.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.with_no_args {:return_value}
-        def with_no_args(&return_value_block)
-          @argument_expectation = Expectations::ArgumentEqualityExpectation.new()
-          install_method_callback return_value_block
-          self
-        end
-      end
-      include ArgumentDefinitionConstructionMethods
-      module TimesDefinitionConstructionMethods
-        # Double#never sets the expectation that the Double will never be
-        # called.
-        #
-        # This method does not accept a block because it will never be called.
-        #
-        #   mock(subject).method_name.never
-        def never
-          @times_matcher = TimesCalledMatchers::NeverMatcher.new
-          self
-        end
-        # Double#once sets the expectation that the Double will be called
-        # 1 time.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.once {:return_value}
-        def once(&return_value_block)
-          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(1)
-          install_method_callback return_value_block
-          self
-        end
-        # Double#twice sets the expectation that the Double will be called
-        # 2 times.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.twice {:return_value}
-        def twice(&return_value_block)
-          @times_matcher = TimesCalledMatchers::IntegerMatcher.new(2)
-          install_method_callback return_value_block
-          self
-        end
-        # Double#at_least sets the expectation that the Double
-        # will be called at least n times.
-        # It works by creating a TimesCalledExpectation.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.at_least(4) {:return_value}
-        def at_least(number, &return_value_block)
-          @times_matcher = TimesCalledMatchers::AtLeastMatcher.new(number)
-          install_method_callback return_value_block
-          self
-        end
-        # Double#at_most allows sets the expectation that the Double
-        # will be called at most n times.
-        # It works by creating a TimesCalledExpectation.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.at_most(4) {:return_value}
-        def at_most(number, &return_value_block)
-          @times_matcher = TimesCalledMatchers::AtMostMatcher.new(number)
-          install_method_callback return_value_block
-          self
-        end
-        # Double#any_number_of_times sets an that the Double will be called
-        # any number of times. This effectively removes the times called expectation
-        # from the Doublen
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.any_number_of_times
-        def any_number_of_times(&return_value_block)
-          @times_matcher = TimesCalledMatchers::AnyTimesMatcher.new
-          install_method_callback return_value_block
-          self
-        end
-        alias_method :any_times, :any_number_of_times
-        # Double#times creates an TimesCalledExpectation of the passed
-        # in number.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.times(4) {:return_value}
-        def times(matcher_value, &return_value_block)
-          @times_matcher = TimesCalledMatchers::TimesCalledMatcher.create(matcher_value)
-          install_method_callback return_value_block
-          self
-        end
-      end
-      include TimesDefinitionConstructionMethods
-      module DefinitionConstructionMethods
-        # Double#ordered sets the Double to have an ordered
-        # expectation.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.ordered {return_value}
-        def ordered(&return_value_block)
-          raise(
-            Errors::DoubleDefinitionError,
-            "Double Definitions must have a dedicated Double to be ordered. " <<
-            "For example, using instance_of does not allow ordered to be used. " <<
-            "proxy the class's #new method instead."
-          ) unless @double
-          @ordered = true
-          space.register_ordered_double(@double)
-          install_method_callback return_value_block
-          DoubleDefinitionCreateBlankSlate.new(double_definition_create)
-        end
-        alias_method :then, :ordered
-        # Double#yields sets the Double to invoke a passed in block when
-        # the Double is called.
-        # An Expection will be raised if no block is passed in when the
-        # Double is called.
-        #
-        # Passing in a block sets the return value.
-        #
-        #   mock(subject).method_name.yields(yield_arg1, yield_arg2) {return_value}
-        #   subject.method_name {|yield_arg1, yield_arg2|}
-        def yields(*args, &return_value_block)
-          @yields_value = args
-          install_method_callback return_value_block
-          self
-        end
-        # Double#after_call creates a callback that occurs after call
-        # is called. The passed in block receives the return value of
-        # the Double being called.
-        # An Expection will be raised if no block is passed in.
-        #
-        #   mock(subject).method_name {return_value}.after_call {|return_value|}
-        #   subject.method_name # return_value
-        #
-        # This feature is built into proxies.
-        #   mock.proxy(User).find('1') {|user| mock(user).valid? {false}}
-        def after_call(&after_call_proc)
-          raise ArgumentError, "after_call expects a block" unless after_call_proc
-          @after_call_proc = after_call_proc
-          self
-        end
-        # Double#verbose sets the Double to print out each method call it receives.
-        #
-        # Passing in a block sets the return value
-        def verbose(&after_call_proc)
-          @verbose = true
-          @after_call_proc = after_call_proc
-          self
-        end
-        # Double#returns accepts an argument value or a block.
-        # It will raise an ArgumentError if both are passed in.
-        #
-        # Passing in a block causes Double to return the return value of
-        # the passed in block.
-        #
-        # Passing in an argument causes Double to return the argument.
-        def returns(*args, &implementation)
-          if !args.empty? && implementation
-            raise ArgumentError, "returns cannot accept both an argument and a block"
-          end
-          if implementation
-            install_method_callback implementation
-          else
-            install_method_callback(lambda do |*lambda_args|
-              args.first
-            end)
-          end
-          self
-        end
-        def implemented_by_original_method
-          implemented_by ORIGINAL_METHOD
-          self
-        end
-        # Double#implemented_by sets the implementation of the Double.
-        # This method takes a Proc or a Method. Passing in a Method allows
-        # the Double to accept blocks.
-        #
-        #   obj = Object.new
-        #   def obj.foobar
-        #     yield(1)
-        #   end
-        #   mock(obj).method_name.implemented_by(obj.method(:foobar))
-        def implemented_by(implementation)
-          @implementation = implementation
-          self
-        end
-        def verify_method_signature
-          @verify_method_signature = true
-          self
-        end
-        alias_method :strong, :verify_method_signature
-        protected
-        def install_method_callback(block)
-          if block
-            if implementation_is_original_method?
-              after_call(&block)
-            else
-              implemented_by block
-            end
-          end
-        end
-      end
-      include DefinitionConstructionMethods
-      module StateQueryMethods
-        # Double#ordered? returns true when the Double is ordered.
-        #
-        #   mock(subject).method_name.ordered?
-        def ordered?
-          @ordered
-        end
-        # Double#verbose? returns true when verbose has been called on it. It returns
-        # true when the double is set to print each method call it receives.
-        def verbose?
-          @verbose ? true : false
-        end
-        def exact_match?(*arguments)
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
-          @argument_expectation.exact_match?(*arguments)
-        end
-        def wildcard_match?(*arguments)
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @argument_expectation
-          @argument_expectation.wildcard_match?(*arguments)
-        end
-        def terminal?
-          raise(Errors::DoubleDefinitionError, "#argument_expectation must be defined on #{inspect}") unless @times_matcher
-          @times_matcher.terminal?
-        end
-        def expected_arguments
-          argument_expectation ? argument_expectation.expected_arguments : []
-        end
-        def implementation_is_original_method?
-          implementation_strategy.is_a?(Strategies::Implementation::Proxy)
-        end
-        def verify_method_signature?
-          !!@verify_method_signature
-        end
-        alias_method :strong?, :verify_method_signature?
-        protected
-        def implementation_strategy
-          double_definition_create.implementation_strategy
-        end
-      end
-      include StateQueryMethods
-      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
-      def mock(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).mock(subject, method_name, &definition_eval_block)
-      end
-      def stub(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).stub(subject, method_name, &definition_eval_block)
-      end
-      def dont_allow(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).dont_allow(subject, method_name, &definition_eval_block)
-      end
-      def proxy(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).proxy(subject, method_name, &definition_eval_block)
-      end
-      def strong(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).strong(subject, method_name, &definition_eval_block)
-      end
-      def any_instance_of(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).any_instance_of(subject, method_name, &definition_eval_block)
-      end
-      def instance_of(subject=DoubleDefinitionCreate::NO_SUBJECT, method_name=nil, &definition_eval_block)
-        ChildDoubleDefinitionCreate.new(self).instance_of(subject, method_name, &definition_eval_block)
-      end
-    end
-  end
-end

@@ -1,139 +0,0 @@
-module RR
-  module DoubleDefinitions
-    class DoubleDefinitionCreate # :nodoc
-      extend(Module.new do
-        def default_double_injection_strategy
-          @default_double_injection_strategy ||= lambda do |double_injection_create|
-            Strategies::DoubleInjection::Instance.new(double_injection_create)
-          end
-        end
-        def set_default_double_injection_strategy(strategy_lambda)
-          original_strategy_lambda = default_double_injection_strategy
-          begin
-            @default_double_injection_strategy = strategy_lambda
-            yield
-          ensure
-            @default_double_injection_strategy = original_strategy_lambda
-          end
-        end
-      end)
-      attr_reader :subject, :verification_strategy, :implementation_strategy, :double_injection_strategy
-      NO_SUBJECT = Object.new
-      include Space::Reader
-      def initialize
-        @verification_strategy = Strategies::Verification::Stub.new(self)
-        @implementation_strategy = Strategies::Implementation::Reimplementation.new(self)
-        @double_injection_strategy = self.class.default_double_injection_strategy.call(self)
-      end
-      def call(method_name, *args, &handler)
-        definition = DoubleDefinition.new(self)
-        verification_strategy.call(definition, method_name, args, handler)
-        implementation_strategy.call(definition, method_name, args, handler)
-        double_injection_strategy.call(definition, method_name, args, handler)
-        definition
-      end
-      def root_subject
-        subject
-      end
-      def method_name
-        @verification_strategy.method_name
-      end
-      module StrategySetupMethods
-        def no_subject?
-          subject.__id__ === NO_SUBJECT.__id__
-        end
-        protected
-        def add_verification_strategy(verification_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-          add_strategy(subject, method_name, definition_eval_block) do
-            self.verification_strategy = verification_strategy_class.new(self)
-          end
-        end
-        def add_implementation_strategy(implementation_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-          add_strategy(subject, method_name, definition_eval_block) do
-            self.implementation_strategy = implementation_strategy_class.new(self)
-          end
-        end
-        def add_double_injection_strategy(double_injection_strategy_class, subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-          add_strategy(subject, method_name, definition_eval_block) do
-            self.double_injection_strategy = double_injection_strategy_class.new(self)
-          end
-        end
-        def add_strategy(subject, method_name, definition_eval_block)
-          if method_name && definition_eval_block
-            raise ArgumentError, "Cannot pass in a method name and a block"
-          end
-          @subject = subject
-          yield
-          # TODO: Allow hash argument to simulate a Struct.
-          if no_subject?
-            self
-          elsif method_name
-            # TODO: Pass in arguments.
-            call(method_name)
-          else
-            DoubleDefinitionCreateBlankSlate.new(self, &definition_eval_block)
-          end
-        end
-        def verification_strategy=(verification_strategy)
-          @verification_strategy = verification_strategy
-          verification_strategy
-        end
-        def implementation_strategy=(implementation_strategy)
-          @implementation_strategy = implementation_strategy
-        end
-        def double_injection_strategy=(double_injection_strategy)
-          @double_injection_strategy = double_injection_strategy
-        end
-      end
-      include StrategySetupMethods
-      class DoubleDefinitionCreateError < Errors::RRError
-      end
-      # Verification Strategies
-      include ::RR::DoubleDefinitions::Strategies::StrategyMethods
-      def mock(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Mock, subject, method_name, &definition_eval_block)
-      end
-      def stub(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::Stub, subject, method_name, &definition_eval_block)
-      end
-      def dont_allow(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_verification_strategy(::RR::DoubleDefinitions::Strategies::Verification::DontAllow, subject, method_name, &definition_eval_block)
-      end
-      # Implementation Strategies
-      def proxy(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::Proxy, subject, method_name, &definition_eval_block)
-      end
-      def strong(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_implementation_strategy(::RR::DoubleDefinitions::Strategies::Implementation::StronglyTypedReimplementation, subject, method_name, &definition_eval_block)
-      end
-      # DoubleInjection Strategies
-      def instance_of(subject=NO_SUBJECT, method_name=nil, &definition_eval_block)
-        self.add_double_injection_strategy(::RR::DoubleDefinitions::Strategies::DoubleInjection::AnyInstanceOf, subject, method_name, &definition_eval_block)
-      end
-      alias_method :any_instance_of, :instance_of
-      alias_method :all_instances_of, :instance_of
-    end
-  end
-end