eapi 0.0.1 → 0.1.0

data/lib/eapi/value_converter.rb

@@ -0,0 +1,40 @@
+module Eapi
+  module ValueConverter
+    def self.convert_value(value)
+      if value.nil?
+        nil
+      elsif is_list? value
+        value_from_list value
+      elsif is_hash?(value)
+        value_from_hash value
+      else
+        value
+      end
+    end
+
+    private
+    def self.is_hash?(value)
+      value.respond_to? :to_h
+    end
+
+    def self.is_list?(value)
+      return false if value.kind_of?(Hash) || value.kind_of?(OpenStruct)
+
+      value.respond_to? :to_a
+    end
+
+    def self.value_from_list(value)
+      value.to_a.map { |e| convert_value e }.compact
+    end
+
+    def self.value_from_hash(value)
+      {}.tap do |hash|
+        value.to_h.each_pair do |k, v|
+          val     = convert_value v
+          hash[k] = val unless val.nil?
+        end
+        hash.deep_symbolize_keys!
+      end
+    end
+  end
+end

data/lib/eapi/version.rb

@@ -1,3 +1,3 @@
 module Eapi
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/basic_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'basic behaviour' do
+    class MyTestKlass
+      include Eapi::Common
+
+      property :something
+    end
+
+    describe '#something (fluent setter/getter)' do
+      describe '#something as getter' do
+        it 'return the value' do
+          eapi = MyTestKlass.new something: :hey
+          expect(eapi.something).to eq :hey
+        end
+      end
+
+      describe '#something("val")' do
+        it 'set the value and return self' do
+          eapi = MyTestKlass.new something: :hey
+          res  = eapi.something :other
+          expect(eapi).to be res
+          expect(eapi.something).to eq :other
+        end
+      end
+
+      describe '#set_something("val")' do
+        it 'set the value and return self' do
+          eapi = MyTestKlass.new something: :hey
+          res  = eapi.set_something :other
+          expect(eapi).to be res
+          expect(eapi.something).to eq :other
+        end
+      end
+    end
+
+    describe '#get' do
+      it 'will use the getter' do
+        eapi = MyTestKlass.new something: :hey
+        expect(eapi.get(:something)).to eq :hey
+        expect(eapi.get('something')).to eq :hey
+      end
+
+    end
+
+    describe '#set' do
+      it 'will use the fluent setter' do
+        eapi = MyTestKlass.new
+        expect(eapi.set(:something, :hey)).to equal eapi
+        expect(eapi.get(:something)).to eq :hey
+      end
+    end
+
+  end
+
+end

data/spec/definition_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context '#definition_for' do
+    class MyTestKlassDefinition
+      include Eapi::Common
+
+      property :something, type: Hash, unrecognised_option: 1
+    end
+
+    it 'will return the definition of a property, even with the unrecognised options (a copy of the hash, not editable)' do
+      definition = MyTestKlassDefinition.definition_for :something
+      expected   = {type: Hash, unrecognised_option: 1}
+      expect(definition).to eq expected
+
+      #changing the definition
+      definition[:type] = Array
+
+      definition_2 = MyTestKlassDefinition.definition_for :something
+      expect(definition_2).to eq expected
+      expect(definition_2[:type]).to eq Hash
+    end
+  end
+
+end

data/spec/function_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'function initializer' do
+    class MyTestKlassOutside
+      include Eapi::Common
+
+      property :something
+    end
+
+    module Somewhere
+      class TestKlassInModule
+        include Eapi::Common
+
+        property :something
+      end
+    end
+
+    describe 'Eapi::Children' do
+      describe '#list' do
+        it 'returns the list of Eapi enabled classes' do
+          list = Eapi::Children.list
+          expect(list).to include(MyTestKlassOutside)
+        end
+      end
+
+      describe '#has?' do
+        it 'true if the given class is an Eapi enabled class' do
+          expect(Eapi::Children).not_to be_has('nope')
+          expect(Eapi::Children).to be_has(MyTestKlassOutside)
+          expect(Eapi::Children).to be_has('MyTestKlassOutside')
+          expect(Eapi::Children).to be_has('my_test_klass_outside')
+        end
+      end
+
+      describe '#get' do
+        it 'get the given class if it is an Eapi enabled class' do
+          expect(Eapi::Children.get('nope')).to be_nil
+          expect(Eapi::Children.get(MyTestKlassOutside)).to eq MyTestKlassOutside
+          expect(Eapi::Children.get('MyTestKlassOutside')).to eq MyTestKlassOutside
+          expect(Eapi::Children.get('my_test_klass_outside')).to eq MyTestKlassOutside
+        end
+      end
+    end
+
+    describe 'initialise using method calls to Eapi', :focus do
+      [
+        [:MyTestKlassOutside, MyTestKlassOutside],
+        [:my_test_klass_outside, MyTestKlassOutside],
+        [:Somewhere__TestKlassInModule, Somewhere::TestKlassInModule],
+        [:somewhere__test_klass_in_module, Somewhere::TestKlassInModule],
+        [:Somewhere_TestKlassInModule, Somewhere::TestKlassInModule],
+        [:somewhere_test_klass_in_module, Somewhere::TestKlassInModule],
+      ].each do |(meth, klass)|
+        describe "Eapi.#{meth}(...)" do
+          it "calls #{klass}.new" do
+            eapi = Eapi.send meth, something: :hey
+            expect(eapi).to be_a klass
+            expect(eapi.something).to eq :hey
+          end
+        end
+      end
+    end
+
+    it 'will raise NoMethodError if a valid class is not found' do
+      expect { Eapi.this_one_does_not_exist }.to raise_exception NoMethodError
+    end
+  end
+
+end

data/spec/list_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'list' do
+    class MyTestClassValMult
+      include Eapi::Common
+
+      property :something, multiple: true
+    end
+
+    it '#add_something' do
+      eapi = MyTestClassValMult.new something: [1, 2]
+      res  = eapi.add_something 3
+      expect(res).to be eapi
+      expect(eapi.something).to eq [1, 2, 3]
+    end
+
+    it '#init_something called on first add if element is nil' do
+      eapi = MyTestClassValMult.new
+      res  = eapi.add_something :a
+      expect(res).to be eapi
+      expect(eapi.something.to_a).to eq [:a]
+    end
+
+    class MyTestClassValMultImpl
+      include Eapi::Common
+
+      property :something, type: Set
+    end
+
+    class MyMultiple
+      def self.is_multiple?
+        true
+      end
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class MyTestClassValMultImpl2
+      include Eapi::Common
+
+      property :something, type: MyMultiple
+    end
+
+    class MyMultipleEapi
+      include Eapi::Multiple
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class MyTestClassValMultImpl3
+      include Eapi::Common
+
+      property :something, type: MyMultipleEapi
+    end
+
+    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
+      [
+        [MyTestClassValMult, Array],
+        [MyTestClassValMultImpl, Set],
+        [MyTestClassValMultImpl2, MyMultiple],
+        [MyTestClassValMultImpl3, MyMultipleEapi],
+      ].each do |(eapi_class, type_class)|
+        eapi = eapi_class.new
+        res  = eapi.add_something :a
+        expect(res).to be eapi
+        expect(eapi.something.to_a).to eq [:a]
+        expect(eapi.something).to be_a_kind_of type_class
+      end
+    end
+
+    describe 'element validation' do
+      class MyTestClassValElements
+        include Eapi::Common
+        property :something, multiple: true, element_type: Hash
+        property :other, multiple: true, validate_element_with: ->(record, attr, value) do
+          record.errors.add(attr, "element must pass my custom validation") unless value == :valid_val
+        end
+      end
+
+      describe 'using `type_element` property in definition' do
+        it 'will validate the type of all the elements in the list' do
+          eapi = MyTestClassValElements.new
+          eapi.add_something 1
+          expect(eapi).not_to be_valid
+          expect(eapi.errors.full_messages).to eq ["Something element must be a Hash"]
+          expect(eapi.errors.messages).to eq({something: ["element must be a Hash"]})
+
+          eapi.something [{a: :b}]
+          expect(eapi).to be_valid
+        end
+      end
+
+      describe 'using `validate_element_with` property in definition' do
+        it 'will run that custom validation for all the elements in the list' do
+          eapi = MyTestClassValElements.new
+          eapi.add_other 1
+          expect(eapi).not_to be_valid
+          expect(eapi.errors.full_messages).to eq ["Other element must pass my custom validation"]
+          expect(eapi.errors.messages).to eq({other: ["element must pass my custom validation"]})
+
+          eapi.other [:valid_val]
+          expect(eapi).to be_valid
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
 require 'bundler/setup'
 Bundler.setup
 
-require 'coveralls'
-Coveralls.wear!
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
 
 require 'pry'
 require 'eapi'

data/spec/to_h_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context '#to_h' do
+    class MyTestClassToH
+      include Eapi::Common
+
+      property :something, required: true
+      property :other
+    end
+
+    class MyTestObject
+      def to_h
+        {
+          a: 'hello'
+        }
+      end
+    end
+
+    class MyTestObjectComplex
+      def to_h
+        {
+          a: Set.new(['hello', 'world', MyTestObject.new])
+        }
+      end
+
+      def expected
+        {
+          a: [
+               'hello',
+               'world',
+               {a: 'hello'}
+             ]
+        }
+      end
+    end
+
+    it 'raise error if invalid' do
+      eapi = MyTestClassToH.new
+      expect { eapi.to_h }.to raise_error do |error|
+        expect(error).to be_a_kind_of Eapi::Errors::InvalidElementError
+        expect(error.message).to be_start_with "errors: [\"Something can't be blank\"], self: #<MyTestClassToH"
+      end
+
+    end
+
+    it 'create a hash with elements (calling to_h to each element), avoiding nils' do
+      eapi = MyTestClassToH.new
+      eapi.something 'hi'
+      expected = {something: 'hi'}
+      expect(eapi.to_h).to eq expected
+
+      eapi = MyTestClassToH.new
+      eapi.something(MyTestObject.new).other(true)
+      expected = {something: {a: 'hello'}, other: true}
+
+      expect(eapi.to_h).to eq expected
+    end
+
+    it 'hash with elements, all converted to basic Arrays and Hashes (keys as symbols), and exluding nils (if all validations pass)' do
+      list = Set.new [
+                       OpenStruct.new(a: 1, 'b' => 2),
+                       {c: 3, 'd' => 4},
+                       nil
+                     ]
+
+      other = MyTestObjectComplex.new
+
+      expected = {
+        something: [
+                     {a: 1, b: 2},
+                     {c: 3, d: 4},
+                   ],
+
+        other:     other.expected
+      }
+
+      eapi = MyTestClassToH.new
+      eapi.something list
+      eapi.other other
+
+      expect(eapi.to_h).to eq expected
+
+    end
+  end
+end

data/spec/type_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'type check' do
+    class OtherType
+    end
+
+    class MyTestTypeKlass
+      include Eapi::Common
+
+      is :one_thing, :other_thing, OtherType
+    end
+
+    describe '#is? and .is?' do
+      it 'true if asked for the same type' do
+        expect(MyTestTypeKlass).to be_is MyTestTypeKlass
+        expect(MyTestTypeKlass).to be_is 'MyTestTypeKlass'
+        expect(MyTestTypeKlass).to be_is :MyTestTypeKlass
+        expect(MyTestTypeKlass).to be_is :my_test_type_klass
+      end
+
+      it 'false if asked for other class' do
+        expect(MyTestTypeKlass).not_to be_is Hash
+        expect(MyTestTypeKlass).not_to be_is 'Hash'
+        expect(MyTestTypeKlass).not_to be_is :Hash
+      end
+
+      it 'true if asked for a type specified on the class with `is` method' do
+        expect(MyTestTypeKlass).not_to be_is :not_you
+        expect(MyTestTypeKlass).to be_is :one_thing
+        expect(MyTestTypeKlass).to be_is :other_thing
+        expect(MyTestTypeKlass).to be_is OtherType
+        expect(MyTestTypeKlass).to be_is :OtherType
+      end
+    end
+
+    describe '#is?' do
+      it 'behaves exactly like class method `.is?`' do
+        obj = MyTestTypeKlass.new
+
+        expect(obj).to be_is MyTestTypeKlass
+        expect(obj).to be_is 'MyTestTypeKlass'
+        expect(obj).to be_is :MyTestTypeKlass
+        expect(obj).to be_is :my_test_type_klass
+
+        expect(obj).not_to be_is Hash
+        expect(obj).not_to be_is 'Hash'
+        expect(obj).not_to be_is :Hash
+
+        expect(obj).not_to be_is :not_you
+        expect(obj).to be_is :one_thing
+        expect(obj).to be_is :other_thing
+        expect(obj).to be_is OtherType
+        expect(obj).to be_is :OtherType
+      end
+    end
+
+    describe '`#is_a_specific_type?` and `#is_an_other_type?`' do
+      it 'will use #is? inside' do
+        obj = MyTestTypeKlass.new
+        expect(obj).to be_is_a_my_test_type_klass
+        expect(obj).not_to be_is_a_not_you
+        expect(obj).to be_is_an_one_thing
+        expect(obj).to be_is_an_other_thing
+      end
+
+      it 'method_missing still works' do
+        expect { MyTestTypeKlass.new.some_other_method? }.to raise_exception(NoMethodError)
+      end
+    end
+
+    describe '`.is_a_specific_type?` and `.is_an_other_type?`' do
+      it 'will use .is? inside' do
+        expect(MyTestTypeKlass).to be_is_a_my_test_type_klass
+        expect(MyTestTypeKlass).not_to be_is_a_not_you
+        expect(MyTestTypeKlass).to be_is_an_one_thing
+        expect(MyTestTypeKlass).to be_is_an_other_thing
+      end
+
+      it 'method_missing still works' do
+        expect { MyTestTypeKlass.some_other_method? }.to raise_exception(NoMethodError)
+      end
+    end
+  end
+end