tng 0.5.2 → 0.5.4

data/lib/tng/analyzers/service.rb

@@ -24,7 +24,7 @@ module Tng
         Tng::Analyzer::Service.parse_service_file(file_path)
       end
 
-      def self.methods_for_service(service_name)
+      def self.methods_for_service(service_name, file_path = nil)
         raise "service_name is required" if service_name.nil?
 
         begin
@@ -35,11 +35,12 @@ module Tng
                              service_class.private_instance_methods(false)
           class_methods = service_class.public_methods(false) - Class.public_methods
 
-          # Try to get source file from any method, fallback to const_source_location
-          service_file = nil
+          # Prefer explicit file path or class definition location
+          service_file = file_path
+          service_file ||= Object.const_source_location(service_class.name)&.first
 
-          # First try to get file from an instance method
-          if instance_methods.any?
+          # Fallback to any instance method source location
+          if service_file.nil? && instance_methods.any?
             begin
               service_file = service_class.instance_method(instance_methods.first).source_location&.first
             rescue StandardError
@@ -47,9 +48,6 @@ module Tng
             end
           end
 
-          # Fallback to const_source_location if no method source found
-          service_file ||= Object.const_source_location(service_class.name)&.first
-
           service_methods = if service_file && File.exist?(service_file)
                               source_code = File.read(service_file)
                               result = Prism.parse(source_code)
@@ -68,7 +66,11 @@ module Tng
                                 defined_methods.include?(method_name.to_s)
                               end
 
-                              filtered_instance_methods + filtered_class_methods
+                              if filtered_instance_methods.empty? && filtered_class_methods.empty? && defined_methods.any?
+                                defined_methods
+                              else
+                                filtered_instance_methods + filtered_class_methods
+                              end
                             else
                               []
                             end
@@ -107,7 +109,7 @@ module Tng
             path: file_path,
             relative_path: relative_path
           }
-        end
+        end.reject { |file| Tng::Utils.ignored_path?(file[:path]) }
       end
     end
   end

data/lib/tng/api/http_client.rb

@@ -6,10 +6,10 @@ module Tng
       @api_endpoint = api_endpoint
       @api_key = api_key
       @timeout = {
-        connect_timeout: 300,
-        read_timeout: 300,
-        write_timeout: 300,
-        request_timeout: 300
+        connect_timeout: 420,
+        read_timeout: 420,
+        write_timeout: 420,
+        request_timeout: 420
       }
     end
 

data/lib/tng/services/direct_generation.rb

@@ -35,13 +35,27 @@ module Tng
           return
         end
 
-        resolved_path = FileTypeDetector.resolve_file_path(file_path)
+        if Tng::Utils.ignored_path?(file_path)
+          @go_ui.display_error(@pastel.red("❌ Ignored by TNG config (ignore_files/ignore_folders). Remove it from config to proceed."))
+          return
+        end
+
+        resolved_result = FileTypeDetector.resolve_file_path(file_path)
+        if resolved_result.is_a?(Hash) && resolved_result[:ignored]
+          @go_ui.display_error(@pastel.red("❌ Ignored by TNG config (ignore_files/ignore_folders). Remove it from config to proceed."))
+          return
+        end
+        resolved_path = resolved_result.is_a?(Hash) ? resolved_result[:path] : resolved_result
 
         unless resolved_path && File.exist?(resolved_path)
           @go_ui.display_error(@pastel.red("❌ File not found: #{file_path}"))
           suggest_similar_files(file_path)
           return
         end
+        if Tng::Utils.ignored_path?(resolved_path)
+          @go_ui.display_error(@pastel.red("❌ Ignored by TNG config (ignore_files/ignore_folders). Remove it from config to proceed."))
+          return
+        end
 
         type = FileTypeDetector.detect_type(resolved_path)
 
@@ -72,6 +86,7 @@ module Tng
           next unless Dir.exist?(File.join(rails_root, dir))
 
           Dir.glob(File.join(rails_root, dir, "**", "*#{base_name}*.rb")).each do |file|
+            next if Tng::Utils.ignored_path?(file)
             similar_files << file.gsub(%r{^#{Regexp.escape(rails_root)}/}, "")
           end
         end
@@ -89,6 +104,9 @@ module Tng
         end
 
         method_info = methods.find { |m| m[:name].downcase == method_name.downcase }
+        if method_info && @params[:class_name]
+          method_info = method_info.merge(class_name: @params[:class_name])
+        end
 
         unless method_info
           @go_ui.display_error(@pastel.red("❌ Method '#{method_name}' not found in #{file_object[:name]}"))

data/lib/tng/services/extract_methods.rb

@@ -4,21 +4,21 @@ module Tng
   module Services
     module ExtractMethods
       def extract_controller_methods(controller)
-        Tng::Analyzers::Controller.methods_for_controller(controller[:name]) || []
+        Tng::Analyzers::Controller.methods_for_controller(controller[:name], controller[:path]) || []
       rescue StandardError => e
         puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing controller: #{e.message}", Tng::UI::Theme.color(:error)))
         []
       end
 
       def extract_model_methods(model)
-        Tng::Analyzers::Model.methods_for_model(model[:name]) || []
+        Tng::Analyzers::Model.methods_for_model(model[:name], model[:path]) || []
       rescue StandardError => e
         puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing model: #{e.message}", Tng::UI::Theme.color(:error)))
         []
       end
 
       def extract_service_methods(service)
-        Tng::Analyzers::Service.methods_for_service(service[:name]) || []
+        Tng::Analyzers::Service.methods_for_service(service[:name], service[:path]) || []
       rescue StandardError => e
         puts center_text(@pastel.decorate("#{Tng::UI::Theme.icon(:error)} Error analyzing service: #{e.message}", Tng::UI::Theme.color(:error)))
         []

data/lib/tng/services/file_type_detector.rb

@@ -70,33 +70,69 @@ module Tng
           lib app/lib
         ].freeze
 
-        def find_file_in_project(file_name)
+        def candidate_paths_for(file_name)
           file_with_ext = file_name.end_with?('.rb') ? file_name : "#{file_name}.rb"
+          candidates = []
 
-          return File.expand_path(file_with_ext) if File.exist?(file_with_ext)
+          if File.exist?(file_with_ext)
+            candidates << File.expand_path(file_with_ext)
+          end
 
           rails_root = defined?(Rails) && Rails.root ? Rails.root.to_s : Dir.pwd
 
           SEARCH_PATHS.each do |dir|
             full_path = File.join(rails_root, dir, file_with_ext)
-            return full_path if File.exist?(full_path)
+            candidates << full_path if File.exist?(full_path)
 
-            found_files = Dir.glob(File.join(rails_root, dir, '**', file_with_ext))
-            return found_files.first unless found_files.empty?
+            candidates.concat(Dir.glob(File.join(rails_root, dir, '**', file_with_ext)))
           end
 
-          nil
+          candidates.uniq
+        end
+
+        def find_file_in_project(file_name)
+          candidate_paths_for(file_name).find { |candidate| !Tng::Utils.ignored_path?(candidate) }
+        end
+
+        def find_ignored_in_project(file_name)
+          candidate_paths_for(file_name).find { |candidate| Tng::Utils.ignored_path?(candidate) }
         end
 
         def resolve_file_path(file_path)
-          resolved = if file_path.start_with?('/')
-                       File.exist?(file_path) ? file_path : File.exist?("#{file_path}.rb") ? "#{file_path}.rb" : nil
-                     else
-                       found = find_file_in_project(file_path)
-                       found ? File.expand_path(found) : nil
-                     end
-
-          resolved
+          if file_path.start_with?('/')
+            candidates = []
+            candidates << file_path if File.exist?(file_path)
+            candidates << "#{file_path}.rb" if File.exist?("#{file_path}.rb")
+
+            ignored_candidate = nil
+            candidates.each do |candidate|
+              expanded = File.expand_path(candidate)
+              if Tng::Utils.ignored_path?(expanded)
+                ignored_candidate ||= expanded
+                next
+              end
+
+              return { path: expanded, ignored: false }
+            end
+
+            return { path: ignored_candidate, ignored: true } if ignored_candidate
+            return nil
+          end
+
+          ignored_candidate = nil
+          candidate_paths_for(file_path).each do |candidate|
+            expanded = File.expand_path(candidate)
+            if Tng::Utils.ignored_path?(expanded)
+              ignored_candidate ||= expanded
+              next
+            end
+
+            return { path: expanded, ignored: false }
+          end
+
+          return { path: ignored_candidate, ignored: true } if ignored_candidate
+
+          nil
         end
 
         def extract_relative_path(file_path, type)

data/lib/tng/services/test_generator.rb

@@ -89,7 +89,7 @@ module Tng
           job_id = job_data["job_id"]
           return { error: :server_error, message: "No job_id returned" } unless job_id
 
-          # Poll for completion (similar to test generation)
+          # Poll for completion (audit only)
           result = poll_for_completion(job_id, progress: progress)
           return { error: :timeout, message: "Audit timed out" } unless result
 
@@ -234,33 +234,7 @@ module Tng
         max_attempts = MAX_POLL_DURATION_SECONDS / POLL_INTERVAL_SECONDS
 
         # Initialize agent steps if progress tracking is enabled
-        agent_step_indices = {}
-        if progress
-          # Current step index in progress updater (assuming it follows previous steps)
-          # We create 4 generic steps for the agents
-          # Note: indices are relative to the current session, so we just append them.
-          # But we need their indices to update them later.
-          # Since we can't ask progress for current index easily without hacking,
-          # we rely on the fact that we call update 4 times.
-
-          # Use a base offset if we could know it, but we can't reliably.
-          # Actually, if we use explicit_step, we need absolute indices.
-          # Let's assume the previous steps were 0, 1, 2, 3 based on bin/tng.
-          # So we start at 4.
-          base_idx = 4
-
-          progress.update("Context Builder: Pending...", nil, step_increment: true)
-          agent_step_indices["context_agent_status"] = base_idx
-
-          progress.update("Style Analyzer: Pending...", nil, step_increment: true)
-          agent_step_indices["style_agent_status"] = base_idx + 1
-
-          progress.update("Logic Analyzer: Pending...", nil, step_increment: true)
-          agent_step_indices["logical_issue_status"] = base_idx + 2
-
-          progress.update("Logic Generator: Pending...", nil, step_increment: true)
-          agent_step_indices["behavior_expert_status"] = base_idx + 3
-        end
+        agent_step_indices = init_agent_steps(progress)
 
         loop do
           attempts += 1
@@ -294,56 +268,7 @@ module Tng
             status = status_data[:status]
 
             # Update UI with granular info
-            if progress && status_data[:info].is_a?(Hash)
-              info = status_data[:info]
-
-              agent_step_indices.each do |key, step_idx|
-                item_data = info[key.to_sym]
-                next unless item_data
-
-                agent_status = "pending"
-                values = []
-
-                if item_data.is_a?(Hash)
-                  agent_status = item_data[:status] || "pending"
-                  values = item_data[:values] || []
-                else
-                  agent_status = item_data.to_s
-                end
-
-                label = case key
-                        when "context_agent_status" then "Context Builder"
-                        when "style_agent_status" then "Style Analyzer"
-                        when "logical_issue_status" then "Logic Analyzer"
-                        when "behavior_expert_status" then "Logic Generator"
-                        else key
-                        end
-
-                msg = if agent_status == "processing"
-                        "#{label}: Processing..."
-                      elsif agent_status == "completed"
-                        "#{label}: Completed"
-                      elsif agent_status == "failed"
-                        "#{label}: Failed"
-                      else
-                        "#{label}: #{agent_status.capitalize}..."
-                      end
-
-                if values.any?
-                  # Clean values
-                  clean_vals = values.map { |v| v.to_s.gsub("_", " ").gsub("'", "").gsub(":", "").strip }
-                  display_str = clean_vals.first(3).join(", ")
-                  display_str += ", ..." if clean_vals.size > 3
-                  msg += " (#{display_str})"
-                end
-
-                # Pass percentage only on the last step (Logic Generator) to keep main bar moving?
-                # Or pass it on all updates.
-                p = step_idx == agent_step_indices["behavior_expert_status"] ? pct : nil
-
-                progress.update(msg, p, step_increment: false, explicit_step: step_idx)
-              end
-            end
+            update_progress_from_info(progress, agent_step_indices, status_data[:info], pct) if progress
 
             case status
             when "completed"
@@ -381,6 +306,70 @@ module Tng
         exit(0)
       end
 
+      def init_agent_steps(progress)
+        return {} unless progress
+
+        base_idx = 4
+        progress.update("Context Builder: Pending...", nil, step_increment: true)
+        progress.update("Style Analyzer: Pending...", nil, step_increment: true)
+        progress.update("Logic Analyzer: Pending...", nil, step_increment: true)
+        progress.update("Logic Generator: Pending...", nil, step_increment: true)
+
+        {
+          "context_agent_status" => base_idx,
+          "style_agent_status" => base_idx + 1,
+          "logical_issue_status" => base_idx + 2,
+          "behavior_expert_status" => base_idx + 3
+        }
+      end
+
+      def update_progress_from_info(progress, agent_step_indices, info, percent)
+        return unless progress && info.is_a?(Hash)
+
+        agent_step_indices.each do |key, step_idx|
+          item_data = info[key.to_s] || info[key.to_sym]
+          next unless item_data
+
+          agent_status = "pending"
+          values = []
+
+          if item_data.is_a?(Hash)
+            agent_status = item_data[:status] || item_data["status"] || "pending"
+            values = item_data[:values] || item_data["values"] || []
+          else
+            agent_status = item_data.to_s
+          end
+
+          label = case key
+                  when "context_agent_status" then "Context Builder"
+                  when "style_agent_status" then "Style Analyzer"
+                  when "logical_issue_status" then "Logic Analyzer"
+                  when "behavior_expert_status" then "Logic Generator"
+                  else key
+                  end
+
+          msg = if agent_status == "processing"
+                  "#{label}: Processing..."
+                elsif agent_status == "completed"
+                  "#{label}: Completed"
+                elsif agent_status == "failed"
+                  "#{label}: Failed"
+                else
+                  "#{label}: #{agent_status.capitalize}..."
+                end
+
+          if values.any?
+            clean_vals = values.map { |v| v.to_s.gsub("_", " ").gsub("'", "").gsub(":", "").strip }
+            display_str = clean_vals.first(3).join(", ")
+            display_str += ", ..." if clean_vals.size > 3
+            msg += " (#{display_str})"
+          end
+
+          p = (percent && step_idx == agent_step_indices["behavior_expert_status"]) ? percent : nil
+          progress.update(msg, p, step_increment: false, explicit_step: step_idx)
+        end
+      end
+
       def trigger_cleanup(job_id)
         @http_client.patch("#{CONTENT_RESPONSES_PATH}/#{job_id}/cleanup")
       rescue StandardError => e

data/lib/tng/ui/go_ui_session.rb

@@ -256,7 +256,7 @@ module Tng
         puts "Trace results error: #{e.message}"
       end
 
-      # Show impact audit results
+      # Show regression check results
       # @param impact_file_path [String] Path to JSON impact file
       def show_impact_results(impact_file_path)
         system(@binary_path, "ruby-impact-results", "--file", impact_file_path)
@@ -415,7 +415,7 @@ module Tng
             { cmd: "bundle exec tng --file=FILE --method=METHOD", desc: "Direct test generation" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --audit", desc: "Direct audit mode" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --trace", desc: "Symbolic trace mode" },
-            { cmd: "bundle exec tng --file=FILE --method=METHOD --impact", desc: "Impact audit mode" },
+            { cmd: "bundle exec tng --file=FILE --method=METHOD --impact", desc: "Regression check mode" },
             { cmd: "bundle exec tng --file=FILE --clones", desc: "Check for code duplicates" },
             { cmd: "bundle exec tng --file=FILE --deadcode", desc: "Run dead code detection" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --xray", desc: "X-Ray visualization" }
@@ -426,7 +426,7 @@ module Tng
             "Per-method test generation",
             "Code audit for issues & behaviors",
             "Symbolic execution traces",
-            "Impact audit against Git HEAD",
+            "Regression check against Git HEAD",
             "Duplicate code detection (Clones)",
             "Dead code detection (Rust-powered)",
             "X-Ray Logic Flow Visualization",
@@ -438,7 +438,7 @@ module Tng
             { flag: "--method=NAME", desc: "Method name to generate test for" },
             { flag: "--audit", desc: "Run audit mode instead of test generation" },
             { flag: "--trace", desc: "Run symbolic trace mode" },
-            { flag: "--impact", desc: "Run impact audit mode" },
+            { flag: "--impact", desc: "Run regression check mode" },
             { flag: "--clones", desc: "Run clone detection mode" },
             { flag: "--level=1|2|3|all", desc: "Set clone detection level (default: all)" },
             { flag: "--deadcode", desc: "Run dead code detection" },

data/lib/tng/ui/post_install_box.rb

@@ -17,9 +17,9 @@ class PostInstallBox
 
   def content
     [
-      pastel.public_send(Tng::UI::Theme.color(:success)).bold("#{Tng::UI::Theme.icon(:success)} Tng installed successfully!"),
+      pastel.public_send(Tng::UI::Theme.color(:success)).bold("#{Tng::UI::Theme.icon(:success, ascii: true)} Tng installed successfully!"),
       "",
-      pastel.public_send(Tng::UI::Theme.color(:warning)).bold("#{Tng::UI::Theme.icon(:config)} SETUP REQUIRED"),
+      pastel.public_send(Tng::UI::Theme.color(:warning)).bold("#{Tng::UI::Theme.icon(:config, ascii: true)} SETUP REQUIRED"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary), "1. Generate configuration:"),
       pastel.public_send(Tng::UI::Theme.color(:secondary), "   rails g tng:install"),
@@ -31,30 +31,30 @@ class PostInstallBox
       pastel.public_send(Tng::UI::Theme.color(:secondary), "   config.api_key = 'your-license-key-here'"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary),
-                         "#{Tng::UI::Theme.icon(:config)} Check documentation for the correct authentication setup"),
+                         "#{Tng::UI::Theme.icon(:config, ascii: true)} Check documentation for the correct authentication setup"),
       "",
-      pastel.public_send(Tng::UI::Theme.color(:accent)).bold("#{Tng::UI::Theme.icon(:rocket)} Usage:"),
+      pastel.public_send(Tng::UI::Theme.color(:accent)).bold("#{Tng::UI::Theme.icon(:rocket, ascii: true)} Usage:"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary), "Interactive mode:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                 "  - Interactive CLI with method selection"),
+                         "#{Tng::UI::Theme.icon(:bullet, ascii: true)} bundle exec tng") + pastel.public_send(Tng::UI::Theme.color(:muted),
+                                                                                                              "  - Interactive CLI with method selection"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary), "Features:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} Test 20+ file types: Controllers, Models, Services + Jobs, Helpers, Lib, Policies, Presenters, Mailers, GraphQL, and more"),
+                         "#{Tng::UI::Theme.icon(:bullet, ascii: true)} Test 20+ file types: Controllers, Models, Services + Jobs, Helpers, Lib, Policies, Presenters, Mailers, GraphQL, and more"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} Select specific methods to test"),
+                         "#{Tng::UI::Theme.icon(:bullet, ascii: true)} Select specific methods to test"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} Search and filter through methods"),
+                         "#{Tng::UI::Theme.icon(:bullet, ascii: true)} Search and filter through methods"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:primary), "Help:"),
       pastel.public_send(Tng::UI::Theme.color(:success),
-                         "#{Tng::UI::Theme.icon(:bullet)} bundle exec tng --help") + pastel.public_send(Tng::UI::Theme.color(:muted),
-                                                                                                        "  - Show help information"),
+                         "#{Tng::UI::Theme.icon(:bullet, ascii: true)} bundle exec tng --help") + pastel.public_send(Tng::UI::Theme.color(:muted),
+                                                                                                                     "  - Show help information"),
       "",
       pastel.public_send(Tng::UI::Theme.color(:muted),
-                         "#{Tng::UI::Theme.icon(:lightbulb)} Generate tests for individual methods with precision")
+                         "#{Tng::UI::Theme.icon(:lightbulb, ascii: true)} Generate tests for individual methods with precision")
     ].join("\n")
   end
 

data/lib/tng/ui/theme.rb

@@ -26,6 +26,23 @@ module Tng
         bullet: "•"
       }.freeze
 
+      ICONS_ASCII = {
+        success: "[OK]",
+        error: "[ERR]",
+        warning: "[!]",
+        info: "[i]",
+        rocket: ">>",
+        run: ">",
+        wave: "hi",
+        stats: "[stats]",
+        config: "[cfg]",
+        heart: "<3",
+        lightbulb: "[tip]",
+        back: "<- ",
+        marker: ">",
+        bullet: "-"
+      }.freeze
+
       # Colors - terminal-agnostic color scheme
       COLORS = {
         # Primary status colors
@@ -119,6 +136,11 @@ module Tng
         @background_cache
       end
 
+      def icon(key, ascii: false)
+        icons = ascii ? ICONS_ASCII : ICONS
+        icons[key] || ""
+      end
+
       def get_background_color
         return :dark unless $stdout.tty? && $stdin.tty? && interactive_session?
 

data/lib/tng/utils.rb

@@ -76,6 +76,69 @@ module Tng
       false
     end
 
+    def self.project_root
+      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        Rails.root.to_s
+      else
+        Dir.pwd
+      end
+    end
+
+    def self.normalize_path(entry, root)
+      return nil unless entry.is_a?(String)
+
+      trimmed = entry.strip
+      return nil if trimmed.empty?
+
+      normalized = trimmed.tr("\\", "/")
+      if normalized.start_with?("/")
+        File.expand_path(normalized)
+      else
+        File.expand_path(normalized, root)
+      end
+    end
+
+    def self.ignored_path?(path, root: nil)
+      return false unless path
+
+      root ||= project_root
+      target = normalize_path(path.to_s, root)
+      return false unless target
+
+      ignore_files = Array(Tng.config[:ignore_files])
+      ignore_folders = Array(Tng.config[:ignore_folders])
+
+      ignore_files.each do |entry|
+        resolved = normalize_path(entry.to_s, root)
+        next unless resolved
+        return true if resolved == target
+      end
+
+      ignore_folders.each do |entry|
+        resolved = normalize_path(entry.to_s, root)
+        next unless resolved
+        resolved = resolved.end_with?("/") ? resolved.chomp("/") : resolved
+        return true if target == resolved || target.start_with?(resolved + "/")
+      end
+
+      false
+    end
+
+    def self.filter_ignored_files(files, root: nil, path_key: :path)
+      return [] if files.nil?
+      root ||= project_root
+
+      files.reject do |file|
+        candidate =
+          if file.is_a?(Hash)
+            file[path_key] || file[path_key.to_s]
+          else
+            file
+          end
+        ignored_path?(candidate, root: root)
+      end
+    end
+
     def self.save_test_file(test_content)
       puts "📋 Raw API response: #{test_content[0..200]}..." if ENV["DEBUG"]
       parsed_response = JSON.parse(test_content)

data/lib/tng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tng
-  VERSION = "0.5.2"
+  VERSION = "0.5.4"
 end

data/lib/tng.rb

@@ -98,7 +98,9 @@ module Tng
     base_url: "https://app.tng.sh/",
     test_helper_path: nil,
     authentication_enabled: false,
-    authentication_methods: []
+    authentication_methods: [],
+    ignore_files: [],
+    ignore_folders: []
   }
 
   def self.configure
@@ -148,4 +150,20 @@ module Tng
   def self.authentication_enabled
     @config[:authentication_enabled]
   end
+
+  def self.ignore_files=(value)
+    @config[:ignore_files] = value
+  end
+
+  def self.ignore_files
+    @config[:ignore_files]
+  end
+
+  def self.ignore_folders=(value)
+    @config[:ignore_folders] = value
+  end
+
+  def self.ignore_folders
+    @config[:ignore_folders]
+  end
 end