wardrobe 0.1.0

data/sandbox/bench_test_1.rb

@@ -0,0 +1,50 @@
+require 'pry'
+require 'pry-byebug'
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require_relative '../lib/wardrobe'
+require 'virtus'
+require 'benchmark/ips'
+
+# Test 1: Simple object
+# Simple class with one attribute where input does not need coercion.
+
+VanillaStruct = Struct.new(:name)
+
+class VanillaClass
+  attr_reader :name
+
+  def initialize(name:)
+    @name = name
+  end
+end
+
+class SimpleVirtus
+  include Virtus.model
+  attribute :name, String
+end
+
+class SimpleWardrobe
+  include Wardrobe
+  attribute :name, String
+end
+
+Benchmark.ips do |x|
+  x.report('Vanilla Struct') {
+    instance = VanillaStruct.new('Test')
+    instance.name == 'Test'
+  }
+  x.report('Vanilla Class') {
+    instance = VanillaClass.new(name: 'Test')
+    instance.name == 'Test'
+  }
+  x.report('Wardrobe Simple') {
+    instance = SimpleWardrobe.new(name: 'Test')
+    instance.name == 'Test'
+  }
+  x.report('Virtus Simple') {
+    instance = SimpleVirtus.new(name: 'Test')
+    instance.name == 'Test'
+  }
+  x.compare!
+end

data/sandbox/bench_test_2.rb

@@ -0,0 +1,48 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require_relative '../lib/wardrobe'
+require 'virtus'
+require 'benchmark/ips'
+require 'pry'
+require 'pry-byebug'
+
+# Test 2: Normal object
+# A user class where an integer and a float will need to be coerced from a string
+
+class UserVirtus
+  include Virtus.model
+  attribute :first_name, String
+  attribute :last_name,  String
+  attribute :age,        Integer
+  attribute :a_float,    Float
+end
+
+class UserWardrobe
+  include Wardrobe
+  attribute :first_name, String
+  attribute :last_name,  String
+  attribute :age,        Integer
+  attribute :a_float,    Float
+end
+
+test_2_hash = {
+  first_name: 'Test', last_name: 'Person', age: '1', a_float: '0.001'
+}
+
+Benchmark.ips do |x|
+  x.report('Wardrobe Normal') {
+    instance = UserWardrobe.new(test_2_hash)
+    instance.first_name == 'Test'
+    instance.last_name == 'Person'
+    instance.age == 1
+    instance.a_float == 0.001
+  }
+  x.report('Virtus Normal') {
+    instance = UserVirtus.new(test_2_hash)
+    instance.first_name == 'Test'
+    instance.last_name == 'Person'
+    instance.age == 1
+    instance.a_float == 0.001
+  }
+  x.compare!
+end

data/sandbox/bench_test_3.rb

@@ -0,0 +1,92 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require_relative '../lib/wardrobe'
+require 'virtus'
+require 'benchmark/ips'
+require 'pry'
+require 'pry-byebug'
+
+# Test 3: Advanced object
+# As in test 2 but with an address that needs to be coerced into a sub class.
+
+class AddressVirtus
+  include Virtus.model
+  attribute :street, String
+  attribute :zip_code, String
+end
+
+class UserAdvancedVirtus
+  include Virtus.model
+  attribute :first_name,           String
+  attribute :last_name,            String
+  attribute :age,                  Integer
+  attribute :a_float,              Float
+  attribute :with_default_literal, String, default: 'literal'
+  attribute :with_default_proc,    String, default: ->(_,_) {'proc'}
+  attribute :with_default_method,  String, default: :default_method
+  attribute :address,              AddressVirtus
+
+  def default_method
+    'method'
+  end
+end
+
+class AddressWardrobe
+  include Wardrobe
+  attribute :street, String
+  attribute :zip_code, String
+end
+
+class UserAdvancedWardrobe
+  include Wardrobe
+  plugin :default
+  attribute :first_name,           String
+  attribute :last_name,            String
+  attribute :age,                  Integer
+  attribute :a_float,              Float
+  attribute :with_default_literal, String, default: 'literal'
+  attribute :with_default_proc,    String, default: -> { 'proc' }
+  attribute :with_default_method,  String, default: :default_method
+  attribute :address,              AddressWardrobe
+
+  def default_method
+    'method'
+  end
+end
+
+test_3_hash = {
+  first_name: 'Test', last_name: 'Person', age: '1', a_float: '0.001',
+  address: {
+    street: 'Somewhere In Japan',
+    zip_code: 12345
+  }
+}
+
+
+Benchmark.ips do |x|
+  x.report('Wardrobe Advanced') {
+    instance = UserAdvancedWardrobe.new(test_3_hash)
+    instance.first_name == 'Test'
+    instance.last_name == 'Person'
+    instance.age == 1
+    instance.a_float == 0.001
+    instance.with_default_literal == 'literal'
+    instance.with_default_proc == 'proc'
+    instance.with_default_method == 'method'
+    instance.address.street == 'Somewhere In Japan'
+    instance.address.zip_code == 12345
+  }
+  x.report('Virtus Advanced') {
+    instance = UserAdvancedVirtus.new(test_3_hash)
+    instance.first_name == 'Test'
+    instance.last_name == 'Person'
+    instance.age == 1
+    instance.a_float == 0.001
+    instance.with_default_literal == 'literal'
+    instance.with_default_proc == 'proc'
+    instance.with_default_method == 'method'
+    instance.address.street == 'Somewhere In Japan'
+    instance.address.zip_code == 12345
+  }
+  x.compare!
+end

data/sandbox/cnn_article_find.rb

@@ -0,0 +1,20 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require_relative '../lib/wardrobe'
+require 'http'
+require 'pry'
+require 'pry-byebug'
+
+class Article
+  include Wardrobe
+  plugin :html_initializer
+  attribute :title, String, html_selector: ->(h) { h.at_xpath('//h1[@class="pg-headline"]').text }
+
+  def self.find(url)
+    new(HTTP.get(url).to_s)
+  end
+end
+
+
+article = Article.find('http://edition.cnn.com/2017/04/27/sport/yorkshire-cycling-revolution/index.html')
+binding.pry
+article.title

data/sandbox/define_method_procs.rb

@@ -0,0 +1,139 @@
+require 'pry'
+require 'pry-byebug'
+
+class Middleware
+  attr_reader :next_middleware
+  def initialize(next_middleware = nil)
+    @next_middleware = next_middleware
+    freeze
+  end
+
+  def call(input)
+    return input unless next_middleware
+    next_middleware.call(input)
+  end
+
+  def self.build(*arr)
+    arr.reverse!
+    arr.inject(arr.shift.new) do |previous, current|
+      current.new(previous)
+    end
+  end
+end
+
+class Split < Middleware
+  def call(value)
+    super(value.split(''))
+  end
+end
+
+class EachDowncase < Middleware
+  def call(value)
+    super(value.map(&:downcase))
+  end
+end
+
+class EachAddSpace < Middleware
+  def call(value)
+    super(value.map { |item| item + ' ' })
+  end
+end
+
+stack = Middleware.build(Split, EachDowncase, EachAddSpace)
+stack.call('abc')
+binding.pry
+
+# module Split
+#   def self.call(input, instance)
+#     result = input.split('')
+#     if block_given?
+#       yield result, instance
+#     else
+#       result
+#     end
+#   end
+# end
+#
+# module EachDowncase
+#   def self.call(input, instance)
+#     result = input.each(&:downcase)
+#     if block_given?
+#       yield result, instance
+#     else
+#       result
+#     end
+#   end
+# end
+
+array = [
+  Split,
+  EachDowncase
+]
+
+val = 'abcde'
+
+stack =
+
+
+# arr = [
+#   a_proc,
+#   a_proc,
+#   a_proc
+# ].each do
+#
+# loop do
+#   begin
+#     current = arr.next
+#     next_ = arr.peek
+#     binding.pry
+#
+#   rescue StopIteration => e
+#     binding.pry
+#   end
+# end
+
+# arr.inject(->(_,_){ input }).to_enum.each do |item|
+# end
+
+
+
+first_proc.call('', &another_proc)
+
+proc_enum = procs.to_enum
+
+proc_enum
+
+proc_enum.inject(nil) do |value, pr|
+
+  binding.pry
+end
+
+
+
+# procs.each do |proc|
+#   binding.pry
+# end
+#
+
+
+
+
+
+
+class SomeClass
+  proc2 = -> (one, two, &blk) {
+    one + two
+  }
+
+  define_method(:name, &proc2)
+
+  # end
+end
+
+ddd = SomeClass.new
+ddd
+
+binding.pry
+ddd
+
+1

data/sandbox/hanami_validations.rb

@@ -0,0 +1,40 @@
+require 'hanami'
+require 'pry'
+require 'pry-byebug'
+
+class Foo
+  include Hanami::Validations
+
+  validations do
+    required(:one) { size?(3) }
+    required(:two) { hash? { size?(2..4) } }
+    required(:three) { hash? { size?(2..4) { each { int? }} } }
+    required(:four) { hash? { min_size?(3) } }
+    required(:five) { hash? { max_size?(0) } }
+    required(:six) { str? }
+  end
+end
+
+class Bar
+  include Hanami::Validations
+
+  validations do
+    required(:one) { format?(/ccc/) | format?(/ddd/) }
+    # required(:two) { included_in?(['one']) }
+    # required(:three) { included_in?(['one', [1], Time.now]) }
+    # required(:four) { empty? }
+    # required(:five) { empty? }
+    # required(:six) { empty? }
+  end
+end
+
+result = Bar.new(
+  one: 'abb',
+  two: :'',
+  three: [],
+  four: {},
+  five: nil
+).validate
+
+
+binding.irb

data/sandbox/middleware_bench_test.rb

@@ -0,0 +1,97 @@
+require 'benchmark/ips'
+require 'pry'
+require 'pry-byebug'
+require 'ostruct'
+require 'middleware'
+
+procs = [
+  Proc.new { |val, instance| instance.name + val },
+  Proc.new { |val, instance| instance.name + val },
+  Proc.new { |val, instance| instance.name + val }
+]
+
+lambdas = [
+  lambda { |val, instance| instance.name + val },
+  lambda { |val, instance| instance.name + val },
+  lambda { |val, instance| instance.name + val }
+]
+
+modules = [
+  Module.new {
+    def self.call(val, instance)
+      instance.name + val
+    end
+  },
+  Module.new {
+    def self.call(val, instance)
+      instance.name + val
+    end
+  },
+  Module.new {
+    def self.call(val, instance)
+      instance.name + val
+    end
+  }
+]
+
+classes = [
+  Class.new {
+    def call(val, instance)
+      instance.name + val
+    end
+  },
+  Class.new {
+    def call(val, instance)
+      instance.name + val
+    end
+  },
+  Class.new {
+    def call(val, instance)
+      instance.name + val
+    end
+  }
+]
+
+mid = Middleware::Builder.new { |b|
+  b.use lambda { |data| data[:val] = data[:instance].name + data[:val]; data }
+  b.use lambda { |data| data[:val] = data[:instance].name + data[:val]; data }
+  b.use lambda { |data| data[:val] = data[:instance].name + data[:val]; data }
+}
+
+instance = OpenStruct.new(name: 'Yes! ')
+
+procs.inject('') do |val, item|
+  item.call(val, instance)
+end
+
+modules.inject('') do |val, item|
+  item.call(val, instance)
+end
+
+
+Benchmark.ips do |x|
+  x.report('Procs') {
+    procs.inject('') do |val, item|
+      item.call(val, instance)
+    end
+  }
+  x.report('Lambdas') {
+    lambdas.inject('') do |val, item|
+      item.call(val, instance)
+    end
+  }
+  x.report('Modules') {
+    modules.inject('') do |val, item|
+      item.call(val, instance)
+    end
+  }
+  x.report('Classes') {
+    classes.inject('') do |val, item|
+      item.new.call(val, instance)
+    end
+  }
+  x.report('Middleware Gem') {
+    mid.call({val: '', instance: instance})[:val]
+  }
+  x.compare!
+end

data/sandbox/middleware_bench_v2_test.rb

@@ -0,0 +1,130 @@
+require 'benchmark/ips'
+require 'pry'
+require 'pry-byebug'
+require 'ostruct'
+require 'middleware'
+
+### One - Custom middleware System
+
+class One
+  attr_reader :next_middleware
+  def initialize(next_middleware = nil)
+    @next_middleware = next_middleware
+    freeze
+  end
+
+  def call(input)
+    return input unless next_middleware
+    next_middleware.call(input)
+  end
+
+  def self.build(*arr)
+    arr.reverse!
+    arr.inject(arr.shift.new) do |previous, current|
+      current.new(previous)
+    end
+  end
+end
+
+class Split < One
+  def call(value)
+    super(value.split(''))
+  end
+end
+
+class EachDowncase < One
+  def call(value)
+    super(value.map(&:downcase))
+  end
+end
+
+class EachAddSpace < One
+  def call(value)
+    super(value.map { |item| item + ' ' })
+  end
+end
+
+one_stack = One.build(Split, EachDowncase, EachAddSpace)
+
+
+#### Two - CUSTOM MIDDLEWARE SYSTEM WITH DYNAMIC CALL
+
+module Some
+  def call(input)
+    return input unless next_middleware
+    next_middleware.call(input)
+  end
+end
+
+
+class Two
+  attr_reader :middlewares
+  def initialize(middlewares = arr)
+    @middlewares = middlewares
+    freeze
+  end
+
+  def call(input)
+    middlewares.inject(input) do |val, pro|
+      pro.call(val)
+    end
+  end
+
+  def self.build(*arr)
+    new(arr)
+  end
+end
+
+split_2 = ->(value) {
+  value.split('')
+}
+
+each_downcase_2 = ->(value) {
+  value.map(&:downcase)
+}
+
+each_add_space_2 = ->(value) {
+  value.map { |item| item + ' ' }
+}
+
+two_stack = Two.build(split_2, each_downcase_2, each_add_space_2)
+
+CORRECT = ['a ', 'b ', 'c ', 'd ', 'e ', 'f ']
+
+
+Benchmark.ips do |x|
+  x.report('One - Custom') {
+    result = one_stack.call('abcdef')
+    # raise "ERROR" unless result == CORRECT
+  }
+
+  x.report('Two - Array of procs with inject') {
+    result = two_stack.call('abcdef')
+    # raise "ERROR" unless result == CORRECT
+  }
+
+  # x.report('Procs') {
+  #   procs.inject('') do |val, item|
+  #     item.call(val, instance)
+  #   end
+  # }
+  # x.report('Lambdas') {
+  #   lambdas.inject('') do |val, item|
+  #     item.call(val, instance)
+  #   end
+  # }
+  # x.report('Modules') {
+  #   modules.inject('') do |val, item|
+  #     item.call(val, instance)
+  #   end
+  # }
+  # x.report('Classes') {
+  #   classes.inject('') do |val, item|
+  #     item.new.call(val, instance)
+  #   end
+  # }
+  # x.report('Middleware Gem') {
+  #   mid.call({val: '', instance: instance})[:val]
+  # }
+  x.compare!
+end

data/test/assertions.rb

@@ -0,0 +1,22 @@
+module Minitest::Assertions
+  def assert_instance_method_call_count(count, klass, method, &blk)
+    actual_count = instance_method_call_count(count, klass, method, &blk)
+    assert actual_count == count,
+      "Expected #{count} calls to method #{method} on klass #{klass} but registered #{actual_count}"
+  end
+
+  private
+
+  def instance_method_call_count(count, klass, method)
+    registered_counts = 0
+    klass.class_exec do
+      alias_method "old_#{method}", method
+      define_method(method) do |*args|
+        registered_counts += 1
+        send("old_#{method}", *args)
+      end
+    end
+    yield
+    registered_counts
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,37 @@
+require 'simplecov'
+SimpleCov.start do
+  # TODO: Figure out a way to include these files in the report. Fork is used.
+  add_filter 'test/unit/plugins/json_initializer_test.rb'
+  add_filter 'lib/wardrobe/plugins/json_initializer.rb'
+end
+
+require 'pry'
+require 'pry-byebug'
+
+require 'minitest/autorun'
+require 'assertions'
+require 'wardrobe'
+
+
+LOG_MESSAGES = []
+
+class TestBase < Minitest::Test
+  def log_messages
+    LOG_MESSAGES
+  end
+
+  def teardown
+    LOG_MESSAGES.clear
+  end
+end
+
+class TestLogger < Logger
+  def format_message(severity, datetime, progname, msg)
+    LOG_MESSAGES << [severity, datetime, progname, msg]
+    super
+  end
+end
+
+Wardrobe.configure do |c|
+  c.logger = TestLogger.new(File.open(File::NULL, "w"))
+end

data/test/unit/atrs_config_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class WardrobeConfigTest < TestBase
+  CUSTOM_ATRS_MODULE = Wardrobe()
+  CUSTOM_ATRS_MODULE.configure do |config|
+    config.register_default_plugin :default
+  end
+
+  class Person
+    include CUSTOM_ATRS_MODULE
+    attribute :name, String, default: 'Example Person'
+  end
+
+  def test_plugin_registered_in_module
+    assert CUSTOM_ATRS_MODULE.config.default_plugins.include?(:default)
+  end
+
+  def test_plugin_added_to_class
+    assert Person.plugin_store[:default]
+    assert Person.option_store[:default]
+  end
+
+  def test_correct_plugin_and_option_count
+    assert_equal 2, Person.option_store.store.count
+    assert_equal 2, Person.plugin_store.store.count
+  end
+
+  def test_one
+    assert_equal 'Example Person', Person.new.name
+  end
+end