brakeman 5.2.2 → 7.1.1

data/bundle/ruby/2.7.0/gems/haml-5.2.2/TODO

@@ -1,24 +0,0 @@
-# -*- mode: org -*-
-#+STARTUP: nofold
-
-* Documentation
-  Redo tutorial?
-  Using helpers
-    haml_concat and haml_tag in particular
-  Syntax highlighting?
-
-* Code
-  Keep track of error offsets everywhere
-    Use this to show error location in messages
-** Haml
-   Support finer-grained HTML-escaping in filters
-   Speed
-     Make tags with dynamic attributes pre-render as much as possible
-     Including the attribute name where doable
-   :html improvements
-     Ignore closing tags where we can
-       http://code.google.com/speed/articles/optimizing-html.html
-       Requires Haml parsing refactor
-     Don't quote attributes that don't require it
-       http://www.w3.org/TR/REC-html40/intro/sgmltut.html#h-3.2.2
-       http://www.w3.org/TR/html5/syntax.html#attributes

data/bundle/ruby/2.7.0/gems/haml-5.2.2/haml.gemspec

@@ -1,45 +0,0 @@
-($LOAD_PATH << File.expand_path("../lib", __FILE__)).uniq!
-require "haml/version"
-
-Gem::Specification.new do |spec|
-  spec.name        = 'haml'
-  spec.summary     = "An elegant, structured (X)HTML/XML templating engine."
-  spec.version     = Haml::VERSION
-  spec.authors     = ['Natalie Weizenbaum', 'Hampton Catlin', 'Norman Clarke', 'Akira Matsuda']
-  spec.email       = ['haml@googlegroups.com', 'ronnie@dio.jp']
-
-  spec.executables = ['haml']
-  spec.files       = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{\Atest/})
-  end
-  spec.homepage    = 'http://haml.info/'
-  spec.license     = "MIT"
-  spec.metadata    = {
-    "bug_tracker_uri"   => "https://github.com/haml/haml/issues",
-    "changelog_uri"     => "https://github.com/haml/haml/blob/main/CHANGELOG.md",
-    "documentation_uri" => "http://haml.info/docs.html",
-    "homepage_uri"      => "http://haml.info",
-    "mailing_list_uri"  => "https://groups.google.com/forum/?fromgroups#!forum/haml",
-    "source_code_uri"   => "https://github.com/haml/haml"
-  }
-
-  spec.required_ruby_version = '>= 2.0.0'
-
-  spec.add_dependency 'temple', '>= 0.8.0'
-  spec.add_dependency 'tilt'
-
-  spec.add_development_dependency 'rails', '>= 4.0.0'
-  spec.add_development_dependency 'rbench'
-  spec.add_development_dependency 'minitest', '>= 4.0'
-  spec.add_development_dependency 'nokogiri'
-  spec.add_development_dependency 'simplecov'
-
-  spec.description = <<-END
-Haml (HTML Abstraction Markup Language) is a layer on top of HTML or XML that's
-designed to express the structure of documents in a non-repetitive, elegant, and
-easy way by using indentation rather than closing tags and allowing Ruby to be
-embedded with ease. It was originally envisioned as a plugin for Ruby on Rails,
-but it can function as a stand-alone templating engine.
-END
-
-end

data/bundle/ruby/2.7.0/gems/haml-5.2.2/lib/haml/attribute_builder.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-module Haml
-  module AttributeBuilder
-    # https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
-    INVALID_ATTRIBUTE_NAME_REGEX = /[ \0"'>\/=]/
-
-    class << self
-      def build(class_id, obj_ref, is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, *attributes_hashes)
-        attributes = class_id
-        attributes_hashes.each do |old|
-          result = {}
-          old.each { |k, v| result[k.to_s] = v }
-          merge_attributes!(attributes, result)
-        end
-        merge_attributes!(attributes, parse_object_ref(obj_ref)) if obj_ref
-        build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes)
-      end
-
-      def build_attributes(is_html, attr_wrapper, escape_attrs, hyphenate_data_attrs, attributes = {})
-        # @TODO this is an absolutely ridiculous amount of arguments. At least
-        # some of this needs to be moved into an instance method.
-        join_char = hyphenate_data_attrs ? '-' : '_'
-
-        attributes.each do |key, value|
-          if value.is_a?(Hash)
-            data_attributes = attributes.delete(key)
-            data_attributes = flatten_data_attributes(data_attributes, '', join_char)
-            data_attributes = build_data_keys(data_attributes, hyphenate_data_attrs, key)
-            verify_attribute_names!(data_attributes.keys)
-            attributes = data_attributes.merge(attributes)
-          end
-        end
-
-        result = attributes.collect do |attr, value|
-          next if value.nil?
-
-          value = filter_and_join(value, ' ') if attr == 'class'
-          value = filter_and_join(value, '_') if attr == 'id'
-
-          if value == true
-            next " #{attr}" if is_html
-            next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
-          elsif value == false
-            next
-          end
-
-          value =
-            if escape_attrs == :once
-              Haml::Helpers.escape_once_without_haml_xss(value.to_s)
-            elsif escape_attrs
-              Haml::Helpers.html_escape_without_haml_xss(value.to_s)
-            else
-              value.to_s
-            end
-          " #{attr}=#{attr_wrapper}#{value}#{attr_wrapper}"
-        end
-        result.compact!
-        result.sort!
-        result.join
-      end
-
-      # @return [String, nil]
-      def filter_and_join(value, separator)
-        return '' if (value.respond_to?(:empty?) && value.empty?)
-
-        if value.is_a?(Array)
-          value = value.flatten
-          value.map! {|item| item ? item.to_s : nil}
-          value.compact!
-          value = value.join(separator)
-        else
-          value = value ? value.to_s : nil
-        end
-        !value.nil? && !value.empty? && value
-      end
-
-      # Merges two attribute hashes.
-      # This is the same as `to.merge!(from)`,
-      # except that it merges id, class, and data attributes.
-      #
-      # ids are concatenated with `"_"`,
-      # and classes are concatenated with `" "`.
-      # data hashes are simply merged.
-      #
-      # Destructively modifies `to`.
-      #
-      # @param to [{String => String,Hash}] The attribute hash to merge into
-      # @param from [{String => Object}] The attribute hash to merge from
-      # @return [{String => String,Hash}] `to`, after being merged
-      def merge_attributes!(to, from)
-        from.keys.each do |key|
-          to[key] = merge_value(key, to[key], from[key])
-        end
-        to
-      end
-
-      # Merge multiple values to one attribute value. No destructive operation.
-      #
-      # @param key [String]
-      # @param values [Array<Object>]
-      # @return [String,Hash]
-      def merge_values(key, *values)
-        values.inject(nil) do |to, from|
-          merge_value(key, to, from)
-        end
-      end
-
-      def verify_attribute_names!(attribute_names)
-        attribute_names.each do |attribute_name|
-          if attribute_name =~ INVALID_ATTRIBUTE_NAME_REGEX
-            raise InvalidAttributeNameError.new("Invalid attribute name '#{attribute_name}' was rendered")
-          end
-        end
-      end
-
-      private
-
-      # Merge a couple of values to one attribute value. No destructive operation.
-      #
-      # @param to [String,Hash,nil]
-      # @param from [Object]
-      # @return [String,Hash]
-      def merge_value(key, to, from)
-        if from.kind_of?(Hash) || to.kind_of?(Hash)
-          from = { nil => from } if !from.is_a?(Hash)
-          to   = { nil => to }   if !to.is_a?(Hash)
-          to.merge(from)
-        elsif key == 'id'
-          merged_id = filter_and_join(from, '_')
-          if to && merged_id
-            merged_id = "#{to}_#{merged_id}"
-          elsif to || merged_id
-            merged_id ||= to
-          end
-          merged_id
-        elsif key == 'class'
-          merged_class = filter_and_join(from, ' ')
-          if to && merged_class
-            merged_class = (to.split(' ') | merged_class.split(' ')).join(' ')
-          elsif to || merged_class
-            merged_class ||= to
-          end
-          merged_class
-        else
-          from
-        end
-      end
-
-      def build_data_keys(data_hash, hyphenate, attr_name="data")
-        Hash[data_hash.map do |name, value|
-          if name == nil
-            [attr_name, value]
-          elsif hyphenate
-            ["#{attr_name}-#{name.to_s.tr('_', '-')}", value]
-          else
-            ["#{attr_name}-#{name}", value]
-          end
-        end]
-      end
-
-      def flatten_data_attributes(data, key, join_char, seen = [])
-        return {key => data} unless data.is_a?(Hash)
-
-        return {key => nil} if seen.include? data.object_id
-        seen << data.object_id
-
-        data.sort {|x, y| x[0].to_s <=> y[0].to_s}.inject({}) do |hash, (k, v)|
-          joined = key == '' ? k : [key, k].join(join_char)
-          hash.merge! flatten_data_attributes(v, joined, join_char, seen)
-        end
-      end
-
-      # Takes an array of objects and uses the class and id of the first
-      # one to create an attributes hash.
-      # The second object, if present, is used as a prefix,
-      # just like you can do with `dom_id()` and `dom_class()` in Rails
-      def parse_object_ref(ref)
-        prefix = ref[1]
-        ref = ref[0]
-        # Let's make sure the value isn't nil. If it is, return the default Hash.
-        return {} if ref.nil?
-        class_name =
-          if ref.respond_to?(:haml_object_ref)
-            ref.haml_object_ref
-          else
-            underscore(ref.class)
-          end
-        ref_id =
-          if ref.respond_to?(:to_key)
-            key = ref.to_key
-            key.join('_') unless key.nil?
-          else
-            ref.id
-          end
-        id = "#{class_name}_#{ref_id || 'new'}"
-        if prefix
-          class_name = "#{ prefix }_#{ class_name}"
-          id = "#{ prefix }_#{ id }"
-        end
-
-        { 'id'.freeze => id, 'class'.freeze => class_name }
-      end
-
-      # Changes a word from camel case to underscores.
-      # Based on the method of the same name in Rails' Inflector,
-      # but copied here so it'll run properly without Rails.
-      def underscore(camel_cased_word)
-        word = camel_cased_word.to_s.dup
-        word.gsub!(/::/, '_')
-        word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-        word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        word.tr!('-', '_')
-        word.downcase!
-        word
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/haml-5.2.2/lib/haml/attribute_compiler.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-require 'haml/attribute_parser'
-
-module Haml
-  class AttributeCompiler
-    # @param type [Symbol] :static or :dynamic
-    # @param key [String]
-    # @param value [String] Actual string value for :static type, value's Ruby literal for :dynamic type.
-    AttributeValue = Struct.new(:type, :key, :value)
-
-    # @param options [Haml::Options]
-    def initialize(options)
-      @is_html = [:html4, :html5].include?(options[:format])
-      @attr_wrapper = options[:attr_wrapper]
-      @escape_attrs = options[:escape_attrs]
-      @hyphenate_data_attrs = options[:hyphenate_data_attrs]
-    end
-
-    # Returns Temple expression to render attributes.
-    #
-    # @param attributes [Hash]
-    # @param object_ref [String,:nil]
-    # @param dynamic_attributes [Haml::Parser::DynamicAttributes]
-    # @return [Array] Temple expression
-    def compile(attributes, object_ref, dynamic_attributes)
-      if object_ref != :nil || !AttributeParser.available?
-        return [:dynamic, compile_runtime_build(attributes, object_ref, dynamic_attributes)]
-      end
-
-      parsed_hashes = [dynamic_attributes.new, dynamic_attributes.old].compact.map do |attribute_hash|
-        unless (hash = AttributeParser.parse(attribute_hash))
-          return [:dynamic, compile_runtime_build(attributes, object_ref, dynamic_attributes)]
-        end
-        hash
-      end
-      attribute_values = build_attribute_values(attributes, parsed_hashes)
-      AttributeBuilder.verify_attribute_names!(attribute_values.map(&:key))
-
-      [:multi, *group_values_for_sort(attribute_values).map { |value_group|
-        compile_attribute_values(value_group)
-      }]
-    end
-
-    private
-
-    # Returns a script to render attributes on runtime.
-    #
-    # @param attributes [Hash]
-    # @param object_ref [String,:nil]
-    # @param dynamic_attributes [Haml::Parser::DynamicAttributes]
-    # @return [String] Attributes rendering code
-    def compile_runtime_build(attributes, object_ref, dynamic_attributes)
-      arguments = [@is_html, @attr_wrapper, @escape_attrs, @hyphenate_data_attrs].map(&method(:to_literal)).join(', ')
-      "::Haml::AttributeBuilder.build(#{to_literal(attributes)}, #{object_ref}, #{arguments}, #{dynamic_attributes.to_literal})"
-    end
-
-    # Build array of grouped values whose sort order may go back and forth, which is also sorted with key name.
-    # This method needs to group values with the same start because it can be changed in `Haml::AttributeBuidler#build_data_keys`.
-    # @param values [Array<Haml::AttributeCompiler::AttributeValue>]
-    # @return [Array<Array<Haml::AttributeCompiler::AttributeValue>>]
-    def group_values_for_sort(values)
-      sorted_values = values.sort_by(&:key)
-      [].tap do |value_groups|
-        until sorted_values.empty?
-          key = sorted_values.first.key
-          value_group, sorted_values = sorted_values.partition { |v| v.key.start_with?(key) }
-          value_groups << value_group
-        end
-      end
-    end
-
-    # Returns array of AttributeValue instances from static attributes and dynamic_attributes. For each key,
-    # the values' order in returned value is preserved in the same order as Haml::Buffer#attributes's merge order.
-    #
-    # @param attributes [{ String => String }]
-    # @param parsed_hashes [{ String => String }]
-    # @return [Array<AttributeValue>]
-    def build_attribute_values(attributes, parsed_hashes)
-      [].tap do |attribute_values|
-        attributes.each do |key, static_value|
-          attribute_values << AttributeValue.new(:static, key, static_value)
-        end
-        parsed_hashes.each do |parsed_hash|
-          parsed_hash.each do |key, dynamic_value|
-            attribute_values << AttributeValue.new(:dynamic, key, dynamic_value)
-          end
-        end
-      end
-    end
-
-    # Compiles attribute values with the similar key to Temple expression.
-    #
-    # @param values [Array<AttributeValue>] whose `key`s are partially or fully the same from left.
-    # @return [Array] Temple expression
-    def compile_attribute_values(values)
-      if values.map(&:key).uniq.size == 1
-        compile_attribute(values.first.key, values)
-      else
-        runtime_build(values)
-      end
-    end
-
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def runtime_build(values)
-      hash_content = values.group_by(&:key).map do |key, values_for_key|
-        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
-      end.join(', ')
-      arguments = [@is_html, @attr_wrapper, @escape_attrs, @hyphenate_data_attrs].map(&method(:to_literal)).join(', ')
-      [:dynamic, "::Haml::AttributeBuilder.build({ #{hash_content} }, nil, #{arguments})"]
-    end
-
-    # Renders attribute values statically.
-    #
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def static_build(values)
-      hash_content = values.group_by(&:key).map do |key, values_for_key|
-        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
-      end.join(', ')
-
-      arguments = [@is_html, @attr_wrapper, @escape_attrs, @hyphenate_data_attrs]
-      code = "::Haml::AttributeBuilder.build_attributes"\
-        "(#{arguments.map(&method(:to_literal)).join(', ')}, { #{hash_content} })"
-      [:static, eval(code).to_s]
-    end
-
-    # @param key [String]
-    # @param values [Array<AttributeValue>]
-    # @return [String]
-    def merged_value(key, values)
-      if values.size == 1
-        attr_literal(values.first)
-      else
-        "::Haml::AttributeBuilder.merge_values(#{frozen_string(key)}, #{values.map(&method(:attr_literal)).join(', ')})"
-      end
-    end
-
-    # @param str [String]
-    # @return [String]
-    def frozen_string(str)
-      "#{to_literal(str)}.freeze"
-    end
-
-    # Compiles attribute values for one key to Temple expression that generates ` key='value'`.
-    #
-    # @param key [String]
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_attribute(key, values)
-      if values.all? { |v| Temple::StaticAnalyzer.static?(attr_literal(v)) }
-        return static_build(values)
-      end
-
-      case key
-      when 'id', 'class'
-        compile_id_or_class_attribute(key, values)
-      else
-        compile_common_attribute(key, values)
-      end
-    end
-
-    # @param id_or_class [String] "id" or "class"
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_id_or_class_attribute(id_or_class, values)
-      var = unique_name
-      [:multi,
-       [:code, "#{var} = (#{merged_value(id_or_class, values)})"],
-       [:case, var,
-        ['Hash, Array', runtime_build([AttributeValue.new(:dynamic, id_or_class, var)])],
-        ['false, nil', [:multi]],
-        [:else, [:multi,
-                 [:static, " #{id_or_class}=#{@attr_wrapper}"],
-                 [:escape, Escapable::EscapeSafeBuffer.new(@escape_attrs), [:dynamic, var]],
-                 [:static, @attr_wrapper]],
-        ]
-       ],
-      ]
-    end
-
-    # @param key [String] Not "id" or "class"
-    # @param values [Array<AttributeValue>]
-    # @return [Array] Temple expression
-    def compile_common_attribute(key, values)
-      var = unique_name
-      [:multi,
-       [:code, "#{var} = (#{merged_value(key, values)})"],
-       [:case, var,
-        ['Hash', runtime_build([AttributeValue.new(:dynamic, key, var)])],
-        ['true', true_value(key)],
-        ['false, nil', [:multi]],
-        [:else, [:multi,
-                 [:static, " #{key}=#{@attr_wrapper}"],
-                 [:escape, Escapable::EscapeSafeBuffer.new(@escape_attrs), [:dynamic, var]],
-                 [:static, @attr_wrapper]],
-        ]
-       ],
-      ]
-    end
-
-    def true_value(key)
-      if @is_html
-        [:static, " #{key}"]
-      else
-        [:static, " #{key}=#{@attr_wrapper}#{key}#{@attr_wrapper}"]
-      end
-    end
-
-    def unique_name
-      @unique_name ||= 0
-      "_haml_attribute_compiler#{@unique_name += 1}"
-    end
-
-    # @param [Haml::AttributeCompiler::AttributeValue] attr
-    def attr_literal(attr)
-      case attr.type
-      when :static
-        to_literal(attr.value)
-      when :dynamic
-        attr.value
-      end
-    end
-
-    # For haml/haml#972
-    # @param [Object] value
-    def to_literal(value)
-      case value
-      when true, false
-        value.to_s
-      else
-        Haml::Util.inspect_obj(value)
-      end
-    end
-  end
-end

data/bundle/ruby/2.7.0/gems/haml-5.2.2/lib/haml/attribute_parser.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'ripper'
-rescue LoadError
-end
-require 'temple/static_analyzer'
-
-module Haml
-  # Haml::AttriubuteParser parses Hash literal to { String (key name) => String (value literal) }.
-  module AttributeParser
-    class UnexpectedTokenError < StandardError; end
-    class UnexpectedKeyError < StandardError; end
-
-    # Indices in Ripper tokens
-    TYPE = 1
-    TEXT = 2
-
-    IGNORED_TYPES = %i[on_sp on_ignored_nl].freeze
-
-    class << self
-      # @return [Boolean] - return true if AttributeParser.parse can be used.
-      def available?
-        defined?(Ripper) && Temple::StaticAnalyzer.available?
-      end
-
-      # @param  [String] exp - Old attributes literal or Hash literal generated from new attributes.
-      # @return [Hash<String, String>,nil] - Return parsed attribute Hash whose values are Ruby literals, or return nil if argument is not a single Hash literal.
-      def parse(exp)
-        return nil unless hash_literal?(exp)
-
-        hash = {}
-        each_attribute(exp) do |key, value|
-          hash[key] = value
-        end
-        hash
-      rescue UnexpectedTokenError, UnexpectedKeyError
-        nil
-      end
-
-      private
-
-      # @param  [String] exp - Ruby expression
-      # @return [Boolean] - Return true if exp is a single Hash literal
-      def hash_literal?(exp)
-        return false if Temple::StaticAnalyzer.syntax_error?(exp)
-        sym, body = Ripper.sexp(exp)
-        sym == :program && body.is_a?(Array) && body.size == 1 && body[0] && body[0][0] == :hash
-      end
-
-      # @param [Array] tokens - Ripper tokens. Scanned tokens will be destructively removed from this argument.
-      # @return [String] - attribute name in String
-      def shift_key!(tokens)
-        while !tokens.empty? && IGNORED_TYPES.include?(tokens.first[TYPE])
-          tokens.shift # ignore spaces
-        end
-
-        _, type, first_text = tokens.shift
-        case type
-        when :on_label # `key:`
-          first_text.tr(':', '')
-        when :on_symbeg # `:key =>`, `:'key' =>` or `:"key" =>`
-          key = tokens.shift[TEXT]
-          if first_text != ':' # `:'key'` or `:"key"`
-            expect_string_end!(tokens.shift)
-          end
-          shift_hash_rocket!(tokens)
-          key
-        when :on_tstring_beg # `"key":`, `'key':` or `"key" =>`
-          key = tokens.shift[TEXT]
-          next_token = tokens.shift
-          if next_token[TYPE] != :on_label_end # on_label_end is `":` or `':`, so `"key" =>`
-            expect_string_end!(next_token)
-            shift_hash_rocket!(tokens)
-          end
-          key
-        else
-          raise UnexpectedKeyError.new("unexpected token is given!: #{first_text} (#{type})")
-        end
-      end
-
-      # @param [Array] token - Ripper token
-      def expect_string_end!(token)
-        if token[TYPE] != :on_tstring_end
-          raise UnexpectedTokenError
-        end
-      end
-
-      # @param [Array] tokens - Ripper tokens
-      def shift_hash_rocket!(tokens)
-        until tokens.empty?
-          _, type, str = tokens.shift
-          break if type == :on_op && str == '=>'
-        end
-      end
-
-      # @param [String] hash_literal
-      # @param [Proc] block - that takes [String, String] as arguments
-      def each_attribute(hash_literal, &block)
-        all_tokens = Ripper.lex(hash_literal.strip)
-        all_tokens = all_tokens[1...-1] || [] # strip tokens for brackets
-
-        each_balanced_tokens(all_tokens) do |tokens|
-          key   = shift_key!(tokens)
-          value = tokens.map {|t| t[2] }.join.strip
-          block.call(key, value)
-        end
-      end
-
-      # @param [Array] tokens - Ripper tokens
-      # @param [Proc] block - that takes balanced Ripper tokens as arguments
-      def each_balanced_tokens(tokens, &block)
-        attr_tokens = []
-        open_tokens = Hash.new { |h, k| h[k] = 0 }
-
-        tokens.each do |token|
-          case token[TYPE]
-          when :on_comma
-            if open_tokens.values.all?(&:zero?)
-              block.call(attr_tokens)
-              attr_tokens = []
-              next
-            end
-          when :on_lbracket
-            open_tokens[:array] += 1
-          when :on_rbracket
-            open_tokens[:array] -= 1
-          when :on_lbrace
-            open_tokens[:block] += 1
-          when :on_rbrace
-            open_tokens[:block] -= 1
-          when :on_lparen
-            open_tokens[:paren] += 1
-          when :on_rparen
-            open_tokens[:paren] -= 1
-          when :on_embexpr_beg
-            open_tokens[:embexpr] += 1
-          when :on_embexpr_end
-            open_tokens[:embexpr] -= 1
-          when *IGNORED_TYPES
-            next if attr_tokens.empty?
-          end
-
-          attr_tokens << token
-        end
-        block.call(attr_tokens) unless attr_tokens.empty?
-      end
-    end
-  end
-end