fig 1.1.0 → 1.2.0

data/lib/fig/grammar/v1_base.treetop

@@ -0,0 +1,229 @@
+# Reusable parts of Treetop (http://treetop.rubyforge.org/) grammar for package
+# definitions in v1 format.
+
+# Some aspects of this grammar are significantly dumber than they could be
+# because:
+#
+#   * We want to treat statements as identically as possible to their
+#     command-line equivalents.
+#   * Treetop parse errors are pretty inscrutable at times and we can make
+#     error messages clearer by validating a lot of the terminals ourselves.
+
+require 'treetop'
+
+module Fig
+  module Grammar
+    # Consumers of this need to mix in Fig::Grammar::Base and
+    # Fig::Grammar::Version and have a "rule config_statement".
+    grammar V1Base
+      # Shim between "package" and "package_statement" rules to allow the
+      # compiled v0 and v1 grammars to have the same interface.
+      rule package_statement_with_ws
+        package_statement:package_statement ws_or_comment+ {
+          def to_package_statement(build_state)
+            return package_statement.to_package_statement(build_state)
+          end
+        }
+      end
+
+      rule package_statement
+        archive / resource / retrieve / config
+      end
+
+      rule archive
+        statement_start:'archive'
+        ws_or_comment+
+        location:quoted_or_bare_string
+        {
+          def to_package_statement(build_state)
+            return build_state.new_asset_statement(
+              Statement::Archive, statement_start, location
+            )
+          end
+        }
+      end
+
+      rule resource
+        statement_start:'resource'
+        ws_or_comment+
+        location:quoted_or_bare_string
+        {
+          def to_package_statement(build_state)
+            return build_state.new_asset_statement(
+              Statement::Resource, statement_start, location
+            )
+          end
+        }
+      end
+
+      rule retrieve
+        statement_start:'retrieve'
+        ws_or_comment+
+        variable:environment_variable_name '->' path:quoted_or_bare_string
+        {
+          def to_package_statement(build_state)
+            return build_state.new_retrieve_statement(
+              statement_start, variable, path
+            )
+          end
+        }
+      end
+
+      rule config
+        statement_start:'config'
+        ws_or_comment+
+        config_name
+        ws_or_comment+
+        statements:config_statement_with_ws*
+        'end'
+        {
+          def to_package_statement(build_state)
+            return build_state.new_configuration_statement(
+              statement_start, config_name, statements
+            )
+          end
+        }
+      end
+
+      # Shim between "config" and "config_statement" rules to allow the
+      # compiled v0 and v1 grammars to have the same interface.
+      rule config_statement_with_ws
+        config_statement:config_statement ws_or_comment+ {
+          def to_config_statement(build_state)
+            return config_statement.to_config_statement(build_state)
+          end
+        }
+      end
+
+      # Need rule config_statement
+
+      rule include
+        statement_start:'include' ws_or_comment+ descriptor_string {
+          def to_config_statement(build_state)
+            return build_state.new_include_statement(
+              statement_start, descriptor_string
+            )
+          end
+        }
+      end
+
+      rule override
+        statement_start:'override' ws_or_comment+ descriptor_string {
+          def to_config_statement(build_state)
+            return build_state.new_override_statement(
+              statement_start, descriptor_string
+            )
+          end
+        }
+      end
+
+      rule set
+        statement_start:'set' ws_or_comment+ environment_variable_name_value {
+          def to_config_statement(build_state)
+            return build_state.new_environment_variable_statement(
+              Statement::Set, statement_start, environment_variable_name_value
+            )
+          end
+        }
+      end
+
+      rule path
+        statement_start:('add' / 'append' / 'path')
+        ws_or_comment+
+        environment_variable_name_value
+        {
+          def to_config_statement(build_state)
+            return build_state.new_environment_variable_statement(
+              Statement::Path, statement_start, environment_variable_name_value
+            )
+          end
+        }
+      end
+
+      rule command
+        statement_start:'command'
+        ws_or_comment+
+        command_line
+        ws_or_comment+
+        'end'
+        {
+          def to_config_statement(build_state)
+            return build_state.new_v1_command_statement(
+              statement_start, gather_command_argument_nodes(command_line)
+            )
+          end
+
+          def gather_command_argument_nodes(node, arguments = [])
+            if node.respond_to? 'quoted_or_bare_string?'
+              arguments << node
+              return arguments
+            end
+
+            return arguments if not node.elements
+
+            node.elements.each do
+              |element|
+              gather_command_argument_nodes(element, arguments)
+            end
+
+            return arguments
+          end
+        }
+      end
+
+      rule command_line
+        quoted_or_bare_string
+        ! { |sequence| sequence[-1].text_value == 'end' }
+        (
+          ws_or_comment+
+          quoted_or_bare_string
+          ! { |sequence| sequence[-1].text_value == 'end' }
+        )*
+      end
+
+      # Terminals
+
+      rule descriptor_string
+        [^\s#]+
+      end
+
+      rule config_name
+        [a-zA-Z0-9_.-]+
+      end
+
+      rule quoted_or_bare_string
+        # In order to deal with the hierarchy of nodes that the command_line
+        # rule above generates, we tag each of the expressions here so that
+        # they can be found in the syntax tree.
+        [^\s#\\"]* '"' ( [^"\\] / '\\' . )* '"'
+        { def quoted_or_bare_string?() return true end }
+
+        /
+
+        [^\s#\\']* "'" ( [^'\\] / '\\' . )* "'"
+        { def quoted_or_bare_string?() return true end }
+
+        /
+
+        [^\s#]+
+        { def quoted_or_bare_string?() return true end }
+      end
+
+      rule environment_variable_name
+        [a-zA-Z0-9_]+
+      end
+
+      rule environment_variable_name_value
+        # This is like quoted_or_bare_string, but allows for the unquoted
+        # variable name followed by equals sign prior to the quotation marks
+        # coming in.
+        #
+        # Should result in somewhat reasonable handling by Treetop when
+        # encountering mis-quoted constructs.
+        [^\s#\\'"]* '"' ( [^"\\] / '\\' . )* '"' /
+        [^\s#\\'"]* "'" ( [^'\\] / '\\' . )* "'" /
+        [^\s#]+
+      end
+    end
+  end
+end

data/lib/fig/grammar/v2.rb

@@ -0,0 +1,508 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+# Treetop (http://treetop.rubyforge.org/) grammar for package definitions in v2
+# format.
+
+require 'treetop'
+
+require 'fig/grammar/base'
+require 'fig/grammar/v1_base'
+require 'fig/grammar/version'
+
+module Fig
+  module Grammar
+    module V2
+      include Treetop::Runtime
+
+      def root
+        @root ||= :package
+      end
+
+      include Fig::Grammar::Base
+
+      include Fig::Grammar::Version
+
+      include Fig::Grammar::V1Base
+
+      module Package0
+        def optional_ws_or_comment1
+          elements[0]
+        end
+
+        def grammar_version
+          elements[1]
+        end
+
+        def statements
+          elements[2]
+        end
+
+        def optional_ws_or_comment2
+          elements[3]
+        end
+      end
+
+      module Package1
+        def to_package(unparsed_package, build_state)
+          return build_state.new_package_statement(
+            unparsed_package, grammar_version, statements
+          )
+        end
+      end
+
+      def _nt_package
+        start_index = index
+        if node_cache[:package].has_key?(index)
+          cached = node_cache[:package][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_optional_ws_or_comment
+        s0 << r1
+        if r1
+          r3 = _nt_grammar_version
+          if r3
+            r2 = r3
+          else
+            r2 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r2
+          if r2
+            s4, i4 = [], index
+            loop do
+              r5 = _nt_package_statement_with_ws
+              if r5
+                s4 << r5
+              else
+                break
+              end
+            end
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            s0 << r4
+            if r4
+              r6 = _nt_optional_ws_or_comment
+              s0 << r6
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(Package0)
+          r0.extend(Package1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:package][start_index] = r0
+
+        r0
+      end
+
+      def _nt_config_statement
+        start_index = index
+        if node_cache[:config_statement].has_key?(index)
+          cached = node_cache[:config_statement][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        r1 = _nt_override
+        if r1
+          r0 = r1
+        else
+          r2 = _nt_include
+          if r2
+            r0 = r2
+          else
+            r3 = _nt_include_file
+            if r3
+              r0 = r3
+            else
+              r4 = _nt_command
+              if r4
+                r0 = r4
+              else
+                r5 = _nt_path
+                if r5
+                  r0 = r5
+                else
+                  r6 = _nt_set
+                  if r6
+                    r0 = r6
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        node_cache[:config_statement][start_index] = r0
+
+        r0
+      end
+
+      module IncludeFile0
+        def config_name
+          elements[1]
+        end
+      end
+
+      module IncludeFile1
+        def statement_start
+          elements[0]
+        end
+
+        def path
+          elements[2]
+        end
+
+        def config
+          elements[3]
+        end
+      end
+
+      module IncludeFile2
+        def to_config_statement(build_state)
+          config_name = nil
+          if config.respond_to? :config_name
+            config_name = config.config_name
+          end
+
+          return build_state.new_include_file_statement(
+            statement_start, path, config_name
+          )
+        end
+      end
+
+      def _nt_include_file
+        start_index = index
+        if node_cache[:include_file].has_key?(index)
+          cached = node_cache[:include_file][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        if has_terminal?('include-file', false, index)
+          r1 = instantiate_node(SyntaxNode,input, index...(index + 12))
+          @index += 12
+        else
+          terminal_parse_failure('include-file')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            r3 = _nt_ws_or_comment
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          if s2.empty?
+            @index = i2
+            r2 = nil
+          else
+            r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          end
+          s0 << r2
+          if r2
+            r4 = _nt_file_path
+            s0 << r4
+            if r4
+              i6, s6 = index, []
+              if has_terminal?(':', false, index)
+                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure(':')
+                r7 = nil
+              end
+              s6 << r7
+              if r7
+                r8 = _nt_config_name
+                s6 << r8
+              end
+              if s6.last
+                r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                r6.extend(IncludeFile0)
+              else
+                @index = i6
+                r6 = nil
+              end
+              if r6
+                r5 = r6
+              else
+                r5 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s0 << r5
+            end
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(IncludeFile1)
+          r0.extend(IncludeFile2)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:include_file][start_index] = r0
+
+        r0
+      end
+
+      module FilePath0
+      end
+
+      module FilePath1
+      end
+
+      module FilePath2
+      end
+
+      module FilePath3
+      end
+
+      def _nt_file_path
+        start_index = index
+        if node_cache[:file_path].has_key?(index)
+          cached = node_cache[:file_path][index]
+          if cached
+            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        i1, s1 = index, []
+        if has_terminal?('"', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('"')
+          r2 = nil
+        end
+        s1 << r2
+        if r2
+          s3, i3 = [], index
+          loop do
+            i4 = index
+            if has_terminal?('\G[^"\\\\]', true, index)
+              r5 = true
+              @index += 1
+            else
+              r5 = nil
+            end
+            if r5
+              r4 = r5
+            else
+              i6, s6 = index, []
+              if has_terminal?('\\', false, index)
+                r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure('\\')
+                r7 = nil
+              end
+              s6 << r7
+              if r7
+                if index < input_length
+                  r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure("any character")
+                  r8 = nil
+                end
+                s6 << r8
+              end
+              if s6.last
+                r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+                r6.extend(FilePath0)
+              else
+                @index = i6
+                r6 = nil
+              end
+              if r6
+                r4 = r6
+              else
+                @index = i4
+                r4 = nil
+              end
+            end
+            if r4
+              s3 << r4
+            else
+              break
+            end
+          end
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+          s1 << r3
+          if r3
+            if has_terminal?('"', false, index)
+              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('"')
+              r9 = nil
+            end
+            s1 << r9
+          end
+        end
+        if s1.last
+          r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+          r1.extend(FilePath1)
+        else
+          @index = i1
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          i10, s10 = index, []
+          if has_terminal?("'", false, index)
+            r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure("'")
+            r11 = nil
+          end
+          s10 << r11
+          if r11
+            s12, i12 = [], index
+            loop do
+              i13 = index
+              if has_terminal?('\G[^\'\\\\]', true, index)
+                r14 = true
+                @index += 1
+              else
+                r14 = nil
+              end
+              if r14
+                r13 = r14
+              else
+                i15, s15 = index, []
+                if has_terminal?('\\', false, index)
+                  r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure('\\')
+                  r16 = nil
+                end
+                s15 << r16
+                if r16
+                  if index < input_length
+                    r17 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                    @index += 1
+                  else
+                    terminal_parse_failure("any character")
+                    r17 = nil
+                  end
+                  s15 << r17
+                end
+                if s15.last
+                  r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+                  r15.extend(FilePath2)
+                else
+                  @index = i15
+                  r15 = nil
+                end
+                if r15
+                  r13 = r15
+                else
+                  @index = i13
+                  r13 = nil
+                end
+              end
+              if r13
+                s12 << r13
+              else
+                break
+              end
+            end
+            r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
+            s10 << r12
+            if r12
+              if has_terminal?("'", false, index)
+                r18 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("'")
+                r18 = nil
+              end
+              s10 << r18
+            end
+          end
+          if s10.last
+            r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
+            r10.extend(FilePath3)
+          else
+            @index = i10
+            r10 = nil
+          end
+          if r10
+            r0 = r10
+          else
+            s19, i19 = [], index
+            loop do
+              if has_terminal?('\G[^\\s#:]', true, index)
+                r20 = true
+                @index += 1
+              else
+                r20 = nil
+              end
+              if r20
+                s19 << r20
+              else
+                break
+              end
+            end
+            if s19.empty?
+              @index = i19
+              r19 = nil
+            else
+              r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
+            end
+            if r19
+              r0 = r19
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+
+        node_cache[:file_path][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class V2Parser < Treetop::Runtime::CompiledParser
+      include V2
+    end
+
+  end
+end