sinclair 1.14.2 → 1.15.0

data/lib/sinclair.rb

@@ -12,13 +12,13 @@ require 'active_support/core_ext'
 #   class MyModel
 #   end
 #
-#   buider = Sinclair.new(MyModel)
-#
 #   value = 10
-#   builder.add_method(:default_value) { value }
-#   builder.add_method(:value, '@value || default_value')
-#   builder.add_method(:value=) { |val| @value = val }
-#   builder.build
+#
+#   Sinclair.build(MyModel) do
+#     add_method(:default_value) { value }
+#     add_method(:value, '@value || default_value')
+#     add_method(:value=) { |val| @value = val }
+#   end
 #
 #   instance = MyModel.new
 #   instance.value # returns 10
@@ -83,6 +83,7 @@ class Sinclair
   require 'sinclair/options_parser'
 
   autoload :VERSION,           'sinclair/version'
+  autoload :Caster,            'sinclair/caster'
   autoload :ClassMethods,      'sinclair/class_methods'
   autoload :Config,            'sinclair/config'
   autoload :ConfigBuilder,     'sinclair/config_builder'
@@ -104,6 +105,8 @@ class Sinclair
   extend ClassMethods
 
   # @method self.build(klass, options = {}, &block)
+  # @api public
+  #
   # Runs build using a block for adding the methods
   #
   # The block is executed adding the methods and after the builder
@@ -135,7 +138,6 @@ class Sinclair
   #   builder = Sinclair.new(Purchase)
   #
   # @example Passing building options (Used on subclasses)
-  #
   #   class MyBuilder < Sinclair
   #     def add_methods
   #       if options_object.rescue_error
@@ -159,10 +161,9 @@ class Sinclair
   #   class MyModel
   #   end
   #
-  #   builder = MyBuilder.new(MyModel, rescue_error: true)
-  #
-  #   builder.add_method
-  #   builder.build
+  #   MyBuilder.build(MyModel, rescue_error: true) do
+  #     add_method
+  #   end
   #
   #   instance = MyModel.new
   #
@@ -216,9 +217,9 @@ class Sinclair
   #       end
   #     end
   #
-  #     builder = Sinclair.new(Person)
-  #     builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-  #     builder.build
+  #     Sinclair.build(Person) do
+  #       add_method(:full_name, '[first_name, last_name].join(" ")')
+  #     end
   #
   #     Person.new('john', 'wick').full_name # returns 'john wick'
   #
@@ -240,9 +241,9 @@ class Sinclair
   #       end
   #     end
   #
-  #     builder = Sinclair.new(Person)
-  #     builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
-  #     builder.build
+  #     Sinclair.build(Person) do
+  #       add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+  #     end
   #
   #     Person.new('john', 'wick').bond_name # returns 'wick, john wick'
   #
@@ -267,11 +268,11 @@ class Sinclair
   #       end
   #     end
   #
-  #     builder = Sinclair.new(Person)
-  #     builder.add_method(:bond_name, type: :block, cached: true) do
-  #       "{last_name}, #{first_name} #{last_name}"
+  #     Sinclair.build(Person) do
+  #       add_method(:bond_name, type: :block, cached: true) do
+  #         "{last_name}, #{first_name} #{last_name}"
+  #       end
   #     end
-  #     builder.build
   #
   #     person.Person.new('john', 'wick')
   #

data/spec/integration/readme/sinclair/types_of_definition_spec.rb

@@ -9,9 +9,9 @@ describe Sinclair do
         klass = Class.new
         instance = klass.new
 
-        builder = described_class.new(klass)
-        builder.add_method(:random_number) { Random.rand(10..20) }
-        builder.build
+        Sinclair.build(klass) do
+          add_method(:random_number) { Random.rand(10..20) }
+        end
 
         expect(instance.random_number).to be_between(10, 20)
       end
@@ -34,11 +34,11 @@ describe Sinclair do
       it 'adds the method' do
         klass = Class.new
 
-        builder = described_class.new(klass)
-        builder.add_class_method(
-          :function, 'a ** b + c', parameters: [:a], named_parameters: [:b, { c: 15 }]
-        )
-        builder.build
+        Sinclair.build(klass) do
+          add_class_method(
+            :function, 'a ** b + c', parameters: [:a], named_parameters: [:b, { c: 15 }]
+          )
+        end
 
         expect(klass.function(10, b: 2)).to eq(115)
       end

data/spec/integration/yard/my_builder_spec.rb

@@ -4,23 +4,17 @@ require 'spec_helper'
 
 describe MyBuilder do
   describe '#yard' do
-    subject(:builder) do
-      described_class.new(klass, rescue_error: true)
-    end
+    let(:klass) { Class.new }
 
-    let(:klass)    { Class.new }
-    let(:instance) { klass.new }
+    describe 'Passing building options (Used on subclasses)' do
+      it 'builds the methods' do
+        MyBuilder.build(klass, rescue_error: true) do
+          add_methods
+        end
 
-    describe '#build' do
-      before do
-        builder.add_methods
-        builder.build
-      end
+        instance = klass.new
 
-      context 'when calling built method' do
-        it 'returns default value' do
-          expect(instance.symbolize).to eq(:default)
-        end
+        expect(instance.symbolize).to eq(:default)
       end
     end
   end

data/spec/integration/yard/sinclair/add_method_spec.rb

@@ -7,9 +7,9 @@ describe 'yard Sinclair#add_method' do
     let(:klass) { Class.new(Person) }
 
     it 'creates new method' do
-      builder = Sinclair.new(klass)
-      builder.add_method(:full_name, '[first_name, last_name].join(" ")')
-      builder.build
+      Sinclair.build(klass) do
+        add_method(:full_name, '[first_name, last_name].join(" ")')
+      end
 
       expect(klass.new('john', 'wick').full_name).to eq('john wick')
     end
@@ -19,9 +19,9 @@ describe 'yard Sinclair#add_method' do
     let(:klass) { Class.new(Person) }
 
     it 'creates new method' do
-      builder = Sinclair.new(klass)
-      builder.add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
-      builder.build
+      Sinclair.build(klass) do
+        add_method(:bond_name) { "#{last_name}, #{first_name} #{last_name}" }
+      end
 
       expect(klass.new('john', 'wick').bond_name).to eq('wick, john wick')
     end
@@ -31,11 +31,12 @@ describe 'yard Sinclair#add_method' do
     let(:klass) { Class.new(Person) }
 
     it 'creates new method' do
-      builder = Sinclair.new(klass)
-      builder.add_method(:bond_name, type: :block, cached: true) do
-        "#{last_name}, #{first_name} #{last_name}"
+      Sinclair.build(klass) do
+        add_method(:bond_name, type: :block, cached: true) do
+          "#{last_name}, #{first_name} #{last_name}"
+        end
       end
-      builder.build
+
       person = klass.new('john', 'wick')
 
       expect(person.bond_name).to eq('wick, john wick')

data/spec/integration/yard/sinclair/caster/cast_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair::Caster' do
+  describe '.cast' do
+    it 'Casts with a symbol key' do
+      initial = Random.rand(10..20)
+      log = MathCaster.cast(initial, :log)
+      exp = MathCaster.cast(log, :exp)
+
+      expect(exp).to be_between(initial - 0.0001, initial + 0.0001)
+    end
+
+    it 'Casts passing parameter' do
+      base = Random.rand(3..6)
+      initial = Random.rand(10..20)
+      log = MathCaster.cast(initial, :log, base: base)
+      exp = MathCaster.cast(log, :exp, base: base)
+
+      expect(exp).to be_between(initial - 0.0001, initial + 0.0001)
+    end
+
+    it 'Casts with class key' do
+      hash = { a: 1, b: 2, 'c' => nil }
+      string = 'my string'
+      symbol = :the_symbol
+      number = 10
+      null = nil
+
+      code = <<-RUBY
+        hash_value = #{RubyStringCaster.to_ruby_string(hash)}
+        string_value = #{RubyStringCaster.to_ruby_string(string)}
+        symbol_value = #{RubyStringCaster.to_ruby_string(symbol)}
+        number = #{RubyStringCaster.to_ruby_string(number)}
+        null_value = #{RubyStringCaster.to_ruby_string(null)}
+      RUBY
+
+      expect(code).to eq(<<-RUBY)
+        hash_value = {:a=>1, :b=>2, "c"=>nil}
+        string_value = "my string"
+        symbol_value = :the_symbol
+        number = 10
+        null_value = nil
+      RUBY
+    end
+  end
+
+  describe '#cast' do
+    it 'Casts from a selected caster' do
+      caster = MathCaster.caster_for(:log)
+
+      expect(caster.cast(100)).to eq(2)
+      expect(caster.cast(8, base: 2)).to eq(3)
+    end
+  end
+end

data/spec/integration/yard/sinclair/caster/cast_with_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair::Caster.cast_with' do
+  let(:my_caster) { Class.new(Sinclair::Caster) }
+
+  it 'Casting from pre registered symbol caster' do
+    my_caster.cast_with(:json, :to_json)
+
+    expect(my_caster.cast({ key: :value }, :json)).to eq('{"key":"value"}')
+  end
+
+  it 'Casting from pre registered block caster' do
+    my_caster.cast_with(:complex) do |hash|
+      real = hash[:real]
+      imaginary = hash[:imaginary]
+
+      "#{real.to_f} + #{imaginary.to_f} i"
+    end
+
+    value = { real: 10, imaginary: 5 }
+
+    expect(my_caster.cast(value, :complex)).to eq('10.0 + 5.0 i')
+  end
+
+  it 'Casting from pre registered class' do
+    my_caster.cast_with(Numeric, :to_i)
+
+    expect(my_caster.cast('10', Integer)).to eq(10)
+  end
+
+  it 'Casting from pre registered block caster from a class' do
+    my_caster.cast_with(HashModel) do |value, klass:|
+      klass.new(value)
+    end
+
+    my_caster.cast_with(String, &:to_json)
+
+    values = [
+      { klass: String, value: { name: 'john', age: 20, country: 'BR' } },
+      { klass: HashPerson, value: { name: 'Mary', age: 22, country: 'IT' } }
+    ]
+
+    values.map! do |config|
+      value = config[:value]
+      klass = config[:klass]
+      my_caster.cast(value, klass, klass: klass)
+    end
+
+    expect(values[0]).to eq('{"name":"john","age":20,"country":"BR"}')
+    expect(values[1]).to eq(HashPerson.new(name: 'Mary', age: 22))
+  end
+end

data/spec/integration/yard/sinclair/caster/caster_for_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair::Caster.cast' do
+  it 'Getting the caster with symbol key' do
+    expect(EnumConverter.to_array({ key: :value })).to eq([%i[key value]])
+    expect(EnumConverter.to_hash([%i[key value]])).to eq({ key: :value })
+  end
+
+  it 'Getting the caster with class key' do
+    expect(StringParser.cast('{"key":"value"}', JSON)).to eq({ 'key' => 'value' })
+    expect(StringParser.cast('10.2', Integer)).to eq(10)
+    expect(StringParser.cast('10.2', Float)).to eq(10.2)
+  end
+end

data/spec/integration/yard/sinclair/caster/class_methods_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: false
+
+require 'spec_helper'
+
+describe 'yard Sinclair::Caster::ClassMethods' do
+  let(:my_caster) { Class.new(Sinclair::Caster) }
+
+  describe '.master_caster!' do
+    it 'Making a class to be a master caster' do
+      expect(my_caster.cast(10, :string)).to eq('10')
+
+      my_caster.master_caster!
+
+      expect(my_caster.cast(10, :string)).to eq(10)
+    end
+  end
+end

data/spec/integration/yard/sinclair/config_builder_spec.rb

@@ -5,16 +5,14 @@ require 'spec_helper'
 describe Sinclair::ConfigBuilder do
   describe 'yard' do
     describe '#instance_eval' do
-      subject(:builder) do
-        described_class.new(config, :name)
-      end
+      it 'sets variable from config' do
+        config =  MyConfig.new
 
-      let(:config) { MyConfig.new }
+        builder = described_class.new(config, :name)
 
-      it 'sets variable from config' do
-        expect { builder.instance_eval { |c| c.name 'John' } }
-          .to change(config, :name)
-          .from(nil).to('John')
+        builder.instance_eval { |c| c.name 'John' }
+
+        expect(config.name).to eq('John')
       end
     end
   end

data/spec/integration/yard/sinclair/config_class_spec.rb

@@ -5,33 +5,19 @@ require 'spec_helper'
 describe Sinclair::ConfigClass do
   describe 'yard' do
     describe '.add_configs' do
-      subject(:config) { AppConfig.new }
+      it 'Adding configurations to config class' do
+        config = AppConfig.new
 
-      it 'has a secret configuration method' do
         expect(config.secret).to be_nil
-      end
-
-      it 'has a app_name configuration method' do
         expect(config.app_name).to eq('MyApp')
-      end
-
-      context 'when configured' do
-        let(:config_builder) do
-          Sinclair::ConfigBuilder.new(config)
-        end
 
-        before do
-          config_builder.secret '123abc'
-          config_builder.app_name 'MySuperApp'
-        end
+        config_builder = Sinclair::ConfigBuilder.new(config)
 
-        it 'has a secret configuration method' do
-          expect(config.secret).to eq('123abc')
-        end
+        config_builder.secret '123abc'
+        config_builder.app_name 'MySuperApp'
 
-        it 'has a app_name configuration method' do
-          expect(config.app_name).to eq('MySuperApp')
-        end
+        expect(config.secret).to eq('123abc')
+        expect(config.app_name).to eq('MySuperApp')
       end
     end
   end

data/spec/integration/yard/sinclair_spec.rb

@@ -4,10 +4,8 @@ require 'spec_helper'
 
 describe Sinclair do
   describe 'yard' do
-    let(:klass)         { Class.new(MyModel) }
-    let(:instance)      { klass.new }
-    let(:builder)       { described_class.new(klass) }
-    let(:default_value) { 10 }
+    let(:klass)   { Class.new(MyModel) }
+    let(:builder) { described_class.new(klass) }
 
     describe 'Using cache' do
       subject(:server) { Server.new }
@@ -85,38 +83,21 @@ describe Sinclair do
       end
     end
 
-    describe '#build' do
-      before do
-        value = default_value
-        builder.add_method(:default_value) { value }
-        builder.add_method(:value, '@value || default_value')
-        builder.add_method(:value=) { |val| @value = val }
-      end
-
-      describe 'after the build' do
-        before { builder.build }
+    describe 'Stand alone usage' do
+      it 'builds the methods' do
+        value = 10
 
-        it 'creates the expected methods' do
-          expect(instance.value).to eq(10)
+        Sinclair.build(klass) do
+          add_method(:default_value) { value }
+          add_method(:value, '@value || default_value')
+          add_method(:value=) { |val| @value = val }
         end
 
-        context 'when default value is overwritten' do
-          before do
-            instance.value = 20
-          end
+        instance = klass.new
 
-          it 'returns the new written value' do
-            expect(instance.value).to eq(20)
-          end
-        end
-      end
-
-      context 'when calling the build' do
-        it do
-          expect do
-            builder.build
-          end.to change { instance.respond_to?(:default_value) }.to(true)
-        end
+        expect(instance.value).to eq(10)
+        instance.value = 20
+        expect(instance.value).to eq(20)
       end
     end
   end

data/spec/lib/sinclair/caster/class_methods_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Sinclair::Caster::ClassMethods do
+  subject(:caster) { Class.new(Sinclair::Caster) }
+
+  describe '.cast_with' do
+    let(:value)       { instance_double('value', to_p: final_value) }
+    let(:final_value) { Random.rand(100) }
+
+    context 'when a proc is given' do
+      it do
+        expect { caster.cast_with(:problem, &:to_p) }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(:problem, &:to_p) }
+
+        it 'returns the cast value' do
+          expect(caster.cast(value, :problem)).to eq(final_value)
+        end
+      end
+    end
+
+    context 'when a proc with two arguments is given' do
+      it do
+        expect { caster.cast_with(:problem) { |v, **_opts| v.to_p } }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(:problem) { |v, sum:| v.to_p + sum } }
+
+        it 'returns the cast value' do
+          expect(caster.cast(value, :problem, sum: 2))
+            .to eq(final_value + 2)
+        end
+      end
+    end
+
+    context 'when a symbol is given' do
+      let(:instance) { Sinclair::Caster.new(&:to_p) }
+
+      it do
+        expect { caster.cast_with(:problem, instance) }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(:problem, instance) }
+
+        it 'returns the cast value' do
+          expect(caster.cast(value, :problem)).to eq(final_value)
+        end
+      end
+    end
+
+    context 'when a caster is given is given' do
+      it do
+        expect { caster.cast_with(:problem, :to_p) }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(:problem, :to_p) }
+
+        it 'returns the cast value' do
+          expect(caster.cast(value, :problem)).to eq(final_value)
+        end
+      end
+    end
+
+    context 'when key is a class' do
+      it do
+        expect { caster.cast_with(Integer, :to_i) }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(Integer, :to_i) }
+
+        it 'returns the cast value' do
+          expect(caster.cast('10', Integer)).to eq(10)
+        end
+      end
+    end
+
+    context 'when key is a module' do
+      it do
+        expect { caster.cast_with(JSON) { |value| JSON.parse(value) } }
+          .not_to raise_error
+      end
+
+      context 'when casting is called' do
+        before { caster.cast_with(JSON) { |value| JSON.parse(value) } }
+
+        it 'returns the cast value' do
+          expect(caster.cast('{"key":"value"}', JSON))
+            .to eq({ 'key' => 'value' })
+        end
+      end
+    end
+
+    context 'when key is a superclass' do
+      it do
+        expect { caster.cast_with(Numeric, :to_i) }
+          .not_to raise_error
+      end
+
+      context 'when casting is called with the child class' do
+        before { caster.cast_with(Numeric, :to_i) }
+
+        it 'returns the cast value' do
+          expect(caster.cast('10', Integer)).to eq(10)
+        end
+      end
+    end
+  end
+
+  describe '.caster_for' do
+    context 'when the key has been defined with a symbol key' do
+      before { caster.cast_with(:problem, :to_p) }
+
+      it do
+        expect(caster.caster_for(:problem))
+          .to be_a(Sinclair::Caster)
+      end
+    end
+
+    context 'when the key has not been defined' do
+      it do
+        expect(caster.caster_for(:problem))
+          .to be_a(Sinclair::Caster)
+      end
+    end
+  end
+
+  describe '.cast' do
+    let(:value) { values.sample }
+    let(:values) do
+      [Random.rand, 'some string', { key: 10 }, Object.new, Class.new, [2, 3]]
+    end
+
+    context 'when klass is nil' do
+      it 'returns the value' do
+        expect(caster.cast(value, nil))
+          .to eq(value)
+      end
+    end
+
+    context 'when class is :string' do
+      it 'returns the value as string' do
+        expect(caster.cast(value, :string))
+          .to eq(value.to_s)
+      end
+    end
+
+    context 'when class is :integer' do
+      let(:value) { '10.5' }
+
+      it 'returns the value as integer' do
+        expect(caster.cast(value, :integer))
+          .to eq(10)
+      end
+    end
+
+    context 'when class is :float' do
+      let(:value) { '10.5' }
+
+      it 'returns the value as float' do
+        expect(caster.cast(value, :float))
+          .to eq(10.5)
+      end
+    end
+  end
+
+  describe '.master_caster!' do
+    it 'ignores superclass registered casters' do
+      expect { caster.master_caster! }
+        .to change { caster.cast('10', :integer) }
+        .from(10).to('10')
+    end
+  end
+end