modelish 0.3.0 → 1.0.0.pre.1

data/spec/modelish/configuration_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Modelish::Configuration do
+RSpec.describe Modelish::Configuration do
   let(:test_module) do
     module TestModule
       extend Modelish::Configuration
@@ -11,10 +13,10 @@ describe Modelish::Configuration do
 
   after { test_module.reset }
 
-  it { should respond_to(:configure) }
+  it { is_expected.to respond_to(:configure) }
 
   context 'with default configuration' do
-    its(:ignore_unknown_properties) { should be_false }
+    its(:ignore_unknown_properties) { is_expected.to eq(false) }
   end
 
   describe '.configure' do
@@ -29,12 +31,12 @@ describe Modelish::Configuration do
 
       context 'when ignore_unknown_properties is true' do
         let(:ignore_unknown_props) { true }
-        its(:ignore_unknown_properties) { should be_true }
+        its(:ignore_unknown_properties) { is_expected.to eq(true) }
       end
 
       context 'when ignore_unknown_properties is false' do
         let(:ignore_unknown_props) { false }
-        its(:ignore_unknown_properties) { should be_false }
+        its(:ignore_unknown_properties) { is_expected.to eq(false) }
       end
     end
   end
@@ -44,8 +46,9 @@ describe Modelish::Configuration do
 
     before { test_module.configure { |c| c.ignore_unknown_properties = true } }
 
-    it 'should reset the value of ignore_unknown_properties' do
-      expect { subject }.to change { test_module.ignore_unknown_properties }.from(true).to(false)
+    it 'resets the value of ignore_unknown_properties' do
+      expect { subject }.to change { test_module.ignore_unknown_properties }
+        .from(true).to(false)
     end
   end
 
@@ -57,24 +60,26 @@ describe Modelish::Configuration do
     context 'when ignore_unknown_properties is true' do
       let(:ignore_unknown_props) { true }
 
-      it 'should not change the setting' do
+      it 'does not change the setting' do
         expect { subject }.to_not change { test_module.ignore_unknown_properties }
       end
-    end 
+    end
 
     context 'when ignore_unknown_properties is false' do
       let(:ignore_unknown_props) { false }
 
-      it 'should change the setting' do
-        expect { subject }.to change { test_module.ignore_unknown_properties }.from(false).to(true)
+      it 'changes the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }
+          .from(false).to(true)
       end
     end
 
     context 'when ignore_unknown_properties is nil' do
       let(:ignore_unknown_props) { nil }
 
-      it 'should change the setting' do
-        expect { subject }.to change { test_module.ignore_unknown_properties }.from(nil).to(true)
+      it 'changes the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }
+          .from(nil).to(true)
       end
     end
   end
@@ -87,15 +92,16 @@ describe Modelish::Configuration do
     context 'when ignore_unknown_properties is true' do
       let(:ignore_unknown_props) { true }
 
-      it 'should change the setting' do
-        expect { subject }.to change { test_module.ignore_unknown_properties }.from(true).to(false)
+      it 'changes the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }
+          .from(true).to(false)
       end
-    end 
+    end
 
     context 'when ignore_unknown_properties is false' do
       let(:ignore_unknown_props) { false }
 
-      it 'should not change the setting' do
+      it 'does not change the setting' do
         expect { subject }.to_not change { test_module.ignore_unknown_properties }
       end
     end
@@ -103,8 +109,9 @@ describe Modelish::Configuration do
     context 'when ignore_unknown_properties is nil' do
       let(:ignore_unknown_props) { nil }
 
-      it 'should change the setting' do
-        expect { subject }.to change { test_module.ignore_unknown_properties }.from(nil).to(false)
+      it 'changes the setting' do
+        expect { subject }.to change { test_module.ignore_unknown_properties }
+          .from(nil).to(false)
       end
     end
   end

data/spec/modelish/property_translations_spec.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Modelish::PropertyTranslations do
-  let(:model_class) do 
-    Class.new do 
+RSpec.describe Modelish::PropertyTranslations do
+  let(:model_class) do
+    Class.new do
       include Modelish::PropertyTranslations
 
       attr_accessor :foo_prop, :bar_prop
@@ -16,50 +18,53 @@ describe Modelish::PropertyTranslations do
   describe '.translations' do
     subject { model_class.translations }
 
-    it { should be_a Hash }
-    it { should be_empty }
+    it { is_expected.to be_a Hash }
+    it { is_expected.to be_empty }
   end
 
   describe '.add_property_translation' do
-    subject { add_translation }
-    let(:add_translation) { model_class.add_property_translation(from_name, to_name) }
+    subject(:add_translation) do
+      model_class.add_property_translation(from_name, to_name)
+    end
 
-    context 'when there are no existing translations for the property' do
+    context 'when there are no existing translations' do
       context 'with symbolic property names' do
         let(:from_name) { :my_input_prop }
         let(:to_name) { :foo_prop }
 
-        it 'should map the input property to the output property in the translations hash' do
-          expect { subject }.to change { model_class.translations[from_name] }.to([to_name])
+        it 'maps the input property to the output property' do
+          expect { subject }.to change { model_class.translations[from_name] }
+            .to([to_name])
         end
 
-        describe "the generated model" do
+        describe 'the generated model' do
           before { add_translation }
 
           subject { model }
 
-          it { should respond_to(to_name) }
-          it { should_not respond_to(from_name) }
-
-          it { should respond_to("#{to_name}=") }
+          it { is_expected.to respond_to(to_name) }
+          it { is_expected.to_not respond_to(from_name) }
+          it { is_expected.to respond_to("#{to_name}=") }
 
           let(:value) { 'blah' }
 
-          describe "non-translated mutator" do
+          describe 'non-translated mutator' do
             subject { model.send("#{to_name}=", value) }
 
-            it 'should change the property value' do
-              expect { subject }.to change { model.send(to_name) }.from(nil).to(value)
+            it 'changes the property value' do
+              expect { subject }.to change { model.send(to_name) }
+                .from(nil).to(value)
             end
           end
 
-          it { should respond_to("#{from_name}=") }
+          it { is_expected.to respond_to("#{from_name}=") }
 
-          describe "translated mutator" do
+          describe 'translated mutator' do
             subject { model.send("#{from_name}=", value) }
 
-            it 'should change the property value' do
-              expect { subject }.to change { model.send(to_name) }.from(nil).to(value)
+            it 'changes the property value' do
+              expect { subject }.to change { model.send(to_name) }
+                .from(nil).to(value)
             end
           end
         end
@@ -69,8 +74,11 @@ describe Modelish::PropertyTranslations do
         let(:from_name) { 'my_input_prop' }
         let(:to_name) { 'foo_prop' }
 
-        it 'should map the symbolic input property to the symbolic output property in the translations hash' do
-          expect { subject }.to change { model_class.translations[from_name.to_sym] }.from(nil).to([to_name.to_sym])
+        it 'maps the symbolic input property to the symbolic output property' do
+          from_key = from_name.to_sym
+          to_key = to_name.to_sym
+          expect { subject }.to change { model_class.translations[from_key] }
+            .to([to_key])
         end
       end
     end
@@ -81,60 +89,60 @@ describe Modelish::PropertyTranslations do
       let(:from_name) { :input_prop }
       let(:to_name) { :foo_prop }
 
-      it 'should add output property to the mapping for the input property' do
+      it 'adds output property to the mapping for the input property' do
         subject
-        model_class.translations[from_name].should include(to_name)
-        model_class.translations[from_name].should include(other_to_name)
+        expect(model_class.translations[from_name]).to include(to_name,
+                                                               other_to_name)
       end
 
       describe 'generated model' do
         before { add_translation }
         subject { model }
 
-        it { should respond_to(other_to_name) }
-        it { should respond_to(to_name) }
-        it { should_not respond_to(from_name) }
+        it { is_expected.to respond_to(other_to_name) }
+        it { is_expected.to respond_to(to_name) }
+        it { is_expected.to_not respond_to(from_name) }
 
-        it { should respond_to("#{other_to_name}=") }
+        it { is_expected.to respond_to("#{other_to_name}=") }
 
         let(:value) { 'blah' }
 
         describe 'non-translated mutator for the existing property' do
           subject { model.send("#{other_to_name}=", value) }
 
-          it 'should change the value for the existing property' do
+          it 'changes the value for the existing property' do
             expect { subject }.to change { model.send(other_to_name) }.to(value)
           end
 
-          it 'should not change the value for the new property' do
+          it 'does not change the value for the new property' do
             expect { subject }.to_not change { model.send(to_name) }
           end
         end
 
-        it { should respond_to("#{to_name}=") }
+        it { is_expected.to respond_to("#{to_name}=") }
 
         describe 'non-translated mutator for the new property' do
           subject { model.send("#{to_name}=", value) }
 
-          it 'should change the value for the new property' do
+          it 'changes the value for the new property' do
             expect { subject }.to change { model.send(to_name) }.to(value)
           end
 
-          it 'should not change the value for the existing property' do
+          it 'does not change the value for the existing property' do
             expect { subject }.to_not change { model.send(other_to_name) }
           end
         end
 
-        it { should respond_to("#{from_name}=") }
+        it { is_expected.to respond_to("#{from_name}=") }
 
         describe 'translated mutator' do
           subject { model.send("#{from_name}=", value) }
 
-          it 'should change the value for the existing property' do
+          it 'changes the value for the existing property' do
             expect { subject }.to change { model.send(other_to_name) }.to(value)
           end
 
-          it 'should change the value for the new property' do
+          it 'changes the value for the new property' do
             expect { subject }.to change { model.send(to_name) }.to(value)
           end
         end

data/spec/modelish/property_types_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Modelish::PropertyTypes do
+RSpec.describe Modelish::PropertyTypes do
   let(:model_class) { Class.new { include Modelish::PropertyTypes } }
   let(:model) { model_class.new }
 
@@ -8,91 +10,93 @@ describe Modelish::PropertyTypes do
 
   subject { model_class }
 
-  context "when included" do
-    it { should respond_to(:add_property_type) }
-    it { should respond_to(:property_types) }
+  context 'when included' do
+    it { is_expected.to respond_to(:add_property_type) }
+    it { is_expected.to respond_to(:property_types) }
 
-    describe "property_types" do
+    describe 'property_types' do
       subject { model_class.property_types }
 
-      it { should be_a Hash }
-      it { should be_empty }
+      it { is_expected.to be_a Hash }
+      it { is_expected.to be_empty }
     end
   end
 
-  describe "#add_property_type" do
+  describe '#add_property_type' do
     before { model_class.add_property_type(property_name, property_type) }
 
     let(:default_value) { nil }
 
-    context "when property_type is Integer" do
+    context 'when property_type is Integer' do
       let(:property_type) { Integer }
 
-      it_should_behave_like 'a typed property', :my_property, Integer do
+      it_behaves_like 'a typed property', :my_property, Integer do
         let(:valid_string) { '42' }
         let(:valid_typed_value) { 42 }
         let(:invalid_value) { 'forty-two' }
       end
     end
 
-    context "when property_type is Float" do
+    context 'when property_type is Float' do
       let(:property_type) { Float }
 
-      it_should_behave_like 'a typed property', :my_property, Float do
+      it_behaves_like 'a typed property', :my_property, Float do
         let(:valid_string) { '42.5' }
         let(:valid_typed_value) { 42.5 }
         let(:invalid_value) { 'forty-two point five' }
       end
     end
 
-    context "when property_type is Date" do
+    context 'when property_type is Date' do
       let(:property_type) { Date }
 
-      it_should_behave_like 'a typed property', :my_property, Date do
+      it_behaves_like 'a typed property', :my_property, Date do
         let(:valid_string) { '2011-03-10' }
-        let(:valid_typed_value) { Date.civil(2011, 03, 10) }
+        let(:valid_typed_value) { Date.civil(2011, 3, 10) }
         let(:invalid_value) { 'foo' }
       end
     end
 
-    context "when property_type is DateTime" do
+    context 'when property_type is DateTime' do
       let(:property_type) { DateTime }
 
-      it_should_behave_like 'a typed property', :my_property, DateTime do
+      it_behaves_like 'a typed property', :my_property, DateTime do
         let(:valid_string) { '2011-02-24T14:09:43-07:00' }
-        let(:valid_typed_value) { DateTime.civil(2011, 2, 24, 14, 9, 43, Rational(-7, 24)) }
+        let(:valid_typed_value) do
+          DateTime.civil(2011, 2, 24, 14, 9, 43, Rational(-7, 24))
+        end
         let(:invalid_value) { 'foo' }
       end
     end
 
-    context "when property_type is String" do
+    context 'when property_type is String' do
       let(:property_type) { String }
 
-      it_should_behave_like 'a typed property', :my_property, String do
+      it_behaves_like 'a typed property', :my_property, String do
         let(:valid_string) { "\tmy_string  \n" }
-        let(:valid_typed_value) { "my_string" }
-      end 
+        let(:valid_typed_value) { 'my_string' }
+      end
     end
 
-    context "when property_type is Symbol" do
+    context 'when property_type is Symbol' do
       let(:property_type) { Symbol }
 
-      it_should_behave_like 'a typed property', :my_property, Symbol do
+      it_behaves_like 'a typed property', :my_property, Symbol do
         let(:valid_string) { 'MyCrazy    String' }
         let(:valid_typed_value) { :my_crazy_string }
       end
     end
 
-    context "when property_type is Array" do
+    context 'when property_type is Array' do
       let(:property_type) { Array }
 
-      it_should_behave_like 'a typed property', :my_property, Array do
+      it_behaves_like 'a typed property', :my_property, Array do
         let(:valid_string) { 'my valid string' }
         let(:valid_typed_value) { ['my valid string'] }
       end
     end
 
-    context "when type is an arbitrary class" do
+    context 'when type is an arbitrary class' do
       class CustomType
         attr_accessor :foo
 
@@ -102,68 +106,72 @@ describe Modelish::PropertyTypes do
           elsif raw_val.is_a?(String)
             self.foo = raw_val
           else
-            raise TypeError.new
+            raise TypeError
           end
         end
 
         def ==(other)
-          other.respond_to?(:foo) && other.foo == self.foo
+          other.respond_to?(:foo) && other.foo == foo
         end
       end
 
       let(:property_type) { CustomType }
 
-      it_should_behave_like 'a typed property', :my_property, CustomType do
+      it_behaves_like 'a typed property', :my_property, CustomType do
         let(:valid_string) { 'bar' }
         let(:valid_typed_value) { CustomType.new(valid_string) }
         let(:invalid_value) { Object.new }
+        let(:error_type) { TypeError }
       end
     end
 
-    context "when type is a closure" do
+    context 'when type is a closure' do
       let(:property_type) do
         lambda do |val|
           value = val.respond_to?(:split) ? val.split(',') : val
-          value.collect { |n| n.to_i }
+          value.map(&:to_i)
         end
       end
 
-      it_should_behave_like 'a typed property', :my_property do
+      it_behaves_like 'a typed property', :my_property do
         let(:valid_string) { '1,2,3' }
-        let(:valid_typed_value) { [1,2,3] }
+        let(:valid_typed_value) { [1, 2, 3] }
         let(:invalid_value) { Object.new }
+        let(:error_type) { NoMethodError }
       end
     end
 
-    context "when a property is defined more than once" do
-      before { model_class.add_property_type(property_name, other_property_type) }
+    context 'when a property is defined more than once' do
+      before do
+        model_class.add_property_type(property_name, other_property_type)
+      end
 
-      let(:property_type) { Integer } 
+      let(:property_type) { Integer }
 
-      context "with the same property_type" do
+      context 'with the same property_type' do
         let(:other_property_type) { property_type }
 
-        it "should not raise an error when the property is accessed" do
+        it 'does not raise an error when the property is accessed' do
           expect { model.send(property_name) }.to_not raise_error
         end
 
-        it_should_behave_like 'a typed property', :my_property, Integer do
+        it_behaves_like 'a typed property', :my_property, Integer do
           let(:valid_string) { '112358' }
-          let(:valid_typed_value) { 112358 }
+          let(:valid_typed_value) { 112_358 }
           let(:invalid_value) { 'blah' }
         end
       end
 
-      context "with different property_types" do
+      context 'with different property_types' do
         let(:other_property_type) { Float }
 
-        it "should not raise an error when the property is accessed" do
+        it 'does not raise an error when the property is accessed' do
           expect { model.send(property_name) }.to_not raise_error
         end
 
-        it_should_behave_like 'a typed property', :my_property, Float do
+        it_behaves_like 'a typed property', :my_property, Float do
           let(:valid_string) { '112358.13' }
-          let(:valid_typed_value) { 112358.13 }
+          let(:valid_typed_value) { 112_358.13 }
           let(:invalid_value) { 'blah' }
         end
       end