libgems 0.0.1

data/lib/libgems/gem_runner.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'libgems/command_manager'
+require 'libgems/config_file'
+require 'libgems/doc_manager'
+
+##
+# Run an instance of the gem program.
+#
+# LibGems::GemRunner is only intended for internal use by SlimGems itself.  It
+# does not form any public API and may change at any time for any reason.
+#
+# If you would like to duplicate functionality of `gem` commands, use the
+# classes they call directly.
+
+class LibGems::GemRunner
+
+  def initialize(options={})
+    @command_manager_class = options[:command_manager] || LibGems::CommandManager
+    @config_file_class = options[:config_file] || LibGems::ConfigFile
+    @doc_manager_class = options[:doc_manager] || LibGems::DocManager
+  end
+
+  ##
+  # Run the gem command with the following arguments.
+
+  def run(args)
+    start_time = Time.now
+
+    if args.include?('--')
+      # We need to preserve the original ARGV to use for passing gem options
+      # to source gems.  If there is a -- in the line, strip all options after
+      # it...its for the source building process.
+      build_args = args[args.index("--") + 1...args.length]
+      args = args[0...args.index("--")]
+    end
+
+    LibGems::Command.build_args = build_args if build_args
+
+    do_configuration args
+    cmd = @command_manager_class.instance
+
+    cmd.command_names.each do |command_name|
+      config_args = LibGems.configuration[command_name]
+      config_args = case config_args
+                    when String
+                      config_args.split ' '
+                    else
+                      Array(config_args)
+                    end
+      LibGems::Command.add_specific_extra_args command_name, config_args
+    end
+
+    cmd.run LibGems.configuration.args
+    end_time = Time.now
+
+    if LibGems.configuration.benchmark then
+      printf "\nExecution time: %0.2f seconds.\n", end_time - start_time
+      puts "Press Enter to finish"
+      STDIN.gets
+    end
+  end
+
+  private
+
+  def do_configuration(args)
+    LibGems.configuration = @config_file_class.new(args)
+    LibGems.use_paths(LibGems.configuration[:gemhome], LibGems.configuration[:gempath])
+    LibGems::Command.extra_args = LibGems.configuration[:gem]
+    @doc_manager_class.configured_args = LibGems.configuration[:rdoc]
+  end
+
+end
+
+LibGems.load_plugins

data/lib/libgems/gemcutter_utilities.rb

@@ -0,0 +1,49 @@
+require 'libgems/remote_fetcher'
+
+module LibGems::GemcutterUtilities
+
+  def sign_in
+    return if LibGems.configuration.rubygems_api_key
+
+    say "Enter your rubygems.org credentials."
+    say "Don't have an account yet? Create one at http://rubygems.org/sign_up"
+
+    email    =              ask "   Email: "
+    password = ask_for_password "Password: "
+    say "\n"
+
+    response = rubygems_api_request :get, "api/v1/api_key" do |request|
+      request.basic_auth email, password
+    end
+
+    with_response response do |resp|
+      say "Signed in."
+      LibGems.configuration.rubygems_api_key = resp.body
+    end
+  end
+
+  def rubygems_api_request(method, path, host = LibGems.host, &block)
+    require 'net/http'
+    host = ENV['RUBYGEMS_HOST'] if ENV['RUBYGEMS_HOST']
+    uri = URI.parse "#{host}/#{path}"
+
+    request_method = Net::HTTP.const_get method.to_s.capitalize
+
+    LibGems::RemoteFetcher.fetcher.request(uri, request_method, &block)
+  end
+
+  def with_response(resp)
+    case resp
+    when Net::HTTPSuccess then
+      if block_given? then
+        yield resp
+      else
+        say resp.body
+      end
+    else
+      say resp.body
+      terminate_interaction 1
+    end
+  end
+
+end

data/lib/libgems/indexer.rb

@@ -0,0 +1,720 @@
+require 'fileutils'
+require 'tmpdir'
+require 'zlib'
+
+require 'libgems'
+require 'libgems/format'
+
+begin
+  gem 'builder'
+  require 'builder/xchar'
+rescue LoadError
+end
+
+##
+# Top level class for building the gem repository index.
+
+class LibGems::Indexer
+
+  include LibGems::UserInteraction
+
+  ##
+  # Build indexes for SlimGems older than 1.2.0 when true
+
+  attr_accessor :build_legacy
+
+  ##
+  # Build indexes for SlimGems 1.2.0 and newer when true
+
+  attr_accessor :build_modern
+
+  ##
+  # Index install location
+
+  attr_reader :dest_directory
+
+  ##
+  # Specs index install location
+
+  attr_reader :dest_specs_index
+
+  ##
+  # Latest specs index install location
+
+  attr_reader :dest_latest_specs_index
+
+  ##
+  # Prerelease specs index install location
+
+  attr_reader :dest_prerelease_specs_index
+
+  ##
+  # Index build directory
+
+  attr_reader :directory
+
+  ##
+  # Create an indexer that will index the gems in +directory+.
+
+  def initialize(directory, options = {})
+    unless defined?(Builder::XChar) then
+      raise "LibGems::Indexer requires that the XML Builder library be installed:" \
+           "\n\tgem install builder"
+    end
+
+    options = { :build_legacy => true, :build_modern => true }.merge options
+
+    @build_legacy = options[:build_legacy]
+    @build_modern = options[:build_modern]
+
+    @rss_title = options[:rss_title]
+    @rss_host = options[:rss_host]
+    @rss_gems_host = options[:rss_gems_host]
+
+    @dest_directory = directory
+    @directory = File.join Dir.tmpdir, "gem_generate_index_#{$$}"
+
+    marshal_name = "Marshal.#{LibGems.marshal_version}"
+
+    @master_index = File.join @directory, 'yaml'
+    @marshal_index = File.join @directory, marshal_name
+
+    @quick_dir = File.join @directory, 'quick'
+
+    @quick_marshal_dir = File.join @quick_dir, marshal_name
+
+    @quick_index = File.join @quick_dir, 'index'
+    @latest_index = File.join @quick_dir, 'latest_index'
+
+    @specs_index = File.join @directory, "specs.#{LibGems.marshal_version}"
+    @latest_specs_index = File.join @directory,
+                                    "latest_specs.#{LibGems.marshal_version}"
+    @prerelease_specs_index = File.join(@directory,
+                                        "prerelease_specs.#{LibGems.marshal_version}")
+
+    @dest_specs_index = File.join @dest_directory,
+                                  "specs.#{LibGems.marshal_version}"
+    @dest_latest_specs_index = File.join @dest_directory,
+                                         "latest_specs.#{LibGems.marshal_version}"
+    @dest_prerelease_specs_index = File.join @dest_directory,
+                                            "prerelease_specs.#{LibGems.marshal_version}"
+
+    @rss_index = File.join @directory, 'index.rss'
+
+    @files = []
+  end
+
+  ##
+  # Abbreviate the spec for downloading.  Abbreviated specs are only used for
+  # searching, downloading and related activities and do not need deployment
+  # specific information (e.g. list of files).  So we abbreviate the spec,
+  # making it much smaller for quicker downloads.
+
+  def abbreviate(spec)
+    spec.files = []
+    spec.test_files = []
+    spec.rdoc_options = []
+    spec.extra_rdoc_files = []
+    spec.cert_chain = []
+    spec
+  end
+
+  ##
+  # Build various indicies
+
+  def build_indicies(index)
+    # Marshal gemspecs are used by both modern and legacy SlimGems
+    build_marshal_gemspecs index
+    build_legacy_indicies index if @build_legacy
+    build_modern_indicies index if @build_modern
+    build_rss index
+
+    compress_indicies
+  end
+
+  ##
+  # Builds indicies for SlimGems older than 1.2.x
+
+  def build_legacy_indicies(index)
+    progress = ui.progress_reporter index.size,
+                                    "Generating YAML quick index gemspecs for #{index.size} gems",
+                                    "Complete"
+
+    LibGems.time 'Generated YAML quick index gemspecs' do
+      index.released_gems.each do |original_name, spec|
+        spec_file_name = "#{original_name}.gemspec.rz"
+        yaml_name = File.join @quick_dir, spec_file_name
+
+        yaml_zipped = LibGems.deflate spec.to_yaml
+        open yaml_name, 'wb' do |io| io.write yaml_zipped end
+
+        progress.updated original_name
+      end
+
+      progress.done
+    end
+
+    say "Generating quick index"
+
+    LibGems.time 'Generated quick index' do
+      open @quick_index, 'wb' do |io|
+        io.puts index.sort.map { |_, spec| spec.original_name }
+      end
+    end
+
+    say "Generating latest index"
+
+    LibGems.time 'Generated latest index' do
+      open @latest_index, 'wb' do |io|
+        io.puts index.latest_specs.sort.map { |spec| spec.original_name }
+      end
+    end
+
+    # Don't need prerelease legacy index
+
+    say "Generating Marshal master index"
+
+    LibGems.time 'Generated Marshal master index' do
+      open @marshal_index, 'wb' do |io|
+        io.write index.dump
+      end
+    end
+
+    progress = ui.progress_reporter index.size,
+                                    "Generating YAML master index for #{index.size} gems (this may take a while)",
+                                    "Complete"
+
+    LibGems.time 'Generated YAML master index' do
+      open @master_index, 'wb' do |io|
+        io.puts "--- !ruby/object:#{index.class}"
+        io.puts "gems:"
+
+        gems = index.sort_by { |name, gemspec| gemspec.sort_obj }
+        gems.each do |original_name, gemspec|
+          yaml = gemspec.to_yaml.gsub(/^/, '    ')
+          yaml = yaml.sub(/\A    ---/, '') # there's a needed extra ' ' here
+          io.print "  #{original_name}:"
+          io.puts yaml
+
+          progress.updated original_name
+        end
+      end
+
+      progress.done
+    end
+
+    @files << @quick_dir
+    @files << @master_index
+    @files << "#{@master_index}.Z"
+    @files << @marshal_index
+    @files << "#{@marshal_index}.Z"
+  end
+
+  ##
+  # Builds Marshal quick index gemspecs.
+
+  def build_marshal_gemspecs(index)
+    progress = ui.progress_reporter index.size,
+                                    "Generating Marshal quick index gemspecs for #{index.size} gems",
+                                    "Complete"
+
+    files = []
+
+    LibGems.time 'Generated Marshal quick index gemspecs' do
+      index.gems.each do |original_name, spec|
+        spec_file_name = "#{original_name}.gemspec.rz"
+        marshal_name = File.join @quick_marshal_dir, spec_file_name
+
+        marshal_zipped = LibGems.deflate Marshal.dump(spec)
+        open marshal_name, 'wb' do |io| io.write marshal_zipped end
+
+        files << marshal_name
+
+        progress.updated original_name
+      end
+
+      progress.done
+    end
+
+    @files << @quick_marshal_dir
+
+    files
+  end
+
+  ##
+  # Build a single index for SlimGems 1.2 and newer
+
+  def build_modern_index(index, file, name)
+    say "Generating #{name} index"
+
+    LibGems.time "Generated #{name} index" do
+      open(file, 'wb') do |io|
+        specs = index.map do |*spec|
+          # We have to splat here because latest_specs is an array,
+          # while the others are hashes. See the TODO in source_index.rb
+          spec = spec.flatten.last
+          platform = spec.original_platform
+
+          # win32-api-1.0.4-x86-mswin32-60
+          unless String === platform then
+            alert_warning "Skipping invalid platform in gem: #{spec.full_name}"
+            next
+          end
+
+          platform = LibGems::Platform::RUBY if platform.nil? or platform.empty?
+          [spec.name, spec.version, platform]
+        end
+
+        specs = compact_specs(specs)
+        Marshal.dump(specs, io)
+      end
+    end
+  end
+
+  ##
+  # Builds indicies for SlimGems 1.2 and newer. Handles full, latest, prerelease
+
+  def build_modern_indicies(index)
+    build_modern_index(index.released_specs.sort, @specs_index, 'specs')
+    build_modern_index(index.latest_specs.sort,
+                       @latest_specs_index,
+                       'latest specs')
+    build_modern_index(index.prerelease_specs.sort,
+                       @prerelease_specs_index,
+                       'prerelease specs')
+
+    @files += [@specs_index,
+               "#{@specs_index}.gz",
+               @latest_specs_index,
+               "#{@latest_specs_index}.gz",
+               @prerelease_specs_index,
+               "#{@prerelease_specs_index}.gz"]
+  end
+
+  ##
+  # Builds an RSS feed for past two days gem releases according to the gem's
+  # date.
+
+  def build_rss(index)
+    if @rss_host.nil? or @rss_gems_host.nil? then
+      if LibGems.configuration.really_verbose then
+        alert_warning "no --rss-host or --rss-gems-host, RSS generation disabled"
+      end
+      return
+    end
+
+    require 'cgi'
+    require 'libgems/text'
+
+    extend LibGems::Text
+
+    LibGems.time 'Generated rss' do
+      open @rss_index, 'wb' do |io|
+        rss_host = CGI.escapeHTML @rss_host
+        rss_title = CGI.escapeHTML(@rss_title || 'gems')
+
+        io.puts <<-HEADER
+<?xml version="1.0"?>
+<rss version="2.0">
+  <channel>
+    <title>#{rss_title}</title>
+    <link>http://#{rss_host}</link>
+    <description>Recently released gems from http://#{rss_host}</description>
+    <generator>#{LibGems::NAME} v#{LibGems::VERSION} (RubyGems v#{LibGems::GEM_VERSION})</generator>
+    <docs>http://cyber.law.harvard.edu/rss/rss.html</docs>
+        HEADER
+
+        today = LibGems::Specification::TODAY
+        yesterday = today - 86400
+
+        index = index.select do |_, spec|
+          spec_date = spec.date
+
+          case spec_date
+          when Date
+            Time.parse(spec_date.to_s) >= yesterday
+          when Time
+            spec_date >= yesterday
+          end
+        end
+
+        index = index.select do |_, spec|
+          spec_date = spec.date
+
+          case spec_date
+          when Date
+            Time.parse(spec_date.to_s) <= today
+          when Time
+            spec_date <= today
+          end
+        end
+
+        index.sort_by { |_, spec| [-spec.date.to_i, spec] }.each do |_, spec|
+          gem_path = CGI.escapeHTML "http://#{@rss_gems_host}/gems/#{spec.file_name}"
+          size = File.stat(spec.loaded_from).size rescue next
+
+          description = spec.description || spec.summary || ''
+          authors = Array spec.authors
+          emails = Array spec.email
+          authors = emails.zip(authors).map do |email, author|
+            email += " (#{author})" if author and not author.empty?
+          end.join ', '
+
+          description = description.split(/\n\n+/).map do |chunk|
+            format_text chunk, 78
+          end
+
+          description = description.join "\n\n"
+
+          item = ''
+
+          item << <<-ITEM
+    <item>
+      <title>#{CGI.escapeHTML spec.full_name}</title>
+      <description>
+&lt;pre&gt;#{CGI.escapeHTML description.chomp}&lt;/pre&gt;
+      </description>
+      <author>#{CGI.escapeHTML authors}</author>
+      <guid>#{CGI.escapeHTML spec.full_name}</guid>
+      <enclosure url=\"#{gem_path}\"
+                 length=\"#{size}\" type=\"application/octet-stream\" />
+      <pubDate>#{spec.date.rfc2822}</pubDate>
+          ITEM
+
+          item << <<-ITEM if spec.homepage
+      <link>#{CGI.escapeHTML spec.homepage}</link>
+          ITEM
+
+          item << <<-ITEM
+    </item>
+          ITEM
+
+          io.puts item
+        end
+
+        io.puts <<-FOOTER
+  </channel>
+</rss>
+        FOOTER
+      end
+    end
+
+    @files << @rss_index
+  end
+
+  ##
+  # Collect specifications from .gem files from the gem directory.
+
+  def collect_specs(gems = gem_file_list)
+    index = LibGems::SourceIndex.new
+
+    progress = ui.progress_reporter gems.size,
+                                    "Loading #{gems.size} gems from #{@dest_directory}",
+                                    "Loaded all gems"
+
+    LibGems.time 'loaded' do
+      gems.each do |gemfile|
+        if File.size(gemfile.to_s) == 0 then
+          alert_warning "Skipping zero-length gem: #{gemfile}"
+          next
+        end
+
+        begin
+          spec = LibGems::Format.from_file_by_path(gemfile).spec
+          spec.loaded_from = gemfile
+
+          unless gemfile =~ /\/#{Regexp.escape spec.original_name}.*\.gem\z/i then
+            expected_name = spec.full_name
+            expected_name << " (#{spec.original_name})" if
+              spec.original_name != spec.full_name
+            alert_warning "Skipping misnamed gem: #{gemfile} should be named #{expected_name}"
+            next
+          end
+
+          abbreviate spec
+          sanitize spec
+
+          index.add_spec spec, spec.original_name
+
+          progress.updated spec.original_name
+
+        rescue SignalException => e
+          alert_error "Received signal, exiting"
+          raise
+        rescue Exception => e
+          alert_error "Unable to process #{gemfile}\n#{e.message} (#{e.class})\n\t#{e.backtrace.join "\n\t"}"
+        end
+      end
+
+      progress.done
+    end
+
+    index
+  end
+
+  ##
+  # Compresses indicies on disk
+  #--
+  # All future files should be compressed using gzip, not deflate
+
+  def compress_indicies
+    say "Compressing indicies"
+
+    LibGems.time 'Compressed indicies' do
+      if @build_legacy then
+        compress @quick_index, 'rz'
+        paranoid @quick_index, 'rz'
+
+        compress @latest_index, 'rz'
+        paranoid @latest_index, 'rz'
+
+        compress @marshal_index, 'Z'
+        paranoid @marshal_index, 'Z'
+
+        compress @master_index, 'Z'
+        paranoid @master_index, 'Z'
+      end
+
+      if @build_modern then
+        gzip @specs_index
+        gzip @latest_specs_index
+        gzip @prerelease_specs_index
+      end
+    end
+  end
+
+  ##
+  # Compacts Marshal output for the specs index data source by using identical
+  # objects as much as possible.
+
+  def compact_specs(specs)
+    names = {}
+    versions = {}
+    platforms = {}
+
+    specs.map do |(name, version, platform)|
+      names[name] = name unless names.include? name
+      versions[version] = version unless versions.include? version
+      platforms[platform] = platform unless platforms.include? platform
+
+      [names[name], versions[version], platforms[platform]]
+    end
+  end
+
+  ##
+  # Compress +filename+ with +extension+.
+
+  def compress(filename, extension)
+    data = LibGems.read_binary filename
+
+    zipped = LibGems.deflate data
+
+    open "#{filename}.#{extension}", 'wb' do |io|
+      io.write zipped
+    end
+  end
+
+  ##
+  # List of gem file names to index.
+
+  def gem_file_list
+    Dir.glob(File.join(@dest_directory, "gems", "*.gem"))
+  end
+
+  ##
+  # Builds and installs indicies.
+
+  def generate_index
+    make_temp_directories
+    index = collect_specs
+    build_indicies index
+    install_indicies
+  rescue SignalException
+  ensure
+    FileUtils.rm_rf @directory
+  end
+
+  ##
+  # Zlib::GzipWriter wrapper that gzips +filename+ on disk.
+
+  def gzip(filename)
+    Zlib::GzipWriter.open "#{filename}.gz" do |io|
+      io.write LibGems.read_binary(filename)
+    end
+  end
+
+  ##
+  # Install generated indicies into the destination directory.
+
+  def install_indicies
+    verbose = LibGems.configuration.really_verbose
+
+    say "Moving index into production dir #{@dest_directory}" if verbose
+
+    files = @files.dup
+    files.delete @quick_marshal_dir if files.include? @quick_dir
+
+    if files.include? @quick_marshal_dir and
+       not files.include? @quick_dir then
+      files.delete @quick_marshal_dir
+      quick_marshal_dir = @quick_marshal_dir.sub @directory, ''
+
+      dst_name = File.join @dest_directory, quick_marshal_dir
+
+      FileUtils.mkdir_p File.dirname(dst_name), :verbose => verbose
+      FileUtils.rm_rf dst_name, :verbose => verbose
+      FileUtils.mv @quick_marshal_dir, dst_name, :verbose => verbose,
+                   :force => true
+    end
+
+    files = files.map do |path|
+      path.sub @directory, ''
+    end
+
+    files.each do |file|
+      src_name = File.join @directory, file
+      dst_name = File.join @dest_directory, file
+
+      FileUtils.rm_rf dst_name, :verbose => verbose
+      FileUtils.mv src_name, @dest_directory, :verbose => verbose,
+                   :force => true
+    end
+  end
+
+  ##
+  # Make directories for index generation
+
+  def make_temp_directories
+    FileUtils.rm_rf @directory
+    FileUtils.mkdir_p @directory, :mode => 0700
+    FileUtils.mkdir_p @quick_marshal_dir
+  end
+
+  ##
+  # Ensure +path+ and path with +extension+ are identical.
+
+  def paranoid(path, extension)
+    data = LibGems.read_binary path
+    compressed_data = LibGems.read_binary "#{path}.#{extension}"
+
+    unless data == LibGems.inflate(compressed_data) then
+      raise "Compressed file #{compressed_path} does not match uncompressed file #{path}"
+    end
+  end
+
+  ##
+  # Sanitize the descriptive fields in the spec.  Sometimes non-ASCII
+  # characters will garble the site index.  Non-ASCII characters will
+  # be replaced by their XML entity equivalent.
+
+  def sanitize(spec)
+    spec.summary = sanitize_string(spec.summary)
+    spec.description = sanitize_string(spec.description)
+    spec.post_install_message = sanitize_string(spec.post_install_message)
+    spec.authors = spec.authors.collect { |a| sanitize_string(a) }
+
+    spec
+  end
+
+  ##
+  # Sanitize a single string.
+
+  def sanitize_string(string)
+    return string unless string
+
+    # HACK the #to_s is in here because RSpec has an Array of Arrays of
+    # Strings for authors.  Need a way to disallow bad values on gempsec
+    # generation.  (Probably won't happen.)
+    string = string.to_s
+
+    begin
+      Builder::XChar.encode string
+    rescue NameError, NoMethodError
+      string.to_xs
+    end
+  end
+
+  ##
+  # Perform an in-place update of the repository from newly added gems.  Only
+  # works for modern indicies, and sets #build_legacy to false when run.
+
+  def update_index
+    @build_legacy = false
+
+    make_temp_directories
+
+    specs_mtime = File.stat(@dest_specs_index).mtime
+    newest_mtime = Time.at 0
+
+    updated_gems = gem_file_list.select do |gem|
+      gem_mtime = File.stat(gem).mtime
+      newest_mtime = gem_mtime if gem_mtime > newest_mtime
+      gem_mtime >= specs_mtime
+    end
+
+    if updated_gems.empty? then
+      say 'No new gems'
+      terminate_interaction 0
+    end
+
+    index = collect_specs updated_gems
+
+    files = build_marshal_gemspecs index
+
+    LibGems.time 'Updated indexes' do
+      update_specs_index index.released_gems, @dest_specs_index, @specs_index
+      update_specs_index index.released_gems, @dest_latest_specs_index, @latest_specs_index
+      update_specs_index(index.prerelease_gems, @dest_prerelease_specs_index,
+                         @prerelease_specs_index)
+    end
+
+    compress_indicies
+
+    verbose = LibGems.configuration.really_verbose
+
+    say "Updating production dir #{@dest_directory}" if verbose
+
+    files << @specs_index
+    files << "#{@specs_index}.gz"
+    files << @latest_specs_index
+    files << "#{@latest_specs_index}.gz"
+    files << @prerelease_specs_index
+    files << "#{@prerelease_specs_index}.gz"
+
+    files = files.map do |path|
+      path.sub @directory, ''
+    end
+
+    files.each do |file|
+      src_name = File.join @directory, file
+      dst_name = File.join @dest_directory, File.dirname(file)
+
+      FileUtils.mv src_name, dst_name, :verbose => verbose,
+                   :force => true
+
+      File.utime newest_mtime, newest_mtime, dst_name
+    end
+  end
+
+  ##
+  # Combines specs in +index+ and +source+ then writes out a new copy to
+  # +dest+.  For a latest index, does not ensure the new file is minimal.
+
+  def update_specs_index(index, source, dest)
+    specs_index = Marshal.load LibGems.read_binary(source)
+
+    index.each do |_, spec|
+      platform = spec.original_platform
+      platform = LibGems::Platform::RUBY if platform.nil? or platform.empty?
+      specs_index << [spec.name, spec.version, platform]
+    end
+
+    specs_index = compact_specs specs_index.uniq.sort
+
+    open dest, 'wb' do |io|
+      Marshal.dump specs_index, io
+    end
+  end
+
+end
+