virtus_model 0.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f21f80530d6cc87de3ae040817f78c8c83b4567f
+  data.tar.gz: 572466a814d7c485b6bd89aaed1614e29b837b4a
+SHA512:
+  metadata.gz: 75489e6017e171d19a196a82f228713682728331c2a58ca0e6d1da4a33cebeb590128053b90a21afe4482b7be6b256f05b5782667f1dfb22335eae7aff39618d
+  data.tar.gz: c39b394204e97a0f26b49693cea7addd5e34fedb7366a5626e9a25567a46333441e13d677d02018c235ddda0ef011914d619a193b7f50cb754ab131136d19f6c

data/lib/virtus_model/base.rb

@@ -0,0 +1,165 @@
+require 'virtus'
+require 'active_model'
+
+module VirtusModel
+  class Base
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include Virtus.model
+
+    set_callback :validate, :validate_associations
+
+    # Get an array of attribute names.
+    def self.attributes
+      attribute_set.map(&:name)
+    end
+
+    # Is there an attribute with the provided name?
+    def self.attribute?(name)
+      attributes.include?(name)
+    end
+
+    # Is there an association with the provided name and type (optional)?
+    def self.association?(name, *types)
+      associations(*types).include?(name)
+    end
+
+    # Get an array of association names by type (optional).
+    def self.associations(*types)
+      classes = {
+        one: Virtus::Attribute::EmbeddedValue,
+        many: Virtus::Attribute::Collection
+      }.select do |type, _|
+        types.empty? || types.include?(type)
+      end
+
+      attribute_set.select do |field|
+        classes.any? { |_, cls| field.class <= cls }
+      end.map(&:name)
+    end
+
+    # Initialize attributes using the provided hash or object.
+    def initialize(model = nil)
+      super(compact_hash(extract_attributes(model)))
+    end
+
+    # Recursively update attributes and return a self-reference.
+    def assign_attributes(model)
+      self.attributes = extract_attributes(model)
+      self
+    end
+
+    # Update attributes and validate.
+    def update(model = nil, options = {})
+      assign_attributes(model)
+      validate(options)
+    end
+
+    # Two models are equal if their attributes are equal.
+    def ==(other)
+      if other.is_a?(VirtusModel::Base)
+        self.attributes == other.attributes
+      else
+        self.attributes == other
+      end
+    end
+
+    # Recursively convert all attributes to hash pairs.
+    def export(options = nil)
+      self.class.attributes.reduce({}) do |result, name|
+        value = attributes[name]
+        if self.class.association?(name, :many)
+          result[name] = export_values(value, options)
+        elsif self.class.association?(name, :one)
+          result[name] = export_value(value, options)
+        else
+          result[name] = value
+        end
+        result
+      end
+    end
+
+    # Alias of #export.
+    def to_hash(options = nil)
+      export(options)
+    end
+
+    # Alias of #to_hash.
+    def to_h(options = nil)
+      to_hash(options)
+    end
+
+    # Alias of #export.
+    def as_json(options = nil)
+      export(options)
+    end
+
+    # Convert the #as_json result to JSON.
+    def to_json(options = nil)
+      as_json(options).to_json
+    end
+
+    protected
+
+    # Extract model attributes into a hash.
+    def extract_attributes(model)
+      self.class.attributes.reduce({}) do |result, name|
+        if model.respond_to?(name)
+          result[name] = model.public_send(name)
+        elsif model.respond_to?(:[])
+          result[name] = model[name]
+        end
+        result
+      end
+    end
+
+    # Validate all associations by type and import resulting errors.
+    def validate_associations
+      validate_associations_one
+      validate_associations_many
+    end
+
+    # Validate "one" associations and import errors.
+    def validate_associations_one
+      self.class.associations(:one).each do |name|
+        import_errors(name, attributes[name])
+      end
+    end
+
+    # Validate "many" associations and import errors.
+    def validate_associations_many
+      self.class.associations(:many).each do |name|
+        values = attributes[name] || []
+        values.each.with_index do |value, index|
+          import_errors("#{name}[#{index}]", value)
+        end
+      end
+    end
+
+    # Merge associated errors using the current validation context.
+    def import_errors(name, model)
+      return unless model.respond_to?(:validate)
+      return if model.validate(validation_context)
+      model.errors.each do |field, error|
+        errors.add("#{name}[#{field}]", error)
+      end
+    end
+
+    # Export each value with the provided options.
+    def export_values(values, options = nil)
+      return if values.nil?
+      values.map { |v| export_value(v, options) }
+    end
+
+    # Export the value with the provided options.
+    def export_value(value, options = nil)
+      return if value.nil?
+      value.respond_to?(:export) ? value.export(options) : value
+    end
+
+    # Omit keys with nil values.
+    def compact_hash(hash)
+      hash.select { |_, value| !value.nil? }
+    end
+  end
+end

data/lib/virtus_model/version.rb

@@ -0,0 +1,3 @@
+module VirtusModel
+  VERSION = '0.2.5'.freeze
+end

data/lib/virtus_model.rb

@@ -0,0 +1,2 @@
+require 'virtus_model/base'
+require 'virtus_model/version'

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'virtus_model'
+require 'shoulda/matchers'
+require 'active_support/core_ext/object/try'
+
+Shoulda::Matchers.configure do |config|
+  config.integrate do |with|
+    with.test_framework :rspec
+    with.library :active_model
+  end
+end

data/spec/virtus_model/base_spec.rb

@@ -0,0 +1,355 @@
+describe VirtusModel::Base do
+  class SimpleModel < VirtusModel::Base
+    attribute :name, String
+    validates :name, presence: true
+  end
+
+  let(:simple_model) { SimpleModel.new(simple_model_attributes) }
+  let(:simple_model_attributes) { { name: 'test' } }
+
+  describe SimpleModel, type: :model do
+    it { is_expected.to validate_presence_of(:name) }
+  end
+
+  class ComplexModel < VirtusModel::Base
+    attribute :model, SimpleModel
+    attribute :models, Array[SimpleModel]
+    validates :model, presence: true
+    validates :models, presence: true
+  end
+
+  let(:complex_model) { ComplexModel.new(complex_model_attributes) }
+  let(:complex_model_attributes) do
+    {
+      model: simple_model_attributes,
+      models: [simple_model_attributes]
+    }
+  end
+
+  describe ComplexModel, type: :model do
+    it { is_expected.to validate_presence_of(:model) }
+    it { is_expected.to validate_presence_of(:models) }
+  end
+
+  class InheritedModel < ComplexModel
+    attribute :name, String
+  end
+
+  describe InheritedModel, type: :model do
+    it { is_expected.to validate_presence_of(:model) }
+    it { is_expected.to validate_presence_of(:models) }
+  end
+
+  describe '.attribute?' do
+    context SimpleModel do
+      subject { SimpleModel }
+
+      it { expect(subject.attribute?(:name)).to be(true) }
+      it { expect(subject.attribute?(:other)).to be(false) }
+    end
+
+    context ComplexModel do
+      subject { ComplexModel }
+
+      it { expect(subject.attribute?(:model)).to be(true) }
+      it { expect(subject.attribute?(:models)).to be(true) }
+      it { expect(subject.attribute?(:other)).to be(false) }
+    end
+  end
+
+  describe '.association?' do
+    context SimpleModel do
+      subject { SimpleModel }
+
+      it { expect(subject.association?(:name)).to be(false) }
+      it { expect(subject.association?(:other)).to be(false) }
+    end
+
+    context ComplexModel do
+      subject { ComplexModel }
+
+      it { expect(subject.association?(:model)).to be(true) }
+      it { expect(subject.association?(:models)).to be(true) }
+      it { expect(subject.association?(:other)).to be(false) }
+    end
+  end
+
+  describe '.associations' do
+    context SimpleModel do
+      subject { SimpleModel }
+
+      it { expect(subject.associations).to eq([]) }
+    end
+
+    context ComplexModel do
+      subject { ComplexModel }
+
+      it { expect(subject.associations).to eq([:model, :models]) }
+      it { expect(subject.associations(:one)).to eq([:model]) }
+      it { expect(subject.associations(:many)).to eq([:models]) }
+    end
+  end
+
+  describe '#initialize' do
+    context SimpleModel do
+      subject { SimpleModel.new(attributes) }
+
+      context 'attributes are blank' do
+        let(:attributes) { nil }
+        it { expect(subject.attributes).to eq(name: nil) }
+      end
+
+      context 'attributes are present' do
+        let(:attributes) { { name: 'test', other: 'test' } }
+        it { expect(subject.attributes).to eq(name: 'test') }
+        it { expect(subject.attributes).not_to eq(other: 'test') }
+      end
+    end
+
+    context ComplexModel do
+      subject { ComplexModel.new(attributes) }
+
+      context 'attributes are blank' do
+        let(:attributes) { nil }
+        it { expect(subject.attributes).to eq(model: nil, models: []) }
+      end
+
+      context 'attributes are present' do
+        let(:attributes) { { model: model, models: [model], other: 'test' } }
+        let(:model) { { name: 'test' } }
+        it { expect(subject.export[:model]).to eq(model) }
+        it { expect(subject.export[:models]).to eq([model]) }
+        it { expect(subject.attributes).not_to eq(other: 'test') }
+      end
+    end
+  end
+
+  describe '#assign_attributes' do
+    context SimpleModel do
+      subject { SimpleModel.new.assign_attributes(attributes) }
+
+      context 'hash' do
+        let(:attributes) { { name: 'test', other: 'test' } }
+        it { expect(subject.attributes).to include(name: 'test') }
+        it { expect(subject.attributes).not_to include(other: 'test') }
+      end
+
+      context 'object' do
+        let(:attributes) { simple_model }
+        it { expect(subject == simple_model).to be(true) }
+      end
+    end
+
+    context ComplexModel do
+      subject { ComplexModel.new.assign_attributes(attributes) }
+
+      context 'hash' do
+        let(:attributes) { { model: model, models: [model], other: 'test' } }
+        let(:model) { { name: 'test', other: 'test' } }
+        it { expect(subject.attributes[:model]).to eq(SimpleModel.new(model)) }
+        it { expect(subject.attributes[:models]).to eq([SimpleModel.new(model)]) }
+        it { expect(subject.attributes).not_to include(other: 'test') }
+      end
+
+      context 'object' do
+        let(:attributes) { complex_model }
+        it { expect(subject == complex_model).to be(true) }
+      end
+    end
+  end
+
+  describe '#update' do
+    let!(:valid) { subject.update(attributes) }
+
+    context SimpleModel do
+      subject { SimpleModel.new }
+
+      context 'attributes are blank' do
+        let(:attributes) { nil }
+        it { expect(subject.export).to eq(name: nil) }
+        it { expect(valid).to be(false) }
+      end
+
+      context 'attributes are invalid' do
+        let(:attributes) { { name: '' } }
+        it { expect(subject.export).to eq(name: '') }
+        it { expect(valid).to be(false) }
+      end
+
+      context 'attributes are valid' do
+        let(:attributes) { simple_model_attributes }
+        it { expect(subject.export).to eq(name: 'test') }
+        it { expect(valid).to be(true) }
+      end
+    end
+
+    context ComplexModel do
+      subject { ComplexModel.new }
+
+      context 'attributes are blank' do
+        let(:attributes) { nil }
+        it { expect(subject.export).to eq(model: nil, models: []) }
+        it { expect(valid).to be(false) }
+      end
+
+      context 'attributes are invalid' do
+        let(:attributes) { { model: {} } }
+        it { expect(subject.export[:model]).to include(name: nil) }
+        it { expect(valid).to be(false) }
+      end
+
+      context 'attributes are valid' do
+        let(:attributes) { complex_model_attributes }
+        it { expect(subject.export[:model]).to include(name: 'test') }
+        it { expect(valid).to be(true) }
+      end
+    end
+  end
+
+  describe '#==' do
+    context SimpleModel do
+      subject { simple_model }
+
+      context 'equal hash' do
+        let(:other) { subject.dup.export }
+        it { expect(subject == other).to be(true) }
+      end
+
+      context 'equal object' do
+        let(:other) { subject.dup }
+        it { expect(subject == other).to be(true) }
+      end
+
+      context 'unequal hash' do
+        let(:other) { subject.dup.export.merge(name: 'test2') }
+        it { expect(subject == other).to be(false) }
+      end
+
+      context 'unequal object' do
+        let(:other) { subject.dup.assign_attributes(name: 'test2') }
+        it { expect(subject == other).to be(false) }
+      end
+    end
+
+    context ComplexModel do
+      subject { complex_model }
+
+      context 'equal hash' do
+        let(:other) { subject.dup.export }
+        it { expect(subject == other).to be(true) }
+      end
+
+      context 'equal object' do
+        let(:other) { subject.dup }
+        it { expect(subject == other).to be(true) }
+      end
+
+      context 'unequal hash' do
+        let(:other) { subject.dup.export.merge(models: { name: 'test2' }) }
+        it { expect(subject == other).to be(false) }
+      end
+
+      context 'unequal object' do
+        let(:other) { subject.dup.assign_attributes(models: [{ name: 'test2' }]) }
+        it { expect(subject == other).to be(false) }
+      end
+    end
+  end
+
+  describe '#export' do
+    context SimpleModel do
+      subject { simple_model }
+
+      it { expect(subject.export).to eq(simple_model_attributes) }
+    end
+
+    context ComplexModel do
+      subject { complex_model }
+
+      it { expect(subject.export).to eq(complex_model_attributes) }
+    end
+  end
+
+  describe '#to_hash' do
+    context SimpleModel do
+      subject { simple_model }
+
+      it { expect(subject.to_hash).to eq(subject.export) }
+      it { expect(subject.to_h).to eq(subject.to_hash) }
+      it { expect(subject.as_json).to eq(subject.to_hash) }
+    end
+
+    context ComplexModel do
+      subject { complex_model }
+
+      it { expect(subject.to_hash).to eq(subject.export) }
+      it { expect(subject.to_h).to eq(subject.to_hash) }
+      it { expect(subject.as_json).to eq(subject.to_hash) }
+    end
+  end
+
+  describe '#to_json' do
+    context SimpleModel do
+      subject { simple_model }
+
+      it { expect(subject.to_json).to eq(subject.export.to_json) }
+    end
+
+    context ComplexModel do
+      subject { complex_model }
+
+      it { expect(subject.to_json).to eq(subject.export.to_json) }
+    end
+  end
+
+  describe '#validate' do
+    before { subject.validate }
+
+    context SimpleModel do
+      context 'valid' do
+        subject { simple_model }
+
+        it { expect(subject.valid?).to be(true) }
+        it { expect(subject.errors).to be_blank }
+      end
+
+      context 'invalid' do
+        subject { simple_model.assign_attributes(name: '') }
+
+        it { expect(subject.valid?).to be(false) }
+        it { expect(subject.errors.messages).to include(name: ["can't be blank"]) }
+      end
+    end
+
+    context ComplexModel do
+      context 'valid' do
+        subject { complex_model }
+
+        it { expect(subject.valid?).to be(true) }
+        it { expect(subject.errors).to be_blank }
+      end
+
+      context 'invalid' do
+        subject { complex_model.assign_attributes(model: {}, models: [{}]) }
+
+        it { expect(subject.valid?).to be(false) }
+        it { expect(subject.errors.messages).to include(:"model[name]" => ["can't be blank"]) }
+        it { expect(subject.errors.messages).to include(:"models[0][name]" => ["can't be blank"]) }
+      end
+    end
+  end
+
+  describe '#to_json' do
+    context SimpleModel do
+      subject { simple_model }
+
+      it { expect(subject.to_json).to eq(subject.export.to_json) }
+    end
+
+    context ComplexModel do
+      subject { complex_model }
+
+      it { expect(subject.to_json).to eq(subject.export.to_json) }
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: virtus_model
+version: !ruby/object:Gem::Version
+  version: 0.2.5
+platform: ruby
+authors:
+- Derek Schaefer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+description: VirtusModel
+email:
+- derek.schaefer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/virtus_model.rb
+- lib/virtus_model/base.rb
+- lib/virtus_model/version.rb
+- spec/spec_helper.rb
+- spec/virtus_model/base_spec.rb
+homepage: https://github.com/derek-schaefer/virtus_model
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: VirtusModel
+test_files:
+- spec/spec_helper.rb
+- spec/virtus_model/base_spec.rb