activerecord 1.0.0 → 2.0.0

data/README

@@ -1,14 +1,14 @@
 = Active Record -- Object-relation mapping put on rails
 
 Active Record connects business objects and database tables to create a persistable
-domain model where logic and data is presented in one wrapping. It's an implementation 
+domain model where logic and data are presented in one wrapping. It's an implementation 
 of the object-relational mapping (ORM) pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] 
 by the same name as described by Martin Fowler:
 
   "An object that wraps a row in a database table or view, encapsulates 
        the database access, and adds domain logic on that data."
 
-Active Records main contribution to the pattern is to relieve the original of two stunting problems:
+Active Record's main contribution to the pattern is to relieve the original of two stunting problems:
 lack of associations and inheritance. By adding a simple domain language-like set of macros to describe
 the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the
 gap of functionality between the data mapper and active record approach.
@@ -29,7 +29,7 @@ A short rundown of the major features:
 
    ...which again gives Product#name and Product#name=(new_name) 
    
-  Learn more in link:classes/ActiveRecord/Base.html
+  {Learn more}[link:classes/ActiveRecord/Base.html]
 
 
 * Associations between objects controlled by simple meta-programming macros. 
@@ -40,7 +40,7 @@ A short rundown of the major features:
      belongs_to :conglomorate
    end
 
-  Learn more in link:classes/ActiveRecord/Associations/ClassMethods.html
+  {Learn more}[link:classes/ActiveRecord/Associations/ClassMethods.html]
 
 
 * Aggregations of value objects controlled by simple meta-programming macros. 
@@ -52,23 +52,33 @@ A short rundown of the major features:
                  :mapping => [%w(address_street street), %w(address_city city)]
    end
 
-  Learn more in link:classes/ActiveRecord/Aggregations/ClassMethods.html
+  {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
 
 
 * Validation rules that can differ for new or existing objects.
 
-   class Post < ActiveRecord::Base
-     def validate # validates on both creates and updates
-       errors.add_on_empty "title"
-     end
+    class Account < ActiveRecord::Base
+      validates_presence_of     :subdomain, :name, :email_address, :password
+      validates_uniqueness_of   :subdomain
+      validates_acceptance_of   :terms_of_service, :on => :create
+      validates_confirmation_of :password, :email_address, :on => :create
+    end
+
+  {Learn more}[link:classes/ActiveRecord/Validations.html]
 
-     def validate_on_update
-       errors.add_on_empty "password"
-     end
-   end
 
-  Learn more in link:classes/ActiveRecord/Validations.html
+* Acts that can make records work as lists or trees:
 
+    class Item < ActiveRecord::Base
+      belongs_to   :list
+      acts_as_list :scope => :list
+    end
+    
+    item.move_higher
+    item.move_to_bottom
+
+  Learn about {acts_as_list}[link:classes/ActiveRecord/Acts/List/ClassMethods.html], {the instance methods acts_as_list provides}[link:classes/ActiveRecord/Acts/List/InstanceMethods.html], and
+  {acts_as_tree}[link:classes/ActiveRecord/Acts/Tree/ClassMethods.html]
  
 * Callbacks as methods or queues on the entire lifecycle (instantiation, saving, destroying, validating, etc).
 
@@ -82,18 +92,18 @@ A short rundown of the major features:
      after_find :eager_load, 'self.class.announce(#{id})'
    end
 
-  Learn more in link:classes/ActiveRecord/Callbacks.html
+  {Learn more}[link:classes/ActiveRecord/Callbacks.html]
 
 
 * Observers for the entire lifecycle
 
    class CommentObserver < ActiveRecord::Observer
      def after_create(comment) # is called just after Comment#save
-       NotificationService.send_email("david@loudthinking.com", comment)
+       Notifications.deliver_new_comment("david@loudthinking.com", comment)
      end
    end
 
-  Learn more in link:classes/ActiveRecord/Observer.html
+  {Learn more}[link:classes/ActiveRecord/Observer.html]
 
 
 * Inheritance hierarchies 
@@ -103,11 +113,11 @@ A short rundown of the major features:
    class Client < Company; end
    class PriorityClient < Client; end
 
-  Learn more in link:classes/ActiveRecord/Base.html
+  {Learn more}[link:classes/ActiveRecord/Base.html]
 
 
 * Transaction support on both a database and object level. The latter is implemented 
-  by using Transaction::Simple[http://www.halostatue.ca/ruby/Transaction__Simple.html]
+  by using Transaction::Simple[http://railsmanual.com/module/Transaction::Simple]
 
     # Just database transaction
     Account.transaction do
@@ -121,7 +131,7 @@ A short rundown of the major features:
       mary.deposit(100)
     end
 
-  Learn more in link:classes/ActiveRecord/Transactions/ClassMethods.html
+  {Learn more}[link:classes/ActiveRecord/Transactions/ClassMethods.html]
 
 
 * Reflections on columns, associations, and aggregations
@@ -130,7 +140,7 @@ A short rundown of the major features:
     reflection.klass # => Client (class)
     Firm.columns # Returns an array of column descriptors for the firms table
 
-  Learn more in link:classes/ActiveRecord/Reflection/ClassMethods.html
+  {Learn more}[link:classes/ActiveRecord/Reflection/ClassMethods.html]
 
 
 * Direct manipulation (instead of service invocation)
@@ -147,15 +157,15 @@ A short rundown of the major features:
 
      pkId = 1234
      cat = Cat.find(pkId)
-     # something even more interesting involving a the same cat...
+     # something even more interesting involving the same cat...
      cat.save
 
-  Learn more in link:classes/ActiveRecord/Base.html
+  {Learn more}[link:classes/ActiveRecord/Base.html]
 
 
 * Database abstraction through simple adapters (~100 lines) with a shared connector
 
-   ActiveRecord::Base.establish_connection(:adapter => "sqlite", :dbfile => "dbfile")
+   ActiveRecord::Base.establish_connection(:adapter => "sqlite", :database => "dbfile")
 
    ActiveRecord::Base.establish_connection(
      :adapter  => "mysql", 
@@ -165,7 +175,8 @@ A short rundown of the major features:
      :database => "activerecord"
    )
 
-  Learn more in link:classes/ActiveRecord/Base.html#M000081
+  {Learn more}[link:classes/ActiveRecord/Base.html#M000081] and read about the built-in support for
+  MySQL[link:classes/ActiveRecord/ConnectionAdapters/MysqlAdapter.html], PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], SQLite[link:classes/ActiveRecord/ConnectionAdapters/SQLiteAdapter.html], Oracle[link:classes/ActiveRecord/ConnectionAdapters/OracleAdapter.html], SQLServer[link:classes/ActiveRecord/ConnectionAdapters/SQLServerAdapter.html], and DB2[link:classes/ActiveRecord/ConnectionAdapters/DB2Adapter.html].
 
 
 * Logging support for Log4r[http://log4r.sourceforge.net] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc]
@@ -178,7 +189,7 @@ A short rundown of the major features:
 
 Data definitions are specified only in the database. Active Record queries the database for 
 the column names (that then serves to determine which attributes are valid) on regular
-objects instantiation through the new constructor and relies on the column names in the rows
+object instantiation through the new constructor and relies on the column names in the rows
 with the finders.
  
    # CREATE TABLE companies (
@@ -224,7 +235,7 @@ Active Record will also automatically link the "Person" object to the "people" t
 
 == Simple example (2/2): Using the domain
 
-Picking a database connection for all the active records
+Picking a database connection for all the Active Records
 
    ActiveRecord::Base.establish_connection(
      :adapter  => "mysql", 
@@ -253,7 +264,7 @@ Lots of different finders
    next_angle = Firm.find(1)    
 
    # SQL: SELECT * FROM companies WHERE id = 1 AND name = 'Next Angle'
-   next_angle = Company.find_first "name = 'Next Angle'"
+   next_angle = Company.find(:first, :conditions => "name = 'Next Angle'")
 
    next_angle = Firm.find_by_sql("SELECT * FROM companies WHERE id = 1").first
 
@@ -287,22 +298,11 @@ the examples themselves.
 It's also highly recommended to have a look at the unit tests. Read more in link:files/RUNNING_UNIT_TESTS.html
 
 
-== Database support
-
-Active Record ships with adapters for MySQL/Ruby[http://www.tmtm.org/en/mysql/ruby/] 
-(compatible with Ruby/MySQL[http://www.tmtm.org/ruby/mysql/README_en.html]), 
-PostgreSQL[http://www.postgresql.jp/interfaces/ruby/], and 
-SQLite[http://rubyforge.org/projects/sqlite-ruby/] (needs SQLite 2.8.13+ and SQLite-Ruby 1.1.2+).
-The adapters are around 100 lines of code fulfilling the interface specified by 
-ActiveRecord::ConnectionAdapters::AbstractAdapter. Writing a new adapter should be a small task --
-especially considering the extensive test suite that'll make sure you're fulfilling the contract.
-
-
 == Philosophy 
 
-Active Record attempts to provide a coherent wrapping for the inconvenience that is 
+Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is 
 object-relational mapping. The prime directive for this mapping has been to minimize
-the amount of code needed to built a real-world domain model. This is made possible
+the amount of code needed to build a real-world domain model. This is made possible
 by relying on a number of conventions that make it easy for Active Record to infer
 complex relations and structures from a minimal amount of explicit direction.
 
@@ -324,7 +324,7 @@ The latest version of Active Record can be found at
 
 Documentation can be found at 
 
-* http://ar.rubyonrails.org
+* http://ar.rubyonrails.com
 
 
 == Installation
@@ -333,7 +333,7 @@ The prefered method of installing Active Record is through its GEM file. You'll
 RubyGems[http://rubygems.rubyforge.org/wiki/wiki.pl] installed for that, though. If you have,
 then use:
 
-  % [sudo] gem install activerecord-0.9.0.gem
+  % [sudo] gem install activerecord-1.10.0.gem
 
 You can also install Active Record the old-fashion way with the following command:
 
@@ -344,12 +344,12 @@ from its distribution directory.
 
 == License
 
-Active Record is released under the same license as Ruby.
+Active Record is released under the MIT license.
 
 
 == Support
 
-The Active Record homepage is http://activerecord.rubyonrails.org. You can find the Active Record
+The Active Record homepage is http://www.rubyonrails.com. You can find the Active Record
 RubyForge page at http://rubyforge.org/projects/activerecord. And as Jim from Rake says:
 
    Feel free to submit commits or feature requests.  If you send a patch,
@@ -358,4 +358,3 @@ RubyForge page at http://rubyforge.org/projects/activerecord. And as Jim from Ra
 
 For other information, feel free to ask on the ruby-talk mailing list
 (which is mirrored to comp.lang.ruby) or contact mailto:david@loudthinking.com.
-

data/RUNNING_UNIT_TESTS

@@ -7,30 +7,27 @@ test/connections/<your database>/connection.rb.
 When you have the database online, you can import the fixture tables with 
 the test/fixtures/db_definitions/*.sql files.
 
-Make sure that you create database objects with the same user that you specified in i
-connection.rb otherwise (on Postgres, at least) tests for default values will fail
-(see http://dev.rubyonrails.org/trac.cgi/ticket/118)
+Make sure that you create database objects with the same user that you specified in 
+connection.rb otherwise (on Postgres, at least) tests for default values will fail.
 
 == Running with Rake
 
 The easiest way to run the unit tests is through Rake. The default task runs
 the entire test suite for all the adapters. You can also run the suite on just
-one adapter by using the tasks test_mysql_ruby, test_ruby_mysql, test_sqlite, 
-or test_postresql. For more information, checkout the full array of rake tasks with "rake -T"
+one adapter by using the tasks test_mysql, test_sqlite, test_postgresql or any
+of the other test_ tasks. For more information, checkout the full array of rake
+tasks with "rake -T"
 
 Rake can be found at http://rake.rubyforge.org
 
 == Running by hand
 
 Unit tests are located in test directory. If you only want to run a single test suite, 
-or don't want to bother with Rake, you can do so with something like:
+you can do so with:
 
-   cd test; ruby -I "connections/native_mysql" base_test.rb
+   rake test_mysql TEST=base_test.rb
    
-That'll run the base suite using the MySQL-Ruby adapter. Change the adapter
-and test suite name as needed.
+That'll run the base suite using the MySQL-Ruby adapter.
 
-You can also run all the suites on a specific adapter with:
 
-   cd test; all.sh "connections/native_mysql"
 

data/Rakefile

@@ -0,0 +1,247 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require File.join(File.dirname(__FILE__), 'lib', 'active_record', 'version')
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'activerecord'
+PKG_VERSION   = ActiveRecord::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "activerecord"
+RUBY_FORGE_USER    = "webster132"
+
+PKG_FILES = FileList[
+    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "[A-Z]*", "install.rb", "Rakefile"
+].exclude(/\bCVS\b|~$/)
+
+
+desc 'Run mysql, sqlite, and postgresql tests by default'
+task :default => :test
+
+desc 'Run mysql, sqlite, and postgresql tests'
+task :test => %w(test_mysql test_sqlite test_sqlite3 test_postgresql)
+
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird db2 oracle sybase openbase frontbase )
+  Rake::TestTask.new("test_#{adapter}") { |t|
+    t.libs << "test" << "test/connections/native_#{adapter}"
+    adapter_short = adapter == 'db2' ? adapter : adapter[/^[a-z]+/]
+    t.pattern = "test/**/*_test{,_#{adapter_short}}.rb"
+    t.verbose = true
+  }
+
+  namespace adapter do
+    task :test => "test_#{adapter}"
+  end
+end
+
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do
+    %x( mysqladmin  create activerecord_unittest )
+    %x( mysqladmin  create activerecord_unittest2 )
+    %x( mysql -e "grant all on activerecord_unittest.* to rails@localhost" )
+    %x( mysql -e "grant all on activerecord_unittest2.* to rails@localhost" )
+  end
+
+  desc 'Drop the MySQL test databases'
+  task :drop_databases do
+    %x( mysqladmin -f drop activerecord_unittest )
+    %x( mysqladmin -f drop activerecord_unittest2 )
+  end
+
+  desc 'Rebuild the MySQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_mysql_databases => 'mysql:build_databases'
+task :drop_mysql_databases => 'mysql:drop_databases'
+task :rebuild_mysql_databases => 'mysql:rebuild_databases'
+
+
+namespace :postgresql do
+  desc 'Build the PostgreSQL test databases'
+  task :build_databases do
+    %x( createdb -U postgres activerecord_unittest )
+    %x( createdb -U postgres activerecord_unittest2 )
+    %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} postgres )
+    %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')}  postgres )
+  end
+
+  desc 'Drop the PostgreSQL test databases'
+  task :drop_databases do
+    %x( dropdb -U postgres activerecord_unittest )
+    %x( dropdb -U postgres activerecord_unittest2 )
+  end
+
+  desc 'Rebuild the PostgreSQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+end
+
+task :build_postgresql_databases => 'postgresql:build_databases'
+task :drop_postgresql_databases => 'postgresql:drop_databases'
+task :rebuild_postgresql_databases => 'postgresql:rebuild_databases'
+
+
+namespace :frontbase do
+  desc 'Build the FrontBase test databases'
+  task :build_databases => :rebuild_frontbase_databases
+
+  desc 'Rebuild the FrontBase test databases'
+  task :rebuild_databases do
+    build_frontbase_database = Proc.new do |db_name, sql_definition_file|
+      %(
+        STOP DATABASE #{db_name};
+        DELETE DATABASE #{db_name};
+        CREATE DATABASE #{db_name};
+
+        CONNECT TO #{db_name} AS SESSION_NAME USER _SYSTEM;
+        SET COMMIT FALSE;
+
+        CREATE USER RAILS;
+        CREATE SCHEMA RAILS AUTHORIZATION RAILS;
+        COMMIT;
+
+        SET SESSION AUTHORIZATION RAILS;
+        SCRIPT '#{sql_definition_file}';
+
+        COMMIT;
+
+        DISCONNECT ALL;
+      )
+    end
+    create_activerecord_unittest  = build_frontbase_database['activerecord_unittest',  File.join(SCHEMA_PATH, 'frontbase.sql')]
+    create_activerecord_unittest2 = build_frontbase_database['activerecord_unittest2', File.join(SCHEMA_PATH, 'frontbase2.sql')]
+    execute_frontbase_sql = Proc.new do |sql|
+      system(<<-SHELL)
+      /Library/FrontBase/bin/sql92 <<-SQL
+      #{sql}
+      SQL
+      SHELL
+    end
+    execute_frontbase_sql[create_activerecord_unittest]
+    execute_frontbase_sql[create_activerecord_unittest2]
+  end
+end
+
+task :build_frontbase_databases => 'frontbase:build_databases'
+task :rebuild_frontbase_databases => 'frontbase:rebuild_databases'
+
+
+# Generate the RDoc documentation
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Active Record -- Object-relation mapping put on rails"
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.exclude('lib/active_record/vendor/*')
+  rdoc.rdoc_files.include('dev-utils/*.rb')
+}
+
+# Enhance rdoc task to copy referenced images also
+task :rdoc do
+  FileUtils.mkdir_p "doc/files/examples/"
+  FileUtils.copy "examples/associations.png", "doc/files/examples/associations.png"
+end
+
+
+# Create compressed packages
+
+dist_dirs = [ "lib", "test", "examples" ]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Implements the ActiveRecord pattern for ORM."
+  s.description = %q{Implements the ActiveRecord pattern (Fowler, PoEAA) for ORM. It ties database tables and classes together for business objects, like Customer or Subscription, that can find, save, and destroy themselves without resorting to manual SQL.}
+
+  s.files = [ "Rakefile", "install.rb", "README", "RUNNING_UNIT_TESTS", "CHANGELOG" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+
+  s.add_dependency('activesupport', '= 2.0.0' + PKG_BUILD)
+
+  s.files.delete "test/fixtures/fixture_database.sqlite"
+  s.files.delete "test/fixtures/fixture_database_2.sqlite"
+  s.files.delete "test/fixtures/fixture_database.sqlite3"
+  s.files.delete "test/fixtures/fixture_database_2.sqlite3"
+  s.require_path = 'lib'
+  s.autorequire = 'active_record'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README )
+  s.rdoc_options.concat ['--main',  'README']
+
+  s.author = "David Heinemeier Hansson"
+  s.email = "david@loudthinking.com"
+  s.homepage = "http://www.rubyonrails.org"
+  s.rubyforge_project = "activerecord"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/active_record/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+
+    total_lines     += lines
+    total_codelines += codelines
+
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+
+# Publishing ------------------------------------------------------
+
+desc "Publish the beta gem"
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new("davidhh@wrath.rubyonrails.org", "public_html/ar", "doc").upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  require 'rubyforge'
+
+  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end

data/install.rb

@@ -18,43 +18,13 @@ unless $sitedir
   end
 end
 
-makedirs = %w{ active_record/associations active_record/connection_adapters active_record/support active_record/vendor }
-makedirs.each {|f| File::makedirs(File.join($sitedir, *f.split(/\//)))}
-
-# deprecated files that should be removed
-# deprecated = %w{ }
-
-# files to install in library path
-files = %w-
- active_record.rb
- active_record/aggregations.rb
- active_record/associations.rb
- active_record/associations/association_collection.rb
- active_record/associations/has_and_belongs_to_many_association.rb
- active_record/associations/has_many_association.rb
- active_record/base.rb
- active_record/callbacks.rb
- active_record/connection_adapters/abstract_adapter.rb
- active_record/connection_adapters/mysql_adapter.rb
- active_record/connection_adapters/postgresql_adapter.rb
- active_record/connection_adapters/sqlite_adapter.rb
- active_record/deprecated_associations.rb
- active_record/fixtures.rb
- active_record/observer.rb
- active_record/reflection.rb
- active_record/support/class_attribute_accessors.rb
- active_record/support/class_inheritable_attributes.rb
- active_record/support/clean_logger.rb
- active_record/support/inflector.rb
- active_record/transactions.rb
- active_record/validations.rb
- active_record/vendor/mysql.rb
- active_record/vendor/simple.rb
--
-
-# the acual gruntwork
+# the actual gruntwork
 Dir.chdir("lib")
-# File::safe_unlink *deprecated.collect{|f| File.join($sitedir, f.split(/\//))}
-files.each {|f| 
-  File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+
+Find.find("active_record", "active_record.rb") { |f|
+  if f[-3..-1] == ".rb"
+    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
+  else
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
 }