Class: SeeingIsBelieving::Binary::Config

Inherits:

HashStruct

• Object
• HashStruct
• SeeingIsBelieving::Binary::Config

Defined in:

lib/seeing_is_believing/binary/config.rb

Constant Summary

DeprecatedArgMessage =

Binary::ErrorMessage.for :args do
  def to_s
    "Deprecated: `#{args.join ' '}` #{explanation}"
  end
end

Instance Method Summary

• #add_error(explanation) ⇒ Object
• #finalize(stdin, stdout, stderr, file_class) ⇒ Object
• #parse_args(args) ⇒ Object

Methods inherited from HashStruct

#==, #[], #[]=, #each, #fetch, #hash, #initialize, #inspect, inspect, #key?, #keys, #merge, #pretty_print, #to_hash, #values

Constructor Details

This class inherits a constructor from SeeingIsBelieving::HashStruct

Instance Method Details

#add_error(explanation) ⇒ Object

# File 'lib/seeing_is_believing/binary/config.rb', line 46

def add_error(explanation)
  errors << ErrorMessage.new(explanation: explanation)
end

#finalize(stdin, stdout, stderr, file_class) ⇒ Object

# File 'lib/seeing_is_believing/binary/config.rb', line 276

def finalize(stdin, stdout, stderr, file_class)
  if print_event_stream?
    require 'seeing_is_believing/event_stream/handlers/stream_json_events'
    lib_options.event_handler = EventStream::Handlers::StreamJsonEvents.new(stdout)
  end

  stdin.set_encoding 'utf-8'

  case debug
  when String
    debug_file    = File.open(debug, 'a').tap { |f| f.sync = true }
    self.debugger = Debugger.new stream: debug_file, colour: false
  when true
    self.debugger = Debugger.new stream: stderr, colour: stderr.tty?
  end
  self.lib_options.debugger = debugger

  if filename && body
    add_error("Cannot give a program body and a filename to get the program body from.")
  elsif filename && file_class.exist?(filename)
    self.lib_options.stdin = stdin
    # TODO: this doesn't seem like a safe assumption
    self.body = file_class.read filename, external_encoding: "utf-8"
  elsif filename
    add_error("#{filename} does not exist!")
  elsif body
    self.lib_options.stdin = stdin
  elsif print_version? || print_help? || errors.any?
    self.body = ""
  else
    self.body = stdin.read
  end

  self
end

#parse_args(args) ⇒ Object

# File 'lib/seeing_is_believing/binary/config.rb', line 50

def parse_args(args)
  args          = args.dup
  as            = nil
  filenames     = []
  unknown_flags = []

  extract_positive_int_for = lambda do |flagname, &on_success|
    string = args.shift
    int    = string.to_i
    if int.to_s == string && 0 < int
      on_success.call int
    else
      add_error "#{flagname} expects a positive integer argument"
    end
    string
  end

  extract_non_negative_float_for = lambda do |flagname, &on_success|
    begin
      string = args.shift
      float  = Float string
      raise if float < 0
      on_success.call float
      string
    rescue
      add_error "#{flagname} expects a positive float or integer argument"
    end
  end

  saw_deprecated = lambda do |explanation, *args|
    self.deprecations << DeprecatedArgMessage.new(explanation: explanation, args: args)
  end

  encodings_are_deprecated = lambda do |*args|
    saw_deprecated.call "The ability to set encodings is deprecated. If you need this, details are at https://github.com/JoshCheek/seeing_is_believing/wiki/Encodings",
                        *args
  end

  next_arg = lambda do |flagname, argtype, &on_success|
    arg = args.shift
    arg ? on_success.call(arg) :
          add_error("#{flagname} needs an argument (#{argtype})")
    arg
  end

  until args.empty?
    case (arg = args.shift)
    when '-c', '--clean'
      self.print_cleaned = true

    when '-v', '--version'
      self.print_version = true

    when '--ignore-unknown-flags'
      self.ignore_unknown_flags = true

    when '-x', '--xmpfilter-style'
      self.annotator                 = AnnotateMarkedLines
      self.lib_options.rewrite_code  = AnnotateMarkedLines.code_rewriter(markers)
      self.remove_value_prefixes     = false
      self.lib_options.require_files << 'pp'
      self.lib_options.require_files << 'seeing_is_believing/customize_pp'

    when '--toggle-mark'
      extract_positive_int_for.call arg do |n|
        self.toggle_mark = n
      end

    when '-i', '--inherit-exitstatus', '--inherit-exit-status'
      self.inherit_exitstatus = true
      arg.include?("exit-status") &&
        saw_deprecated.call("Dash has been removed for consistency, use --inherit-exitstatus", arg)

    when '-j', '--json'
      self.result_as_json = true

    when '--stream'
      self.print_event_stream = true

    when '-h', '--help'
      self.print_help = true
      self.help_screen = Binary.help_screen(markers)

    when '-h+', '--help+'
      self.print_help  = true
      self.help_screen = Binary.help_screen_extended(markers)

    when '-g', '--debug'
      self.debug = true

    when '--debug-to'
      next_arg.call arg, "a filename" do |filename|
        self.debug = filename
      end

    when '-d', '--line-length'
      extract_positive_int_for.call arg do |n|
        self.annotator_options.max_line_length = n
      end

    when '-D', '--result-length'
      extract_positive_int_for.call arg do |n|
        self.annotator_options.max_result_length = n
      end

    when '-n', '--max-line-captures', '--number-of-captures'
      extracted = extract_positive_int_for.call arg do |n|
        self.lib_options.max_line_captures = n
      end
      seen = [arg]
      seen << extracted if extracted
      '--number-of-captures' == arg && saw_deprecated.call("use --max-line-captures instead", *seen)

    when '-t', '--timeout-seconds', '--timeout'
      extracted = extract_non_negative_float_for.call arg do |n|
        self.timeout_seconds             = n
        self.lib_options.timeout_seconds = n
      end
      '--timeout' == arg  && saw_deprecated.call("use --timeout-seconds instead", arg, extracted)

    when '-r', '--require'
      next_arg.call arg, "a filename" do |filename|
        self.lib_options.require_files << filename
      end

    when '-I', '--load-path'
      next_arg.call arg, "a directory" do |dir|
        self.lib_options.load_path_dirs << dir
      end

    when '-e', '--program'
      next_arg.call arg, "the program body" do |program|
        self.body = program
      end

    when '-a', '--as'
      next_arg.call arg, "a filename"  do |filename|
        as = filename
      end

    when '--local-cwd'
      self.lib_options.local_cwd = true

    when '-s', '--alignment-strategy'
      strategies     = {'file' => AlignFile, 'chunk' => AlignChunk, 'line' => AlignLine}
      strategy_names = strategies.keys.inspect
      next_arg.call arg, "one of these alignment strategies: #{strategy_names}" do |name|
        if strategies[name]
          self.annotator_options.alignment_strategy = strategies[name]
        else
          add_error("#{arg} got the alignment strategy #{name.inspect}, expected one of: #{strategy_names}")
        end
      end

    when '--interline-align'
      self.annotator_options.interline_align = true

    when '--no-interline-align'
      self.annotator_options.interline_align = false

    when '--shebang'
      executable = args.shift
      if executable
        saw_deprecated.call "SiB now uses the Ruby it was invoked with", arg, executable
      else
        add_error("#{arg} expected an arg: path to a ruby executable")
        saw_deprecated.call "SiB now uses the Ruby it was invoked with", arg
      end

    when /\A-K(.+)/
      self.lib_options.encoding = $1
      encodings_are_deprecated.call arg

    when '-K', '--encoding'
      next_arg.call arg, "an encoding" do |encoding|
        self.lib_options.encoding = encoding
        encodings_are_deprecated.call arg, encoding
      end

    when /^(-.|--.*)$/
      unknown_flags << arg

    when /^-[^-]/
      needs_arg = 'adDeIKnrst'
      arg.scan(/[#{needs_arg}].*|h\+|[^-]\+?/).reverse.each do |flag|
        if flag =~ /([#{needs_arg}])(.+)/
          args.unshift "-#{$1}", $2
        else
          args.unshift "-#{flag}"
        end
      end

    else
      filenames << arg
    end
  end

  unknown_flags.each do |flag|
    break if ignore_unknown_flags?
    add_error "#{flag} is not a flag, see the help screen (-h) for a list of options"
  end

  filenames.size > 1 &&
    add_error("can only have one filename but found #{filenames.map(&:inspect).join ', '}")

  result_as_json? && annotator == AnnotateMarkedLines &&
    add_error("SiB does not currently support output with both json and xmpfilter... maybe v4 :)")

  print_event_stream? && (result_as_json? || annotator == AnnotateMarkedLines) &&
    add_error("can only have one output format, --stream is not compatible with --json, -x, and --xmpfilter-style")

  toggle_mark? && print_event_stream? &&
    add_error("--toggle-mark and --stream are mutually exclusive")

  toggle_mark? && result_as_json? &&
    add_error("--toggle-mark and --json are mutually exclusive")


  self.filename                  = filenames.first
  self.lib_options.filename      = as || filename
  self.lib_options.debugger      = debugger
  self.annotator_options.markers = markers

  self
end