spy 0.2.5 → 0.3.0

data/README.md

@@ -6,7 +6,7 @@
 
 [Docs](http://rdoc.info/gems/spy/frames)
 
-Spy is a lightweight stubbing framework with support for method spies, constant stubs, and object doubles.
+Spy is a lightweight stubbing framework with support for method spies, constant stubs, and object mocks.
 
 Spy was designed for 1.9.3+.
 
@@ -44,6 +44,7 @@ Fail faster, code faster.
 * #with is not supported
   * you can usually just check the call logs.
   * if you do need to use this. It is probably a code smell. You either need to abstract your method more or add separate tests.
+* you want to use dumb double, Spy has smart mocks, they are better
 * you use `mock_model` and `stub_model` (I want to impliment this soon)
 
 ## Installation
@@ -93,20 +94,26 @@ Book.new(title: "Siddhartha").title   #=> "Cannery Row"
 Book.new(title: "The Big Cheese").title   #=> "Cannery Row"
 ```
 
-### Test Doubles
+### Test Mocks
 
-A test double is an object that stands in for a real object.
+A test mock is an object that quacks like a given class but will raise an error
+when the method is not stubbed. You can spy on the classes and call through to
+the original method.
 
 ```ruby
-Spy.double("book")
-```
+book = Spy.mock(Book)
+Spy.on(book, first_name: "Neil", last_name: "Gaiman")
+Spy.on(book, :author).and_call_through
+book.author #=> "Neil Gaiman"
 
-Spy will let you stub on any method even if it doesn't exist if the object is a double.
+book.responds_to? :title #=> true
+book.title #=> Spy::NeverHookedError: 'title' was never hooked on mock spy.
+```
 
-Spy comes with a shortcut to define an object with methods.
+To stub methods during instantiation just add arguments.
 
 ```ruby
-Spy.double("book", title: "Grapes of Wrath", author: "John Steinbeck")
+book = Spy.mock(book, :first_name, author: "Neil Gaiman")
 ```
 
 ### Arbitrary Handling

data/lib/spy/agency.rb

@@ -22,8 +22,7 @@ module Spy
     # @return [spy]
     def recruit(spy)
       raise AlreadyStubbedError if @spies[spy.object_id]
-      case spy
-      when Subroutine,  Constant, Double
+      if spy.is_a? Base
         @spies[spy.object_id] = spy
       else
         raise ArgumentError, "#{spy}, was not a spy"
@@ -35,8 +34,7 @@ module Spy
     # @return [spy]
     def retire(spy)
       raise NoSpyError unless @spies[spy.object_id]
-      case spy
-      when Subroutine,  Constant, Double
+      if spy.is_a? Base
         @spies.delete(spy.object_id)
       else
         raise ArgumentError, "#{spy}, was not a spy"
@@ -47,8 +45,7 @@ module Spy
     # @param spy [Subroutine, Constant, Double]
     # @return [Boolean]
     def active?(spy)
-      case spy
-      when Subroutine,  Constant, Double
+      if spy.is_a? Base
         @spies.has_key?(spy.object_id)
       else
         raise ArgumentError, "#{spy}, was not a spy"

data/lib/spy/base.rb

@@ -0,0 +1,4 @@
+module Spy
+  module Base
+  end
+end

data/lib/spy/constant.rb

@@ -1,6 +1,6 @@
 module Spy
   class Constant
-
+    include Base
     # @!attribute [r] base_module
     #   @return [Module] the module that is being watched
     #

data/lib/spy/exceptions.rb

@@ -2,32 +2,32 @@ module Spy
   class Error < StandardError; end
 
   class AlreadyStubbedError < Error
-    def message
-      "Spy is already stubbed."
+    def to_s
+      @mesg || "Spy is already stubbed."
     end
   end
 
   class AlreadyHookedError < Error
-    def message
-      "Spy is already hooked."
+    def to_s
+      @mesg || "Spy is already hooked."
     end
   end
 
   class NotHookedError < Error
-    def message
-      "Spy was not hooked."
+    def to_s
+      @mesg || "Spy was not hooked."
     end
   end
 
   class NeverHookedError < Error
-    def message
-      "Spy was never hooked."
+    def to_s
+      @mesg || "Spy was never hooked."
     end
   end
 
   class NoSpyError < Error
-    def message
-      "Spy could not be found"
+    def to_s
+      @mesg || "Spy could not be found"
     end
   end
 end

data/lib/spy/mock.rb

@@ -0,0 +1,122 @@
+module Spy
+  # A Mock is an object that has all the same methods as the given class.
+  # Each method however will raise a NeverHookedError if it hasn't been stubbed.
+  # If you attempt to stub a method on the mock that doesn't exist on the
+  # original class it will raise an error.
+  module Mock
+    include Base
+    CLASSES_NOT_TO_OVERRIDE = [Enumerable, Numeric, Comparable, Class, Module, Object]
+    METHODS_NOT_TO_OVERRIDE = [:initialize, :method]
+
+    def initialize
+    end
+
+    def is_a?(other)
+      self.class.ancestors.include?(other)
+    end
+
+    alias :kind_of? :is_a?
+
+    def instance_of?(other)
+      other == self.class
+    end
+
+    def method(method_name)
+      new_method = super
+      if new_method.parameters.size >= 1 &&
+        new_method.parameters.last.last == :never_hooked
+
+        begin
+          _mock_class.send(:remove_method, method_name)
+          real_method = super
+        ensure
+          _mock_class.send(:define_method, method_name, new_method)
+        end
+
+        real_method
+      else
+        new_method
+      end
+    end
+
+    class << self
+      def new(klass)
+        mock_klass = Class.new(klass)
+        mock_klass.class_exec do
+          alias :_mock_class :class
+          private :_mock_class
+
+          define_method(:class) do
+            klass
+          end
+
+          include Mock
+        end
+        Agency.instance.recruit(mock_klass)
+        mock_klass
+      end
+
+      def included(mod)
+        method_classes = classes_to_override_methods(mod)
+
+        mocked_methods = []
+        [:public, :protected, :private].each do |visibility|
+          get_inherited_methods(method_classes, visibility).each do |method_name|
+            mocked_methods << method_name
+            args = args_for_method(mod.instance_method(method_name))
+
+            mod.class_eval <<-DEF_METHOD, __FILE__, __LINE__+1
+              def #{method_name}(#{args})
+                raise ::Spy::NeverHookedError, "'#{method_name}' was never hooked on mock spy."
+              end
+
+              #{visibility} :#{method_name}
+            DEF_METHOD
+          end
+        end
+
+        mod.define_singleton_method(:mocked_methods) do
+          mocked_methods
+        end
+      end
+
+      private
+
+      def classes_to_override_methods(mod)
+        method_classes = mod.ancestors
+        method_classes.shift
+        method_classes.delete(self)
+        CLASSES_NOT_TO_OVERRIDE.each do |klass|
+          index = method_classes.index(klass)
+          method_classes.slice!(index..-1) if index
+        end
+        method_classes
+      end
+
+      def get_inherited_methods(klass_ancestors, visibility)
+        instance_methods = klass_ancestors.map do |klass|
+         klass.send("#{visibility}_instance_methods".to_sym, false)
+        end
+        instance_methods.flatten!
+        instance_methods.uniq!
+        instance_methods - METHODS_NOT_TO_OVERRIDE
+      end
+
+      def args_for_method(method)
+        args = method.parameters.map do |type,name|
+          name ||= :args
+          case type
+          when :req
+            name
+          when :opt
+            "#{name} = nil"
+          when :rest
+            "*#{name}"
+          end
+        end.compact
+        args << "&never_hooked"
+        args.join(",")
+      end
+    end
+  end
+end

data/lib/spy/subroutine.rb

@@ -1,5 +1,6 @@
 module Spy
   class Subroutine
+    include Base
     # @!attribute [r] base_object
     #   @return [Object] the object that is being watched
     #
@@ -45,7 +46,6 @@ module Spy
       @hook_opts = opts
       @original_method_visibility = method_visibility_of(method_name)
       hook_opts[:visibility] ||= original_method_visibility
-      hook_opts[:force] ||= base_object.is_a?(Double)
 
       if original_method_visibility || !hook_opts[:force]
         @original_method = current_method
@@ -361,14 +361,11 @@ module Spy
         end.compact
       end
 
-      private
-
+      # @private
       def get_spy_id(method)
         return nil unless method.parameters[0].is_a?(Array)
-        first_param_name = method.parameters[0][1].to_s
-        if first_param_name.include?("__spy_args")
-          first_param_name.split("_").last.to_i
-        end
+        id = method.parameters[0][1].to_s.sub!("__spy_args_", "")
+        id.to_i if id
       end
     end
   end

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/lib/spy.rb

@@ -1,9 +1,10 @@
 require "spy/core_ext/marshal"
 require "spy/agency"
+require "spy/base"
 require "spy/call_log"
 require "spy/constant"
-require "spy/double"
 require "spy/exceptions"
+require "spy/mock"
 require "spy/nest"
 require "spy/subroutine"
 require "spy/version"
@@ -107,17 +108,31 @@ module Spy
       spies.size > 1 ? spies : spies.first
     end
 
+    def mock(klass, *stubs)
+      new_mock = Mock.new(klass).new
+      if stubs.size > 0
+        on(new_mock, *stubs)
+      end
+      new_mock
+    end
+
+    def mock_all(klass, *stubs)
+      mock_klass = Mock.new(klass)
+      new_mock = mock_klass.new
+
+      spies = stubs.size > 0 ? on(new_mock, *stubs) : []
+
+      unstubbed_methods = mock_klass.mocked_methods - spies.map(&:method_name)
+      on(new_mock, *unstubbed_methods) if unstubbed_methods.size > 0
+
+      new_mock
+    end
+
     # unhook all methods
     def teardown
       Agency.instance.dissolve!
     end
 
-    # returns a double
-    # (see Double#initizalize)
-    def double(*args)
-      Double.new(*args)
-    end
-
     # retrieve the spy from an object
     # @param base_object
     # @param method_names *[Symbol]

data/spec/spy/mutate_const_spec.rb

@@ -16,14 +16,9 @@ class TestSubClass < TestClass
   P = :p
 end
 
-require "rspec/mocks/mutate_const"
-
 module Spy
   describe "Constant Mutating" do
 
-    require "rspec/mocks/mutate_const"
-    include RSpec::Mocks::RecursiveConstMethods
-
     def reset_rspec_mocks
       Spy.teardown
     end
@@ -360,9 +355,6 @@ module Spy
   end
 
   describe Constant do
-    require "rspec/mocks/mutate_const"
-    include RSpec::Mocks::RecursiveConstMethods
-
     def reset_rspec_mocks
       Spy.teardown
     end

data/test/integration/test_mocking.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class TestMocking < MiniTest::Unit::TestCase
+  def teardown
+    Spy::Agency.instance.dissolve!
+  end
+
+  def test_spy_on_mock_does_not_raise
+    mock = Spy.mock(Pen)
+    spy = Spy.on(mock, :write).and_return(:awesome)
+    assert_equal :awesome, mock.write("hello")
+    assert spy.has_been_called?
+  end
+
+  def test_spy_mock_shortcuts
+    mock = Spy.mock(Pen, :another, write_hello: :goodbye)
+    assert_nil mock.another
+    assert_equal :goodbye, mock.write_hello
+  end
+
+  def test_spy_mock_all
+    mock = Spy.mock_all(Pen)
+    assert_nil mock.another
+  end
+end

data/test/integration/test_subroutine_spying.rb

@@ -39,5 +39,4 @@ class TestSpy < MiniTest::Unit::TestCase
     assert_equal "hello world", @pen.write("hello world")
     refute pen_write_spy.has_been_called?
   end
-
 end

data/test/spy/test_mock.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module Spy
+  class TestMock < MiniTest::Unit::TestCase
+    class BluePen < Pen
+      def write_hello(other)
+      end
+    end
+
+    def setup
+      @pen_mock = Mock.new(BluePen)
+      @pen = @pen_mock.new
+    end
+
+    def teardown
+      Spy::Agency.instance.dissolve!
+    end
+
+    def test_class_methods
+      assert @pen.kind_of?(BluePen)
+      assert @pen.kind_of?(Pen)
+      assert @pen.is_a?(Pen)
+      assert @pen.is_a?(BluePen)
+      assert @pen.instance_of?(BluePen)
+      assert_equal BluePen, @pen.class
+    end
+
+    def test_raises_error_on_unstubbed_method
+      assert_raises Spy::NeverHookedError do
+        @pen.write("")
+      end
+    end
+
+    def test_mimics_visibility
+      assert @pen.singleton_class.public_method_defined? :public_method
+      assert @pen.singleton_class.protected_method_defined? :protected_method
+      assert @pen.singleton_class.private_method_defined? :private_method
+    end
+
+    def test_that_method_spy_keeps_arity
+      assert_raises ArgumentError do
+        @pen.write
+      end
+
+      assert_raises ArgumentError do
+        @pen.write("hello", "world")
+      end
+
+      assert_raises ArgumentError do
+        @pen.write_hello
+      end
+
+      assert_raises ArgumentError do
+        @pen.greet
+      end
+
+      assert_raises ArgumentError do
+        @pen.greet("hello", "bob", "error")
+      end
+    end
+
+    def test_that_and_call_original_works
+      Spy.on(@pen, :another).and_call_through
+      assert_equal "another", @pen.another
+      Spy.off(@pen, :another)
+      assert_raises Spy::NeverHookedError do
+        @pen.another
+      end
+    end
+
+    def test_mocked_methods
+      pen_methods = Pen.public_instance_methods(false) +
+        Pen.protected_instance_methods(false) +
+        Pen.private_instance_methods(false)
+      pen_methods.delete(:initialize)
+      assert_equal pen_methods.sort, @pen_mock.mocked_methods.sort
+    end
+
+    def test_base_class_methods_are_not_stubbed
+      (Object.instance_methods - [:tap, :pretty_print_inspect]).each do |method_name|
+        object_method = Object.instance_method(method_name)
+        if object_method.parameters == []
+          @pen.send(method_name)
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spy
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-10 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -124,11 +124,12 @@ files:
 - Rakefile
 - lib/spy.rb
 - lib/spy/agency.rb
+- lib/spy/base.rb
 - lib/spy/call_log.rb
 - lib/spy/constant.rb
 - lib/spy/core_ext/marshal.rb
-- lib/spy/double.rb
 - lib/spy/exceptions.rb
+- lib/spy/mock.rb
 - lib/spy/nest.rb
 - lib/spy/subroutine.rb
 - lib/spy/version.rb
@@ -138,7 +139,6 @@ files:
 - spec/spy/any_instance_spec.rb
 - spec/spy/hash_excluding_matcher_spec.rb
 - spec/spy/hash_including_matcher_spec.rb
-- spec/spy/mock_spec.rb
 - spec/spy/mutate_const_spec.rb
 - spec/spy/nil_expectation_warning_spec.rb
 - spec/spy/null_object_mock_spec.rb
@@ -152,8 +152,9 @@ files:
 - spy.gemspec
 - test/integration/test_constant_spying.rb
 - test/integration/test_instance_method.rb
+- test/integration/test_mocking.rb
 - test/integration/test_subroutine_spying.rb
-- test/spy/test_double.rb
+- test/spy/test_mock.rb
 - test/spy/test_subroutine.rb
 - test/support/pen.rb
 - test/test_helper.rb
@@ -191,7 +192,6 @@ test_files:
 - spec/spy/any_instance_spec.rb
 - spec/spy/hash_excluding_matcher_spec.rb
 - spec/spy/hash_including_matcher_spec.rb
-- spec/spy/mock_spec.rb
 - spec/spy/mutate_const_spec.rb
 - spec/spy/nil_expectation_warning_spec.rb
 - spec/spy/null_object_mock_spec.rb
@@ -204,8 +204,9 @@ test_files:
 - spec/spy/to_ary_spec.rb
 - test/integration/test_constant_spying.rb
 - test/integration/test_instance_method.rb
+- test/integration/test_mocking.rb
 - test/integration/test_subroutine_spying.rb
-- test/spy/test_double.rb
+- test/spy/test_mock.rb
 - test/spy/test_subroutine.rb
 - test/support/pen.rb
 - test/test_helper.rb

data/lib/spy/double.rb

@@ -1,28 +0,0 @@
-module Spy
-  class Double
-    def initialize(name, *args)
-      @name = name
-
-      if args.size > 0
-        Spy.on(self,*args)
-      end
-    end
-
-    # @private
-    def ==(other)
-      other == self
-    end
-
-    # @private
-    def inspect
-      "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
-    end
-
-    # @private
-    def to_s
-      inspect.gsub('<','[').gsub('>',']')
-    end
-
-    alias_method :to_str, :to_s
-  end
-end

data/spec/spy/mock_spec.rb

@@ -1,222 +0,0 @@
-require 'spec_helper'
-
-module Spy
-  describe Double do
-    before(:each) { @double = Spy.double("test double") }
-
-    it "has method_missing as private" do
-      expect(Spy.double("stuff").private_instance_methods).to include_method(:method_missing)
-    end
-
-    it "does not respond_to? method_missing (because it's private)" do
-      expect(Spy.double("stuff")).not_to respond_to(:method_missing)
-    end
-
-    it "fails when receiving message specified as not to be received" do
-      spy = Spy.on(@double, :not_expected)
-      expect(spy).to_not have_been_called
-    end
-
-    it "fails if unexpected method called" do
-      expect {
-        @double.something("a","b","c")
-      }.to raise_error
-    end
-
-    it "uses block for expectation if provided" do
-      spy = Spy.on(@double, :something).and_return do | a, b |
-        expect(a).to eq "a"
-        expect(b).to eq "b"
-        "booh"
-      end
-      expect(@double.something("a", "b")).to eq "booh"
-      expect(spy).to have_been_called
-    end
-
-    it "fails if expectation block fails" do
-      Spy.on(@double, :something).and_return do | bool|
-        expect(bool).to be_true
-      end
-
-      expect {
-        @double.something false
-      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-    end
-
-    it "passes proc to expectation block without an argument" do
-      spy = Spy.on(@double, :foo).and_return do |&block|
-        expect(block.call).to eq(:bar)
-      end
-      @double.foo { :bar }
-      expect(spy).to have_been_called
-    end
-
-    it "passes proc to expectation block with an argument" do
-      spy = Spy.on(@double, :foo).and_return do |arg, &block|
-        expect(block.call).to eq(:bar)
-      end
-      @double.foo(:arg) { :bar }
-      expect(spy).to have_been_called
-    end
-
-    it "passes proc to stub block without an argurment" do
-      spy = Spy.on(@double, :foo).and_return do |&block|
-        expect(block.call).to eq(:bar)
-      end
-      @double.foo { :bar }
-      expect(spy).to have_been_called
-    end
-
-    it "passes proc to stub block with an argument" do
-      spy = Spy.on(@double, :foo) do |arg, &block|
-        expect(block.call).to eq(:bar)
-      end
-      @double.foo(:arg) { :bar }
-      expect(spy).to have_been_called
-    end
-
-    it "fails right away when method defined as never is received" do
-      Spy.on(@double, :not_expected).never
-      expect { @double.not_expected }.
-        to raise_error(RSpec::Mocks::MockExpectationError,
-                       %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
-                      )
-    end
-
-    it "raises RuntimeError by default" do
-      Spy.on(@double, :something).and_raise
-      expect { @double.something }.to raise_error(RuntimeError)
-    end
-
-    it "raises RuntimeError with a message by default" do
-      Spy.on(@double, :something).and_raise("error message")
-      expect { @double.something }.to raise_error(RuntimeError, "error message")
-    end
-
-    it "raises an exception of a given type without an error message" do
-      Spy.on(@double, :something).and_raise(StandardError)
-      expect { @double.something }.to raise_error(StandardError)
-    end
-
-    it "raises an exception of a given type with a message" do
-      Spy.on(@double, :something).and_raise(RuntimeError, "error message")
-      expect { @double.something }.to raise_error(RuntimeError, "error message")
-    end
-
-    it "raises a given instance of an exception" do
-      Spy.on(@double, :something).and_raise(RuntimeError.new("error message"))
-      expect { @double.something }.to raise_error(RuntimeError, "error message")
-    end
-
-    class OutOfGas < StandardError
-      attr_reader :amount, :units
-      def initialize(amount, units)
-        @amount = amount
-        @units  = units
-      end
-    end
-
-    it "raises a given instance of an exception with arguments other than the standard 'message'" do
-      Spy.on(@double, :something).and_raise(OutOfGas.new(2, :oz))
-
-      begin
-        @double.something
-        fail "OutOfGas was not raised"
-      rescue OutOfGas => e
-        expect(e.amount).to eq 2
-        expect(e.units).to eq :oz
-      end
-    end
-
-    it "throws when told to" do
-      Spy.on(@double, :something).and_throw(:blech)
-      expect {
-        @double.something
-      }.to throw_symbol(:blech)
-    end
-
-    it "returns value from block by default" do
-      spy = Spy.on(@double, :method_that_yields).and_yield
-      value = @double.method_that_yields { :returned_obj }
-      expect(value).to eq :returned_obj
-      expect(spy).to have_been_called
-    end
-
-    it "is able to raise from method calling yielding double" do
-      spy = Spy.on(@double, :yield_me).and_yield 44
-
-      expect {
-        @double.yield_me do |x|
-          raise "Bang"
-        end
-      }.to raise_error(StandardError, "Bang")
-
-      expect(spy).to have_been_called
-    end
-
-    it "assigns stub return values" do
-      double = Spy.double('name', :message => :response)
-      expect(double.message).to eq :response
-    end
-
-  end
-
-  describe "a double message receiving a block" do
-    before(:each) do
-      @double = Spy.double("double")
-      @calls = 0
-    end
-
-    def add_call
-      @calls = @calls + 1
-    end
-
-    it "calls the block after #should_receive" do
-      spy = Spy.on(@double, :foo).and_return { add_call }
-
-      @double.foo
-
-      expect(@calls).to eq 1
-      expect(spy).to have_been_called
-    end
-  end
-
-  describe 'string representation generated by #to_s' do
-    it 'does not contain < because that might lead to invalid HTML in some situations' do
-      double = Spy.double("Dog")
-      valid_html_str = "#{double}"
-      expect(valid_html_str).not_to include('<')
-    end
-  end
-
-  describe "string representation generated by #to_str" do
-    it "looks the same as #to_s" do
-      double = Spy.double("Foo")
-      expect(double.to_str).to eq double.to_s
-    end
-  end
-
-  describe "double created with no name" do
-    it "does not use a name in a failure message" do
-      double = Spy.double()
-      expect {double.foo}.to raise_error(/Double received/)
-    end
-
-    it "does respond to initially stubbed methods" do
-      double = Spy.double("name", :foo => "woo", :bar => "car")
-      expect(double.foo).to eq "woo"
-      expect(double.bar).to eq "car"
-    end
-  end
-
-  describe "==" do
-    it "sends '== self' to the comparison object" do
-      first = Spy.double('first')
-      second = Spy.double('second')
-
-      spy = Spy.on(first, :==)
-      second == first
-      expect(spy.calls.first.args).to eq([second])
-    end
-  end
-end

data/test/spy/test_double.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-module Spy
-  class TestDouble < MiniTest::Unit::TestCase
-    def teardown
-      Spy::Agency.instance.dissolve!
-    end
-
-    def test_double_creation
-      double = Double.new("NewDouble", :meth_1, :meth_2)
-
-      assert_nil double.meth_1
-      assert_nil double.meth_2
-    end
-
-    def test_double_hash_input
-      double = Double.new("NewDouble", meth_1: :meth_1, meth_2: :meth_2)
-
-      assert_equal :meth_1, double.meth_1
-      assert_equal :meth_2, double.meth_2
-    end
-  end
-end