xezat 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ce894f06157cf37deb9e4e97f41da557c51a0a4af3b6c81caede3ee88f2f018
-  data.tar.gz: 5dba5ffae008660e41e8f2ec9c0e8940f05e5d1b7be432d013be58b84439627d
+  metadata.gz: 0053db8d2a6f202e9aa40b7454f00f8ced3fdacd2c174944bec6c02a2ae106c4
+  data.tar.gz: 5abd0d6bd506b6a44ca306675e7b37b81d8834ff12d1165f47ad2c100ec87fcb
 SHA512:
-  metadata.gz: 1bb76ee8cc4c1a9717f6f07403c741eb9d09e819db8f08505a34f55a04374834bf1f0b45d724b968450f9d48a3c772214305f036fe5b39400d02338fe5207ae3
-  data.tar.gz: 4eb4b364e0e5baf15de4a9c5b486494c8efe84c4ffa71624b55a78c30cd34d224a66c9beb8ae759c7b688347d75eb9a4d5d0ad615bcbad5167551ea8326e9a64
+  metadata.gz: eb736dd2128a11b7b249db02e58732b54578085808f3e8d4ad36cfa74741ae2583194e3337b810d82e2a048cf9f7a893e9df1941d589e8953de270abe1799196
+  data.tar.gz: f8a26d86744acd8391b21c89db39afe00a880bf26b2660de5fc51d04ccae070a0e2761f650dea28c32a38cfc4b757f739b7baf4cad74aad5a480a4585e89e2dd

data/.circleci/config.yml

@@ -1,13 +1,10 @@
-# Ruby CircleCI 2.0 configuration file
-#
-# Check https://circleci.com/docs/2.0/language-ruby/ for more details
-#
-version: 2
+version: 2.1
+orbs:
+  ruby: circleci/ruby@1.4.0
 jobs:
-  build:
+  test:
     docker:
-      # specify the version you desire here
-       - image: circleci/ruby
+      - image: cimg/ruby:2.6
 
     working_directory: ~/repo
 
@@ -76,3 +73,38 @@ jobs:
       - store_artifacts:
           path: ~/repo/coverage
           destination: coverage
+
+  deploy:
+    docker:
+      - image: cimg/ruby:2.6
+    steps:
+      - checkout
+      - run:
+          name: Install native libraries
+          command: |
+            sudo apt-get install cmake libicu-dev
+
+      - run:
+          name: Install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - run:
+          name: Publish gem to Rubygems
+          command: bundle exec rake release
+
+workflows:
+  test:
+    jobs:
+      - test:
+          filters:
+            tags:
+              only: /.*/
+      - deploy:
+          requires:
+            - test
+          filters:
+            tags:
+              only: /^v.*/
+            branches:
+              ignore: /.*/

data/.rubocop.yml

@@ -1,6 +1,8 @@
 require: rubocop-performance
 
 AllCops:
+  NewCops: enable
+  SuggestExtensions: false
   TargetRubyVersion: 2.6
   Exclude:
     - 'spec/cygport/**/*'
@@ -10,7 +12,7 @@ Layout/LineLength:
   Max: 160
 
 Metrics/AbcSize:
-  Max: 40
+  Max: 45
 Metrics/BlockLength:
   Exclude:
     - '*.gemspec'

data/.ruby-version

@@ -0,0 +1 @@
+2.6.4

data/lib/xezat/command/announce.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'xezat/variables'
+
+module Xezat
+  module Command
+    class Announce
+      include Xezat
+
+      def initialize(options, cygport)
+        @options = options
+        @cygport = cygport
+      end
+
+      def execute
+        variables = variables(@cygport)
+        erb = File.expand_path(File.join(TEMPLATE_DIR, 'announce.erb'))
+        print ERB.new(File.readlines(erb).join(nil), trim_mode: '%-').result(binding).chop # remove redundant new line
+      end
+    end
+  end
+end

data/lib/xezat/command/bump/changelog.rb

@@ -9,7 +9,7 @@ module Xezat
   module Command
     class Bump
       def get_changelog(variables, options, readme_file)
-        Xezat.logger.debug('Append latest log to changelog')
+        Xezat.logger.debug('  Try to append latest log to changelog...')
         current_version = variables[:PVR].intern
         if FileTest.exist?(readme_file)
           raise FilePermissionError, "Cannot read #{readme_file}" unless FileTest.readable?(readme_file)
@@ -17,10 +17,16 @@ module Xezat
 
           changelog = Cygchangelog.new(File.read(readme_file))
           message = options['message'] || 'Version bump.'
-          changelog[current_version] = message unless changelog.key?(current_version)
+          if changelog.length > 1 || !changelog.key?(current_version)
+            changelog[current_version] = message # overwrite unless initial package
+            Xezat.logger.debug("    '#{message}' appended")
+          else
+            Xezat.logger.warn('    Initial release protected')
+          end
         else
           changelog = Cygchangelog.new
           changelog[current_version] = 'Initial release by fd0 <https://github.com/fd00/>'
+          Xezat.logger.debug('    Initial release by you')
         end
         changelog
       end

data/lib/xezat/command/bump/compiler.rb

@@ -6,9 +6,9 @@ module Xezat
   module Command
     class Bump
       def get_compilers(languages, _variables)
-        Xezat.logger.debug('Collect compilers')
-        compiler_file = File.expand_path(File.join(DATA_DIR, 'compilers.json'))
-        compiler_candidates = JSON.parse(File.read(compiler_file))
+        Xezat.logger.debug('  Collect compilers')
+        compiler_file = File.expand_path(File.join(DATA_DIR, 'compilers.yaml'))
+        compiler_candidates = YAML.safe_load(File.open(compiler_file), [Symbol])
         compilers = []
         languages.uniq.each do |language|
           next unless compiler_candidates.key?(language)

data/lib/xezat/command/bump/cygport_dep.rb

@@ -7,15 +7,15 @@ require 'xezat'
 module Xezat
   module Command
     class Bump
-      def invoke_cygport_dep(vars, cygport)
-        candidate_files = Find.find(vars[:D]).select do |file|
+      def invoke_cygport_dep(variables, cygport)
+        candidate_files = Find.find(variables[:D]).select do |file|
           file.end_with?('.exe', '.dll', '.so')
         end
         additional_path = candidate_files.map do |file|
           File.dirname(file)
         end.sort.uniq.join(':')
-        command = ['bash', File.expand_path(File.join(DATA_DIR, 'invoke_cygport_dep.sh')), cygport]
-        result, error, status = Open3.capture3({ 'PATH' => ENV['PATH'] + ':' + additional_path }, command.join(' '))
+        command = ['bash', File.expand_path(File.join(DATA_DIR, 'cygport_dep.sh')), cygport]
+        result, error, status = Open3.capture3({ 'PATH' => "#{ENV.fetch('PATH')}:#{additional_path}" }, command.join(' '))
         raise CygportProcessError, error unless status.success?
 
         result

data/lib/xezat/command/bump/development_package.rb

@@ -8,15 +8,42 @@ require 'xezat/command/bump/tool'
 module Xezat
   module Command
     class Bump
-      def get_development_packages(variables, packages)
-        Xezat.logger.debug('Collect development packages')
+      def get_development_packages(variables, packages, runtimes, pkg2files)
+        Xezat.logger.debug('  Collect development packages')
         compilers = get_compilers(get_languages(variables[:S]), variables)
         tools = get_tools(variables)
-        development_packages = (compilers + tools + [:cygport]).uniq.sort
+        build_requires = variables[:BUILD_REQUIRES].nil? ? [] : variables[:BUILD_REQUIRES].split.map(&:to_sym)
+        development_packages = (compilers + tools + build_requires + [:cygport]).uniq
+
+        resolve_development_package(development_packages)
+
+        # Check gcc-gfortran
+        if runtimes.grep(/^libgfortran/).empty?
+          delete_fortran = true
+          pkg2files.each_value do |files|
+            delete_fortran = false unless files.grep(/\.mod$/).empty?
+          end
+          development_packages.delete(:'gcc-fortran') if delete_fortran
+        end
+
+        development_packages.sort!
+
         development_packages.map! do |package|
-          packages[package] || ''
+          pkg = packages[package]
+          raise "Package #{package} is not installed in your system" if pkg.nil?
+
+          pkg
         end
       end
+
+      def resolve_development_package(development_packages)
+        # Check libssl duplication
+        development_packages.delete(:'libssl-devel') if development_packages.include?(:'libssl1.0-devel')
+
+        # Check lua duplication
+        development_packages.delete(:lua) if development_packages.include?(:'lua5.1-devel')
+        development_packages.delete(:lua) if development_packages.include?(:'luajit-devel')
+      end
     end
   end
 end

data/lib/xezat/command/bump/file.rb

@@ -9,10 +9,10 @@ module Xezat
   module Command
     class Bump
       def get_files(variables)
-        Xezat.logger.debug('Collect files')
+        Xezat.logger.debug('  Collect files')
         pkg2files = {}
         variables[:pkg_name].each do |pkg_name|
-          Xezat.logger.debug("  Collect #{pkg_name}")
+          Xezat.logger.debug("    Collect #{pkg_name}")
           lst_file = File.expand_path(File.join(variables[:T], ".#{pkg_name}.lst"))
           raise IllegalStateError, "No such file: #{lst_file}" unless FileTest.readable?(lst_file)
 

data/lib/xezat/command/bump/language.rb

@@ -7,9 +7,9 @@ module Xezat
   module Command
     class Bump
       def get_languages(top_src_dir)
-        Xezat.logger.debug('Collect languages')
-        languages_file = File.expand_path(File.join(DATA_DIR, 'languages.json'))
-        languages_candidates = JSON.parse(File.read(languages_file))
+        Xezat.logger.debug('  Collect languages')
+        languages_file = File.expand_path(File.join(DATA_DIR, 'languages.yaml'))
+        languages_candidates = YAML.safe_load(File.open(languages_file), [Symbol])
         languages = []
         Find.find(top_src_dir) do |path|
           next if FileTest.directory?(path)

data/lib/xezat/command/bump/runtime_package.rb

@@ -7,10 +7,16 @@ require 'xezat/variables'
 module Xezat
   module Command
     class Bump
-      def get_runtime_packages(vars, cygport)
-        Xezat.logger.debug('Collect runtime packages from cygport dep')
-        result = invoke_cygport_dep(vars, cygport)
-        result.gsub(/^.*\*\*\*.*$/, '').split($INPUT_RECORD_SEPARATOR).map(&:lstrip)
+      def get_runtime_packages(variables, pkgs, cygport)
+        Xezat.logger.debug('  Collect runtime packages from cygport dep')
+        result = invoke_cygport_dep(variables, cygport)
+        runtime_packages = result.gsub(/^.*\*\*\*.*$/, '').split($INPUT_RECORD_SEPARATOR).map(&:lstrip)
+        build_requires = variables[:BUILD_REQUIRES].nil? ? [] : variables[:BUILD_REQUIRES].split.map(&:to_sym)
+        runtime_packages.delete(pkgs[:'libssl-devel']) if build_requires.include?(:'libssl1.0-devel')
+        variables[:REQUIRES]&.split&.each do |req|
+          runtime_packages << pkgs[req.to_sym]
+        end
+        runtime_packages.sort
       end
     end
   end

data/lib/xezat/command/bump/src_uri.rb

@@ -6,15 +6,15 @@ require 'xezat/cygclasses'
 module Xezat
   module Command
     class Bump
-      def get_src_uri(vars, cygclasses = CygclassManager.new)
-        Xezat.logger.debug('Collect SRC_URI')
+      def get_src_uri(variables, cygclasses = CygclassManager.new)
+        Xezat.logger.debug('  Collect SRC_URI')
         cygclasses.vcs.each do |vcs|
-          next unless vars.key?("_#{vcs}_CYGCLASS_".intern)
+          next unless variables.key?("_#{vcs}_CYGCLASS_".intern)
 
           src_uri_key = "#{vcs.to_s.upcase}_URI".intern
-          return vars[src_uri_key].split if vars.key?(src_uri_key)
+          return variables[src_uri_key].split if variables.key?(src_uri_key)
         end
-        vars[:SRC_URI].split
+        variables[:SRC_URI].split
       end
     end
   end

data/lib/xezat/command/bump.rb

@@ -30,15 +30,14 @@ module Xezat
         vars = variables(@cygport)
         readme_file = File.expand_path(File.join(vars[:C], 'README'))
 
-        info = {
-          src_uri: get_src_uri(vars),
-          runtimes: get_runtime_packages(vars, @cygport),
-          developments: get_development_packages(vars, pkgs),
-          files: get_files(vars),
-          changelog: get_changelog(vars, @options, readme_file)
-        }
-
-        Xezat.logger.debug('Write ChangeLog atomically')
+        info = {}
+        info[:src_uri] = get_src_uri(vars)
+        info[:runtimes] = get_runtime_packages(vars, pkgs, @cygport)
+        info[:files] = get_files(vars)
+        info[:developments] = get_development_packages(vars, pkgs, info[:runtimes], info[:files])
+        info[:changelog] = get_changelog(vars, @options, readme_file)
+
+        Xezat.logger.debug('  Write ChangeLog atomically')
         File.atomic_write(readme_file) do |f|
           f.write(get_embedded_contents(vars, info))
         end

data/lib/xezat/command/doctor.rb

@@ -7,8 +7,6 @@ module Xezat
     class Doctor
       include Xezat
 
-      def initialize; end
-
       def execute
         get_contents_uniqueness.each do |path, pkg|
           puts "#{path} is not unique: #{pkg}" if pkg.length > 1

data/lib/xezat/command/generate.rb

@@ -5,8 +5,9 @@ require 'thor'
 module Xezat
   module Command
     class Generate < Thor
-      desc 'generate pkgconfig cygport', 'Generate *.pc'
+      desc 'pkgconfig cygport', 'Generate *.pc'
       option :overwrite, type: :boolean, aliases: '-o', desc: 'overwrite *.pc'
+      option :srcdir, type: :string, aliases: '-s', desc: 'relative path to Makefile.am / CMakeLists.txt'
 
       def pkgconfig(cygport)
         require 'xezat/generator/pkgconfig'

data/lib/xezat/command/init.rb

@@ -41,10 +41,10 @@ module Xezat
 
       def get_repository_variables(repository)
         if repository
-          repository_file = File.expand_path(File.join(REPOSITORY_DIR, "#{repository}.json"))
+          repository_file = File.expand_path(File.join(REPOSITORY_DIR, "#{repository}.yaml"))
           raise NoSuchRepositoryError, "No such repository: #{template}" unless FileTest.exist?(repository_file) || FileTest.readable?(repository_file)
 
-          JSON.parse(File.read(repository_file), symbolize_names: true)
+          YAML.safe_load(File.open(repository_file), symbolize_names: true)
         else
           {
             HOMEPAGE: '',

data/lib/xezat/command/port.rb

@@ -43,7 +43,7 @@ module Xezat
         port_dir = conf['xezat']['portdir'] || options[:portdir]
         raise NoPortDirectoryError if port_dir.nil?
 
-        Xezat.logger.debug("Port directory: #{port_dir}")
+        Xezat.logger.debug("  Port directory: #{port_dir}")
         port_dir
       end
     end

data/lib/xezat/command/validate/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'pkg-config'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_config(variables, gcc_version)
+        configs = Dir.glob(File.join(variables[:D], '/usr/bin/*-config'))
+        configs.each do |config|
+          basename = File.basename(config)
+          Xezat.logger.debug("    #{basename} found")
+
+          result, _, status = Open3.capture3("#{config} --cflags")
+          if status.success?
+            Xezat.logger.debug("      cflags = #{result.strip}")
+          else
+            Xezat.logger.warn('       cflags not supported')
+          end
+
+          result, _, status = Open3.capture3("#{config} --cxxflags")
+          if status.success?
+            Xezat.logger.debug("      cxxflags = #{result.strip}")
+          else
+            Xezat.logger.warn('       cxxflags not supported')
+          end
+
+          result, _, status = Open3.capture3("#{config} --libs")
+          if status.success?
+            Xezat.logger.debug("      libs = #{result.strip}")
+            validate_libs(variables, result.strip, gcc_version)
+          else
+            Xezat.logger.warn('       libs not supported')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate/license.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spdx'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_license(vars)
+        license = vars[:LICENSE]
+        if license.nil? || license.empty?
+          Xezat.logger.warn('     LICENSE is not defined')
+        elsif Spdx.valid?(license)
+          Xezat.logger.debug("    LICENSE = #{license}")
+        else
+          Xezat.logger.error("    LICENSE = #{license} (invalid)")
+        end
+
+        license_uri = vars[:LICENSE_URI]
+        if license_uri.nil? || license_uri.empty?
+          Xezat.logger.warn('     LICENSE_URI is not defined')
+        elsif File.exist?(File.join(vars[:S], license_uri))
+          Xezat.logger.debug("    LICENSE_URI = #{license_uri}")
+        else
+          Xezat.logger.error("    LICENSE_URI = #{license_uri} (not found)")
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate/pkgconfig.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'pkg-config'
+require 'xezat'
+
+module Xezat
+  module Command
+    class Validate
+      def validate_pkgconfig(variables, gcc_version)
+        pkgconfig_path = File.join(variables[:D], 'usr', 'lib', 'pkgconfig')
+        PKGConfig.add_path(pkgconfig_path)
+        Dir.glob('*.pc', 0, base: pkgconfig_path).each do |pc|
+          Xezat.logger.debug("    #{pc} found")
+          basename = File.basename(pc, '.pc')
+
+          modversion = PKGConfig.modversion(basename)
+          Xezat.logger.debug("      modversion = #{modversion}")
+          pv = variables[:PV][0].gsub(/\+.+$/, '')
+          Xezat.logger.error("        modversion differs from $PN = #{pv}") unless modversion == pv
+
+          prefix = PKGConfig.variable(basename, 'prefix')
+          if prefix.nil? || prefix.empty? || prefix.eql?('/usr')
+            Xezat.logger.debug("      prefix = #{prefix}")
+          else
+            Xezat.logger.warn("       prefix = #{prefix} (not standard)")
+          end
+
+          Xezat.logger.debug("      cflags = #{PKGConfig.cflags(basename)}")
+
+          libs = PKGConfig.libs(basename)
+          Xezat.logger.debug("      libs = #{libs}")
+          validate_libs(variables, libs, gcc_version)
+        end
+      end
+    end
+  end
+end

data/lib/xezat/command/validate.rb

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
-require 'pkg-config'
+require 'net/http'
+require 'uri'
+require 'xezat/command/validate/config'
+require 'xezat/command/validate/license'
+require 'xezat/command/validate/pkgconfig'
+require 'xezat/cygversion'
+require 'xezat/packages'
 require 'xezat/variables'
 
 module Xezat
@@ -16,22 +22,94 @@ module Xezat
       def execute
         Xezat.logger.debug('Start validating')
         vars = variables(@cygport)
-        validate_pkgconfig(vars)
+        pkgs = packages
+
+        gcc_version = Cygversion.new(pkgs[:'gcc-core'].gsub(/^gcc-core-/, '')).version.split('.')[0]
+
+        Xezat.logger.debug('  Validate .cygport')
+        validate_cygport(@cygport)
+
+        Xezat.logger.debug('  Validate category')
+        validate_category(vars[:CATEGORY])
+
+        Xezat.logger.debug('  Validate homepage')
+        validate_homepage(vars[:HOMEPAGE])
+
+        Xezat.logger.debug('  Validate licenses')
+        validate_license(vars)
+
+        Xezat.logger.debug('  Validate BUILD_REQUIRES')
+        validate_build_requires(vars[:BUILD_REQUIRES], pkgs)
+
+        Xezat.logger.debug('  Validate *.pc')
+        validate_pkgconfig(vars, gcc_version)
+
+        Xezat.logger.debug('  Validate *-config')
+        validate_config(vars, gcc_version)
+
         Xezat.logger.debug('End validating')
       end
 
-      def validate_pkgconfig(variables)
-        pkgconfig_path = File.join(variables[:D], 'usr', 'lib', 'pkgconfig')
-        PKGConfig.add_path(pkgconfig_path)
-        Dir.glob('*.pc', 0, base: pkgconfig_path).each do |pc|
-          basename = File.basename(pc, '.pc')
-          Xezat.logger.debug("  #{basename}.pc found")
-          modversion = PKGConfig.modversion(basename)
-          Xezat.logger.debug("    modversion = #{modversion}")
-          pv = variables[:PV][0]
-          Xezat.logger.error("      modversion differs from $PN = #{pv}") unless modversion == pv
-          Xezat.logger.debug("    cflags = #{PKGConfig.cflags(basename)}")
-          Xezat.logger.debug("    libs = #{PKGConfig.libs(basename)}")
+      def validate_cygport(cygport)
+        original_string = File.read(cygport)
+        stripped_string = original_string.gsub(/^\xEF\xBB\xBF/, '')
+        Xezat.logger.error('    .cygport contains BOM') unless original_string == stripped_string
+      end
+
+      def validate_category(category)
+        categories_file = File.expand_path(File.join(DATA_DIR, 'categories.yaml'))
+        Xezat.logger.error("    Category is invalid : #{category}") unless YAML.safe_load(File.open(categories_file), [Symbol]).include?(category.downcase)
+      end
+
+      def validate_homepage(homepage)
+        response = Net::HTTP.get_response(URI.parse(homepage))
+        code = response.code
+        if code == '200'
+          Xezat.logger.debug("    code = #{code}")
+        else
+          Xezat.logger.error("    code = #{code}")
+        end
+      rescue OpenSSL::SSL::SSLError => e
+        raise e unless @options[:ignore]
+
+        Xezat.logger.error('    Ignore SSLError')
+      end
+
+      def validate_build_requires(build_requires, pkgs)
+        return if build_requires.nil?
+
+        build_requires.split.each do |build_require|
+          build_require_pkg = pkgs[build_require.to_sym]
+          if build_require_pkg.nil?
+            Xezat.logger.error("    #{build_require} not found")
+          else
+            Xezat.logger.debug("    #{build_require_pkg}")
+          end
+        end
+      end
+
+      def validate_libs(variables, libs, gcc_version)
+        lib_dirs = [File.join(variables[:D], '/usr/lib'), '/usr/lib', '/usr/lib/w32api', "/usr/lib/gcc/x86_64-pc-cygwin/#{gcc_version}"]
+        libs.split do |option|
+          if option.start_with?('-l')
+            lib_name = option[2, 255] # Assume file length limit
+            found = false
+            lib_dirs.each do |dir|
+              archive_path = File.join(dir, "lib#{lib_name}.dll.a")
+              if File.exist?(archive_path)
+                Xezat.logger.debug("        #{lib_name} -> #{archive_path.gsub(variables[:D], '$D')}")
+                found = true
+                break
+              end
+              static_path = File.join(dir, "lib#{lib_name}.a")
+              next unless File.exist?(static_path)
+
+              Xezat.logger.debug("        #{lib_name} -> #{static_path}")
+              found = true
+              break
+            end
+            Xezat.logger.error("        #{lib_name} not found") unless found
+          end
         end
       end
     end

data/lib/xezat/cygchangelog.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'English'
 require 'xezat/cygversion'
 
 module Xezat
@@ -24,7 +25,7 @@ module Xezat
           next
         end
         matched_content = /^(.+)$/.match(line)
-        next unless matched_content
+        next if matched_content.nil?
         raise ReadmeSyntaxError, 'Version missing' if version.nil?
 
         if @changelogs.key?(version)
@@ -48,13 +49,15 @@ module Xezat
       @changelogs.key?(key)
     end
 
-    def each
+    def each(&block)
       logs = @changelogs.sort do |a, b|
         -(Cygversion.new(a[0].to_s) <=> Cygversion.new(b[0].to_s))
       end
-      logs.each do |k, v|
-        yield(k, v)
-      end
+      logs.each(&block)
+    end
+
+    def length
+      @changelogs.length
     end
   end
 end