flatito 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a906047322b5ee01c3e8fe05e16d4ad9155032ad2d6ffa1756270de8f3339a2
-  data.tar.gz: 07d41acd512f19c0c0b0c03cd3be90261faada0789dc3db66c4f9b4fefc0c1be
+  metadata.gz: 7864bfbf6505512a8f41e61b75efdb1081a62677f8686c37276a631f51572e96
+  data.tar.gz: d40ab3fd44a41e0cbd091e3dfbc62de98b931318fdda2efbbb8d89e206e20799
 SHA512:
-  metadata.gz: 3be43b0a5232da51a840cf9cc5b79de24dc0159af605255552299a4bd988f6ec1e9b1a2d2df0d1c450df0d354a8bb8f43d9c9f257cc02307be20a77352de0a0d
-  data.tar.gz: 7e04d4621eee22bac06148cad9cebf83de29b1b3d299bd0cd5c162a797c447e6ae922f903784ecfc8678781121852593326d21f07545528b2d64237db15e5578
+  metadata.gz: 263878449f3724e3d1b46c8a18eebfad0445504a080726cb38b29a25675ea23db278ab0f5157041f6effff62b3ec7d50eb97d76e531ad1ba412e0d603c0a8607
+  data.tar.gz: 3c04d9bf798fd85b72af32946c03dabc888355c5b315a300bdff1aa4c8a7c0fcbcb3aa4db24c3a3e94fe27bba8e48afd19a1c38cb7a09ff9f63391c3a115cf9d

data/.rubocop.yml

@@ -1,9 +1,12 @@
 AllCops:
   TargetRubyVersion: 3.0
   NewCops: enable
+  Exclude:
+    - "benchmark.rb"
+    - "vendor/**/*"
 
 
-require:
+plugins:
   - rubocop-performance
   - rubocop-minitest
   - rubocop-rake

data/README.md

@@ -1,6 +1,6 @@
 # Flatito: Grep for YAML and JSON files
 
-A kind of grep for YAML and JSON files. It allows you to search for a key and get the value and the line number where it is located.
+A kind of grep for YAML and JSON files. It allows you to search by key or value and get the matching entries with their line numbers.
 
 ![Example](docs/screenshot.png)
 
@@ -30,14 +30,27 @@ It is also available as [nixpkgs](https://search.nixos.org/packages?channel=unst
 ```sh
 Usage:    flatito PATH [options]
 Example:  flatito . -k "search string" -e "json,yaml"
+Example:  flatito . -c "search value"
 Example:  cat file.yaml | flatito -k "search string"
 
     -h, --help                       Prints this help
     -V, --version                    Show version
-    -k, --search-key=SEARCH          Search string
+    -k, --search-key=SEARCH          Search by key
+    -c, --search-value=SEARCH        Search by value
+    -s, --case-sensitive             Case sensitive search
         --no-color                   Disable color output
     -e, --extensions=EXTENSIONS      File extensions to search, separated by comma, default: (json,yaml,yaml)
         --no-skipping                Do not skip hidden files
+        --no-gitignore               Do not respect .gitignore
+```
+
+Searches are case-insensitive by default. Use `-s` to force exact case matching.
+
+Both `-k` and `-c` support regular expressions and can be combined:
+
+```sh
+# Find keys matching "database" with values containing "production"
+flatito . -k "database" -c "production"
 ```
 
 ## Development

data/benchmark.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "English"
+require "flatito"
+
+# --- Helpers ---
+
+def measure_time(times, &block)
+  gc_was_disabled = GC.disable
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  times.times(&block)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+  GC.enable unless gc_was_disabled
+  elapsed
+end
+
+def measure_memory
+  GC.start
+  GC.compact if GC.respond_to?(:compact)
+  before_mem = `ps -o rss= -p #{$PROCESS_ID}`.strip.to_i
+  before_gc = GC.stat[:total_allocated_objects]
+
+  yield
+
+  after_gc = GC.stat[:total_allocated_objects]
+  after_mem = `ps -o rss= -p #{$PROCESS_ID}`.strip.to_i
+
+  { rss_kb: after_mem - before_mem, objects: after_gc - before_gc }
+end
+
+def report(label, times, &block)
+  # Warmup
+  3.times(&block)
+
+  elapsed = measure_time(times, &block)
+  mem = measure_memory { times.times(&block) }
+  per_iter = (elapsed / times * 1000).round(3)
+
+  puts format(
+    "  %-40s %8.3f ms/iter  |  RSS: %+6d KB  |  Allocs: %d",
+    label, per_iter, mem[:rss_kb], mem[:objects]
+  )
+end
+
+# --- Setup ---
+
+yaml_small = (1..100).map { |i| "key_#{i}: Value number #{i}" }.join("\n")
+yaml_medium = (1..1000).map { |i| "key_#{i}: Value number #{i} with some extra text" }.join("\n")
+
+nested_lines = (1..200).map do |i|
+  "group_#{i / 10}:\n  key_#{i}: Value number #{i} with nested content"
+end
+yaml_nested = nested_lines.join("\n")
+
+json_content = "{\n" + (1..1000).map { |i| "  \"key_#{i}\": \"Value number #{i}\"" }.join(",\n") + "\n}"
+
+items_medium = Flatito::FlattenYaml.items_from_content(yaml_medium)
+
+null_io = File.open(File::NULL, "w")
+Flatito::Config.stdout = null_io
+Flatito::Config.prepare_with_options({ no_color: true })
+
+# --- Benchmark ---
+
+puts "Flatito Benchmark"
+puts "Ruby #{RUBY_VERSION} | #{RUBY_PLATFORM}"
+puts "=" * 90
+
+puts "\n[Parsing]"
+report("YAML 100 keys", 1000) { Flatito::FlattenYaml.items_from_content(yaml_small) }
+report("YAML 1000 keys", 500) { Flatito::FlattenYaml.items_from_content(yaml_medium) }
+report("YAML 200 nested keys", 500) { Flatito::FlattenYaml.items_from_content(yaml_nested) }
+report("JSON 1000 keys", 500) { Flatito::FlattenYaml.items_from_content(json_content) }
+
+puts "\n[Filtering]"
+pi = Flatito::PrintItems.new("key_50")
+report("by key (literal)", 5000) { pi.filter_by_search(items_medium) }
+
+pi = Flatito::PrintItems.new("key_(5|9)\\d\\d")
+report("by key (regex)", 5000) { pi.filter_by_search(items_medium) }
+
+if Flatito::PrintItems.instance_method(:initialize).arity.abs > 1
+  pi = Flatito::PrintItems.new(nil, "number 50")
+  report("by value (literal)", 5000) { pi.filter_by_value(items_medium) }
+
+  pi = Flatito::PrintItems.new(nil, "number (5|9)\\d\\d")
+  report("by value (regex)", 5000) { pi.filter_by_value(items_medium) }
+
+  pi = Flatito::PrintItems.new("key_5", "number 5")
+  report("by key + value", 5000) do
+    filtered = pi.filter_by_search(items_medium)
+    pi.filter_by_value(filtered)
+  end
+end
+
+puts "\n[Rendering]"
+Flatito::Config.prepare_with_options({})
+pi = Flatito::PrintItems.new("key_50")
+report("filter + print (key, 11 matches)", 2000) { pi.print(items_medium) }
+
+if Flatito::PrintItems.instance_method(:initialize).arity.abs > 1
+  pi = Flatito::PrintItems.new(nil, "number 50")
+  report("filter + print (value, 11 matches)", 2000) { pi.print(items_medium) }
+end
+
+pi = Flatito::PrintItems.new(nil)
+report("print all (1000 items, no filter)", 20) { pi.print(items_medium) }
+
+puts "\n[Memory - large parse]"
+GC.start
+GC.compact if GC.respond_to?(:compact)
+before = GC.stat[:total_allocated_objects]
+rss_before = `ps -o rss= -p #{$PROCESS_ID}`.strip.to_i
+large_yaml = (1..5000).map { |i| "key_#{i}: Value number #{i} with a longer description to simulate real data" }.join("\n")
+Flatito::FlattenYaml.items_from_content(large_yaml)
+after = GC.stat[:total_allocated_objects]
+rss_after = `ps -o rss= -p #{$PROCESS_ID}`.strip.to_i
+puts format("  %-40s RSS: %+6d KB  |  Allocs: %d", "parse 5000 keys YAML", rss_after - rss_before, after - before)
+
+null_io.close
+puts "\n#{"=" * 90}"

data/exe/flatito

@@ -13,6 +13,7 @@ OptionParser.new do |opts|
   opts.banner = <<~HEREDOC
     Usage:    flatito PATH [options]
     Example:  flatito . -k "search string" -e "json,yaml"
+    Example:  flatito . -c "search value"
     Example:  cat file.yaml | flatito -k "search string"
   HEREDOC
 
@@ -26,10 +27,18 @@ OptionParser.new do |opts|
     exit
   end
 
-  opts.on("-kSEARCH", "--search-key=SEARCH", "Search string") do |s|
+  opts.on("-kSEARCH", "--search-key=SEARCH", "Search by key") do |s|
     options[:search] = s
   end
 
+  opts.on("-cSEARCH", "--search-value=SEARCH", "Search by value") do |s|
+    options[:search_value] = s
+  end
+
+  opts.on("-s", "--case-sensitive", "Case sensitive search") do
+    options[:case_sensitive] = true
+  end
+
   opts.on("--no-color", "Disable color output") do
     options[:no_color] = true
   end
@@ -41,12 +50,18 @@ OptionParser.new do |opts|
   opts.on("--no-skipping", "Do not skip hidden files") do
     options[:skip_hidden] = false
   end
+
+  opts.on("--no-gitignore", "Do not respect .gitignore") do
+    options[:gitignore] = false
+  end
 end.parse!
 
 Flatito::Config.prepare_with_options(options)
 
-if stdin
-  Flatito.flat_content(stdin, options)
-else
-  Flatito.search(ARGV, options)
-end
+matched = if stdin
+            Flatito.flat_content(stdin, options)
+          else
+            Flatito.search(ARGV, options)
+          end
+
+exit 1 unless matched

data/lib/flatito/config.rb

@@ -3,11 +3,9 @@
 module Flatito
   module Config
     @stdout = $stdout
-    @stderr = $stderr
-    @stdin  = $stdin
 
     class << self
-      attr_accessor :renderer, :stdout, :stder, :stdin
+      attr_accessor :renderer, :stdout
 
       def prepare_with_options(options)
         self.renderer = Renderer.build(options)

data/lib/flatito/finder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "English"
+require "etc"
+require "set"
 require_relative "regex_from_search"
 
 module Flatito
@@ -8,28 +11,33 @@ module Flatito
 
     DEFAULT_EXTENSIONS = %w[json yml yaml].freeze
 
-    attr_reader :paths, :search, :extensions, :options, :print_items
+    attr_reader :paths, :search, :search_value, :case_sensitive, :extensions, :options, :print_items
 
     def initialize(paths, options = {})
       @paths = paths
       @search = options[:search]
+      @search_value = options[:search_value]
+      @case_sensitive = options[:case_sensitive]
       @extensions = prepare_extensions(options[:extensions] || DEFAULT_EXTENSIONS)
       @options = options
-      @print_items = PrintItems.new(search)
+      @print_items = PrintItems.new(search, search_value, case_sensitive: case_sensitive)
     end
 
+    FORK_THRESHOLD = 100
+
     def call
+      @matched = false
       renderer.prepare
 
-      paths.each do |path|
-        TreeIterator.new(path, options).each do |pathname|
-          renderer.print_file_progress(pathname)
+      files = collect_candidate_files
 
-          if extensions.include?(pathname.extname)
-            flat_and_filter(pathname)
-          end
-        end
+      if files.size >= FORK_THRESHOLD && Process.respond_to?(:fork)
+        process_with_forks(files)
+      else
+        files.each { |pathname| flat_and_filter(pathname) }
       end
+
+      @matched
     ensure
       renderer.ending
     end
@@ -40,9 +48,122 @@ module Flatito
       Config.renderer
     end
 
+    def collect_candidate_files
+      files = []
+      paths.each do |path|
+        TreeIterator.new(path, options).each do |pathname|
+          renderer.print_file_progress(pathname)
+          next unless extensions.include?(pathname.extname)
+          next if git_candidates && !git_candidates.include?(File.expand_path(pathname.to_s))
+
+          files << pathname
+        end
+      end
+      files
+    end
+
+    def process_with_forks(files)
+      workers = [Etc.nprocessors, files.size].min
+      chunks = files.each_slice((files.size / workers.to_f).ceil).to_a
+
+      readers = chunks.map do |chunk|
+        rd, wr = IO.pipe
+        Process.fork do
+          rd.close
+          results = chunk.filter_map { |pathname| read_and_parse(pathname) }
+          Marshal.dump(results, wr)
+          wr.close
+        end
+        wr.close
+        rd
+      end
+
+      readers.each do |rd|
+        data = rd.read
+        rd.close
+        next if data.empty?
+
+        Marshal.load(data).each do |pathname, items| # rubocop:disable Security/MarshalLoad
+          @matched = true if print_items.print(items, pathname)
+        end
+      end
+
+      Process.waitall
+    end
+
+    def read_and_parse(pathname)
+      content = File.read(pathname)
+      return unless content_may_match?(content)
+
+      items = FlattenYaml.items_from_content(content, pathname: pathname)
+      [pathname, items]
+    end
+
     def flat_and_filter(pathname)
-      items = FlattenYaml.items_from_path(pathname)
-      print_items.print(items, pathname)
+      return if git_candidates && !git_candidates.include?(File.expand_path(pathname.to_s))
+
+      content = File.read(pathname)
+      return unless git_candidates || content_may_match?(content)
+
+      items = FlattenYaml.items_from_content(content, pathname: pathname)
+      @matched = true if print_items.print(items, pathname)
+    end
+
+    def git_candidates
+      return @git_candidates if defined?(@git_candidates)
+
+      @git_candidates = build_git_candidates
+    end
+
+    def build_git_candidates
+      return nil if search.nil? && search_value.nil?
+
+      patterns = []
+      patterns.concat(search.split(".")) if search
+      patterns << search_value if search_value
+
+      candidates = Set.new
+      paths.each do |path|
+        dir = File.directory?(path) ? path : File.dirname(path)
+        files = git_grep(dir, patterns)
+        return nil if files.nil?
+
+        candidates.merge(files)
+      end
+      candidates
+    end
+
+    def git_grep(dir, patterns)
+      expanded_dir = File.expand_path(dir)
+      args = ["git", "-C", expanded_dir, "grep", "--untracked", "-l"]
+      args << "-i" unless case_sensitive
+      args << "--all-match" if patterns.size > 1
+      patterns.each { |p| args.push("-e", p) }
+      args.push("--", ".")
+
+      output = IO.popen(args, err: File::NULL, &:read)
+      return nil unless [0, 1].include?($CHILD_STATUS.exitstatus)
+
+      Set.new(output.lines.map { |f| File.expand_path(f.chomp, expanded_dir) })
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def content_may_match?(content)
+      return true if search.nil? && search_value.nil?
+
+      (!search || key_parts_match?(content)) &&
+        (!search_value || value_regex.match?(content))
+    end
+
+    def key_parts_match?(content)
+      key_part_regexes.all? { |part| part.match?(content) }
+    end
+
+    def key_part_regexes
+      @key_part_regexes ||= search.split(".").map do |part|
+        Regexp.new(part, case_sensitive ? nil : Regexp::IGNORECASE)
+      end
     end
 
     def prepare_extensions(extensions)

data/lib/flatito/flatten_yaml.rb

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "utils"
 module Flatito
   class FlattenYaml
-    include Utils
-
     Item = Struct.new(:key, :value, :line, keyword_init: true)
     class << self
       def items_from_path(pathname)
@@ -12,8 +9,8 @@ module Flatito
         new(content, pathname: pathname).items
       end
 
-      def items_from_content(content)
-        new(content).items
+      def items_from_content(content, pathname: nil)
+        new(content, pathname: pathname).items
       end
     end
 
@@ -25,23 +22,40 @@ module Flatito
     end
 
     def items
-      with_line_numbers.compact.flat_map do |line|
+      if json?
+        result = JsonScanner.scan(content)
+        return result if result
+      end
+
+      psych_items
+    rescue StandardError
+      warn "Error parsing #{pathname}" if pathname
+      []
+    end
+
+    def psych_items
+      with_line_numbers.filter_map do |line|
         flatten_hash(line) if line.is_a?(Hash)
-      end.compact
+      end.flatten
     end
 
     def flatten_hash(hash, prefix = nil)
-      hash.flat_map do |key, value|
-        if value.is_a?(YAMLWithLineNumber::ValueWithLineNumbers)
-          if value.value.is_a?(Hash)
-            flatten_hash(value.value, [prefix, key].compact.join("."))
-          else
-            Item.new(key: [prefix, key].compact.join("."), value: truncate(value.value.to_s), line: value.line)
-          end
+      hash.filter_map do |key, value|
+        next unless value.is_a?(YAMLWithLineNumber::ValueWithLineNumbers)
+
+        full_key = prefix ? "#{prefix}.#{key}" : key
+        if value.value.is_a?(Hash)
+          flatten_hash(value.value, full_key)
+        else
+          Item.new(key: full_key, value: value.value.to_s, line: value.line)
         end
       end
     end
 
+    def json?
+      content.lstrip.start_with?("{", "[")
+    end
+
     def with_line_numbers
       handler = YAMLWithLineNumber::TreeBuilder.new
       handler.parser = Psych::Parser.new(handler)

data/lib/flatito/json_scanner.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Flatito
+  class JsonScanner
+    def self.scan(content)
+      new(content).items
+    end
+
+    attr_reader :content
+
+    def initialize(content)
+      @content = content
+      @line_index = nil
+    end
+
+    def items
+      hash = JSON.parse(content)
+      flatten(hash)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private
+
+    def flatten(hash, prefix = nil)
+      hash.flat_map do |key, value|
+        full_key = prefix ? "#{prefix}.#{key}" : key
+        if value.is_a?(Hash)
+          flatten(value, full_key)
+        else
+          line = find_line(key)
+          FlattenYaml::Item.new(key: full_key, value: value.to_s, line: line)
+        end
+      end
+    end
+
+    def find_line(key)
+      line_index[key] || 0
+    end
+
+    def line_index
+      @line_index ||= build_line_index
+    end
+
+    def build_line_index
+      index = {}
+      content.each_line.with_index(1) do |line, num|
+        if (match = line.match(/"([^"]+)"\s*:/))
+          index[match[1]] ||= num
+        end
+      end
+      index
+    end
+  end
+end

data/lib/flatito/print_items.rb

@@ -4,18 +4,22 @@ module Flatito
   class PrintItems
     include RegexFromSearch
 
-    attr_reader :search
+    attr_reader :search, :search_value, :case_sensitive
 
-    def initialize(search)
+    def initialize(search, search_value = nil, case_sensitive: false)
       @search = search
+      @search_value = search_value
+      @case_sensitive = case_sensitive
     end
 
-    def print(items, pathname = nil)
+    def print(items, pathname = nil) # rubocop:disable Naming/PredicateMethod
       items = filter_by_search(items) if search
-      return unless items.any?
+      items = filter_by_value(items) if search_value
+      return false unless items.any?
 
       renderer.print_pathname(pathname) if pathname
       renderer.print_items(items)
+      true
     end
 
     def filter_by_search(items)
@@ -24,6 +28,14 @@ module Flatito
       end
     end
 
+    def filter_by_value(items)
+      items.select do |item|
+        value_regex.match?(item.value)
+      end
+    end
+
+    private
+
     def renderer
       Config.renderer
     end

data/lib/flatito/regex_from_search.rb

@@ -3,7 +3,11 @@
 module Flatito
   module RegexFromSearch
     def regex
-      @regex ||= Regexp.new(search)
+      @regex ||= Regexp.new(search, case_sensitive ? nil : Regexp::IGNORECASE)
+    end
+
+    def value_regex
+      @value_regex ||= Regexp.new(search_value, case_sensitive ? nil : Regexp::IGNORECASE)
     end
   end
 end

data/lib/flatito/renderer.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "io/console"
 require_relative "regex_from_search"
 require_relative "utils"
 
@@ -19,11 +18,14 @@ module Flatito
     include Utils
     include RegexFromSearch
 
-    attr_reader :search, :no_color
+    attr_reader :search, :search_value, :no_color, :case_sensitive
 
     def initialize(options)
       @no_color = options[:no_color] || false
       @search = options[:search]
+      @search_value = options[:search_value]
+      @case_sensitive = options[:case_sensitive]
+      @no_color_resolved = nil
     end
 
     def prepare; end
@@ -47,7 +49,8 @@ module Flatito
     def print_item(item, line_number_padding)
       line_number = colorize("#{item.line.to_s.rjust(line_number_padding)}: ", :yellow)
       value = if item.value.length.positive?
-                colorize("=> #{item.value}", :gray)
+                display_value = truncate_value(item.value)
+                colorize("=> ", :gray) + matched_value(display_value, :gray)
               else
                 ""
               end
@@ -60,14 +63,24 @@ module Flatito
     def matched_string(string)
       return string if search.nil? || no_color?
 
-      regex.match(string).to_a.each do |match|
-        string = string.gsub(/#{match}/, match.colorize(:light_red))
-      end
-      string
+      string.gsub(regex) { |match| match.colorize(:light_red) }
+    end
+
+    def matched_value(string, default_color)
+      return colorize(string, default_color) if search_value.nil? || no_color?
+
+      string.gsub(value_regex) { |match| match.colorize(:light_red) }
+    end
+
+    def truncate_value(string)
+      match_position = search_value && value_regex.match(string)&.begin(0)
+      truncate(string, match_position: match_position)
     end
 
     def no_color?
-      ENV["TERM"] == "dumb" || ENV["NO_COLOR"] == "true" || no_color == true
+      return @no_color_resolved unless @no_color_resolved.nil?
+
+      @no_color_resolved = ENV["TERM"] == "dumb" || ENV["NO_COLOR"] == "true" || no_color == true
     end
 
     def stdout
@@ -102,7 +115,7 @@ module Flatito
     end
 
     def print_file_progress(pathname)
-      print truncate(pathname.to_s, stdout_width - 4)
+      stdout.print truncate(pathname.to_s, max: stdout_width - 4)
       clear_line
     end
 

data/lib/flatito/tree_iterator.rb

@@ -1,14 +1,18 @@
 # frozen_string_literal: true
 
+require "English"
+require "set"
+
 module Flatito
   class TreeIterator
     include Enumerable
 
-    attr_reader :base_path, :skip_hidden
+    attr_reader :base_path, :skip_hidden, :gitignore
 
     def initialize(base_path, options = {})
       @base_path = base_path
-      @skip_hidden = options[:skip_hidden] || true
+      @skip_hidden = options.fetch(:skip_hidden, true)
+      @gitignore = options.fetch(:gitignore, true)
     end
 
     def each(&block)
@@ -18,6 +22,7 @@ module Flatito
     def tree(parent, &block)
       if parent.directory?
         return if parent.symlink?
+        return if gitignore && ignored_dir?(parent)
 
         parent.each_child.each do |pathname|
           next if skip_hidden && pathname.basename.to_s[0] == "."
@@ -32,5 +37,29 @@ module Flatito
 
       []
     end
+
+    private
+
+    def ignored_dir?(dir)
+      expanded = File.expand_path(dir.to_s)
+      ignored_dirs.any? { |ignored| expanded.start_with?(ignored) }
+    end
+
+    def ignored_dirs
+      @ignored_dirs ||= build_ignored_dirs
+    end
+
+    def build_ignored_dirs
+      base = File.expand_path(base_path)
+      output = `git -C "#{base}" ls-files --others --ignored --exclude-standard --directory 2>/dev/null`
+      return [] unless $CHILD_STATUS.success?
+
+      output.lines.filter_map do |line|
+        path = line.chomp
+        File.join(base, path.delete_suffix("/")) if path.end_with?("/")
+      end
+    rescue Errno::ENOENT
+      []
+    end
   end
 end

data/lib/flatito/utils.rb

@@ -2,8 +2,19 @@
 
 module Flatito
   module Utils
-    def truncate(string, max = 50)
-      string.length > max ? "#{string[0...max]}..." : string
+    def truncate(string, max: 50, match_position: nil)
+      return string if string.length <= max
+
+      if match_position && match_position > max
+        start = [match_position - (max / 2), 0].max
+        ending = start + max
+        result = string[start...ending]
+        result = "...#{result}" if start.positive?
+        result = "#{result}..." if ending < string.length
+        result
+      else
+        "#{string[0...max]}..."
+      end
     end
   end
 end

data/lib/flatito/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flatito
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/flatito.rb

@@ -5,6 +5,7 @@ require "colorize"
 require_relative "flatito/version"
 require_relative "flatito/tree_iterator"
 require_relative "flatito/flatten_yaml"
+require_relative "flatito/json_scanner"
 require_relative "flatito/finder"
 require_relative "flatito/yaml_with_line_number"
 require_relative "flatito/renderer"
@@ -18,11 +19,12 @@ module Flatito
       Finder.new(paths, options).call
     rescue Interrupt
       warn "\nInterrupted"
+      nil
     end
 
     def flat_content(content, options = {})
       items = FlattenYaml.items_from_content(content)
-      PrintItems.new(options[:search]).print(items)
+      PrintItems.new(options[:search], options[:search_value], case_sensitive: options[:case_sensitive]).print(items) || false
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flatito
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - José Galisteo
@@ -37,12 +37,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark.rb
 - docs/screenshot.png
 - exe/flatito
 - lib/flatito.rb
 - lib/flatito/config.rb
 - lib/flatito/finder.rb
 - lib/flatito/flatten_yaml.rb
+- lib/flatito/json_scanner.rb
 - lib/flatito/print_items.rb
 - lib/flatito/regex_from_search.rb
 - lib/flatito/renderer.rb