fig 2.0.0.pre.alpha.3 → 2.0.0.pre.alpha.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdd1e421366a665108de5fd81a68498c9809df0ce0ad07271101972a767d0d0f
-  data.tar.gz: 68efbaf9fcdffc32985aa9f38816c6e5b924d511506f46710edb693c31b43f4c
+  metadata.gz: 62f48881b3ac7d401f94298e95315f0500b08a26635ecbc36a47de29e9ef172e
+  data.tar.gz: b1833add69c8cf53d54cd0ce76ee6cc1608c713eb487963f0af679671916e22e
 SHA512:
-  metadata.gz: 70d69aa2ba2cfd2ecba24909220b1b4f88f642e026fb3b553ac4025d4dc3d5676f0e8489b787f683ccc9f87fc1b1e3dbade15c7384dcad9340c0b3249c3d998f
-  data.tar.gz: 04b889ccfc8c71e306184cecfe406d482f2200354b72f71a48771057b6ad3d210b9745eddb934555ff227acc88a17f9d8079fb309656ae12de277ae19176d424
+  metadata.gz: 062e6bb0dc0a5ccaa087022de0398cb641393f2dd4938afeecf1199ab0a8d81ef3b7c6c784d116b9f9b43aac5c769df1e177b12ac85a06fa4c54dd08b7249a7a
+  data.tar.gz: 77ec6f3a04820f24d373304f5289c5164ffd66984f3d6922a6de2d02fd3be288432e0b07a319e52dd36f633f877b109b859b79feef609a7aeef9e32ffe8bd98a

data/lib/fig/application_configuration.rb

@@ -5,7 +5,8 @@ module Fig; end
 # Configuration for the Fig program, as opposed to a config in a package.
 class Fig::ApplicationConfiguration
   attr_accessor :base_whitelisted_url
-  attr_accessor :remote_repository_url
+  attr_accessor :remote_download_url
+  attr_accessor :remote_upload_url
 
   def initialize()
     @data = []

data/lib/fig/command/options/parser.rb

@@ -115,8 +115,10 @@ required or allowed is dependent upon what your are doing.
 
 Environment variables:
 
-  FIG_REMOTE_URL     location of remote repository, required for remote
-                     operations
+  FIG_DOWNLOAD_URL   location of remote repository for download, required for remote
+                     download operations
+  FIG_UPLOAD_URL     location of remote repository for upload, required for remote
+                     publish/upload operations
   FIG_HOME           path to local repository, defaults to $HOME/.fighome
   FIG_SVN_EXECUTABLE path to svn executable, set to empty string to suppress
                      use of Subversion

data/lib/fig/command/options.rb

@@ -712,7 +712,7 @@ Running commands:
     end
 
     @parser.on('--no-figrc', 'ignore ~/.figrc') { @no_figrc = true }
-    @parser.on('--no-remote-figrc', 'ignore $FIG_REMOTE_URL/_meta/figrc') {
+    @parser.on('--no-remote-figrc', 'ignore $FIG_DOWNLOAD_URL/_meta/figrc') {
       @no_remote_figrc = true
     }
 

data/lib/fig/command.rb

@@ -236,20 +236,28 @@ class Fig::Command
   def set_up_application_configuration()
     @application_configuration = Fig::FigRC.find(
       @options.figrc,
-      ENV['FIG_REMOTE_URL'],
+      ENV['FIG_DOWNLOAD_URL'],
+      ENV['FIG_UPLOAD_URL'],
       @operating_system,
       @options.home,
       @options.no_figrc?,
       @options.no_remote_figrc?
     )
 
-    if \
-          remote_operation_necessary? \
-      &&  @application_configuration.remote_repository_url.nil?
+    if remote_operation_necessary?
+      # Check if any action is a publishing operation. Note that "publish" doesn't
+      # necessarily mean "upload" b/c it could be publishing to a local repo.
+      publishing_operation = @options.actions.any? {|action| action.publish?}
 
-      raise Fig::UserInputError.new(
-        'Please define the FIG_REMOTE_URL environment variable.'
-      )
+      if publishing_operation && @application_configuration.remote_upload_url.nil?
+        raise Fig::UserInputError.new(
+          'Must set FIG_UPLOAD_URL for publish/upload operations.'
+        )
+      elsif !publishing_operation && @application_configuration.remote_download_url.nil?
+        raise Fig::UserInputError.new(
+          'Must set FIG_DOWNLOAD_URL for download repository operations.'
+        )
+      end
     end
 
     return
@@ -261,7 +269,8 @@ class Fig::Command
       @options,
       @operating_system,
       @options.home(),
-      @application_configuration.remote_repository_url,
+      @application_configuration.remote_download_url,
+      @application_configuration.remote_upload_url,
       @parser,
       @publish_listeners,
     )

data/lib/fig/figrc.rb

@@ -15,10 +15,10 @@ module Fig; end
 class Fig::FigRC
   REPOSITORY_CONFIGURATION =
       "#{Fig::Repository::METADATA_SUBDIRECTORY}/figrc"
-
   def self.find(
     override_path,
-    specified_repository_url,
+    download_repository_url,
+    upload_repository_url,
     operating_system,
     fig_home,
     disable_figrc = false,
@@ -28,17 +28,44 @@ class Fig::FigRC
 
     handle_override_configuration(configuration, override_path)
     handle_figrc(configuration) if not disable_figrc
+    
+    # Check for legacy environment variable usage
+    download_url = derive_repository_url(download_repository_url, 'DOWNLOAD', configuration)
+    upload_url = derive_repository_url(upload_repository_url, 'UPLOAD', configuration)
+    remote_url = ENV['FIG_REMOTE_URL']
+    
+    has_download = !download_url.nil? && !download_url.strip.empty?
+    has_upload = !upload_url.nil? && !upload_url.strip.empty?
+    has_remote = !remote_url.nil? && !remote_url.strip.empty?
+    
+    # Error case: FIG_REMOTE_URL exists but one or both new URLs missing
+    if has_remote && (!has_download || !has_upload)
+      raise Fig::UserInputError.new(
+        'FIG_REMOTE_URL is set but FIG_DOWNLOAD_URL and/or FIG_UPLOAD_URL are missing. ' +
+        'Please set both FIG_DOWNLOAD_URL and FIG_UPLOAD_URL instead of FIG_REMOTE_URL.'
+      )
+    end
 
-    repository_url =
-      derive_repository_url(specified_repository_url, configuration)
-
-    configuration.base_whitelisted_url = repository_url
-    configuration.remote_repository_url = repository_url
-
-    handle_repository_configuration(
-      configuration, repository_url, operating_system, fig_home
-    ) if not disable_remote_figrc
-
+    # Warning case: All three variables exist
+    if has_remote && has_download && has_upload
+      $stderr.puts "WARNING: FIG_REMOTE_URL is set but will be ignored. Using FIG_DOWNLOAD_URL and FIG_UPLOAD_URL instead."
+    end
+    
+    # Set the new URL attributes
+    configuration.remote_download_url = download_url
+    configuration.remote_upload_url = upload_url
+    
+    # For backward compatibility with code expecting whitelisted URLs
+    url_for_whitelist = has_download ? download_url : nil
+    configuration.base_whitelisted_url = url_for_whitelist
+    
+    # Handle repository configuration if enabled
+    if !disable_remote_figrc && has_download
+      handle_repository_configuration(
+        configuration, download_url, operating_system, fig_home
+      )
+    end
+    
     return configuration
   end
 
@@ -73,9 +100,9 @@ class Fig::FigRC
     return
   end
 
-  def self.derive_repository_url(specified_repository_url, configuration)
+  def self.derive_repository_url(specified_repository_url, which, configuration)
     if specified_repository_url.nil?
-      return configuration['default FIG_REMOTE_URL']
+      return configuration["default FIG_#{which}_URL"]
     end
 
     if specified_repository_url.empty? || specified_repository_url =~ /\A\s*\z/

data/lib/fig/protocol/file.rb

@@ -21,10 +21,12 @@ class Fig::Protocol::File
     return packages if ! ::File.exist?(unescaped_path)
 
     ls = ''
+
+    unescaped_path = FileTest.symlink?(unescaped_path) ? ::File.realpath(unescaped_path) : unescaped_path
     Find.find(unescaped_path) {
       |file|
 
-      if FileTest.directory? file
+      if FileTest.directory?(file)
         ls << file.to_s
         ls << "\n"
       end

data/lib/fig/protocol/ftp.rb

@@ -90,17 +90,17 @@ class Fig::Protocol::FTP
   end
 
   def upload(local_file, uri)
-    ftp_uri = Fig::URL.parse(ENV['FIG_REMOTE_URL'])
+    ftp_uri = Fig::URL.parse(ENV['FIG_UPLOAD_URL'])
     ftp_root_path = ftp_uri.path
     ftp_root_dirs = ftp_uri.path.split('/')
-    remote_publish_path = uri.path[0, uri.path.rindex('/')]
-    remote_publish_dirs = remote_publish_path.split('/')
+    remote_upload_path = uri.path[0, uri.path.rindex('/')]
+    remote_upload_dirs = remote_upload_path.split('/')
     # Use array subtraction to deduce which project/version folder to upload
     # to, i.e. [1,2,3] - [2,3,4] = [1]
-    remote_project_dirs = remote_publish_dirs - ftp_root_dirs
+    remote_project_dirs = remote_upload_dirs - ftp_root_dirs
     Net::FTP.open(uri.host) do |ftp|
       ftp_login(ftp, uri.host, :prompt_for_login)
-      # Assume that the FIG_REMOTE_URL path exists.
+      # Assume that the FIG_UPLOAD_URL path exists.
       ftp.chdir(ftp_root_path)
       remote_project_dirs.each do |dir|
         # Can't automatically create parent directories, so do it manually.

data/lib/fig/repository.rb

@@ -33,7 +33,8 @@ class Fig::Repository
     options,
     operating_system,
     local_repository_directory,
-    remote_repository_url,
+    remote_download_url,
+    remote_upload_url,
     parser,
     publish_listeners
   )
@@ -41,7 +42,8 @@ class Fig::Repository
     @options                      = options
     @operating_system             = operating_system
     @local_repository_directory   = local_repository_directory
-    @remote_repository_url        = remote_repository_url
+    @remote_download_url          = remote_download_url
+    @remote_upload_url            = remote_upload_url
     @parser                       = parser
     @publish_listeners            = publish_listeners
 
@@ -77,7 +79,7 @@ class Fig::Repository
   def list_remote_packages
     check_remote_repository_format()
 
-    paths = @operating_system.download_list(remote_repository_url())
+    paths = @operating_system.download_list(remote_download_url())
 
     return paths.reject { |path| path =~ %r< ^ #{METADATA_SUBDIRECTORY} / >xs }
   end
@@ -156,9 +158,9 @@ class Fig::Repository
 
     if not local_only
       publisher.remote_directory_for_package =
-        remote_directory_for_package(descriptor)
+        remote_directory_for_package(descriptor, for_publishing: true)
       publisher.remote_fig_file_for_package =
-        remote_fig_file_for_package(descriptor)
+        remote_fig_file_for_package(descriptor, for_publishing: true)
     end
 
     return publisher.publish_package()
@@ -174,7 +176,8 @@ class Fig::Repository
 
   private
 
-  attr_reader :remote_repository_url
+  attr_reader :remote_download_url
+  attr_reader :remote_upload_url
 
   def initialize_local_repository()
     FileUtils.mkdir_p(@local_repository_directory)
@@ -244,7 +247,7 @@ class Fig::Repository
       temp_dir = base_temp_dir()
       @operating_system.delete_and_recreate_directory(temp_dir)
       remote_version_file = Fig::URL.append_path_components(
-        remote_repository_url(), [VERSION_FILE_NAME]
+        remote_download_url(), [VERSION_FILE_NAME]
       )
       local_version_file = File.join(temp_dir, "remote-#{VERSION_FILE_NAME}")
       begin
@@ -452,9 +455,9 @@ class Fig::Repository
     return
   end
 
-  def remote_fig_file_for_package(descriptor)
+  def remote_fig_file_for_package(descriptor, for_publishing: false)
     return Fig::URL.append_path_components(
-      remote_directory_for_package(descriptor), [PACKAGE_FILE_IN_REPO]
+      remote_directory_for_package(descriptor, for_publishing: for_publishing), [PACKAGE_FILE_IN_REPO]
     )
   end
 
@@ -466,9 +469,10 @@ class Fig::Repository
     File.join(package_download_dir, PACKAGE_FILE_IN_REPO)
   end
 
-  def remote_directory_for_package(descriptor)
+  def remote_directory_for_package(descriptor, for_publishing: false)
+    url = for_publishing ? remote_upload_url() : remote_download_url()
     return Fig::URL.append_path_components(
-      remote_repository_url(), [descriptor.name, descriptor.version]
+      url, [descriptor.name, descriptor.version]
     )
   end
 

data/lib/fig/spec_utils.rb

@@ -0,0 +1,312 @@
+# coding: utf-8
+
+if ENV['FIG_COVERAGE']
+  require 'simplecov' # note that .simplecov will be loaded here.
+
+  SimpleCov.start
+end
+
+require 'rubygems'
+require 'rbconfig'
+require 'rspec'
+
+require 'fileutils'
+require 'tmpdir'
+
+require 'fig/command'
+require 'fig/external_program'
+require 'fig/figrc'
+require 'fig/logging'
+require 'fig/repository'
+
+FIG_SPEC_BASE_DIRECTORY = Dir.mktmpdir 'fig-rspec-'
+at_exit { FileUtils.rm_rf FIG_SPEC_BASE_DIRECTORY }
+
+# "Current" as in current directory when running fig.
+CURRENT_DIRECTORY = FIG_SPEC_BASE_DIRECTORY + '/current-directory'
+
+USER_HOME         = FIG_SPEC_BASE_DIRECTORY + '/user-home'
+FIG_HOME          = FIG_SPEC_BASE_DIRECTORY + '/fig-home'
+
+# For split URL behavior - using distinct directories to catch incorrect URL usage
+FIG_DOWNLOAD_DIR   = File.join(FIG_SPEC_BASE_DIRECTORY, 'remote')
+FIG_UPLOAD_DIR   = File.join(FIG_SPEC_BASE_DIRECTORY, 'upload')
+FIG_DOWNLOAD_URL   = %Q<file://#{FIG_DOWNLOAD_DIR}>
+FIG_UPLOAD_URL   = %Q<file://#{FIG_UPLOAD_DIR}>
+
+#FIG_DIRECTORY     ||= File.expand_path(File.dirname(__FILE__)) + '/../bin'
+FIG_DIRECTORY     ||= File.expand_path(File.dirname(__FILE__)) + '/../../bin'
+FIG_COMMAND_CLASS ||= Fig::Command
+FIG_PROGRAM       ||= ENV['FIG_SPEC_DEBUG']                         \
+    ? 'exit Fig::Command.new.run_fig ARGV'                          \
+    : 'exit Fig::Command.new.run_fig_with_exception_handling ARGV'
+
+# Needed for testing of resources.
+FIG_FILE_GUARANTEED_TO_EXIST =
+  File.expand_path(CURRENT_DIRECTORY + '/file-guaranteed-to-exist')
+
+RUBY_EXE              ||= RbConfig.ruby
+BASE_FIG_COMMAND_LINE ||= [
+  RUBY_EXE,
+  '--external-encoding', 'UTF-8',
+  '--internal-encoding', 'UTF-8',
+  '-r', "#{FIG_DIRECTORY}/../lib/fig/command/initialization.rb",
+  '-e', FIG_PROGRAM,
+  '--',
+]
+
+ENV['HOME']           = USER_HOME
+ENV['FIG_HOME']       = FIG_HOME
+# Set up new environment variables for tests
+ENV['FIG_DOWNLOAD_URL'] = FIG_DOWNLOAD_URL
+ENV['FIG_UPLOAD_URL'] = FIG_UPLOAD_URL
+
+ENV['FIG_COVERAGE_ROOT_DIRECTORY'] =
+  File.expand_path(File.dirname(__FILE__) + '/..')
+
+Fig::Logging.initialize_post_configuration(nil, false, 'off', true)
+
+$fig_run_count = 0 # Nasty, nasty global.
+
+# Options:
+#
+#   :current_directory  What the current directory should be when starting fig.
+#
+#   :figrc              Value of the --figrc option.  If not specified,
+#                       --no-figrc will be passed to fig.
+#
+#   :no_raise_on_error  Normally an exception is thrown if fig returns an error
+#                       code.  If this option is true, then no exception will
+#                       be raised, allowing testing of failure states/output.
+#
+#   :fork               If specified as false, don't run fig as an external
+#                       process, but in-process instead.  This will run faster,
+#                       but will screw up the test suite if fig invokes
+#                       Kernel#exec (due to a command statement) or otherwise
+#                       depends upon at-exit behavior.
+def fig(command_line, first_extra = nil, rest_extra = nil)
+  input, options = _fig_input_options(first_extra, rest_extra)
+
+  $fig_run_count += 1
+  ENV['FIG_COVERAGE_RUN_COUNT'] = $fig_run_count.to_s
+
+  out = err = exit_code = nil
+
+  current_directory = options[:current_directory] || CURRENT_DIRECTORY
+  Dir.chdir current_directory do
+    standard_options = []
+    standard_options.concat %w< --log-level warn >
+    standard_options.concat %w< --file - > if input
+
+    figrc = options[:figrc]
+    if figrc
+      standard_options << '--figrc' << figrc
+    else
+      standard_options << '--no-figrc'
+    end
+
+    if command_line.include?('--update-lock-response')
+      if ! options.fetch(:fork, true)
+        raise 'Cannot specify both ":fork => false" and --update-lock-response.'
+      end
+    elsif ! options.fetch(:fork, true) || Fig::OperatingSystem.windows?
+      standard_options.concat %w< --update-lock-response ignore >
+    end
+
+    command_line = [standard_options, command_line].flatten
+    out, err, exit_code = _run_command command_line, input, options
+  end
+
+  return out, err, exit_code
+end
+
+# A bit of ruby magic to make invoking fig() nicer; this takes advantage of the
+# hash assignment syntax so you can call it like any of
+#
+#     fig([arguments])
+#     fig([arguments], input)
+#     fig([arguments], input, :no_raise_on_error => true)
+#     fig([arguments], :no_raise_on_error => true)
+def _fig_input_options(first_extra, rest_extra)
+  return nil, rest_extra || {} if first_extra.nil?
+
+  if first_extra.is_a? Hash
+    return nil, first_extra
+  end
+
+  return first_extra, rest_extra || {}
+end
+
+def _run_command(command_line, input, options)
+  out = err = exit_code = exit_string = nil
+
+  if options.fetch(:fork, true)
+    out, err, exit_code, exit_string =
+      _run_command_externally command_line, input, options
+  else
+    out, err, exit_code, exit_string =
+      _run_command_internally command_line, input, options
+  end
+
+  if exit_string
+    # Common scenario during development is that the fig process will fail for
+    # whatever reason, but the RSpec expectation is checking whether a file was
+    # created, etc. meaning that we don't see stdout, stderr, etc. but RSpec's
+    # failure message for the expectation, which isn't informative.  Throwing
+    # an exception that RSpec will catch will correctly integrate the fig
+    # output with the rest of the RSpec output.
+    fig_failure = "Fig process failed:\n"
+    fig_failure << "command: #{command_line.join(' ')}\n"
+    fig_failure << "result: #{exit_string}\n"
+    fig_failure << "stdout: #{out.nil? ? '<nil>' : out}\n"
+    fig_failure << "stderr: #{err.nil? ? '<nil>' : err}\n"
+    if input
+      fig_failure << "input: #{input}\n"
+    end
+
+    raise fig_failure
+  end
+
+  if ! options[:dont_strip_output]
+    err.strip!
+    out.strip!
+  end
+
+  return out, err, exit_code
+end
+
+def _run_command_externally(command_line, input, options)
+  full_command_line = BASE_FIG_COMMAND_LINE + command_line
+  out, err, result = Fig::ExternalProgram.capture(full_command_line, input)
+
+  exit_code   = result.nil? ? 0 : result.exitstatus
+  exit_string = nil
+  if result && ! result.success? && ! options[:no_raise_on_error]
+    exit_string = result.to_s
+  end
+
+  # Hooray for Windows line endings!  Not.
+  if out
+    out.gsub!(/\r+\n/, "\n")
+  end
+  if err
+    err.gsub!(/\r+\n/, "\n")
+  end
+
+  return out, err, exit_code, exit_string
+end
+
+def _run_command_internally(command_line, input, options)
+  original_stdin  = $stdin
+  original_stdout = $stdout
+  original_stderr = $stderr
+
+  begin
+    stdin     = input ? StringIO.new(input) : StringIO.new
+    stdout    = StringIO.new
+    stderr    = StringIO.new
+    exit_code = nil
+
+    $stdin  = stdin
+    $stdout = stdout
+    $stderr = stderr
+
+    if ENV['FIG_SPEC_DEBUG']
+      exit_code = FIG_COMMAND_CLASS.new.run_fig command_line
+    else
+      exit_code =
+        FIG_COMMAND_CLASS.new.run_fig_with_exception_handling command_line
+    end
+
+    exit_string = nil
+    if exit_code != 0 && ! options[:no_raise_on_error]
+      exit_string = exit_code.to_s
+    end
+
+    return stdout.string, stderr.string, exit_code, exit_string
+  ensure
+    $stdin  = original_stdin
+    $stdout = original_stdout
+    $stderr = original_stderr
+  end
+end
+
+def set_up_test_environment()
+  FileUtils.mkdir_p FIG_SPEC_BASE_DIRECTORY
+  FileUtils.mkdir_p CURRENT_DIRECTORY
+  FileUtils.mkdir_p USER_HOME
+  FileUtils.mkdir_p FIG_HOME
+  FileUtils.mkdir_p FIG_UPLOAD_DIR
+  FileUtils.ln_s FIG_UPLOAD_DIR, FIG_DOWNLOAD_DIR
+
+  FileUtils.touch FIG_FILE_GUARANTEED_TO_EXIST
+
+  metadata_directory =
+    File.join FIG_UPLOAD_DIR, Fig::Repository::METADATA_SUBDIRECTORY
+  FileUtils.mkdir_p metadata_directory
+
+  File.open(
+    File.join(FIG_UPLOAD_DIR, Fig::FigRC::REPOSITORY_CONFIGURATION), 'w'
+  ) do
+    |handle|
+    handle.puts '{}' # Empty Javascript/JSON object
+  end
+
+  return
+end
+
+def clean_up_test_environment()
+  FileUtils.rm_rf(FIG_SPEC_BASE_DIRECTORY)
+
+  return
+end
+
+def cleanup_home_and_remote(unified: true)
+  FileUtils.rm_rf(FIG_HOME)
+  
+  # Clean up split URL directories
+  FileUtils.rm_rf(FIG_DOWNLOAD_DIR)
+  FileUtils.rm_rf(FIG_UPLOAD_DIR)
+  
+  # Create base directories for split URLs
+  FileUtils.mkdir_p(FIG_UPLOAD_DIR)
+  FileUtils.mkdir_p(File.join(FIG_UPLOAD_DIR, Fig::Repository::METADATA_SUBDIRECTORY))
+
+  if unified
+    # use symlink to simulate an aggregated artifactory repo 
+    FileUtils.ln_s(FIG_UPLOAD_DIR, FIG_DOWNLOAD_DIR)
+  else
+    FileUtils.mkdir_p(FIG_DOWNLOAD_DIR)
+    FileUtils.mkdir_p(File.join(FIG_DOWNLOAD_DIR, Fig::Repository::METADATA_SUBDIRECTORY))
+  end
+  
+  return
+end
+
+def set_local_repository_format_to_future_version()
+  version_file = File.join(FIG_HOME, Fig::Repository::VERSION_FILE_NAME)
+  FileUtils.mkdir_p(FIG_HOME)
+  File.open(version_file, 'w') {
+    |handle| handle.write(Fig::Repository::LOCAL_VERSION_SUPPORTED + 1)
+  }
+
+  return
+end
+
+def set_remote_repository_format_to_future_version()
+  # Set future version in download dir
+  version_file = File.join(FIG_DOWNLOAD_DIR, Fig::Repository::VERSION_FILE_NAME)
+  FileUtils.mkdir_p(FIG_DOWNLOAD_DIR)
+  File.open(version_file, 'w') {
+    |handle| handle.write(Fig::Repository::REMOTE_VERSION_SUPPORTED + 1)
+  }
+  
+  # Set future version in upload dir
+  version_file = File.join(FIG_UPLOAD_DIR, Fig::Repository::VERSION_FILE_NAME)
+  FileUtils.mkdir_p(FIG_UPLOAD_DIR)
+  File.open(version_file, 'w') {
+    |handle| handle.write(Fig::Repository::REMOTE_VERSION_SUPPORTED + 1)
+  }
+
+  return
+end

data/lib/fig/url_access_disallowed_error.rb

@@ -11,5 +11,10 @@ module Fig
       @urls       = urls
       @descriptor = descriptor
     end
+
+    def message
+      "URLAccessDisallowedError:\n  descriptor = #{descriptor.inspect}\n  urls = " +
+        @urls.map { |k,v| " - #{k}: #{v.inspect}" }.join("\n    ")
+    end
   end
 end

data/lib/fig/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module Fig
-  VERSION = '2.0.0-alpha.3'.freeze
+  VERSION = '2.0.0-alpha.5'.freeze
 end