anima 0.1.0 → 0.3.2

data/config/roodi.yml

@@ -1,18 +0,0 @@
----
-AbcMetricMethodCheck:            { score: 11.0 }
-AssignmentInConditionalCheck:    { }
-CaseMissingElseCheck:            { }
-ClassLineCountCheck:             { line_count: 293 }
-ClassNameCheck:                  { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
-ClassVariableCheck:              { }
-CyclomaticComplexityBlockCheck:  { complexity: 2 }
-CyclomaticComplexityMethodCheck: { complexity: 4 }
-EmptyRescueBodyCheck:            { }
-ForLoopCheck:                    { }
-# TODO: decrease line_count to 5 to 10
-MethodLineCountCheck:            { line_count: 14 }
-MethodNameCheck:                 { pattern: !ruby/regexp '/\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|[+*&|-])\z/' }
-ModuleLineCountCheck:            { line_count: 295 }
-ModuleNameCheck:                 { pattern: !ruby/regexp '/\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/' }
-# TODO: decrease parameter_count to 2 or less
-ParameterNumberCheck:            { parameter_count: 3 }

data/config/rubocop.yml

@@ -1,85 +0,0 @@
-AllCops:
-  Includes:
-    - '../**/*.rake'
-    - 'Gemfile'
-    - 'Gemfile.devtools'
-    - 'mutant.gemspec'
-  Excludes:
-    - '**/vendor/**'
-    - '**/benchmarks/**'
-
-# Avoid parameter lists longer than five parameters.
-ParameterLists:
-  Max: 3
-  CountKeywordArgs: true
-
-# Avoid more than `Max` levels of nesting.
-BlockNesting:
-  Max: 3
-
-# Align with the style guide.
-CollectionMethods:
-  PreferredMethods:
-    collect:  'map'
-    inject:   'reduce'
-    find:     'detect'
-    find_all: 'select'
-
-# Do not force public/protected/private keyword to be indented at the same
-# level as the def keyword. My personal preference is to outdent these keywords
-# because I think when scanning code it makes it easier to identify the
-# sections of code and visually separate them. When the keyword is at the same
-# level I think it sort of blends in with the def keywords and makes it harder
-# to scan the code and see where the sections are.
-AccessControl:
-  Enabled: false
-
-MethodLength:
-  CountComments: false
-  Max: 17 # TODO: Bring down to 10
-
-RegexpLiteral: # I do not agree %r(\A) is more readable than /\A/
-  Enabled: false
-
-Eval:
-  Enabled: false # Mutant must use Kernel#eval to inject mutated source
-
-# Limit line length
-LineLength:
-  Max: 124  # TODO: lower to 79
-
-# Disable documentation checking until a class needs to be documented once
-Documentation:
-  Enabled: false
-
-# Do not favor modifier if/unless usage when you have a single-line body
-IfUnlessModifier:
-  Enabled: false
-
-# Mutant needs to define methods like def bar; end in specs
-Semicolon:
-  Enabled: false
-
-# Mutant needs to define multiple methods on same line in specs
-EmptyLineBetweenDefs:
-  Enabled: false
-
-# Mutant needs to define singleton methods like Foo.bar in specs
-ClassMethods:
-  Enabled: false
-
-# Allow case equality operator (in limited use within the specs)
-CaseEquality:
-  Enabled: false
-
-# Constants do not always have to use SCREAMING_SNAKE_CASE
-ConstantName:
-  Enabled: false
-
-# Not all trivial readers/writers can be defined with attr_* methods
-TrivialAccessors:
-  Enabled: false
-
-# And also have a differend opinion here
-AndOr:
-  Enabled: false

data/config/yardstick.yml

@@ -1,2 +0,0 @@
----
-threshold: 100

data/lib/anima/update.rb

@@ -1,29 +0,0 @@
-class Anima
-  # Module for mixin in update functionallity to anima infected clases
-  module Update
-
-    # Return updated instance
-    #
-    # @example
-    #   klass = Class.new do
-    #     include Anima.new(:foo, :bar), Anima::Update
-    #   end
-    #
-    #   foo = klass.new(:foo => 1, :bar => 2)
-    #   updated = foo.update(:foo => 3)
-    #   updated.foo # => 3
-    #   updated.bar # => 2
-    #
-    # @param [Hash] attributes
-    #
-    # @return [Anima]
-    #
-    # @api private
-    #
-    def update(attributes)
-      klass = self.class
-      klass.new(klass.attributes_hash(self).merge(attributes))
-    end
-
-  end # Update
-end # Anima

data/spec/integration/simple_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Anima, 'simple integration' do
-  subject { class_under_test.new(attributes) }
-
-  let(:class_under_test) do
-    Class.new do
-      include Anima.new(:firstname, :lastname)
-
-      def self.name
-        'TestClass'
-      end
-    end
-  end
-
-  context 'when instanciated with all attributes' do
-    let(:attributes) do
-      {
-        firstname: 'Markus',
-        lastname:  'Schirp'
-      }
-    end
-
-    its(:firstname) { should eql('Markus') }
-    its(:lastname) { should eql('Schirp') }
-  end
-
-  context 'with instanciated with extra attributes' do
-    let(:attributes) do
-      {
-        firstname: 'Markus',
-        lastname:  'Schirp',
-        extra:     'Foo'
-      }
-    end
-
-    it 'should raise error' do
-      expect { subject }.to raise_error(
-        Anima::Error::Unknown,
-        'Unknown attribute(s) [:extra] for TestClass'
-      )
-    end
-  end
-
-  context 'when instanciated with missing attribute' do
-
-    let(:attributes) { {} }
-
-    it 'should raise error' do
-      expect { subject }.to raise_error(
-        Anima::Error::Missing,
-        'Missing attribute(s) :firstname for TestClass'
-      )
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-# encoding: utf-8
-
-require 'anima'
-require 'devtools'
-Devtools.init_spec_helper
-
-RSpec.configure do |config|
-end

data/spec/unit/anima/attribute_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-
-describe Anima::Attribute do
-  let(:object) { described_class.new(:foo) }
-
-  describe '#define_reader' do
-    subject { object.define_reader(target_class) }
-
-    let(:target_class) do
-      Class.new do
-        def initialize(foo)
-          @foo = foo
-        end
-      end
-    end
-
-    let(:value) { double('Value') }
-
-    it 'should create a reader' do
-      instance = target_class.new(value)
-      -> { subject }.should change { instance.respond_to?(:foo) }.from(false).to(true)
-    end
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#get' do
-    subject { object.get(target) }
-
-    let(:target_class) do
-      Class.new do
-        attr_reader :foo
-
-        def initialize(foo)
-          @foo = foo
-        end
-      end
-    end
-
-    let(:target) { target_class.new(value) }
-    let(:value) { double('Value') }
-
-    it 'should return value' do
-      should be(value)
-    end
-  end
-
-  describe '#instance_variable_name' do
-    subject { Anima::Attribute.new(:foo).instance_variable_name }
-
-    it { should be(:@foo) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#load' do
-    subject { object.load(target, attribute_hash) }
-
-    let(:target) { Object.new }
-
-    let(:value) { double('Value') }
-
-    context 'when attribute hash contains key' do
-      let(:attribute_hash) { { foo: value } }
-
-      it 'should set value as instance variable' do
-        subject
-        target.instance_variable_get(:@foo).should be(value)
-      end
-
-      it_should_behave_like 'a command method'
-
-    end
-
-    context 'when attribute hash does not contain key' do
-      let(:attribute_hash) { {} }
-
-      it 'should raise error' do
-        expect { subject }.to raise_error(Anima::Error::Missing, Anima::Error::Missing.new(target.class, :foo).message)
-      end
-    end
-  end
-
-  describe '#set' do
-    subject { object.set(target, value) }
-
-    let(:target) { Object.new }
-
-    let(:value) { double('Value') }
-
-    it_should_behave_like 'a command method'
-
-    it 'should set value as instance variable' do
-      subject
-      target.instance_variable_get(:@foo).should be(value)
-    end
-  end
-end

data/spec/unit/anima/error_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Anima::Error, '#message' do
-  let(:object) { described_class.new(klass, name) }
-
-  subject { object.message }
-
-  let(:klass) { double(name: 'THE-CLASS-NAME') }
-  let(:name)  { 'THE-ATTRIBUTE-NAME' }
-
-  it 'should return the message string' do
-    should eql('Error attribute(s) "THE-ATTRIBUTE-NAME" for THE-CLASS-NAME')
-  end
-
-  it_should_behave_like 'an idempotent method'
-end

data/spec/unit/anima/update_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Anima::Update, '#update' do
-  subject { object.update(attributes) }
-
-  let(:object) { class_under_test.new(foo: 1, bar: 2) }
-
-  let(:class_under_test) do
-    Class.new do
-      include Anima.new(:foo, :bar), Anima::Update
-    end
-  end
-
-  context 'with empty attributes' do
-    let(:attributes) { {} }
-
-    it { should eql(object) }
-  end
-
-  context 'with updated attribute' do
-    let(:attributes) { { foo: 3 } }
-
-    it { should eql(class_under_test.new(foo: 3, bar: 2)) }
-  end
-end

data/spec/unit/anima_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe Anima do
-
-  let(:object) { described_class.new(:foo) }
-
-  describe '#attributes_hash' do
-
-    let(:value) { double('Value') }
-
-    let(:instance) { double(foo: value) }
-
-    subject { object.attributes_hash(instance) }
-
-    it { should eql(foo: value) }
-  end
-
-  describe '#remove' do
-    let(:object)  { described_class.new(:foo, :bar) }
-
-    context 'with single attribute' do
-      subject { object.remove(:bar) }
-      it { should eql(described_class.new(:foo)) }
-    end
-
-    context 'with multiple attributes' do
-      subject { object.remove(:foo, :bar) }
-      it { should eql(described_class.new) }
-    end
-
-    context 'with inexisting attribute' do
-      subject { object.remove(:baz) }
-
-      it { should eql(object) }
-    end
-  end
-
-  describe '#add' do
-    context 'with single attribute' do
-      subject { object.add(:bar) }
-      it { should eql(described_class.new(:foo, :bar)) }
-    end
-
-    context 'with multiple attributes' do
-      subject { object.add(:bar, :baz) }
-      it { should eql(described_class.new(:foo, :bar, :baz)) }
-    end
-
-    context 'with duplicate attribute ' do
-      subject { object.add(:foo) }
-      it { should eql(object) }
-    end
-  end
-
-  describe '#attributes' do
-    subject { object.attributes }
-
-    it { should eql([Anima::Attribute.new(:foo)]) }
-    it { should be_frozen                         }
-  end
-
-  describe '#included' do
-    let(:target) do
-      object = self.object
-      Class.new do
-        include object
-      end
-    end
-
-    let(:value) { double('Value') }
-
-    let(:instance)   { target.new(foo: value) }
-    let(:instance_b) { target.new(foo: value) }
-    let(:instance_c) { target.new(foo: double('Bar')) }
-
-    context 'on instance' do
-      subject { instance }
-
-      its(:foo) { should be(value) }
-
-      it { should eql(instance_b) }
-    end
-
-    context 'on singleton' do
-      subject { target }
-
-      it 'should define attribute hash reader' do
-        target.attributes_hash(instance).should eql(foo: value)
-      end
-
-      its(:anima) { should be(object) }
-    end
-  end
-
-  describe '#initialize_instance' do
-    let(:object) { Anima.new(:foo, :bar) }
-
-    let(:target) { Object.new }
-
-    let(:foo) { double('Foo') }
-    let(:bar) { double('Bar') }
-
-    subject { object.initialize_instance(target, attribute_hash) }
-
-    context 'when all keys are present in attribute hash' do
-      let(:attribute_hash) { { foo: foo, bar: bar } }
-
-      it 'should initialize target instance variables' do
-        subject
-        target.instance_variables.map(&:to_sym).to_set.should eql([:@foo, :@bar].to_set)
-        target.instance_variable_get(:@foo).should be(foo)
-        target.instance_variable_get(:@bar).should be(bar)
-      end
-
-      it_should_behave_like 'a command method'
-    end
-
-    context 'when extra key is missing in attribute hash' do
-      let(:attribute_hash) { { foo: foo, bar: bar, baz: double('Baz') } }
-
-      it 'should raise error' do
-        expect { subject }.to raise_error(Anima::Error::Unknown, Anima::Error::Unknown.new(target.class, [:baz]).message)
-      end
-    end
-
-    context 'when a key is missing in attribute hash' do
-      let(:attribute_hash) { { bar: bar } }
-
-      it 'should raise error' do
-        expect { subject }.to raise_error(Anima::Error::Missing, Anima::Error::Missing.new(target.class, :foo).message)
-      end
-    end
-  end
-end