palindrome.rb

class String
  def palindrome?
    lowercase_transform = LOWERCASE_TRANSFORM_FACTORY.builder.input(self).build
    whitespace_transform = WHITESPACE_TRANSFORM_FACTORY.builder.input(lowercase_transform.transform).build
    reverse_transform = REVERSE_TRANSFORM_FACTORY.builder.input(whitespace_transform.transform).build
    if whitespace_transform.transform == reverse_transform.transform
      true
    else
      false
    end
  end
end

class BuilderFactory
  def initialize(opts)
    @factory = opts.delete(:factory)
    @builder_clazz = opts.delete(:builder_clazz)
  end

  def builder
    @builder_clazz.send(:new, @factory)
  end
end

module Factory
  class Base
    class Builder
      def initialize(factory)
        @factory = factory
        @opts = {}
      end

      def build
        @factory.build(@opts)
      end

      def method_missing(name, value)
        @opts[name] = value
        self
      end
    end

    def initialize(opts = {})
      @builder_factory = BuilderFactory.new(opts.merge(factory: self))
    end

    def builder
      @builder_factory.builder
    end
  end
end

class Predicate
  def is?
    raise NotImplementedError
  end
end

class Transform
  def transform
    raise NotImplementedError
  end
end

class PalindromePredicateFactoryBuilder
  def initialize
    @opts = {}
  end

  def build
    PalindromePredicateFactory.new(@opts)
  end

  def method_missing(name, value)
    @opts[name] = value
    self
  end
end

class PalindromePredicateFactory < Factory::Base
  def initialize(opts = {})
    super(opts.merge(builder_clazz: Factory::Base::Builder))
  end

  def self.builder
    PalindromePredicateFactoryBuilder.new
  end

  def build(*args)
    PalindromePredicate.new(*args)
  end
end

class PalindromePredicate < Predicate
  def initialize(opts)
    @str = opts.delete(:input)
  end

  def is?
    @str.palindrome?
  end
end

class LowercaseTransformFactoryBuilder
  def initialize
    @opts = {}
  end

  def build
    LowercaseTransformFactory.new(@opts)
  end

  def method_missing(name, value)
    @opts[name] = value
    self
  end
end

class LowercaseTransformFactory < Factory::Base
  def initialize(opts = {})
    super(opts.merge(builder_clazz: Factory::Base::Builder))
  end

  def self.builder
    LowercaseTransformFactoryBuilder.new
  end

  def build(*args)
    LowercaseTransform.new(*args)
  end
end

class LowercaseTransform < Transform
  def initialize(opts)
    @str = opts.delete(:input)
  end

  def transform
    @str.downcase
  end
end

class WhitespaceTransformFactoryBuilder
  def initialize
    @opts = {}
  end

  def build
    WhitespaceTransformFactory.new(@opts)
  end

  def method_missing(name, value)
    @opts[name] = value
    self
  end
end

class WhitespaceTransformFactory < Factory::Base
  def initialize(opts = {})
    super(opts.merge(builder_clazz: Factory::Base::Builder))
  end

  def self.builder
    WhitespaceTransformFactoryBuilder.new
  end

  def build(*args)
    WhitespaceTransform.new(*args)
  end
end

class WhitespaceTransform < Transform
  def initialize(opts)
    @str = opts.delete(:input)
  end

  def transform
    @str.gsub(/ /, '')
  end
end

class ReverseTransformFactoryBuilder
  def initialize
    @opts = {}
  end

  def build
    ReverseTransformFactory.new(@opts)
  end

  def method_missing(name, value)
    @opts[name] = value
    self
  end
end

class ReverseTransformFactory < Factory::Base
  def initialize(opts = {})
    super(opts.merge(builder_clazz: Factory::Base::Builder))
  end

  def self.builder
    ReverseTransformFactoryBuilder.new
  end

  def build(*args)
    ReverseTransform.new(*args)
  end
end

class ReverseTransform < Transform
  def initialize(opts)
    @str = opts.delete(:input)
  end

  def transform
    @str.reverse
  end
end

PALINDROME_PREDICATE_FACTORY = PalindromePredicateFactory.builder.cache(10).build
LOWERCASE_TRANSFORM_FACTORY = LowercaseTransformFactory.builder.cache(42).build
WHITESPACE_TRANSFORM_FACTORY = WhitespaceTransformFactory.builder.cache(5).build
REVERSE_TRANSFORM_FACTORY = ReverseTransformFactory.builder.cache(78).build

def is_palindrome(str)
  palindrome_predicate = PALINDROME_PREDICATE_FACTORY.builder.input(str).build
  palindrome_predicate.is?
end

require 'rspec'
describe "on my machine" do
  it "should work" do
    [
      ["php", true],
      ["Murder for a jar of red rum", true],
      ["123321", true],
      ["Potato", false],
    ].each do |test, expected|
      expect(is_palindrome(test)).to eq(expected)
    end
  end
end