fmt 0.1.3 → 0.3.0

data/lib/fmt/filter_groups/string_filter_group.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "filter_group"
-
-module Fmt
-  class StringFilterGroup < FilterGroup
-    def initialize
-      super
-
-      # rubocop:disable Layout/ExtraSpacing AllowForAlignment
-      add :capitalize,        ->(s) { s.capitalize }
-      add :chomp,             ->(s) { s.chomp }
-      add :chop,              ->(s) { s.chop }
-      add :downcase,          ->(s) { s.downcase }
-      add :lstrip,            ->(s) { s.lstrip }
-      add :reverse,           ->(s) { s.reverse }
-      add :rstrip,            ->(s) { s.rstrip }
-      add :shellescape,       ->(s) { s.shellescape }
-      add :strip,             ->(s) { s.strip }
-      add :succ,              ->(s) { s.succ }
-      add :swapcase,          ->(s) { s.swapcase }
-      add :undump,            ->(s) { s.undump }
-      add :unicode_normalize, ->(s) { s.unicode_normalize }
-      add :upcase,            ->(s) { s.upcase }
-      # rubocop:enable Layout/ExtraSpacing AllowForAlignment
-    end
-  end
-end

data/lib/fmt/formatter.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require_relative "filter_groups/filter_group"
-require_relative "filter_groups/rainbow_filter_group"
-require_relative "filter_groups/string_filter_group"
-require_relative "scanners"
-require_relative "transformer"
-
-module Fmt
-  class Formatter
-    include Singleton
-
-    attr_reader :filters
-
-    def add_rainbow_filters
-      filters.merge! Fmt::RainbowFilterGroup.new.to_h
-    end
-
-    def add_filter(...)
-      filters.add(...)
-    end
-
-    def format(string, **locals)
-      result = string.to_s
-      transformer = next_transformer(result)
-
-      while transformer
-        result = transformer.transform(result, **locals)
-        transformer = next_transformer(result)
-      end
-
-      result
-    end
-
-    private
-
-    def initialize
-      super
-      @filters = Fmt::FilterGroup.new.merge!(Fmt::StringFilterGroup.new)
-    end
-
-    def next_transformer(string)
-      embed_scanner = Fmt::EmbedScanner.new(string)
-      embed_scanner.scan
-
-      key_scanner = Fmt::KeyScanner.new(string)
-      key = key_scanner.scan
-      return nil unless key
-
-      filter_scanner = Fmt::FilterScanner.new(key_scanner.rest, registered_filters: filters)
-      filter_string = filter_scanner.scan
-
-      Fmt::Transformer.new key.to_sym,
-        embeds: embed_scanner.embeds,
-        filters: filter_scanner.filters,
-        placeholder: "%{#{key}}#{filter_string}".strip
-    end
-  end
-end

data/lib/fmt/scanners/base_scanner.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-require "strscan"
-
-module Fmt
-  class BaseScanner
-    extend Forwardable
-
-    def initialize(string)
-      @string_scanner = StringScanner.new(string)
-    end
-
-    def_delegators :string_scanner, :string, :rest
-    attr_reader :value
-
-    def performed?
-      !!@performed
-    end
-
-    def reset
-      @performed = false
-      string_scanner.reset
-    end
-
-    def scan
-      return if performed?
-      @performed = true
-      perform
-      value
-    end
-
-    protected
-
-    attr_reader :string_scanner
-
-    def perform
-      raise NotImplementedError
-    end
-  end
-end

data/lib/fmt/scanners/embed_scanner.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_scanner"
-require_relative "../embed"
-
-module Fmt
-  class EmbedScanner < BaseScanner
-    def initialize(string, root: nil)
-      super(string)
-      @root ||= root || self
-      @embeds = []
-    end
-
-    def embeds
-      root? ? @embeds : root.embeds
-    end
-
-    attr_reader :root
-
-    def root?
-      root == self
-    end
-
-    protected
-
-    def includes_embed?(string)
-      string.match?(/[{]{2}/)
-    end
-
-    def next_scanner(string)
-      Fmt::EmbedScanner.new string, root: root
-    end
-
-    def scan_embeds(string)
-      return unless includes_embed?(string)
-
-      string = string[string.index(/[{]{2}/) + 2..]
-      scanner = next_scanner(string)
-      while (embed = scanner.scan)
-        embeds << Fmt::Embed.new(embed)
-        scanner = next_scanner(scanner.rest)
-      end
-    end
-
-    def perform?
-      !string.start_with?("}")
-    end
-
-    def perform
-      return unless perform?
-      scan_embeds string # <------------------------------------ extract embeds
-      string_scanner.scan_until(/[{]{2}/) # <------------------- advance to start
-      @value = string_scanner.scan_until(/[^}]*(?=[}]{2})/) # <- extract value
-    end
-  end
-end

data/lib/fmt/scanners/filter_scanner.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_scanner"
-
-module Fmt
-  class FilterScanner < BaseScanner
-    DELIMITER = "|"
-
-    def initialize(string, registered_filters:)
-      @registered_filters = registered_filters
-      @filters = []
-      super(string)
-    end
-
-    alias_method :filter_string, :value
-    attr_reader :filters
-
-    protected
-
-    attr_reader :registered_filters
-
-    def perform
-      @value = string_scanner.scan(/[^\s%]+/) # <- extract value
-      return unless string_scanner.matched?
-
-      @filters = value.split(DELIMITER)&.map do |name|
-        registered_filters.fetch name.to_sym, Fmt::Filter.new(name, name)
-      end
-    end
-  end
-end

data/lib/fmt/scanners/key_scanner.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_scanner"
-
-module Fmt
-  class KeyScanner < BaseScanner
-    protected
-
-    def perform
-      string_scanner.skip_until(/%[{]/) # <------------------------------ advance to start
-      @value = string_scanner.scan(/\w+/) if string_scanner.matched? # <- extract value
-      string_scanner.scan(/[}]/) if string_scanner.matched? # <---------- advance to end
-    end
-  end
-end

data/lib/fmt/scanners.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-Dir[File.join(__dir__, "scanners", "*.rb")].each { |file| require file }

data/lib/fmt/transformer.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Fmt
-  class Transformer
-    def initialize(key, embeds:, filters:, placeholder:)
-      @key = key
-      @embeds = embeds
-      @filters = filters
-      @placeholder = placeholder
-    end
-
-    attr_reader :key, :embeds, :filters, :placeholder, :proc_filters, :string_filters
-
-    def transform(string, **locals)
-      string = transform_embeds(string, **locals)
-
-      raise Fmt::Error, "Missing key! :#{key} <string=#{string.inspect} locals=#{locals.inspect}>" unless locals.key?(key)
-
-      replacement = locals[key]
-
-      filters.each do |filter|
-        if filter.string?
-          begin
-            replacement = sprintf("%#{filter.value}", replacement)
-          rescue
-            raise Fmt::Error, <<~MSG
-              Invalid filter! #{filter.inspect}
-              Verify it has been properly registered. SEE: Fmt.add_filter(:#{filter.name}, &block)
-            MSG
-          end
-        elsif filter.proc?
-          begin
-            replacement = filter.value.call(replacement)
-          rescue => error
-            raise Fmt::Error, <<~MSG
-              Error in filter! #{filter.inspect}
-              #{error.message}
-            MSG
-          end
-        end
-      end
-
-      result = string.sub(placeholder, replacement)
-      defined?(Rainbow) ? Rainbow(result) : result
-    end
-
-    private
-
-    def transform_embeds(string, **locals)
-      while embeds.any?
-        embed = embeds.shift
-        string = string.sub(embed.placeholder, embed.format(**locals))
-      end
-      string
-    end
-  end
-end