tree_haver 5.0.4 → 7.0.0

data/lib/tree_haver/parser.rb

@@ -1,438 +0,0 @@
-# frozen_string_literal: true
-
-module TreeHaver
-  # Unified Parser facade providing a consistent API across all backends
-  #
-  # This class acts as a facade/adapter that delegates to backend-specific
-  # parser implementations. It automatically selects the appropriate backend
-  # and provides a unified interface regardless of which parser is being used.
-  #
-  # == Backend Selection
-  #
-  # The parser automatically selects a backend based on:
-  # 1. Explicit `backend:` parameter in constructor
-  # 2. `TreeHaver.backend` global setting
-  # 3. `TREE_HAVER_BACKEND` environment variable
-  # 4. Auto-detection (tries available backends in order)
-  #
-  # == Supported Backends
-  #
-  # **Tree-sitter backends** (native, high-performance):
-  # - `:mri` - ruby_tree_sitter gem (C extension, MRI only)
-  # - `:rust` - tree_stump gem (Rust via magnus, MRI only)
-  # - `:ffi` - FFI bindings to libtree-sitter (MRI, JRuby)
-  # - `:java` - java-tree-sitter (JRuby only)
-  #
-  # **Pure Ruby backends** (portable, no native dependencies):
-  # - `:citrus` - Citrus PEG parser (e.g., toml-rb)
-  # - `:parslet` - Parslet PEG parser (e.g., toml gem)
-  # - `:prism` - Ruby's official parser (Ruby only)
-  # - `:psych` - YAML parser (stdlib)
-  #
-  # == Wrapping/Unwrapping Responsibility
-  #
-  # TreeHaver::Parser handles ALL object wrapping and unwrapping:
-  #
-  # **Language objects:**
-  # - Unwraps Language wrappers before passing to backend.language=
-  # - MRI backend receives ::TreeSitter::Language
-  # - Rust backend receives String (language name)
-  # - FFI backend receives wrapped Language (needs to_ptr)
-  # - Citrus backend receives grammar module
-  # - Parslet backend receives grammar class
-  #
-  # **Tree objects:**
-  # - parse() receives raw source, backend returns raw tree, Parser wraps it
-  # - parse_string() unwraps old_tree before passing to backend, wraps returned tree
-  # - Backends always work with raw backend trees, never TreeHaver::Tree
-  #
-  # **Node objects:**
-  # - Backends return raw nodes, TreeHaver::Tree and TreeHaver::Node wrap them
-  #
-  # This design ensures:
-  # - Principle of Least Surprise: wrapping happens at boundaries, consistently
-  # - Backends are simple: they don't need to know about TreeHaver wrappers
-  # - Single Responsibility: wrapping logic is only in TreeHaver::Parser
-  #
-  # @example Basic parsing
-  #   parser = TreeHaver::Parser.new
-  #   parser.language = TreeHaver::Language.toml
-  #   tree = parser.parse("[package]\nname = \"foo\"")
-  #
-  # @example Explicit backend selection
-  #   parser = TreeHaver::Parser.new(backend: :citrus)
-  #   parser.language = TreeHaver::Language.toml
-  #   tree = parser.parse(toml_source)
-  #
-  # @see Base::Parser The base class defining the parser interface
-  # @see Backends::Citrus::Parser Citrus backend implementation
-  # @see Backends::Parslet::Parser Parslet backend implementation
-  # @see Backends::Prism::Parser Prism backend implementation
-  class Parser < Base::Parser
-    # Create a new parser instance
-    #
-    # The parser automatically selects the best available backend unless
-    # explicitly specified. Use the `backend:` parameter to force a specific backend.
-    #
-    # @param backend [Symbol, String, nil] optional backend to use (overrides context/global)
-    #   Valid values: :auto, :mri, :rust, :ffi, :java, :citrus, :parslet, :prism, :psych
-    # @raise [NotAvailable] if no backend is available or requested backend is unavailable
-    # @example Default (auto-selects best available backend)
-    #   parser = TreeHaver::Parser.new
-    # @example Explicit backend
-    #   parser = TreeHaver::Parser.new(backend: :citrus)
-    def initialize(backend: nil)
-      super()  # Initialize @language from Base::Parser
-
-      # Convert string backend names to symbols for consistency
-      backend = backend.to_sym if backend.is_a?(String)
-
-      mod = TreeHaver.resolve_backend_module(backend)
-
-      if mod.nil?
-        if backend
-          raise NotAvailable, "Requested backend #{backend.inspect} is not available"
-        else
-          raise NotAvailable, "No TreeHaver backend is available"
-        end
-      end
-
-      # Try to create the parser, with fallback to pure Ruby if tree-sitter fails
-      # This enables auto-fallback when tree-sitter runtime isn't available
-      begin
-        @impl = mod::Parser.new
-        @explicit_backend = backend  # Remember for introspection (always a Symbol or nil)
-      rescue NoMethodError, LoadError => e
-        # Note: FFI::NotFoundError inherits from LoadError, so it's caught here too
-        handle_parser_creation_failure(e, backend)
-      end
-    end
-
-    # Handle parser creation failure with optional Citrus/Parslet fallback
-    #
-    # @param error [Exception] the error that caused parser creation to fail
-    # @param backend [Symbol, nil] the requested backend
-    # @raise [NotAvailable] if no fallback is available
-    # @api private
-    def handle_parser_creation_failure(error, backend)
-      # Tree-sitter backend failed (likely missing runtime library)
-      # Try Citrus or Parslet as fallback if we weren't explicitly asked for a specific backend
-      if backend.nil? || backend == :auto
-        if Backends::Citrus.available?
-          @impl = Backends::Citrus::Parser.new
-          @explicit_backend = :citrus
-        elsif Backends::Parslet.available?
-          @impl = Backends::Parslet::Parser.new
-          @explicit_backend = :parslet
-        else
-          # No fallback available, re-raise original error
-          raise NotAvailable, "Tree-sitter backend failed: #{error.message}. " \
-            "Citrus/Parslet fallback not available. Install tree-sitter runtime, citrus gem, or parslet gem."
-        end
-      else
-        # Explicit backend was requested, don't fallback
-        raise error
-      end
-    end
-
-    # Get the backend this parser is using (for introspection)
-    #
-    # Returns the actual backend in use, resolving :auto to the concrete backend.
-    #
-    # @return [Symbol] the backend name (:mri, :rust, :ffi, :java, :citrus, or :parslet)
-    def backend
-      if @explicit_backend && @explicit_backend != :auto
-        @explicit_backend
-      else
-        # Determine actual backend from the implementation class
-        case @impl.class.name
-        when /MRI/
-          :mri
-        when /Rust/
-          :rust
-        when /FFI/
-          :ffi
-        when /Java/
-          :java
-        when /Citrus/
-          :citrus
-        when /Parslet/
-          :parslet
-        else
-          # Fallback to effective_backend if we can't determine from class name
-          TreeHaver.effective_backend
-        end
-      end
-    end
-
-    # Set the language grammar for this parser
-    #
-    # The language must be compatible with the parser's backend. If a mismatch
-    # is detected (e.g., Citrus language on tree-sitter parser), the parser
-    # will automatically switch to the correct backend.
-    #
-    # @param lang [Language] the language to use for parsing
-    # @return [Language] the language that was set
-    # @example
-    #   parser.language = TreeHaver::Language.from_library("/path/to/grammar.so")
-    def language=(lang)
-      # Auto-switch backend if language type doesn't match current parser
-      # This handles the case where Language.toml returns a Citrus/Parslet language
-      # but the parser was initialized with a tree-sitter backend
-      switch_backend_for_language(lang)
-
-      # Unwrap the language before passing to backend
-      # Backends receive raw language objects, never TreeHaver wrappers
-      inner_lang = unwrap_language(lang)
-      @impl.language = inner_lang
-
-      # Store on base class for API compatibility
-      @language = lang
-    end
-
-    # Parse source code into a syntax tree
-    #
-    # @param source [String] the source code to parse (should be UTF-8)
-    # @return [Tree] the parsed syntax tree
-    # @example
-    #   tree = parser.parse("x = 1")
-    #   puts tree.root_node.type
-    def parse(source)
-      tree_impl = @impl.parse(source)
-      # Wrap backend tree with source so Node#text works
-      Tree.new(tree_impl, source: source)
-    end
-
-    # Parse source code into a syntax tree (with optional incremental parsing)
-    #
-    # This method provides API compatibility with ruby_tree_sitter which uses
-    # `parse_string(old_tree, source)`.
-    #
-    # == Incremental Parsing
-    #
-    # tree-sitter supports **incremental parsing** where you can pass a previously
-    # parsed tree along with edit information to efficiently re-parse only the
-    # changed portions of source code. This is a major performance optimization
-    # for editors and IDEs that need to re-parse on every keystroke.
-    #
-    # The workflow for incremental parsing is:
-    # 1. Parse the initial source: `tree = parser.parse_string(nil, source)`
-    # 2. User edits the source (e.g., inserts a character)
-    # 3. Call `tree.edit(...)` to update the tree's position data
-    # 4. Re-parse with the old tree: `new_tree = parser.parse_string(tree, new_source)`
-    # 5. tree-sitter reuses unchanged nodes, only re-parsing affected regions
-    #
-    # TreeHaver passes through to the underlying backend if it supports incremental
-    # parsing (MRI and Rust backends do). Check `TreeHaver.capabilities[:incremental]`
-    # to see if the current backend supports it.
-    #
-    # @param old_tree [Tree, nil] previously parsed tree for incremental parsing, or nil for fresh parse
-    # @param source [String] the source code to parse (should be UTF-8)
-    # @return [Tree] the parsed syntax tree
-    # @see https://tree-sitter.github.io/tree-sitter/using-parsers#editing tree-sitter incremental parsing docs
-    # @see Tree#edit For marking edits before incremental re-parsing
-    # @example First parse (no old tree)
-    #   tree = parser.parse_string(nil, "x = 1")
-    # @example Incremental parse
-    #   tree.edit(start_byte: 4, old_end_byte: 5, new_end_byte: 6, ...)
-    #   new_tree = parser.parse_string(tree, "x = 42")
-    def parse_string(old_tree, source)
-      # Pass through to backend if it supports incremental parsing
-      if old_tree && @impl.respond_to?(:parse_string)
-        # Extract the underlying implementation from our Tree wrapper
-        old_impl = if old_tree.respond_to?(:inner_tree)
-          old_tree.inner_tree
-        elsif old_tree.respond_to?(:instance_variable_get)
-          # Fallback for compatibility
-          old_tree.instance_variable_get(:@inner_tree) || old_tree.instance_variable_get(:@impl) || old_tree
-        else
-          old_tree
-        end
-        tree_impl = @impl.parse_string(old_impl, source)
-        # Wrap backend tree with source so Node#text works
-        Tree.new(tree_impl, source: source)
-      elsif @impl.respond_to?(:parse_string)
-        tree_impl = @impl.parse_string(nil, source)
-        # Wrap backend tree with source so Node#text works
-        Tree.new(tree_impl, source: source)
-      else
-        # Fallback for backends that don't support parse_string
-        parse(source)
-      end
-    end
-
-    private
-
-    # Switch backend if language type doesn't match current parser
-    #
-    # This is necessary because TreeHaver.parser_for may return a Language
-    # from a different backend than the Parser was initialized with.
-    # For example, Language.toml might return a Citrus::Language when
-    # tree-sitter-toml is not available, but Parser was initialized with :auto.
-    #
-    # @param lang [Object] The language object
-    # @api private
-    def switch_backend_for_language(lang)
-      return unless lang.respond_to?(:backend)
-
-      lang_backend = lang.backend
-      parser_backend = backend
-
-      # No switch needed if backends match
-      return if lang_backend == parser_backend
-
-      # Switch to matching backend parser
-      case lang_backend
-      when :citrus
-        unless @impl.is_a?(Backends::Citrus::Parser)
-          @impl = Backends::Citrus::Parser.new
-          @explicit_backend = :citrus
-        end
-      when :parslet
-        unless @impl.is_a?(Backends::Parslet::Parser)
-          @impl = Backends::Parslet::Parser.new
-          @explicit_backend = :parslet
-        end
-      when :prism
-        unless @impl.is_a?(Backends::Prism::Parser)
-          @impl = Backends::Prism::Parser.new
-          @explicit_backend = :prism
-        end
-      when :psych
-        unless @impl.is_a?(Backends::Psych::Parser)
-          @impl = Backends::Psych::Parser.new
-          @explicit_backend = :psych
-        end
-        # Tree-sitter backends (:mri, :rust, :ffi, :java) - don't auto-switch between them
-        # as that would require reloading the language from the .so file
-      end
-    end
-
-    # Unwrap a language object to extract the raw backend language
-    #
-    # This method is smart about backend compatibility:
-    # 1. If language has a backend attribute, checks if it matches current backend
-    # 2. If mismatch detected, attempts to reload language for correct backend
-    # 3. If reload successful, uses new language; otherwise continues with original
-    # 4. Unwraps the language wrapper to get raw backend object
-    #
-    # @param lang [Object] wrapped or raw language object
-    # @return [Object] raw backend language object appropriate for current backend
-    # @api private
-    def unwrap_language(lang)
-      # Check if this is a TreeHaver language wrapper with backend info
-      if lang.respond_to?(:backend)
-        # Verify backend compatibility FIRST
-        # This prevents passing languages from wrong backends to native code
-        # Exception: :auto backend is permissive - accepts any language
-        current_backend = backend
-
-        if lang.backend != current_backend && current_backend != :auto
-          # Backend mismatch! Try to reload for correct backend
-          reloaded = try_reload_language_for_backend(lang, current_backend)
-          if reloaded
-            lang = reloaded
-          else
-            # Couldn't reload - this is an error
-            raise TreeHaver::Error,
-              "Language backend mismatch: language is for #{lang.backend}, parser is #{current_backend}. " \
-                "Cannot reload language for correct backend. " \
-                "Create a new language with TreeHaver::Language.from_library when backend is #{current_backend}."
-          end
-        end
-
-        # Get the current parser's language (if set)
-        current_lang = @impl.respond_to?(:language) ? @impl.language : nil
-
-        # Language mismatch detected! The parser might have a different language set
-        # Compare the actual language objects using Comparable
-        if current_lang && lang != current_lang
-          # Different language being set (e.g., switching from TOML to JSON)
-          # This is fine, just informational
-        end
-      end
-
-      # Unwrap based on backend type
-      # All TreeHaver Language wrappers have the backend attribute
-      unless lang.respond_to?(:backend)
-        # This shouldn't happen - all our wrappers have backend attribute
-        # If we get here, it's likely a raw backend object that was passed directly
-        raise TreeHaver::Error,
-          "Expected TreeHaver Language wrapper with backend attribute, got #{lang.class}. " \
-            "Use TreeHaver::Language.from_library to create language objects."
-      end
-
-      case lang.backend
-      when :mri
-        return lang.to_language if lang.respond_to?(:to_language)
-        return lang.inner_language if lang.respond_to?(:inner_language)
-        lang
-      when :rust
-        return lang.name if lang.respond_to?(:name)
-        lang
-      when :ffi
-        lang  # FFI needs wrapper for to_ptr
-      when :java
-        lang.impl if lang.respond_to?(:impl)
-      when :citrus
-        lang  # Citrus backend accepts Language wrapper (handles both)
-      when :parslet
-        lang  # Parslet backend accepts Language wrapper (handles both)
-      when :prism
-        lang  # Prism backend expects the Language wrapper
-      when :psych
-        lang  # Psych backend expects the Language wrapper
-      when :commonmarker
-        lang  # Commonmarker backend expects the Language wrapper
-      when :markly
-        lang  # Markly backend expects the Language wrapper
-      else
-        # Unknown backend (e.g., test backend)
-        # Try generic unwrapping methods for flexibility in testing
-        return lang.to_language if lang.respond_to?(:to_language)
-        return lang.inner_language if lang.respond_to?(:inner_language)
-        return lang.impl if lang.respond_to?(:impl)
-        return lang.grammar_module if lang.respond_to?(:grammar_module)
-        return lang.grammar_class if lang.respond_to?(:grammar_class)
-        return lang.name if lang.respond_to?(:name)
-
-        # If nothing works, pass through as-is
-        # This allows test languages to be passed directly
-        lang
-      end
-    end
-
-    # Try to reload a language for the current backend
-    #
-    # This handles the case where a language was loaded for one backend,
-    # but is now being used with a different backend (e.g., after backend switch).
-    #
-    # @param lang [Object] language object with metadata
-    # @param target_backend [Symbol] backend to reload for
-    # @return [Object, nil] reloaded language or nil if reload not possible
-    # @api private
-    def try_reload_language_for_backend(lang, target_backend)
-      # Can't reload without path information
-      return unless lang.respond_to?(:path) || lang.respond_to?(:grammar_module)
-
-      # For tree-sitter backends, reload from path
-      if lang.respond_to?(:path) && lang.path
-        begin
-          # Use Language.from_library which respects current backend
-          return Language.from_library(
-            lang.path,
-            symbol: lang.respond_to?(:symbol) ? lang.symbol : nil,
-            name: lang.respond_to?(:name) ? lang.name : nil,
-          )
-        rescue => e
-          # Reload failed, continue with original
-          warn("TreeHaver: Failed to reload language for backend #{target_backend}: #{e.message}") if $VERBOSE
-          return
-        end
-      end
-
-      # For Citrus, can't really reload as it's just a module reference
-      nil
-    end
-  end
-end

data/lib/tree_haver/parslet_grammar_finder.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module TreeHaver
-  # Utility for finding and registering Parslet grammar gems.
-  #
-  # ParsletGrammarFinder provides language-agnostic discovery of Parslet grammar
-  # gems. Given a language name and gem information, it attempts to load the
-  # grammar and register it with tree_haver.
-  #
-  # Unlike tree-sitter grammars (which are .so files), Parslet grammars are
-  # Ruby classes that inherit from Parslet::Parser. This class handles the
-  # discovery and registration of these grammars.
-  #
-  # @example Basic usage with toml gem
-  #   finder = TreeHaver::ParsletGrammarFinder.new(
-  #     language: :toml,
-  #     gem_name: "toml",
-  #     grammar_const: "TOML::Parslet"
-  #   )
-  #   finder.register! if finder.available?
-  #
-  # @example With custom require path
-  #   finder = TreeHaver::ParsletGrammarFinder.new(
-  #     language: :json,
-  #     gem_name: "json-parslet",
-  #     grammar_const: "JsonParslet::Grammar",
-  #     require_path: "json/parslet"
-  #   )
-  #
-  # @see GrammarFinder For tree-sitter grammar discovery
-  # @see CitrusGrammarFinder For Citrus grammar discovery
-  class ParsletGrammarFinder
-    # @return [Symbol] the language identifier
-    attr_reader :language_name
-
-    # @return [String] the gem name to require
-    attr_reader :gem_name
-
-    # @return [String] the constant path to the grammar class (e.g., "TOML::Parslet")
-    attr_reader :grammar_const
-
-    # @return [String, nil] custom require path (defaults to gem_name)
-    attr_reader :require_path
-
-    # Initialize a Parslet grammar finder
-    #
-    # @param language [Symbol, String] the language name (e.g., :toml, :json)
-    # @param gem_name [String] the gem name (e.g., "toml")
-    # @param grammar_const [String] constant path to grammar class (e.g., "TOML::Parslet")
-    # @param require_path [String, nil] custom require path (defaults to gem_name as-is)
-    def initialize(language:, gem_name:, grammar_const:, require_path: nil)
-      @language_name = language.to_sym
-      @gem_name = gem_name
-      @grammar_const = grammar_const
-      @require_path = require_path || gem_name
-      @load_attempted = false
-      @available = false
-      @grammar_class = nil
-    end
-
-    # Check if the Parslet grammar is available
-    #
-    # Attempts to require the gem and resolve the grammar constant.
-    # Result is cached after first call.
-    #
-    # @return [Boolean] true if grammar is available
-    def available?
-      return @available if @load_attempted
-
-      @load_attempted = true
-      debug = ENV["TREE_HAVER_DEBUG"]
-
-      # Guard against nil require_path (can happen if gem_name was nil)
-      if @require_path.nil? || @require_path.empty?
-        warn("ParsletGrammarFinder: require_path is nil or empty for #{@language_name}") if debug
-        @available = false
-        return false
-      end
-
-      begin
-        # Try to require the gem
-        require @require_path
-
-        # Try to resolve the constant
-        @grammar_class = resolve_constant(@grammar_const)
-
-        # Verify it can create a parser instance with a parse method
-        unless valid_grammar_class?(@grammar_class)
-          if debug
-            warn("ParsletGrammarFinder: #{@grammar_const} is not a valid Parslet grammar class")
-            warn("ParsletGrammarFinder: #{@grammar_const}.class = #{@grammar_class.class}")
-          end
-          @available = false
-          return false
-        end
-
-        @available = true
-      rescue LoadError => e
-        # :nocov: defensive - requires gem to not be installed
-        if debug
-          warn("ParsletGrammarFinder: Failed to load '#{@require_path}': #{e.class}: #{e.message}")
-          warn("ParsletGrammarFinder: LoadError backtrace:\n  #{e.backtrace&.first(10)&.join("\n  ")}")
-        end
-        @available = false
-        # :nocov:
-      rescue NameError => e
-        # :nocov: defensive - requires gem with missing constant
-        if debug
-          warn("ParsletGrammarFinder: Failed to resolve '#{@grammar_const}': #{e.class}: #{e.message}")
-          warn("ParsletGrammarFinder: NameError backtrace:\n  #{e.backtrace&.first(10)&.join("\n  ")}")
-        end
-        @available = false
-        # :nocov:
-      rescue TypeError => e
-        # :nocov: defensive - TruffleRuby-specific edge case
-        warn("ParsletGrammarFinder: TypeError during load of '#{@require_path}': #{e.class}: #{e.message}")
-        warn("ParsletGrammarFinder: This may be a TruffleRuby bundled_gems.rb issue")
-        if debug
-          warn("ParsletGrammarFinder: TypeError backtrace:\n  #{e.backtrace&.first(10)&.join("\n  ")}")
-        end
-        @available = false
-        # :nocov:
-      rescue => e
-        # :nocov: defensive - catch-all for unexpected errors
-        warn("ParsletGrammarFinder: Unexpected error: #{e.class}: #{e.message}")
-        if debug
-          warn("ParsletGrammarFinder: backtrace:\n  #{e.backtrace&.first(10)&.join("\n  ")}")
-        end
-        @available = false
-        # :nocov:
-      end
-
-      @available
-    end
-
-    # Get the resolved grammar class
-    #
-    # @return [Class, nil] the grammar class if available
-    def grammar_class
-      available? # Ensure we've tried to load
-      @grammar_class
-    end
-
-    # Register this Parslet grammar with TreeHaver
-    #
-    # After registration, the language can be used via:
-    #   TreeHaver::Language.{language_name}
-    #
-    # @param raise_on_missing [Boolean] if true, raises when grammar not available
-    # @return [Boolean] true if registration succeeded
-    # @raise [NotAvailable] if grammar not available and raise_on_missing is true
-    def register!(raise_on_missing: false)
-      unless available?
-        if raise_on_missing
-          raise NotAvailable, not_found_message
-        end
-        return false
-      end
-
-      TreeHaver.register_language(
-        @language_name,
-        grammar_class: @grammar_class,
-        gem_name: @gem_name,
-      )
-      true
-    end
-
-    # Get debug information about the search
-    #
-    # @return [Hash] diagnostic information
-    def search_info
-      {
-        language: @language_name,
-        gem_name: @gem_name,
-        grammar_const: @grammar_const,
-        require_path: @require_path,
-        available: available?,
-        grammar_class: @grammar_class&.name,
-      }
-    end
-
-    # Get a human-readable error message when grammar is not found
-    #
-    # @return [String] error message with installation hints
-    def not_found_message
-      "Parslet grammar for #{@language_name} not found. " \
-        "Install #{@gem_name} gem: gem install #{@gem_name}"
-    end
-
-    private
-
-    # Resolve a constant path like "TOML::Parslet"
-    #
-    # @param const_path [String] constant path
-    # @return [Object] the constant
-    # @raise [NameError] if constant not found
-    def resolve_constant(const_path)
-      const_path.split("::").reduce(Object) do |mod, const_name|
-        mod.const_get(const_name)
-      end
-    end
-
-    # Check if the class is a valid Parslet grammar
-    #
-    # @param klass [Class] the class to check
-    # @return [Boolean] true if valid
-    def valid_grammar_class?(klass)
-      return false unless klass.respond_to?(:new)
-
-      # Check if it's a Parslet::Parser subclass
-      if defined?(::Parslet::Parser)
-        return true if klass < ::Parslet::Parser
-      end
-
-      # Fallback: check if it can create an instance that responds to parse
-      begin
-        instance = klass.new
-        instance.respond_to?(:parse)
-      rescue StandardError
-        false
-      end
-    end
-  end
-end