bigrecord 0.0.5

data/spec/lib/broken_migrations/duplicate_version/20090706190623_add_companies_table.rb

@@ -0,0 +1,9 @@
+class AddCompaniesTable < BigRecord::Migration
+
+  def self.up
+  end
+
+  def self.down
+  end
+
+end

data/spec/lib/company.rb

@@ -0,0 +1,14 @@
+class Company < BigRecord::Base
+
+  column 'attribute:name',        'string'
+  column 'attribute:address',     'string'
+  column 'attribute:employees',   'integer'
+  column 'attribute:readonly',    'string'
+
+  column 'log:change',            'string', :alias => 'change_log', :collection => true
+
+  attr_create_accessible :name
+  attr_protected :employees
+  attr_readonly :readonly
+
+end

data/spec/lib/embedded/web_link.rb

@@ -0,0 +1,12 @@
+# This doesn't need to be in the Embedded namespace, but it's placed here for organization.
+
+module Embedded
+
+class WebLink < BigRecord::Embedded
+
+  column :url,           :string
+  column :title,         :string
+
+end
+
+end

data/spec/lib/employee.rb

@@ -0,0 +1,33 @@
+class Employee < BigRecord::Base
+
+  column 'attribute:first_name',      :string
+  column 'attribute:middle_name',     :string
+  column 'attribute:last_name',       :string
+  column 'attribute:email',           :string
+  column 'attribute:title',           :string
+  column 'attribute:company_id',      :string
+  column 'attribute:password',        :string
+  column 'attribute:gender',          :string   # it's not discrimination
+  column 'attribute:age',             :integer
+
+  validates_presence_of   :first_name, :last_name
+  validates_length_of     :first_name, :last_name, :within => 2..50
+  validates_length_of     :middle_name, :within => 1..50, :allow_nil => true
+  validates_format_of     :first_name, :last_name, :with => /^[\w-]/
+  validates_format_of     :middle_name, :with => /^[\w-]/, :allow_nil => true
+  #validates_uniqueness_of :name
+  validates_exclusion_of  :first_name, :last_name, :in => %w( admin superuser )
+  validates_exclusion_of  :middle_name, :in => %w( admin superuser ), :allow_nil => true
+
+  validates_presence_of   :email
+
+  validates_inclusion_of :gender, :in => %w( m f )
+
+  validates_confirmation_of :password
+
+  validates_acceptance_of :contract
+
+
+  belongs_to_big_record :company, :foreign_key => :company_id
+
+end

data/spec/lib/migrations/20090706182535_add_animals_table.rb

@@ -0,0 +1,13 @@
+class AddAnimalsTable < BigRecord::Migration
+
+  def self.up
+    create_table :animals, :force => true do |t|
+      t.family :attribute, :versions => 100
+    end
+  end
+
+  def self.down
+    drop_table :animals
+  end
+
+end

data/spec/lib/migrations/20090706190623_add_books_table.rb

@@ -0,0 +1,15 @@
+class AddBooksTable < BigRecord::Migration
+
+  def self.up
+    create_table :books, :force => true do |t|
+      t.family :attribute, :versions => 100
+      t.family :family2
+      t.family :log, :versions => 100
+    end
+  end
+
+  def self.down
+    drop_table :books
+  end
+
+end

data/spec/lib/migrations/20090706193019_add_companies_table.rb

@@ -0,0 +1,14 @@
+class AddCompaniesTable < BigRecord::Migration
+
+  def self.up
+    create_table :companies, :force => true do |t|
+      t.family :attribute, :versions => 100
+      t.family :log, :versions => 100
+    end
+  end
+
+  def self.down
+    drop_table :companies
+  end
+
+end

data/spec/lib/migrations/20090706194512_add_employees_table.rb

@@ -0,0 +1,13 @@
+class AddEmployeesTable < BigRecord::Migration
+
+  def self.up
+    create_table :employees, :force => true do |t|
+      t.family :attribute, :versions => 100
+    end
+  end
+
+  def self.down
+    drop_table :employees
+  end
+
+end

data/spec/lib/migrations/20090706195741_add_zoos_table.rb

@@ -0,0 +1,13 @@
+class AddZoosTable < BigRecord::Migration
+
+  def self.up
+    create_table :zoos, :force => true do |t|
+      t.family :attr, :versions => 100
+    end
+  end
+
+  def self.down
+    drop_table :zoos
+  end
+
+end

data/spec/lib/novel.rb

@@ -0,0 +1,5 @@
+class Novel < Book
+
+  column :publisher,    :string
+
+end

data/spec/lib/zoo.rb

@@ -0,0 +1,17 @@
+class Zoo < BigRecord::Base
+
+  set_default_family :attr
+
+  column 'attr:name',         'string'
+  column 'attr:address',      'string'
+  column 'attr:employees',    'integer'
+  column 'attr:readonly',     'string'
+  column :description,        :string
+  column 'attr:weblink',      'Embedded::WebLink', :alias => "weblink"
+  column 'attr:animal_ids',   :string,  :collection => true
+
+
+  attr_accessible :name, :address, :description
+
+  belongs_to_many :animals, :foreign_key => 'attr:animal_ids'
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format progress
+--debugger

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require 'pathname'
+require 'rubygems'
+
+gem 'rspec', '~>1.2'
+require 'spec'
+
+SPEC_ROOT = Pathname(__FILE__).dirname.expand_path
+require SPEC_ROOT.parent + 'lib/big_record'
+
+BigRecord::Base.configurations = YAML::load(File.open(File.join(File.dirname(__FILE__), "connections", "bigrecord.yml")))
+BigRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+
+begin
+  require 'connection'
+rescue LoadError
+  BigRecord::Base.logger.info "No data store defined. Using Hbase..."
+  require File.join(File.dirname(__FILE__), 'connections', 'hbase', 'connection')
+end
+
+# Load the various helpers for the spec suite
+Dir.glob( File.join(File.dirname(__FILE__), "lib", "**", "*.rb") ).each do |model|
+  require model
+end
+
+
+# Redefine the Hash class to include two helper methods used only in the specs.
+class Hash
+  # Helper method to determine if a hash is completely contained within other_hash (order is not important).
+  # Matches each key/value pair, and returns false as soon as a mismatch occurs. The other_hash might have
+  # more pairs, but those aren't considered.
+  #
+  #   hash1 = { :key1 => "value1", :key2 => "value2", :key3 => "value3" }
+  #
+  #   hash2 = { :key1 => "value1", :key2 => "value2", :key3 => "value3", :key4 => "value4" }
+  #
+  #   hash3 = { :key1 => "value4", :key2 => "value3", :key3 => "value1", :key4 => "value2" }
+  #
+  #   hash1.subset_of?(hash2) # => true
+  #   hash2.subset_of?(hash1) # => false
+  #   hash3.subset_of?(hash1) # => false
+  #   hash3.subset_of?(hash2) # => false
+  #
+  def subset_of?(other_hash)
+    self.each_pair do |key, value|
+      return false if !other_hash.has_key?(key) || !(other_hash[key] == value)
+    end
+
+    true
+  end
+
+  def superset_of?(other_hash)
+    other_hash.subset_of?(self)
+  end
+
+end

data/spec/unit/abstract_base_spec.rb

@@ -0,0 +1,287 @@
+# Defined as a shared spec because embedded_spec uses it as well
+describe "BigRecord::AbstractBase", :shared => true do
+
+  it "should provide #primary_key" do
+    Book.should respond_to(:primary_key)
+  end
+
+  describe '#columns' do
+
+    before(:all) do
+      # Grab the columns from a simple BigRecord model
+      @columns = Book.columns
+    end
+
+    it 'should return a hash of Column objects describing the columns in the model' do
+      # Verify that each entry is a Column object
+      @columns.each do |column|
+        column.should be_a_kind_of(BigRecord::ConnectionAdapters::Column)
+      end
+
+      # Map the names of each of the columns
+      column_names = @columns.map{ |column| column.name }
+
+      # Verify that each attribute we defined in the Book model is present
+      expected_names = %w( attribute:title attribute:author attribute:description family2: log:change )
+      (column_names & expected_names).sort.should == expected_names.sort
+    end
+
+    it 'should save a default alias name for each column (e.g. attribute:name become alias name automatically)' do
+      lookup = {  'attribute:id' => 'id',
+                  'attribute:title' => 'title',
+                  'attribute:author' => 'author',
+                  'attribute:description' => 'description'}
+
+      # Go through each column and if an attribute name is found that matches the lookup table above,
+      # verify that the alias name it creates is the one we expect.
+      @columns.each do |column|
+        if lookup.has_key?(column.name)
+          column.alias.should == lookup[column.name]
+        end
+      end
+    end
+
+  end
+
+  describe 'column families' do
+
+    it 'should respond to #default_family with a default value, or with the value defined in the model' do
+      Book.should respond_to(:default_family)
+      Book.default_family.should == "attribute"
+
+      Zoo.should respond_to(:default_family)
+      Zoo.default_family.should == "attr"
+    end
+
+    it 'should automatically append the #default_family to columns without one defined' do
+      Zoo.columns.map{|column| column.name}.should include("attr:description")
+      Zoo.new.should respond_to(:description)
+      Zoo.new.should respond_to(:description=)
+    end
+
+  end
+
+  describe '.attributes' do
+
+    before(:each) do
+      @book = Book.new
+    end
+
+    it 'should have getter and setter methods for the attributes from the alias of their names' do
+      # Check that the getters are responding
+      @book.should respond_to(:title)
+      @book.should respond_to(:author)
+      @book.should respond_to(:description)
+
+      # Check that the setters are responding
+      @book.should respond_to(:title=)
+      @book.should respond_to(:author=)
+      @book.should respond_to(:description=)
+
+      # Now we use the setters
+      @book.title = "The Beach"
+      @book.author = "Alex Garland"
+      @book.description = "A furiously intelligent first novel." # this was written on the cover
+
+      # And we check that the getters are working
+      @book.title.should == "The Beach"
+      @book.author.should == "Alex Garland"
+      @book.description.should == "A furiously intelligent first novel."
+    end
+
+    it 'should provide a list of modified attributes with #modified_attributes' do
+      pending "This was deprecated"
+
+      book = Book.new(  :title => "The Beach",
+                        :author => "Alex Garland",
+                        :description => "A furiously intelligent first novel.")
+
+      book.modified_attributes.each_pair do |key, value|
+        %w( title author description ).include?(key.to_s).should be_true
+      end
+    end
+
+    it 'should return a hash of attribute-names and values' do
+      # Set some attributes, and verify that they get stored in the model
+      @book.title = "The Beach"
+      @book.author = "Alex Garland"
+      @book.description = "A furiously intelligent first novel."
+
+      expected_hash = {"log:change"=>[], "attribute:description"=>"A furiously intelligent first novel.", "attribute:title"=>"The Beach", "attribute:links"=>[], "attribute:author"=>"Alex Garland"}
+
+      @book.attributes.superset_of?(expected_hash).should be_true
+    end
+
+    it "should return a hash with all nil or empty list values if the instance is new and has no default values" do
+      @book.attributes.superset_of?({"log:change"=>[], "attribute:description"=>nil, "attribute:title"=>nil, "attribute:links"=>[], "attribute:author"=>nil}).should be_true
+    end
+
+  end
+
+  describe ".attributes=" do
+
+    it 'should be able to mass assign attributes' do
+      # Check that the mass asssignment of attributes works with #new
+      @book = Book.new( :title => "The Beach",
+                        :author => "Alex Garland",
+                        :description => "A furiously intelligent first novel.")
+
+      @book.attributes.superset_of?({"log:change"=>[], "attribute:description"=>"A furiously intelligent first novel.", "attribute:title"=>"The Beach", "attribute:links"=>[], "attribute:author"=>"Alex Garland"}).should be_true
+
+      # Check that it works with the #attributes= method
+      @book.attributes = {:title => "28 Days Later"}
+
+      @book.attributes.superset_of?({"log:change"=>[], "attribute:description"=>"A furiously intelligent first novel.", "attribute:title"=>"28 Days Later", "attribute:links"=>[], "attribute:author"=>"Alex Garland"}).should be_true
+    end
+
+  end
+
+  describe "protected attributes" do
+
+    it 'should respond to the method #protected_attributes' do
+      Company.should respond_to(:protected_attributes)
+    end
+
+    it 'should list #protected_attributes' do
+      Company.protected_attributes.should be_a_kind_of(Set)
+      Company.protected_attributes.should include("employees")
+    end
+
+    it 'should be handled properly' do
+      # Employees is a protected attribute here, so it shouldn't be saved.
+      @company = Company.new(:name => "The Company", :address => "Unknown", :employees => 18000, :readonly => "secret")
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # Check it against the attributes= method
+      @company.attributes = {:employees => 18000}
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # Now check that we can access it with the employees= method
+      @company.employees = 18000
+
+      @company.attributes.superset_of?({"attribute:employees"=>18000, "attribute:address"=>"Unknown", "attribute:readonly"=>"secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+    end
+
+  end
+
+  describe "accessible attributes" do
+
+    it 'should respond to the method #accessible_attributes' do
+      Zoo.should respond_to(:accessible_attributes)
+      Zoo.accessible_attributes.should_not be_empty
+    end
+
+    it 'should list #accessible_attributes' do
+      Zoo.accessible_attributes.should be_a_kind_of(Set)
+      Zoo.accessible_attributes.should include("address")
+      Zoo.accessible_attributes.should include("description")
+    end
+
+    it 'should be handled properly' do
+      # name, address, and description are accessible attributes here
+      attributes_hash = {   :name => "San Francisco",
+                            :address => "Some Address",
+                            :description => "This is a pretty awesome zoo",
+                            :employees => 10000,
+                            :readonly => "should not work" }
+
+      zoo = Zoo.new(attributes_hash)
+
+      zoo.attributes.superset_of?({"attr:readonly"=>nil, "attr:address"=>"Some Address", "attr:description"=>"This is a pretty awesome zoo", "attr:employees"=>nil, "attr:name"=>"San Francisco"}).should be_true
+
+      zoo.attributes = {:address => "1 Zoo Rd", :description => "Awesome address", :employees => 1000}
+
+      zoo.attributes.superset_of?({"attr:readonly"=>nil, "attr:address"=>"1 Zoo Rd", "attr:description"=>"Awesome address", "attr:employees"=>nil, "attr:name"=>"San Francisco"}).should be_true
+
+      zoo.employees = 1000
+
+      zoo.attributes.superset_of?({"attr:readonly"=>nil, "attr:address"=>"1 Zoo Rd", "attr:description"=>"Awesome address", "attr:employees"=>1000, "attr:name"=>"San Francisco"})
+    end
+
+  end
+
+  describe "readonly attributes" do
+
+    it 'should respond to the method #readonly_attributes' do
+      Company.should respond_to(:readonly_attributes)
+    end
+
+    it 'should list #readonly_attributes' do
+      Company.readonly_attributes.should be_a_kind_of(Set)
+      Company.readonly_attributes.should include("readonly")
+    end
+
+    it 'should be handled properly' do
+      pending "this still needs to be implemented in BigRecord::AbstractBase"
+
+      # readonly is the readonly attribute here
+      @company = Company.new(:name => "The Company", :address => "Unknown", :readonly => "secret")
+
+      # It should've been set successfully since this is a new record
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # It should still also be accessible with the attributes= method
+      @company.attributes = {:readonly => "another secret"}
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"another secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # Now when we save it, it should no longer be accessible with mass assignment
+
+      # Mock new_record? so it's essentially acting like it was saved.
+      @company.stub!(:new_record?).and_return(false)
+
+      @company.attributes = {:readonly => "compromised secret"}
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"another secret", "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # And it should still not be accessible with the explicit setter
+      @company.readonly = "compromised secret"
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>"another secret", "log:change"=>[], "attribute:name"=>"Another Company"}).should be_true
+    end
+
+  end
+
+  describe "create_accessible attributes" do
+
+    it 'should respond to the method #create_accessible_attributes' do
+      Company.should respond_to(:create_accessible_attributes)
+    end
+
+    it 'should list #create_accessible_attributes' do
+      Company.create_accessible_attributes.should be_a_kind_of(Set)
+      Company.create_accessible_attributes.should include("name")
+    end
+
+    it 'should be handled properly' do
+      # Name is the create_accessible attribute here
+      @company = Company.new(:name => "Another Company", :address => "Unknown")
+
+      # It should've been set successfully since this is a new record
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>nil, "log:change"=>[], "attribute:name"=>"Another Company"}).should be_true
+
+      # It should still also be accessible with the attributes= method
+      @company.attributes = {:name => "The Company"}
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>nil, "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # Now when we save it, it should no longer be accessible with mass assignment
+
+      # Mock new_record? so it's essentially acting like it was saved.
+      @company.stub!(:new_record?).and_return(false)
+
+      @company.attributes = {:name => "Another Company"}
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>nil, "log:change"=>[], "attribute:name"=>"The Company"}).should be_true
+
+      # But it should still be accessible with the explicit setter
+      @company.name = "Another Company"
+
+      @company.attributes.superset_of?({"attribute:employees"=>nil, "attribute:address"=>"Unknown", "attribute:readonly"=>nil, "log:change"=>[], "attribute:name"=>"Another Company"}).should be_true
+    end
+
+  end
+
+end

data/spec/unit/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'adapter_shared_spec'))
+
+describe BigRecord::ConnectionAdapters::AbstractAdapter do
+
+  before do
+    @adapter = BigRecord::ConnectionAdapters::AbstractAdapter.new("")
+  end
+
+  it_should_behave_like 'a BigRecord Adapter'
+
+  it "should raise NotImplementedError when #update_raw is called" do
+    lambda{ @adapter.update_raw(:table_name, :row, :values, :timestamp) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #update is called" do
+    lambda{ @adapter.update(:table_name, :row, :values, :timestamp) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #get_raw is called" do
+    lambda{ @adapter.get_raw(:table_name, :row, :column, :options) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #get is called" do
+    lambda{ @adapter.get(:table_name, :row, :column, :options) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #get_columns_raw is called" do
+    lambda{ @adapter.get_columns_raw(:table_name, :row, :columns, :options) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #get_columns is called" do
+    lambda{ @adapter.get_columns(:table_name, :row, :columns, :options) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #delete is called" do
+    lambda{ @adapter.delete(:table_name, :row) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #delete_all is called" do
+    lambda{ @adapter.delete_all(:table_name) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #table_exists? is called" do
+    lambda{ @adapter.table_exists?(:table_name) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #create_table is called" do
+    lambda{ @adapter.create_table(:table_name, :column_families) }.should raise_error(NotImplementedError)
+  end
+
+  it "should raise NotImplementedError when #drop_table is called" do
+    lambda{ @adapter.drop_table(:table_name) }.should raise_error(NotImplementedError)
+  end
+
+end

data/spec/unit/adapters/adapter_shared_spec.rb

@@ -0,0 +1,51 @@
+describe "a BigRecord Adapter", :shared => true do
+
+  %w{adapter_name supports_migrations?}.each do |meth|
+    it "should have a ##{meth} method" do
+      @adapter.should respond_to(meth.intern)
+    end
+  end
+
+  describe "with connection management" do
+    %w{active? reconnect! disconnect!}.each do |meth|
+      it "should have a ##{meth} method" do
+        @adapter.should respond_to(meth.intern)
+      end
+    end
+  end
+
+  describe "with data store statements" do
+    %w{update_raw update get_raw get get_columns_raw get_columns get_consecutive_rows_raw get_consecutive_rows delete delete_all}.each do |meth|
+      it "should have a ##{meth} method" do
+        @adapter.should respond_to(meth.intern)
+      end
+    end
+  end
+
+  describe "with schema statements" do
+    %w{table_exists? create_table drop_table}.each do |meth|
+      it "should have a ##{meth} method" do
+        @adapter.should respond_to(meth.intern)
+      end
+    end
+
+    it "should have the methods needed for migrations if supports_migrations? is true" do
+      if @adapter.supports_migrations?
+        %w{initialize_schema_migrations_table get_all_schema_versions add_column_family remove_column_family modify_column_family}.each do |meth|
+          @adapter.should respond_to(meth.intern)
+        end
+      end
+    end
+  end
+
+  describe "timestamp functionality" do
+    it "should use the default Time.to_bigrecord_timestamp or implement it's own method" do
+      Time.now.should respond_to(:to_bigrecord_timestamp)
+      Time.should respond_to(:from_bigrecord_timestamp)
+
+      Time.now.to_bigrecord_timestamp.should_not be_nil
+      Time.from_bigrecord_timestamp(Time.now.to_bigrecord_timestamp).should_not be_nil
+    end
+  end
+
+end

data/spec/unit/adapters/hbase_adapter_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'adapter_shared_spec'))
+
+describe BigRecord::ConnectionAdapters::HbaseAdapter do
+
+  before do
+    # Make sure the connection is defined in spec/connections/bigrecord.yml
+    BigRecord::Base.establish_connection 'hbase'
+
+    @adapter = BigRecord::Base.connection
+  end
+
+  it_should_behave_like 'a BigRecord Adapter'
+
+end

data/spec/unit/ar_associations_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::ArAssociations do
+
+  describe '' do
+  end
+
+end

data/spec/unit/base_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'abstract_base_spec'))
+
+describe BigRecord::Base do
+  it_should_behave_like "BigRecord::AbstractBase"
+end