fig 0.1.77 → 0.1.79

data/lib/fig/statement/resource.rb

@@ -11,15 +11,19 @@ class  Fig::Statement; end
 class Fig::Statement::Resource < Fig::Statement
   include Fig::Statement::Asset
 
-  def initialize(line_column, source_description, url, glob_if_not_url)
+  def initialize(line_column, source_description, location, glob_if_not_url)
     super(line_column, source_description)
 
-    @url             = url
+    @location        = location
     @glob_if_not_url = glob_if_not_url
   end
 
+  def statement_type()
+    return 'resource'
+  end
+
   def asset_name()
-    if Fig::URL.is_url?(url())
+    if Fig::URL.is_url?(location())
       return standard_asset_name()
     end
 

data/lib/fig/statement/retrieve.rb

@@ -27,6 +27,10 @@ class Fig::Statement::Retrieve < Fig::Statement
     end
   end
 
+  def statement_type()
+    return 'retrieve'
+  end
+
   def loaded_but_not_referenced?()
     return added_to_environment? && ! referenced?
   end
@@ -51,7 +55,11 @@ class Fig::Statement::Retrieve < Fig::Statement
     return unparser.retrieve(self)
   end
 
-  def minimum_grammar_version_required()
-    return 0
+  def minimum_grammar_for_emitting_input()
+    return [0]
+  end
+
+  def minimum_grammar_for_publishing()
+    return [0]
   end
 end

data/lib/fig/statement/set.rb

@@ -1,9 +1,12 @@
 require 'fig/statement'
+require 'fig/statement/environment_variable'
 
 module Fig; end
 
 # A statement that sets the value of an environment variable.
 class Fig::Statement::Set < Fig::Statement
+  include Fig::Statement::EnvironmentVariable
+
   # We block quotes right now in order to allow for using them for
   # quoting later.
   VALUE_REGEX          = %r< \A [^\s\\'"]* \z >x
@@ -26,8 +29,6 @@ class Fig::Statement::Set < Fig::Statement
     return [variable, value]
   end
 
-  attr_reader :name, :value
-
   def initialize(line_column, source_description, name, value)
     super(line_column, source_description)
 
@@ -35,6 +36,10 @@ class Fig::Statement::Set < Fig::Statement
     @value = value
   end
 
+  def statement_type()
+    return 'set'
+  end
+
   def is_environment_variable?()
     return true
   end
@@ -42,10 +47,4 @@ class Fig::Statement::Set < Fig::Statement
   def unparse_as_version(unparser)
     return unparser.set(self)
   end
-
-  def minimum_grammar_version_required()
-    # TODO: fix this once going through
-    # Statement.strip_quotes_and_process_escapes()
-    return 0
-  end
 end

data/lib/fig/string_tokenizer.rb

@@ -0,0 +1,195 @@
+require 'fig/tokenized_string'
+require 'fig/tokenized_string/plain_segment'
+
+module Fig; end
+
+class Fig::StringTokenizer
+  def initialize(subexpression_matchers = DEFAULT_SUBEXPRESSION_MATCHER)
+    @subexpression_matchers = subexpression_matchers
+
+    return
+  end
+
+  # Takes a block that is invoked when there is an error.  Block receives a
+  # single parameter of an error message that is the end of a statement
+  # describing the problem, with no leading space character.  For example,
+  # given «'foo», the block will receive a message like 'has unbalanced single
+  # quotes.'.
+  #
+  # Returns the TokenizedString; if there was a parse error, then the return
+  # value will be nil (and the block will have been invoked).
+  def tokenize(string, &error_block)
+    @string        = string.clone
+    @error_block   = error_block
+    @single_quoted = nil
+    @segments      = []
+
+    strip_quotes_and_process_escapes
+
+    return if @segments.empty?
+
+    return Fig::TokenizedString.new(@segments, @single_quoted)
+  end
+
+  private
+
+  DEFAULT_SUBEXPRESSION_MATCHER = [
+    { :pattern => %r<\@>, :action => lambda {|character| character} }
+  ]
+
+  def strip_quotes_and_process_escapes()
+    if @string.length == 0
+      @single_quoted = false
+      @segments << Fig::TokenizedString::PlainSegment.new('')
+
+      return
+    end
+
+    @single_quoted = strip_single_quotes_and_process_escapes
+    return if @single_quoted.nil?
+    if @single_quoted
+      @segments << Fig::TokenizedString::PlainSegment.new(@string.clone)
+
+      return
+    end
+
+    strip_double_quotes_and_process_escapes
+
+    return
+  end
+
+  def strip_single_quotes_and_process_escapes()
+    return false if @string[0..0] != %q<'> && @string[-1..-1] != %q<'>
+    return false if @string =~ %r< \A (?: \\{2} )* \\ ' \z >x # «\'» is legal
+
+    if (
+      @string.length  == 1                         ||
+      @string[0..0]   != %q<'>                     ||
+      @string[-1..-1] != %q<'>                     ||
+      @string =~ %r< [^\\] (?: \\{2} )* \\ ' \z >x
+    )
+      @error_block.call 'has unbalanced single quotes.'
+      return
+    end
+
+    if @string =~ %r< [^\\] (?: \\{2} )*? \\ ([^\\']) >x
+      @error_block.call(
+        "contains a bad escape sequence (\\#{$1}) inside single quotes."
+      )
+      return
+    end
+
+    @string.sub!( %r< \A ' (.*) ' \z >xm, '\1')
+
+    return true
+  end
+
+  def strip_double_quotes_and_process_escapes()
+    return if ! check_and_strip_double_quotes
+
+    if @string == %q<\\'>
+      @segments << Fig::TokenizedString::PlainSegment.new(%q<'>)
+
+      return
+    end
+
+    generate_segments
+
+    return
+  end
+
+  def check_and_strip_double_quotes()
+    # We accept any unquoted single character at this point.  Later validation
+    # will catch bad characters.
+    return true if @string =~ %r< \A \\ . \z >xm
+
+    if @string[0..0] == %q<">
+      if @string.length == 1 || @string[-1..-1] != %q<">
+        @error_block.call 'has unbalanced double quotes.'
+        return
+      end
+      if @string =~ %r< [^\\] (?: \\{2} )*? \\ " \z >xm
+        @error_block.call \
+          'has unbalanced double quotes; the trailing double quote is escaped.'
+        return
+      end
+
+      @string.sub!( %r< \A " (.*) " \z >xm, '\1' )
+    elsif @string =~ %r< (?: \A | [^\\] ) (?: \\{2} )* " \z >xm
+      @error_block.call \
+        %q<has unbalanced double quotes; it ends in a double quote when it didn't start with one.>
+      return
+    end
+
+    return true
+  end
+
+  def generate_segments()
+    plain_string = nil
+
+    while ! @string.empty?
+      if @string =~ %r< \A (\\+) ([^\\] .*)? \z >xm
+        slashes, remainder = $1, $2
+        if slashes.length % 2 == 1
+          if remainder.nil?
+            @error_block.call 'ends in an incomplete escape.'
+            return
+          end
+          if subexpression_match(remainder) || remainder[0..0] == %q<">
+            plain_string ||= ''
+            plain_string << slashes
+            plain_string << remainder[0..0]
+            @string = remainder[1..-1] || ''
+          else
+            @error_block.call "contains a bad escape sequence (\\#{$1})."
+            return
+          end
+        else
+          plain_string ||= ''
+          plain_string << slashes
+          @string = remainder
+        end
+      else
+        replacement, remainder = subexpression_match @string
+        if replacement
+          if replacement.is_a? String
+            plain_string << replacement
+          else
+            @segments << Fig::TokenizedString::PlainSegment.new(plain_string)
+            plain_string = nil
+          end
+          @string = remainder
+        elsif @string =~ %r< \A (["']) >xm # Fix single quotes in quoted strings
+          quote_name = $1 == %q<'> ? 'single' : 'double'
+          @error_block.call "contains an unescaped #{quote_name} quote."
+          return
+        else
+          plain_string ||= ''
+          plain_string << @string[0..0]
+          @string = @string[1..-1] || ''
+        end
+      end
+    end
+
+    if plain_string
+      @segments << Fig::TokenizedString::PlainSegment.new(plain_string)
+    end
+
+    return
+  end
+
+  def subexpression_match(sub_string)
+    @subexpression_matchers.each do
+      |matcher|
+
+      pattern = matcher[:pattern]
+      if sub_string =~ %r< \A ( #{pattern} ) >x
+        subexpression, remainder = $1, $'
+        replacement = matcher[:action].call subexpression
+        return [replacement, remainder]
+      end
+    end
+
+    return
+  end
+end

data/lib/fig/tokenized_string.rb

@@ -0,0 +1,22 @@
+module Fig; end
+
+class Fig::TokenizedString
+  def initialize(segments, single_quoted)
+    @segments      = segments
+    @single_quoted = single_quoted
+
+    return
+  end
+
+  def single_quoted?()
+    return @single_quoted
+  end
+
+  def to_expanded_string()
+    return ( @segments.collect {|segment| segment.to_expanded_string} ).join ''
+  end
+
+  def to_escaped_string()
+    return ( @segments.collect {|segment| segment.to_escaped_string} ).join ''
+  end
+end

data/lib/fig/tokenized_string/plain_segment.rb

@@ -0,0 +1,24 @@
+module Fig; end
+class  Fig::TokenizedString; end
+
+class Fig::TokenizedString::PlainSegment
+  attr_reader :raw_value
+
+  def initialize(raw_value)
+    @raw_value     = raw_value
+
+    return
+  end
+
+  def type
+    return :plain_segment
+  end
+
+  def to_expanded_string()
+    return @raw_value.gsub(%r< \\ (.) >xm, '\1')
+  end
+
+  def to_escaped_string()
+    return @raw_value
+  end
+end

data/lib/fig/tokenized_string/token.rb

@@ -0,0 +1,18 @@
+module Fig; end
+class  Fig::TokenizedString; end
+
+class Fig::TokenizedString::Token
+  attr_reader :type
+  attr_reader :raw_value
+
+  def initialize(type, raw_value)
+    @type      = type
+    @raw_value = raw_value
+
+    return
+  end
+
+  def to_escaped_string()
+    return raw_value
+  end
+end

data/lib/fig/unparser.rb

@@ -1,7 +1,86 @@
 module Fig; end
 
 module Fig::Unparser
+  # Determine the class of Unparser necessary for a set of Statements; the
+  # parameter can be a single statement or multiple.  Returns both the class
+  # and a list of explanations of why the class was picked.
+  def self.class_for_statements(
+    statements, emit_as_input_or_to_be_published_values
+  )
+    # Note: we very specifically do not require the files containing the
+    # Unparser classes in order to avoid circular dependencies.
+    statements = [statements].flatten
+
+    versions =
+      self.gather_versions statements, emit_as_input_or_to_be_published_values
+    version = (versions.map {|version_info| version_info[0]}).max || 0
+    explanations = (versions.collect {|v| v[1]}).reject {|e| e.nil?}
+
+    case version
+    when 0
+      return Fig::Unparser::V0, explanations
+    end
+
+    # TODO: Until v1 grammar handling is done, ensure we don't emit anything
+    # old fig versions cannot handle.
+    if ! ENV['FIG_ALLOW_NON_V0_GRAMMAR']
+      raise 'Reached a point where something could not be represented by the v0 grammar. Bailing out.'
+    end
+
+    return Fig::Unparser::V1, explanations
+  end
+
+  def self.determine_version_and_unparse(
+    statements, emit_as_input_or_to_be_published_values
+  )
+    unparser_class, explanations = self.class_for_statements(
+      statements, emit_as_input_or_to_be_published_values
+    )
+    unparser = unparser_class.new emit_as_input_or_to_be_published_values
+
+    return (unparser.unparse [statements].flatten), explanations
+  end
+
+  private
+
+  def self.gather_versions(statements, emit_as_input_or_to_be_published_values)
+    if emit_as_input_or_to_be_published_values == :emit_as_input
+      return statements.map {
+        |statement|
+
+        self.expand_version_and_explanation(
+          statement, statement.minimum_grammar_for_emitting_input
+        )
+      }
+    end
+
+    return statements.map {
+      |statement|
+
+      self.expand_version_and_explanation(
+        statement, statement.minimum_grammar_for_publishing
+      )
+    }
+  end
+
+  def self.expand_version_and_explanation(statement, version_info)
+    version, explanation = *version_info
+    if explanation.nil?
+      return [version]
+    end
+
+    return [
+      version,
+      "Grammar v#{version} is required because the #{statement.statement_type} statement#{statement.position_string} #{explanation}."
+    ]
+  end
+
+
+  public
+
   def unparse(statements)
+    # It's double dispatch time!
+
     @text         = ''
     @indent_level = @initial_indent_level
 
@@ -101,6 +180,10 @@ module Fig::Unparser
     return
   end
 
+  def grammar_description
+    raise NotImplementedError
+  end
+
   private
 
   def asset(keyword, statement)
@@ -109,7 +192,7 @@ module Fig::Unparser
 
   def asset_path(statement)
     if @emit_as_input_or_to_be_published_values == :emit_as_input
-      return statement.url
+      return statement.location
     end
 
     return statement.asset_name