highline 1.7.10 → 2.0.0.pre.develop.2

data/lib/highline/question/answer_converter.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+
+require 'forwardable'
+
+class HighLine
+  class Question
+    class AnswerConverter
+      extend Forwardable
+
+      def_delegators :@question,
+                     :answer, :answer=, :check_range,
+                     :directory, :answer_type, :choices_complete
+
+      def initialize(question)
+        @question = question
+      end
+
+      def convert
+        return unless answer_type
+
+        self.answer = convert_by_answer_type
+        check_range
+        answer
+      end
+
+      def to_string
+        HighLine::String(answer)
+      end
+
+      # That's a weird name for a method!
+      # But it's working ;-)
+      define_method "to_highline::string" do
+        HighLine::String(answer)
+      end
+
+      def to_integer
+        Kernel.send(:Integer, answer)
+      end
+
+      def to_float
+        Kernel.send(:Float, answer)
+      end
+
+      def to_symbol
+        answer.to_sym
+      end
+
+      def to_regexp
+        Regexp.new(answer)
+      end
+
+      def to_file
+        self.answer = choices_complete(answer)
+        File.open(File.join(directory.to_s, answer.last))
+      end
+
+      def to_pathname
+        self.answer = choices_complete(answer)
+        Pathname.new(File.join(directory.to_s, answer.last))
+      end
+
+      def to_array
+        self.answer = choices_complete(answer)
+        answer.last
+      end
+
+      def to_proc
+        answer_type.call(answer)
+      end
+
+      private
+
+      def convert_by_answer_type
+        if answer_type.respond_to? :parse
+          answer_type.parse(answer)
+        elsif answer_type.is_a? Class
+          send("to_#{answer_type.name.downcase}")
+        else
+          send("to_#{answer_type.class.name.downcase}")
+        end
+      end
+    end
+  end
+end

data/lib/highline/question_asker.rb

@@ -0,0 +1,147 @@
+class HighLine
+  class QuestionAsker
+    attr_reader :question
+
+    include CustomErrors
+
+    def initialize(question, highline)
+      @question = question
+      @highline = highline
+    end
+
+    #
+    # Gets just one answer, as opposed to #gather_answers
+    #
+    def ask_once
+      question.show_question(@highline)
+
+      begin
+        question.get_response_or_default(@highline)
+        raise NotValidQuestionError unless question.valid_answer?
+
+        question.convert
+
+        if question.confirm
+          raise NoConfirmationQuestionError unless @highline.send(:confirm, question)
+        end
+
+      rescue NoConfirmationQuestionError
+        explain_error(nil)
+        retry
+
+      rescue NotInRangeQuestionError
+        explain_error(:not_in_range)
+        retry
+
+      rescue NotValidQuestionError
+        explain_error(:not_valid)
+        retry
+
+      rescue QuestionError
+        retry
+
+      rescue ArgumentError => error
+        case error.message
+        when /ambiguous/
+          # the assumption here is that OptionParser::Completion#complete
+          # (used for ambiguity resolution) throws exceptions containing
+          # the word 'ambiguous' whenever resolution fails
+          explain_error(:ambiguous_completion)
+          retry
+        when /invalid value for/
+          explain_error(:invalid_type)
+          retry
+        else
+          raise
+        end
+
+      rescue NoAutoCompleteMatch
+        explain_error(:no_completion)
+        retry
+      end
+      question.answer
+    end
+
+    ## Multiple questions
+
+    #
+    # Collects an Array/Hash full of answers as described in
+    # HighLine::Question.gather().
+    #
+    def gather_answers
+      original_question_template = question.template
+      verify_match = question.verify_match
+
+      begin   # when verify_match is set this loop will repeat until unique_answers == 1
+        question.template = original_question_template
+
+        answers = gather_answers_based_on_type
+
+        if verify_match && (@highline.send(:unique_answers, answers).size > 1)
+          explain_error(:mismatch)
+        else
+          verify_match = false
+        end
+      end while verify_match
+
+      question.verify_match ? @highline.send(:last_answer, answers) : answers
+    end
+
+    def gather_integer
+      gather_with_array do |answers|
+        (question.gather-1).times { answers << ask_once }
+      end
+    end
+
+    def gather_regexp
+      gather_with_array do |answers|
+        answers << ask_once until answer_matches_regex(answers.last)
+        answers.pop
+      end
+    end
+
+    def gather_hash
+      answers = {}
+
+      question.gather.keys.sort.each do |key|
+        @highline.key = key
+        answers[key]  = ask_once
+      end
+      answers
+    end
+
+
+    private
+
+    ## Delegate to Highline
+    def explain_error(error)
+      @highline.say(question.responses[error]) if error
+      @highline.say(question.ask_on_error_msg)
+    end
+
+    def gather_with_array
+      [].tap do |answers|
+        answers << ask_once
+        question.template = ""
+
+        yield answers
+      end
+    end
+
+    def answer_matches_regex(answer)
+      (question.gather.is_a?(::String) && answer.to_s == question.gather) ||
+      (question.gather.is_a?(Regexp)   && answer.to_s =~ question.gather)
+    end
+
+    def gather_answers_based_on_type
+      case question.gather
+      when Integer
+        gather_integer
+      when ::String, Regexp
+        gather_regexp
+      when Hash
+        gather_hash
+      end
+    end
+  end
+end

data/lib/highline/simulate.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # simulate.rb
 #
 #  Created by Andy Rossmeissl on 2012-04-29.
@@ -6,6 +9,7 @@
 #  This is Free Software.  See LICENSE and COPYING for details.
 #
 # adapted from https://gist.github.com/194554
+
 class HighLine
 
   # Simulates Highline input for use in tests.
@@ -23,7 +27,7 @@ class HighLine
 
     # Simulate StringIO#getbyte by shifting a single character off of the next line of the script
     def getbyte
-      line = gets.dup
+      line = gets
       if line.length > 0
         char = line.slice! 0
         @strings.unshift line

data/lib/highline/statement.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+require 'highline/wrapper'
+require 'highline/paginator'
+require 'highline/template_renderer'
+
+class HighLine::Statement
+  attr_reader :source, :highline
+  attr_reader :template_string
+
+  def initialize(source, highline)
+    @highline = highline
+    @source   = source
+    @template_string = stringfy(source)
+  end
+
+  def statement
+    @statement ||= format_statement
+  end
+
+  def to_s
+    statement
+  end
+
+  private
+
+  def stringfy(template_string)
+    String(template_string || "").dup
+  end
+
+  def format_statement
+    return template_string unless template_string.length > 0
+
+    statement = render_template
+
+    statement = HighLine::Wrapper.wrap(statement, highline.wrap_at)
+    statement = HighLine::Paginator.new(highline).page_print(statement)
+
+    statement = statement.gsub(/\n(?!$)/,"\n#{highline.indentation}") if highline.multi_indent
+    statement
+  end
+
+  def render_template
+    # Assigning to a local var so it may be
+    # used inside instance eval block
+
+    template_renderer = TemplateRenderer.new(template, source, highline)
+    template_renderer.render
+  end
+
+  def template
+    @template ||= ERB.new(template_string, nil, "%")
+  end
+
+  def self.const_missing(constant)
+    HighLine.const_get(constant)
+  end
+end

data/lib/highline/string.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+require "highline/string_extensions"
+
+#
+# HighLine::String is a subclass of String with convenience methods added for colorization.
+#
+# Available convenience methods include:
+#   * 'color' method         e.g.  highline_string.color(:bright_blue, :underline)
+#   * colors                 e.g.  highline_string.magenta
+#   * RGB colors             e.g.  highline_string.rgb_ff6000
+#                             or   highline_string.rgb(255,96,0)
+#   * background colors      e.g.  highline_string.on_magenta
+#   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
+#                             or   highline_string.on_rgb(255,96,0)
+#   * styles                 e.g.  highline_string.underline
+#
+# Additionally, convenience methods can be chained, for instance the following are equivalent:
+#   highline_string.bright_blue.blink.underline
+#   highline_string.color(:bright_blue, :blink, :underline)
+#   HighLine.color(highline_string, :bright_blue, :blink, :underline)
+#
+# For those less squeamish about possible conflicts, the same convenience methods can be
+# added to the built-in String class, as follows:
+#
+#  require 'highline'
+#  Highline.colorize_strings
+#
+
+class HighLine
+  class String < ::String
+    include StringExtensions
+  end
+end

data/lib/highline/string_extensions.rb

@@ -1,33 +1,12 @@
-# Extensions for class String
-#
-# HighLine::String is a subclass of String with convenience methods added for colorization.
-#
-# Available convenience methods include:
-#   * 'color' method         e.g.  highline_string.color(:bright_blue, :underline)
-#   * colors                 e.g.  highline_string.magenta
-#   * RGB colors             e.g.  highline_string.rgb_ff6000
-#                             or   highline_string.rgb(255,96,0)
-#   * background colors      e.g.  highline_string.on_magenta
-#   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
-#                             or   highline_string.on_rgb(255,96,0)
-#   * styles                 e.g.  highline_string.underline
-#
-# Additionally, convenience methods can be chained, for instance the following are equivalent:
-#   highline_string.bright_blue.blink.underline
-#   highline_string.color(:bright_blue, :blink, :underline)
-#   HighLine.color(highline_string, :bright_blue, :blink, :underline)
-#
-# For those less squeamish about possible conflicts, the same convenience methods can be
-# added to the built-in String class, as follows:
-#
-#  require 'highline'
-#  Highline.colorize_strings
+# coding: utf-8
 
 class HighLine
   def self.String(s)
     HighLine::String.new(s)
   end
 
+  # HighLine extensions for String class
+  # Included by HighLine::String
   module StringExtensions
     def self.included(base)
       HighLine::COLORS.each do |color|
@@ -101,10 +80,6 @@ class HighLine
     end
   end
 
-  class HighLine::String < ::String
-    include StringExtensions
-  end
-
   def self.colorize_strings
     ::String.send(:include, StringExtensions)
   end

data/lib/highline/style.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # color_scheme.rb
 #
 # Created by Richard LeBer on 2011-06-27.
@@ -42,18 +45,25 @@ class HighLine
 
     def self.index(style)
       if style.name
-        @@styles ||= {}
-        @@styles[style.name] = style
+        @styles ||= {}
+        @styles[style.name] = style
       end
       if !style.list
-        @@code_index ||= {}
-        @@code_index[style.code] ||= []
-        @@code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
-        @@code_index[style.code] << style
+        @code_index ||= {}
+        @code_index[style.code] ||= []
+        @code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
+        @code_index[style.code] << style
       end
       style
     end
 
+    def self.clear_index
+      # reset to builtin only styles
+      @styles = list.select { |name, style| style.builtin }
+      @code_index = {}
+      @styles.each { |name, style| index(style) }
+    end
+
     def self.rgb_hex(*colors)
       colors.map do |color|
         color.is_a?(Numeric) ? '%02x'%color : color.to_s
@@ -87,11 +97,11 @@ class HighLine
     end
 
     def self.list
-      @@styles ||= {}
+      @styles ||= {}
     end
 
     def self.code_index
-      @@code_index ||= {}
+      @code_index ||= {}
     end
 
     def self.uncolor(string)