openai_101 1.0.0 → 1.2.1

data/gpt-context/theme-prompts.csv

@@ -1,21 +0,0 @@
-Theme,Prompt
-"Futuristic Cityscapes", "A bustling futuristic cityscape where AI and humans coexist seamlessly, with drones flying overhead and digital billboards displaying AI-generated art"
-"Digital Renaissance", "A digital recreation of a Renaissance scene, where figures interact with AI devices, blending classical beauty with modern technology"
-"AI in Nature", "A serene forest where trees and wildlife are monitored and cared for by gentle AI robots, highlighting a balance between technology and natural preservation"
-"Cybernetic Organisms", "A close-up of a flower with digital circuit patterns on its petals, symbolizing the fusion of organic life with AI enhancements"
-"Virtual Reality Worlds", "An individual wearing a VR headset, transported to a breathtaking AI-created fantasy world, showcasing the limitless possibilities of virtual reality"
-"AI as a Companion", "A friendly AI robot walking alongside a human in a park, offering guidance and companionship, symbolizing the supportive role of AI"
-"Abstract Data Visualizations", "An abstract representation of a neural network, with flowing streams of data and colorful nodes, visualizing the complexity and beauty of AI algorithms"
-"Steampunk AI", "A steampunk-inspired workshop with AI robots made of brass and gears, working alongside humans to invent new technologies"
-"Space Exploration", "A robotic AI explorer navigating the rugged terrain of an alien planet, with a distant galaxy shining brightly in the sky above"
-"Underwater Discoveries", "AI-powered submarines exploring coral reefs and ancient underwater ruins, illuminating the depths with advanced technology"
-"Mythical Integration", "A majestic phoenix with digital wings soaring above a futuristic city, blending mythology with advanced AI technology"
-"Digital Nomads", "A group of tech-savvy digital nomads in a remote, exotic location, using AI to work and communicate from anywhere in the world"
-"Retro-Futurism", "A scene set in a neon-lit arcade from the 1980s, where gamers are playing AI-developed video games that predict future events"
-"AI Guardians", "A powerful AI guardian overseeing the digital safety of a smart city, visualized as a holographic entity projecting from a city's central tower"
-"Dystopian vs Utopian AI", "A split scene showing one side as a dystopian world overwhelmed by AI surveillance and control, and the other as a utopian society where AI enhances quality of life"
-"Quantum Computing", "An ethereal quantum realm where qubits float in a space-like environment, representing the power and mystery of quantum computing in AI"
-"AI in Sports and Fitness", "An athletic training session where an AI coach provides personalized feedback and strategies to an athlete wearing smart wearables"
-"Education Through AI", "A futuristic classroom where holographic projections of AI tutors teach students from around the globe in an interactive learning environment"
-"AI in Art and Music", "An AI painting a masterpiece while another composes a symphony, showcasing the creative potential of AI in art and music"
-"AI as a Time Traveler", "An AI entity interacting with historical figures across different eras, from ancient civilizations to future societies, illustrating the timeless impact of AI"

data/lib/openai_101/tools/automate-images-chatgpt.js

@@ -1,60 +0,0 @@
-const { Command } = require('commander');
-const fs = require('fs');
-const robot = require("robotjs");
-
-const program = new Command();
-
-program
-  .option('-f, --file <filename>', 'The file to read prompts from', 'prompts.txt')
-  .option('-o, --completed-file <filename>', 'The file to write completed prompts to', 'completed.txt')
-  .option('-i, --interval <seconds>', 'The interval in seconds between prompts', 80)
-  .option('-m, --max-images <number>', 'The maximum number of images to process', 20);
-
-program.parse(process.argv);
-
-function read_prompts_from_file(file, maxImages) {
-  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
-  return prompts.slice(0, maxImages);
-}
-
-function remove_prompt_from_file(file, prompt) {
-  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
-  const index = prompts.indexOf(prompt);
-  if (index !== -1) {
-    prompts.splice(index, 1);
-    fs.writeFileSync(file, prompts.join('\n'));
-  }
-}
-
-function append_prompt_to_file(file, prompt) {
-  fs.appendFileSync(file, `${prompt}\n`);
-}
-
-function wait(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function send_prompt_to_chat(prompt) {
-  const formattedPrompt = `create image: ${prompt}`;
-  robot.typeString(formattedPrompt);
-  robot.keyTap('enter');
-}
-
-async function start() {
-  console.log('Starting Image Creation Automation');
-  console.log('Please open the ChatGPT interface where you intend to use this script.');
-  console.log('Automation will begin in 10 seconds.');
-  await wait(10000);
-
-  const prompts = read_prompts_from_file(program.opts().file, parseInt(program.opts().maxImages));
-  for (let prompt of prompts) {
-    console.log(`Sending prompt "${prompt}"...`);
-    await send_prompt_to_chat(prompt);
-    await wait(program.opts().interval * 1000);
-    remove_prompt_from_file(program.opts().file, prompt);
-    append_prompt_to_file(program.opts().completedFile, prompt);
-  }
-  console.log('Automation complete.');
-}
-
-start();

data/lib/openai_101/tools/automate-images-midjourney.js

@@ -1,75 +0,0 @@
-const { Command } = require('commander');
-const fs = require('fs');
-const robot = require("robotjs");
-
-const program = new Command();
-
-program
-  .option('-f, --file <filename>', 'The file to read prompts from', 'prompts.txt')
-  .option('-o, --completed-file <filename>', 'The file to write completed prompts to', 'completed.txt')
-  .option('-i, --interval <seconds>', 'The interval in seconds between prompts', 4)
-  .option('-p, --prompts-per-session <prompts>', 'The number of prompts to process in a session', 7)
-  .option('-w, --wait-between-sessions <seconds>', 'The number of seconds to wait between sessions', 180);
-
-program.parse(process.argv);
-
-function read_next_prompt_from_file(file) {
-  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
-  return prompts.shift();
-}
-
-function remove_prompt_from_file(file, prompt) {
-  const lockfile = `${file}.lock`;
-  fs.writeFileSync(lockfile, '', { flag: 'wx' });
-  const prompts = fs.readFileSync(file, 'utf-8').split('\n').filter(Boolean);
-  const index = prompts.indexOf(prompt);
-  prompts.splice(index, 1);
-  fs.writeFileSync(file, prompts.join('\n'));
-  fs.unlinkSync(lockfile);
-}
-
-function append_prompt_to_file(file, prompt) {
-  const lockfile = `${file}.lock`;
-  fs.writeFileSync(lockfile, '', { flag: 'wx' });
-  fs.appendFileSync(file, `${prompt}\n`);
-  fs.unlinkSync(lockfile);
-}
-
-function wait(ms) {
-  const end = Date.now() + ms;
-  while (Date.now() < end) {
-    // Wait
-  }
-}
-
-function send_prompt_to_discord(prompt) {
-  const formattedPrompt = `/imagine prompt: ${prompt}`;
-  robot.typeString(formattedPrompt);
-  robot.keyTap('enter');
-}
-
-function start() {
-  console.log('Starting MidJourney Automation');
-  console.log('Please open Discord and navigate to the MidJourney channel.');
-  console.log('Automation will begin in 10 seconds.');
-  wait(10 * 1000);
-
-  let index = 0;
-  let prompt = read_next_prompt_from_file(program.opts().file);
-  while (prompt) {
-    console.log(`Sending prompt "${prompt}"...`);
-    send_prompt_to_discord(prompt);
-    wait(program.opts().interval * 1000);
-    remove_prompt_from_file(program.opts().file, prompt);
-    append_prompt_to_file(program.opts().completedFile, prompt);
-    index++;
-    if (index % program.opts().promptsPerSession === 0) {
-      console.log(`Pausing for ${program.opts().waitBetweenSessions} seconds.`);
-      wait(program.opts().waitBetweenSessions * 1000);
-    }
-    prompt = read_next_prompt_from_file(program.opts().file);
-  }
-  console.log('Automation complete.');
-}
-
-start();

data/lib/openai_101/tools/bulk_image_bot/base_automator.js

@@ -1,53 +0,0 @@
-const fs = require('fs');
-const { promisify } = require('util');
-const robot = require("robotjs");
-
-const wait = promisify(setTimeout);
-
-class BaseAutomator {
-  constructor({ file, completedFile, interval = 5, maxImages = 20 }) {
-    this.file = file;
-    this.completedFile = completedFile;
-    this.interval = interval;
-    this.maxImages = maxImages;
-  }
-
-  async readPromptsFromFile() {
-    try {
-      const content = await fs.promises.readFile(this.file, 'utf-8');
-      return content.split('\n').filter(Boolean).slice(0, this.maxImages);
-    } catch (error) {
-      console.error('Error reading prompts from file:', error);
-      return [];
-    }
-  }
-
-  async appendToCompletedFile(prompt) {
-    try {
-      await fs.promises.appendFile(this.completedFile, `${prompt}\n`);
-    } catch (error) {
-      console.error('Error appending prompt to completed file:', error);
-    }
-  }
-
-  async removeFromInputFile(prompt) {
-    try {
-      let prompts = await this.readPromptsFromFile();
-      prompts = prompts.filter(line => line !== prompt);
-      await fs.promises.writeFile(this.file, prompts.join('\n'));
-    } catch (error) {
-      console.error('Error removing prompt from input file:', error);
-    }
-  }
-
-  async waitInterval() {
-    await wait(this.interval * 1000);
-  }
-
-  async sendKeystrokes(string) {
-    robot.typeString(string);
-    robot.keyTap('enter');
-  }
-}
-
-module.exports = BaseAutomator;

data/lib/openai_101/tools/bulk_image_bot/chatgpt_automator.js

@@ -1,27 +0,0 @@
-const BaseAutomator = require('./base_automator');
-
-class ChatGPTAutomator extends BaseAutomator {
-  constructor(options) {
-    super(options);
-  }
-
-  async sendPromptToChat(prompt) {
-    const formattedPrompt = `create image: ${prompt}`;
-    await this.sendKeystrokes(formattedPrompt);
-    console.log(`Sending prompt "${prompt}" to ChatGPT...`);
-  }
-
-  async start() {
-    console.log('Starting ChatGPT Image Creation Automation');
-    const prompts = await this.readPromptsFromFile();
-    for (const prompt of prompts) {
-      await this.sendPromptToChat(prompt);
-      await this.waitInterval();
-      await this.removeFromInputPromptFile(prompt);
-      await this.appendToCompletedPromptFile(prompt);
-    }
-    console.log('Automation complete.');
-  }
-}
-
-module.exports = ChatGPTAutomator;

data/lib/openai_101/tools/bulk_image_bot/midjourney_automator.js

@@ -1,49 +0,0 @@
-const BaseAutomator = require('./base_automator');
-const fs = require('fs');
-const robot = require("robotjs");
-
-class MidJourneyAutomator extends BaseAutomator {
-  constructor(options) {
-    super(options);
-  }
-
-  async sendPromptToDiscord(prompt) {
-    const formattedPrompt = this.formatPrompt(prompt);
-    this.sendKeystrokes(formattedPrompt);
-  }
-
-  formatPrompt(prompt) {
-    return `/imagine prompt: ${prompt}`;
-  }
-
-  sendKeystrokes(string) {
-    robot.typeString(string);
-    robot.keyTap('enter');
-  }
-
-  async start() {
-    console.log('Starting MidJourney Automation');
-    console.log('Please open Discord and navigate to the MidJourney channel.');
-    console.log('Automation will begin in 10 seconds.');
-    await this.wait(10 * 1000);
-
-    let index = 0;
-    let prompt = await this.readNextPromptFromFile();
-    while (prompt) {
-      console.log(`Sending prompt "${prompt}"...`);
-      await this.sendPromptToDiscord(prompt);
-      await this.wait(this.interval * 1000);
-      await this.removePromptFromFile(prompt);
-      await this.appendToCompletedFile(this.completedFile, prompt);
-      index++;
-      if (index % this.maxImages === 0) {
-        console.log(`Pausing for ${this.waitBetweenSessions} seconds.`);
-        await this.wait(this.waitBetweenSessions * 1000);
-      }
-      prompt = await this.readNextPromptFromFile();
-    }
-    console.log('Automation complete.');
-  }
-}
-
-module.exports = MidJourneyAutomator;

data/lib/openai_101/tools/clean_ruby_errors.rb

@@ -1,274 +0,0 @@
-# frozen_string_literal: true
-
-module Openai101
-  module Tools
-    # Clean Ruby Errors
-    module ReportFormatter
-      def print_column_names(column_definitions)
-        headings = column_definitions.map { |_, col| col[:label].ljust(col[:width]) }.join(' | ')
-        separator_length = column_definitions.sum { |_, col| col[:width] } + ((column_definitions.keys.size - 1) * 3)
-
-        puts '-' * separator_length
-        puts headings
-        puts '-' * separator_length
-      end
-
-      def print_line(column_definitions, **column_key_values)
-        line = column_definitions.map do |key, col|
-          value = column_key_values[key] || ''
-          value.to_s.ljust(col[:width])
-        end.join(' | ')
-        puts line
-      end
-    end
-
-    # Convert EDL to YouTube description chapters
-    class CleanRubyErrors
-      include ReportFormatter
-
-      attr_reader :file
-      attr_reader :error
-      attr_reader :errors
-
-      def initialize(file)
-        @file = file
-        @errors = []
-      end
-
-      def parse
-        capture_code = []
-        capture_stack = []
-
-        lines.each do |line|
-          @section = detect_section(line)
-
-          case section
-          when :new_error
-            add_stack_to_error(error, capture_stack) if capture_stack.any? && error
-
-            @error = initialize_error(line)
-            errors << error
-
-          when :failure_error1
-            error[:error_technique] = '1'
-            capture_code = []
-            @section = :capture_failure_error
-          when :failure_error2
-            error[:error_technique] = '2'
-            capture_code = []
-            @section = :capture_failure_error
-          when :capture_failure_error
-            capture_code << line.rstrip
-          when :actual_error
-            error[:error_type] = line.strip
-            error[:code_section] = format_code(capture_code)
-            capture_stack = []
-            @section = :capture_stack
-          when :capture_stack
-            capture_stack << line.strip
-          end
-        end
-
-        add_stack_to_error(error, capture_stack) if capture_stack.any? && error
-      end
-
-      def print_errors(errors)
-        column_definitions = {
-          test_number: { label: '#', width: 5 },
-          test_technique: { label: 'Style', width: 7 },
-          error_at: { label: 'Error At', width: 70 },
-          error_by: { label: 'Error By', width: 80 },
-          error_type: { label: 'Error Type', width: 20 },
-          error_message: { label: 'Error Message', width: 180 }
-        }
-
-        print_column_names(column_definitions)
-
-        errors.each do |error|
-          print_line(column_definitions,
-                     test_number: error[:test_number],
-                     test_technique: error[:error_technique],
-                     error_at: "#{error[:error_at][:file]}:#{error[:error_at][:line]}",
-                     error_by: "#{error[:error_by][:file]}:#{error[:error_by][:line]}",
-                     error_type: error[:error_type],
-                     error_message: error[:error_message])
-        end
-
-        print_column_names(column_definitions)
-      end
-
-      def print_aggregated_error(errors)
-        aggregated_errors = aggregate_errors(errors)
-        # puts JSON.pretty_generate(aggregated_errors.first)
-
-        # puts '----------------------'
-        # puts aggregated_errors.first
-
-        column_definitions = {
-          error_type: { label: 'Error Type', width: 20 },
-          error_message: { label: 'Error Message', width: 180 },
-          error_at_file: { label: 'Error At File', width: 70 },
-          error_at_lines: { label: 'L#', width: 5 },
-          error_by_file: { label: 'Error By File', width: 80 },
-          error_by_lines: { label: 'Lines', width: 30 }
-        }
-
-        print_column_names(column_definitions)
-
-        aggregated_errors.each do |error|
-          print_line(column_definitions,
-                     error_type: error[:error_type],
-                     error_message: error[:error_message],
-                     error_at_file: error[:error_at_file],
-                     error_at_lines: error[:error_at_lines].join(', '),
-                     error_by_file: error[:error_by_file],
-                     error_by_lines: error[:error_by_lines].join(', '))
-        end
-
-        print_column_names(column_definitions)
-      end
-
-      #   # column_definitions = {
-      #   #   error_message: { label: "Error Message", width: 180 },
-      #   # }
-
-      #   # # Print the report
-      #   # puts "Error Message | Source File(Line Numbers) | Spec File(Line Numbers)"
-      #   # puts "-" * 100
-
-      #   # aggregated_errors.each do |(message, source_file, spec_file), lines|
-      #   #   source_lines = lines[:source_lines].uniq.sort.join(', ')
-      #   #   spec_lines = lines[:spec_lines].uniq.sort.join(', ')
-      #   #   puts "#{message} | #{source_file}(#{source_lines}) | #{spec_file}(#{spec_lines})"
-      #   # end
-      # end
-
-      private
-
-      def lines
-        @lines ||= File.readlines(file)
-      end
-
-      def detect_section(line)
-        return :new_error           if line.match?(/^\d+\)/)
-        return :failure_error2      if line.include?('Failure/Error: ') # Note the space
-        return :failure_error1      if line.include?('Failure/Error:')
-        return :actual_error        if line.include?('Error:')
-
-        section
-      end
-
-      def section
-        @section ||= :start
-      end
-
-      def initialize_error(line)
-        {
-          error_type: '',
-          error_technique: '',
-          test_number: extract_error_number(line),
-          code_section: [],
-          error_message: '',
-          error_messages: [],
-          stack: [],
-          error_at: { file: '', line: 0 },
-          error_by: { file: '', line: 0 }
-        }
-      end
-
-      def extract_error_number(line)
-        match = line.match(/^(\d+)\)/)
-        match ? match[1] : nil
-      end
-
-      def format_code(code_lines)
-        return 'Investigate!!!' if code_lines.empty?
-
-        first_line_spaces = code_lines.first[/\A */].size
-        code_lines.map { |line| line[first_line_spaces..] }.compact
-      end
-
-      def add_stack_to_error(error, stack_lines)
-        error_messages, stack_trace = split_strack_from_errors(stack_lines)
-
-        error[:error_message] = error_messages.join(' ')
-        error[:error_messages] = error_messages
-        error[:stack] = stack_trace
-
-        error[:error_at] = extract_error_location(stack_trace)
-        error[:error_by] = extract_test_location(stack_trace)
-      end
-
-      def split_strack_from_errors(stack_lines)
-        error_messages, stack_trace = stack_lines.partition { |line| !line.start_with?('#') }
-
-        clean_error_messages = error_messages.reject(&:empty?)
-        clean_stack_trace = stack_trace.map { |line| line.sub(/^#\s*/, '') }
-
-        [clean_error_messages, clean_stack_trace]
-      end
-
-      def extract_error_location(stack_trace)
-        return { file: '', line: 0 } if stack_trace.empty?
-
-        # Matches on file paths ending in .rb followed by a colon and a line number.
-        # It captures the file path and line number into named groups 'file' and 'line'.
-        # Example Match: "./app/models/user.rb:13" => file: "./app/models/user.rb", line: "13"
-        match = stack_trace.first.match(/(?<file>.*\.rb):(?<line>\d+)/)
-        match ? { file: match[:file], line: match[:line] } : { file: 'XXXXXX1', line: 0 }
-      end
-
-      def extract_test_location(stack_trace)
-        stack_trace.reverse_each do |trace_line|
-          # Searches for file paths that specifically end with _spec.rb (indicating a test file),
-          # followed by a colon and a line number. It captures the test file path and line number.
-          # Example Match: "./spec/models/user_spec.rb:26" => file: "./spec/models/user_spec.rb", line: "26"
-          if (match = trace_line.match(/(?<file>.*_spec\.rb):(?<line>\d+)/))
-            return { file: match[:file], line: match[:line] }
-          end
-        end
-        { file: 'XXXXXX2', line: 0 } # Return a default value if no test location is found
-      end
-
-      def aggregate_errors(errors)
-        # Initialize an empty hash for aggregations
-        aggregated_errors = {}
-
-        errors.each do |error|
-          # Create a unique key for each aggregation based on error_message, error_at[:file], and error_by[:file]
-          key = [
-            error[:error_message],
-            error[:error_at][:file],
-            error[:error_by][:file]
-          ].join('|')
-
-          # If the aggregation key doesn't exist, initialize it
-          aggregated_errors[key] ||= {
-            error_type: error[:error_type],
-            error_message: error[:error_message],
-            code_section: error[:code_section], # Assuming code_section is the same for aggregated errors
-            error_at: { file: error[:error_at][:file], lines: [] },
-            error_by: { file: error[:error_by][:file], lines: [] }
-          }
-
-          # Append unique error messages and line numbers for error_at and error_by
-          aggregated_errors[key][:error_at][:lines] |= [error[:error_at][:line]]
-          aggregated_errors[key][:error_by][:lines] |= [error[:error_by][:line]]
-        end
-
-        # Convert the aggregated_errors hash back into an array of values
-        aggregated_errors.values.map do |error|
-          {
-            error_type: error[:error_type],
-            error_message: error[:error_message],
-            code_section: error[:code_section].join("\n"),
-            error_at_file: error[:error_at][:file],
-            error_at_lines: error[:error_at][:lines],
-            error_by_file: error[:error_by][:file],
-            error_by_lines: error[:error_by][:lines]
-          }
-        end
-      end
-    end
-  end
-end

data/lib/openai_101/tools/edl_to_chapters.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Openai101
-  module Tools
-    # Convert EDL to YouTube description chapters
-    class EdlToChapters
-      attr_reader :content
-
-      def initialize(content: nil, file: nil)
-        @content = content
-        @content = File.read(file) if file
-      end
-
-      def convert
-        # TITLE: a36
-        # FCM: NON-DROP FRAME
-
-        # 001  001      V     C        00:00:09:16 00:00:09:17 00:00:09:16 00:00:09:17
-        #  |C:ResolveColorBlue |M:Hey Code Voice Commands |D:1
-
-        # 002  001      V     C        00:00:53:13 00:00:53:14 00:00:53:13 00:00:53:14
-        #  |C:ResolveColorBlue |M:Keyboard Shortcuts |D:1
-
-        # 003  001      V     C        00:01:17:20 00:01:17:21 00:01:17:20 00:01:17:21
-        #  |C:ResolveColorBlue |M:Create code using voice |D:1
-
-        # 004  001      V     C        00:02:17:25 00:02:17:26 00:02:17:25 00:02:17:26
-        #  |C:ResolveColorBlue |M:Next steps |D:1
-
-        chapters = []
-        chapter = nil
-        content.each_line do |line|
-          line = line.strip
-
-          if line =~ /^\d{3}/
-            chapter = build_chapter(line)
-            chapters << chapter
-            next
-          end
-
-          chapter[:description] = line.match(/\|M:(.+?)\|/)[1].strip if chapter && line.match(/\|M:(.+?)\|/) && line.match(/\|M:(.+?)\|/)[1]
-        end
-        chapters.map { |item| "#{item[:time]} #{item[:description]}" }.join("\n")
-      end
-
-      def build_chapter(line)
-        time_code = line.split(/\s+/)[5] # Extract time code
-        hours, minutes, seconds, frames = time_code.split(':').map(&:to_i)
-        total_seconds = (hours * 3600) + (minutes * 60) + seconds + (frames / 30.0)
-        formatted_time = format('%<hours>02d:%<minutes>02d:%<seconds>02d', hours: total_seconds / 3600, minutes: (total_seconds / 60) % 60, seconds: total_seconds % 60)
-
-        { time: formatted_time }
-      end
-    end
-  end
-end

data/lib/openai_101/tools/file_content_gatherer.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Openai101
-  module Tools
-    # Gather content from files in a directory, used by gpt_context_gatherer.rb
-    class FileContentGatherer
-      attr_reader :include_patterns, :exclude_patterns
-
-      def initialize(include_pattern: nil, include_patterns: [], exclude_patterns: [])
-        @include_patterns = Array(include_pattern) + include_patterns
-        @exclude_patterns = exclude_patterns
-      end
-
-      def build
-        concatenated_content = []
-
-        include_patterns.each do |pattern|
-          Dir.glob(pattern).each do |file_path|
-            next if excluded?(file_path) || File.directory?(file_path)
-
-            content = "# file: #{file_path}\n\n#{File.read(file_path)}"
-            concatenated_content << content
-          end
-        end
-
-        concatenated_content.join("\n\n")
-      end
-
-      private
-
-      def excluded?(file_path)
-        exclude_patterns.any? { |pattern| File.fnmatch(pattern, file_path) }
-      end
-    end
-  end
-end