simple_rewriter 0.0.2

data/lib/simple_rewriter/class_resolver.rb

@@ -0,0 +1,68 @@
+module SimpleRewriter
+  class ClassResolver < BaseService
+    NotSupportedAttribute = Class.new(StandardError)
+
+    def initialize(value, guess, options = nil)
+      @value = value
+      @guess = guess
+      @attr_klass = value.class
+      @options = options
+    end
+
+    def call
+      desired_class
+    end
+
+    private
+
+    attr_reader :attr_klass, :options, :klass, :guess
+
+    def desired_class
+      return klass if detect_type? && try_class(detect_type)
+      return klass if default? && try_class(default_class)
+      return klass if try_class(attr_klass)
+      return SimpleRewriter::Readers::ActiveRecordReader if active_record?
+
+      raise_unsupported_error
+    end
+
+    def raise_unsupported_error
+      raise NotSupportedAttribute, "Attribute '#{attr_klass}' is not supported (#{string_to_constantize(attr_klass)})"
+    end
+
+    def try_class(scoped_klass)
+      return false unless result = safe_constantize(string_to_constantize(scoped_klass))
+      @klass = result
+    end
+
+    def string_to_constantize(scoped_klass)
+      guess % { klass: scoped_klass }
+    end
+
+    def default_class
+      options[:default].class
+    end
+
+    def default?
+      options && options[:default]
+    end
+
+    def detect_type?
+      options && options[:detect_type]
+    end
+
+    def detect_type
+      SimpleRewriter::TypeDetector.call(value)
+    end
+
+    def safe_constantize(target)
+      Object.const_get(target)
+    rescue StandardError
+      false
+    end
+
+    def active_record?
+      attr_klass.is_a?(ActiveRecord::Base) if defined?(ActiveRecord::Base)
+    end
+  end
+end

data/lib/simple_rewriter/configuration.rb

@@ -0,0 +1,15 @@
+class SimpleRewriter::Configuration
+  attr_accessor :save, :integer_range, :hash_key_length, :hash_value_length, :rand_num_max, :address,
+                :reader, :writer, :sample_pdf_url
+
+  def initialize
+    @reader = SimpleRewriter::Reader
+    @writer = SimpleRewriter::Writer
+    @save = false
+    @integer_range = 0..10
+    @hash_key_length = 5
+    @rand_num_max = 10
+    @address = nil
+    @sample_pdf_url = "http://www.africau.edu/images/default/sample.pdf"
+  end
+end

data/lib/simple_rewriter/reader.rb

@@ -0,0 +1,48 @@
+class SimpleRewriter::Reader
+  INDEX_OF_ATTRIBUTE_NAME = 0
+
+  def self.call(record, attributes)
+    new(record, attributes).call { |data| yield(data) }
+  end
+
+  def initialize(record, attributes)
+    @record = record
+    @attributes = attributes
+  end
+
+  def call
+    attributes.each do |attribute_with_options|
+      @attribute_with_options = attribute_with_options
+
+      yield [attribute, attr_value, options]
+    end
+  end
+
+  private
+
+  attr_reader :record, :attributes, :attribute_with_options
+
+  def attr_value
+    reader.call(attribute)
+  end
+
+  def reader
+    @_reader ||= reader_class.new(record: record)
+  end
+
+  def attribute
+    attributes_resolver.call(attribute: attribute_with_options).attribute
+  end
+
+  def options
+    attributes_resolver.call(attribute: attribute_with_options).options
+  end
+
+  def attributes_resolver
+    SimpleRewriter::AttributeResolver
+  end
+
+  def reader_class
+    SimpleRewriter::ClassResolver.call(record, "SimpleRewriter::Readers::%{klass}Reader")
+  end
+end

data/lib/simple_rewriter/readers/active_record_reader.rb

@@ -0,0 +1,11 @@
+module SimpleRewriter
+  module Readers
+    class ActiveRecordReader < BaseReader
+      private
+
+      def read_attribute(attribute)
+        record.send(attribute)
+      end
+    end
+  end
+end

data/lib/simple_rewriter/readers/base_reader.rb

@@ -0,0 +1,21 @@
+module SimpleRewriter
+  module Readers
+    class BaseReader
+      def initialize(record:)
+        @record = record
+      end
+
+      def call(attribute)
+        read_attribute(attribute)
+      end
+
+      private
+
+      attr_reader :record
+
+      def read_attribute(_attribute)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/simple_rewriter/readers/hash_reader.rb

@@ -0,0 +1,11 @@
+module SimpleRewriter
+  module Readers
+    class HashReader < BaseReader
+      private
+
+      def read_attribute(attribute)
+        record[attribute.to_s]
+      end
+    end
+  end
+end

data/lib/simple_rewriter/readers/open_struct_reader.rb

@@ -0,0 +1,6 @@
+module SimpleRewriter
+  module Readers
+    class OpenStructReader < ActiveRecordReader
+    end
+  end
+end

data/lib/simple_rewriter/readers.rb

@@ -0,0 +1,6 @@
+module SimpleRewriter::Readers
+  autoload :BaseReader, "simple_rewriter/readers/base_reader"
+  autoload :ActiveRecordReader, "simple_rewriter/readers/active_record_reader"
+  autoload :HashReader, "simple_rewriter/readers/hash_reader"
+  autoload :OpenStructReader, "simple_rewriter/readers/open_struct_reader"
+end

data/lib/simple_rewriter/rewriter.rb

@@ -0,0 +1,57 @@
+require "ostruct"
+
+module SimpleRewriter
+  class Rewriter < BaseService
+    def initialize(record:, attributes: [])
+      @record = record
+      @attributes = attributes
+    end
+
+    def call
+      rewrite_attributes
+      finalize
+    end
+
+    private
+
+    attr_reader :record, :attributes
+
+    def rewrite_attributes
+      configuration.reader.call(record, attributes) do |attribute, attr_value, options|
+        rewrite(attribute, attr_value, options)
+      rescue SimpleRewriter::ClassResolver::NotSupportedAttribute
+        next
+      end
+    end
+
+    def rewrite(attribute, attr_value, options = nil)
+      new_attr_value = new_value_for(attr_value, options)
+      configuration.writer.call(record, attribute, new_attr_value)
+    end
+
+    def new_value_for(value, options)
+      SimpleRewriter::Attribute.new(value, options).generate
+    end
+
+    def finalize
+      OpenStruct.new(
+        success?: success?,
+        record:   record
+      )
+    end
+
+    def success?
+      return true unless saveable?
+      record.save
+    end
+
+    def saveable?
+      return false if record.is_a?(Hash)
+      configuration.save
+    end
+
+    def configuration
+      SimpleRewriter.configuration
+    end
+  end
+end

data/lib/simple_rewriter/rewriters/active_support/time_with_zone_rewriter.rb

@@ -0,0 +1,2 @@
+class SimpleRewriter::Rewriters::ActiveSupport::TimeWithZoneRewriter < SimpleRewriter::Rewriters::DateRewriter
+end

data/lib/simple_rewriter/rewriters/active_support.rb

@@ -0,0 +1,3 @@
+module SimpleRewriter::Rewriters::ActiveSupport
+  autoload :TimeWithZoneRewriter, "simple_rewriter/rewriters/active_support/time_with_zone_rewriter.rb"
+end

data/lib/simple_rewriter/rewriters/array_rewriter.rb

@@ -0,0 +1,18 @@
+class SimpleRewriter::Rewriters::ArrayRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    random_sized_array
+  end
+
+  private
+
+  def array
+    @_array ||= []
+  end
+
+  def random_sized_array
+    rand_num.times do
+      array << string_generator.generate
+    end
+    array
+  end
+end

data/lib/simple_rewriter/rewriters/base.rb

@@ -0,0 +1,42 @@
+require "faker"
+
+class SimpleRewriter::Rewriters::Base
+  include SimpleRewriter::Rewriters::Generators
+  include SimpleRewriter::Rewriters::OptionsResolver
+
+  REGISTERED_OPTIONS = %i(email address hex name first_name last_name phonenumber zip street city date
+                          sample_pdf deep).freeze
+
+  def initialize(attr_value, options)
+    @attr_value = attr_value
+    @_options = options
+  end
+
+  def generate
+    collect_values_from_options
+  end
+
+  private
+
+  attr_reader :attr_value
+
+  def scoped_options
+    REGISTERED_OPTIONS
+  end
+
+  def passed_options
+    options.keys.flatten
+  end
+
+  REGISTERED_OPTIONS.each do |method_name|
+    define_method("#{method_name}?") { options.include?(method_name) }
+  end
+
+  def configuration
+    SimpleRewriter.configuration
+  end
+
+  def options
+    @_options ||= []
+  end
+end

data/lib/simple_rewriter/rewriters/date_rewriter.rb

@@ -0,0 +1,11 @@
+class SimpleRewriter::Rewriters::DateRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    random_date
+  end
+
+  private
+
+  def random_date
+    Time.at(rand * Time.now.to_i)
+  end
+end

data/lib/simple_rewriter/rewriters/float_rewriter.rb

@@ -0,0 +1,14 @@
+class SimpleRewriter::Rewriters::FloatRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    random_float
+  end
+
+  private
+
+  # rand generates pseudo random from 0-1
+  # rand(10) generates pseudo random from 0-10
+  # we use it to get something like 4.41445946155691
+  def random_float
+    rand * rand(10)
+  end
+end

data/lib/simple_rewriter/rewriters/generators.rb

@@ -0,0 +1,69 @@
+module SimpleRewriter::Rewriters::Generators
+  def random_sample_pdf
+    configuration.sample_pdf_url
+  end
+
+  def random_address
+    configuration.address || default_address
+  end
+
+  def default_address
+    {
+      street: random_street,
+      city:   random_city,
+      zip:    random_zip
+    }
+  end
+
+  def random_name
+    Faker::Name.name
+  end
+
+  def random_email
+    "#{random_hex(5)}-#{Faker::Internet.email}"
+  end
+
+  def random_first_name
+    Faker::Name.first_name
+  end
+
+  def random_last_name
+    Faker::Name.last_name
+  end
+
+  def random_phonenumber
+    Faker::PhoneNumber.phone_number
+  end
+
+  def random_hex(hex_length = nil)
+    SecureRandom.hex(hex_length)
+  end
+
+  def random_zip
+    Faker::Address.zip
+  end
+
+  def random_city
+    Faker::Address.city
+  end
+
+  def random_street
+    Faker::Address.street_address
+  end
+
+  def random_date
+    date_generator.generate
+  end
+
+  def rand_num
+    SecureRandom.random_number(configuration.rand_num_max)
+  end
+
+  def string_generator
+    @_string_generator ||= SimpleRewriter::Rewriters::StringRewriter.new(attr_value, options)
+  end
+
+  def date_generator
+    @_date_generator ||= SimpleRewriter::Rewriters::DateRewriter.new(attr_value, options)
+  end
+end

data/lib/simple_rewriter/rewriters/hash_rewriter.rb

@@ -0,0 +1,36 @@
+class SimpleRewriter::Rewriters::HashRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    return super if any_option_passed?
+    random_sized_hash
+  end
+
+  private
+
+  def scoped_options
+    %i(address deep)
+  end
+
+  def random_sized_hash
+    {}.tap do |hash|
+      rand_num.times do |_i|
+        hash[hash_key] = hash_value
+      end
+    end
+  end
+
+  def hash_key
+    random_hex(configuration.hash_key_length)
+  end
+
+  def hash_value
+    string_generator.generate
+  end
+
+  def resolve_options_with(values)
+    values[0]
+  end
+
+  def random_deep
+    SimpleRewriter.call(record: attr_value, attributes: options[:deep_attributes_map]).record
+  end
+end

data/lib/simple_rewriter/rewriters/integer_rewriter.rb

@@ -0,0 +1,7 @@
+require "securerandom"
+
+class SimpleRewriter::Rewriters::IntegerRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    SecureRandom.random_number(configuration.integer_range)
+  end
+end

data/lib/simple_rewriter/rewriters/options_resolver.rb

@@ -0,0 +1,21 @@
+module SimpleRewriter::Rewriters::OptionsResolver
+  def any_option_passed?
+    scoped_options.any? { |option| send(:"#{option}?") }
+  end
+
+  def collect_values_from_options
+    values = filtered_options.each_with_object([]) do |option, arr|
+      arr << send("random_#{option}") if send(:"#{option}?")
+    end
+
+    resolve_options_with(values)
+  end
+
+  def filtered_options
+    passed_options.select { |option| scoped_options.include?(option) }
+  end
+
+  def resolve_options_with(values)
+    values.join(" ")
+  end
+end

data/lib/simple_rewriter/rewriters/string_rewriter.rb

@@ -0,0 +1,18 @@
+require "faker"
+
+class SimpleRewriter::Rewriters::StringRewriter < SimpleRewriter::Rewriters::Base
+  def generate
+    return super if any_option_passed?
+    random_text
+  end
+
+  private
+
+  def scoped_options
+    REGISTERED_OPTIONS - [:deep]
+  end
+
+  def random_text
+    "#{random_hex(5)}-#{Faker::Quote.famous_last_words}"
+  end
+end

data/lib/simple_rewriter/rewriters.rb

@@ -0,0 +1,12 @@
+module SimpleRewriter::Rewriters
+  autoload :Base, "simple_rewriter/rewriters/base"
+  autoload :ArrayRewriter, "simple_rewriter/rewriters/array_rewriter"
+  autoload :DateRewriter, "simple_rewriter/rewriters/date_rewriter"
+  autoload :FloatRewriter, "simple_rewriter/rewriters/float_rewriter"
+  autoload :HashRewriter, "simple_rewriter/rewriters/hash_rewriter"
+  autoload :IntegerRewriter, "simple_rewriter/rewriters/integer_rewriter"
+  autoload :StringRewriter, "simple_rewriter/rewriters/string_rewriter"
+  autoload :ActiveSupport, "simple_rewriter/rewriters/active_support"
+  autoload :Generators, "simple_rewriter/rewriters/generators"
+  autoload :OptionsResolver, "simple_rewriter/rewriters/options_resolver"
+end

data/lib/simple_rewriter/type_detector.rb

@@ -0,0 +1,41 @@
+module SimpleRewriter
+  class TypeDetector < BaseService
+    def initialize(attr_value)
+      @attr_value = attr_value
+    end
+
+    def call
+      detect_type
+    end
+
+    private
+
+    attr_reader :attr_value
+
+    def detect_type
+      return Integer if integer?
+      return Date if date?
+      return Float if float?
+    end
+
+    def integer?
+      return attr_value.match?(/\A[-+]?[0-9]+\z/) if attr_value.respond_to?(:match?)
+      false
+    end
+
+    def date?
+      Date.parse(attr_value) if string?
+    rescue ArgumentError
+      false
+    end
+
+    def float?
+      return attr_value.match?(/[0-9]+[.]{1}[0-9]+/) if attr_value.respond_to?(:match?)
+      false
+    end
+
+    def string?
+      attr_value.is_a?(String)
+    end
+  end
+end

data/lib/simple_rewriter/version.rb

@@ -0,0 +1,3 @@
+module SimpleRewriter
+  VERSION = "0.0.2".freeze
+end

data/lib/simple_rewriter/writer.rb

@@ -0,0 +1,30 @@
+module SimpleRewriter
+  class Writer < BaseService
+    def initialize(record, attribute, new_attr_value)
+      @record = record
+      @attribute = attribute
+      @new_attr_value = new_attr_value
+    end
+
+    def call
+      write_attribute
+    end
+
+    private
+
+    attr_reader :record, :attribute, :new_attr_value
+
+    def write_attribute
+      return write_hash_attribute if record.is_a?(Hash)
+      write_by_method
+    end
+
+    def write_hash_attribute
+      record[attribute.to_s] = new_attr_value
+    end
+
+    def write_by_method
+      record.send("#{attribute}=", new_attr_value)
+    end
+  end
+end

data/lib/simple_rewriter.rb

@@ -0,0 +1,31 @@
+require "simple_rewriter/version"
+
+module SimpleRewriter
+  autoload :Rewriter, "simple_rewriter/rewriter"
+  autoload :Rewriters, "simple_rewriter/rewriters"
+
+  autoload :Reader,  "simple_rewriter/reader"
+  autoload :Readers, "simple_rewriter/readers"
+  autoload :Attribute, "simple_rewriter/attribute"
+  autoload :Writer, "simple_rewriter/writer"
+
+  autoload :Configuration, "simple_rewriter/configuration"
+  autoload :TypeDetector, "simple_rewriter/type_detector"
+  autoload :ClassResolver, "simple_rewriter/class_resolver"
+  autoload :AttributeResolver, "simple_rewriter/attribute_resolver"
+  autoload :BaseService, "simple_rewriter/base_service"
+
+  class << self
+    def call(record:, attributes:)
+      SimpleRewriter::Rewriter.call(record: record, attributes: attributes)
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @_configuration ||= SimpleRewriter::Configuration.new
+    end
+  end
+end

data/simple_rewriter.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path("lib/simple_rewriter/version", __dir__)
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Adam Grzybowski", "Piotr Misiurek", "Michał Szymański"]
+  gem.email = ["adam@ragnarson.com", "piotr@ragnarson.com", "michal.t.szymanski@gmail.com"]
+  gem.description = "Simple rewriter for rails based apps"
+  gem.summary = "Simple rewriter for rails based apps"
+  gem.license = "MIT"
+  gem.homepage = "https://github.com/Verivox/simple_rewriter"
+
+  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "simple_rewriter"
+  gem.require_paths = ["lib"]
+  gem.version       = SimpleRewriter::VERSION
+
+  gem.add_runtime_dependency("faker", "~> 1.9.3")
+
+  gem.add_development_dependency("pry", "~> 0.12.2")
+  gem.add_development_dependency("ragnarson-stylecheck", "~> 0.7.0")
+  gem.add_development_dependency("rake", "~> 12.3.2")
+  gem.add_development_dependency("rspec", "~> 3.8.0")
+end

data/spec/simple_rewriter/attribute_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe SimpleRewriter::Attribute do
+  subject { described_class.new(value, options).generate }
+
+  context "when value is unsupported" do
+    let(:value) { nil }
+    let(:options) { nil }
+
+    it "raises error" do
+      expect do
+        subject
+      end.to raise_error(SimpleRewriter::ClassResolver::NotSupportedAttribute)
+    end
+  end
+end