mutator 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 266ddb73a57d444d63b9f9460df79a5eb8d19089
-  data.tar.gz: 8597a08ee353f97a42a3d7469bf187c494ce1723
+  metadata.gz: d69e47c148240cf6a7f6000f259980b0ef39caa6
+  data.tar.gz: b1aa0ed144d14bd76ab91a1884f7d005519afbb3
 SHA512:
-  metadata.gz: 0f84541de39489ad4dab75b699e895b9f552cf86b0302cc02c93865d64001f43a646d7726515432bb29656df2a6987546122c7906c79047606a1ee0f8f73fb8e
-  data.tar.gz: 0e640ac518c45bf09731a77201096c1d57d860fc34ca8e7c90dc85f58e93222fee50d1c9fd9e4b355bf7adc38705f0d274ab2eebd86b3f4779817a813d1d398b
+  metadata.gz: ae7fdbe701040f8116984b8ed5222231f97333dfa1b62068eec392b3aa9ea5f05cf40ed60d3a33b5ab3616f1175ef910e5b9d6ddeeb268b22806f4d7f2865fc5
+  data.tar.gz: 94afab94f0b66e4b76d1c6f5086fb5080db2040eab6215dc55254ee0b365932a133f0fcdc7597497ba659eead9d185c19d6591e6c39ca117498a2028cc3572c9

data/.hound.yml

@@ -0,0 +1,5 @@
+StringLiterals:
+  Enabled: false
+
+AccessModifierIndentation:
+  EnforcedStyle: outdent

data/README.md

@@ -1,3 +1,8 @@
+[![Gem Version](https://badge.fury.io/rb/mutator.png)](http://badge.fury.io/rb/mutator)
+[![Build Status](https://travis-ci.org/ericroberts/mutator.png?branch=master)](https://travis-ci.org/ericroberts/mutator)
+[![Code Climate](https://codeclimate.com/github/ericroberts/mutator.png)](https://codeclimate.com/github/ericroberts/mutator)
+[![Coverage Status](https://coveralls.io/repos/ericroberts/mutator/badge.png?branch=master)](https://coveralls.io/r/ericroberts/mutator?branch=master)
+
 # Mutator
 
 Yes, this is another state machine gem. Why? Well, among the major state machine gems I found, they didn't quite do what I was looking for. So I wrote my own. Plus, reinventing the wheel is fun!
@@ -46,7 +51,7 @@ end
 
 ### So how do I use it?
 
-Transition looks like this:
+Transitions look like this:
 
 ``` ruby
 wonder = Wonder.new

data/lib/mutator/helpers.rb

@@ -5,7 +5,7 @@ module Mutator
     end
 
     def self.included(base)
-      "Mutator::#{base.name}".constantize.states.each do |state|
+      Mutator.const_get(base.name, false).states.each do |state|
         base.send(:define_singleton_method, state) do
           self.where(state: state)
         end
@@ -15,7 +15,7 @@ module Mutator
   protected
 
     def machine_class
-      "Mutator::#{self.class.name}".constantize
+      Mutator.const_get(self.class.name, false)
     end
   end
 end

data/lib/mutator/machine.rb

@@ -14,11 +14,11 @@ module Mutator
       stateholder.state
     end
 
-    def transition(to:, success: lambda { |_transition| }, failure: lambda { |_transition| })
-      transition = Transition.new(to: to, from: current_state, machine: self)
+    def transition(options)
+      options = extract(options)
+      success, failure, transition = options.values
 
-      if transition.valid?
-        stateholder.state = to
+      if transition.call
         success.call(transition)
         true
       else
@@ -28,8 +28,9 @@ module Mutator
     end
 
     def self.states
-      self.transitions.map do |t|
-        [t[:to], t[:from]]
+      self.transitions.map do |transition|
+        to, from = transition[:to], transition[:from]
+        [to, from]
       end.flatten.uniq
     end
 
@@ -40,5 +41,22 @@ module Mutator
     def transitions
       self.class.transitions
     end
+
+  protected
+
+    def extract(options)
+      to = options[:to]
+      fail ArgumentError, 'must provide state to transition to' unless to
+
+      {
+        success: lambda { |_| },
+        failure: lambda { |_| },
+        transition: Transition.new(
+          to: to,
+          from: current_state,
+          machine: self
+        )
+      }.merge(options)
+    end
   end
 end

data/lib/mutator/transition.rb

@@ -2,23 +2,42 @@ module Mutator
   class Transition
     attr_reader :to, :from, :machine
 
-    def initialize(to:, from:, machine:)
-      @to, @from, @machine = to, from, machine
+    def initialize(opts)
+      require_parameters!(opts)
+      @to, @from, @machine = opts[:to], opts[:from], opts[:machine]
+    end
+
+    def call
+      stateholder.state = to if valid?
     end
 
     def valid?
-      transitions.present?
+      transitions.length > 0
     end
 
     def stateholder
       machine.stateholder
     end
 
+    def ==(other)
+      to == other.to && from == other.from && machine == other.machine
+    end
+
+    def eql?(other)
+      public_send(:==, other)
+    end
+
   protected
 
     def transitions
-      machine.transitions.select do |t|
-        t[:to] == to && t[:from].include?(from)
+      machine.transitions.select do |transition|
+        transition[:to] == to && transition[:from].include?(from)
+      end
+    end
+
+    def require_parameters!(opts)
+      [:to, :from, :machine].each do |attr|
+        fail ArgumentError, "must provide #{attr}" unless opts[attr]
       end
     end
   end

data/lib/mutator/version.rb

@@ -1,3 +1,3 @@
 module Mutator
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/mutator.gemspec

@@ -22,4 +22,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "pry"
 end

data/spec/lib/mutator/helpers_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe Mutator::Helpers do
+  subject { Mutator::Helpers }
+
+  describe '.included' do
+    let(:base) { Stateholder }
+
+    it 'should not error' do
+      expect { subject.included(base) }.to_not raise_error
+    end
+  end
+
+  context 'when included' do
+    subject { Stateholder.new }
+
+    describe '#machine' do
+      it 'should respond to it' do
+        expect(subject).to respond_to :machine
+      end
+
+      it 'should return a Mutator::Stateholder object' do
+        expect(subject.machine).to be_a Mutator::Stateholder
+      end
+    end
+
+    [:initial_state, :second_state, :third_state].each do |state|
+      describe ".#{state}" do
+        it 'should respond to the method' do
+          expect(subject.class).to respond_to state
+        end
+
+        it 'should call where on the stateholder' do
+          expect(subject.class).to receive(:where).
+                                    with(state: state).
+                                    and_return(Stateholder.new)
+          subject.class.public_send(state)
+        end
+      end
+    end
+  end
+end

data/spec/lib/mutator/machine_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe Mutator::Stateholder do
+  subject { Mutator::Stateholder.new(stateholder) }
+  let(:stateholder) { Stateholder.new }
+
+  describe '#initialize' do
+    it 'should not error' do
+      expect { subject }.to_not raise_error
+    end
+  end
+
+  describe '#stateholder' do
+    it 'should return the stateholder it was passed' do
+      expect(subject.stateholder).to eq stateholder
+    end
+  end
+
+  describe '#valid?' do
+    it 'should be valid if the state exists in states list' do
+      subject.stateholder.state = :initial_state
+      expect(subject).to be_valid
+    end
+
+    it 'should not be valid for a state not in states list' do
+      subject.stateholder.state = :foobar
+      expect(subject).to_not be_valid
+    end
+  end
+
+  describe '#current_state' do
+    it 'should return the stateholder state' do
+      expect(subject.current_state).to eq stateholder.state
+    end
+  end
+
+  describe '#transition' do
+    let(:transition) do
+      Mutator::Transition.new(to: to, from: from, machine: subject)
+    end
+
+    context 'arguments' do
+      it 'should raise an exception if you do not provide to' do
+        expect { subject.transition }.to raise_error ArgumentError
+      end
+
+      it 'should not raise if to is provided' do
+        expect { subject.transition to: :any_state }.to_not raise_error
+      end
+    end
+
+    context 'valid transition' do
+      let(:from) { :initial_state }
+      let(:to) { :second_state }
+
+      before { subject.stateholder.state = from }
+
+      it 'should update state' do
+        expect(subject.stateholder.state).to eq from
+        subject.transition(to: to)
+        expect(subject.stateholder.state).to eq to
+      end
+
+      it 'should return true' do
+        expect(subject.transition(to: to)).to be true
+      end
+
+      context 'with success policy' do
+        let(:success) { double }
+
+        before { allow(success).to receive(:call).and_return(true) }
+
+        it 'should still update state' do
+          expect(subject.stateholder.state).to eq from
+          subject.transition(to: to, success: success)
+          expect(subject.stateholder.state).to eq to
+        end
+
+        it 'should still return true' do
+          expect(subject.transition(to: to, success: success)).to be true
+        end
+
+        it 'should call the success policy' do
+          expect(success).to receive(:call).and_return(true)
+          subject.transition(to: to, success: success)
+        end
+
+        it 'should call the success policy with transition' do
+          expect(success).to receive(:call).with(transition).and_return(true)
+          subject.transition(to: to, success: success)
+        end
+      end
+    end
+
+    context 'invalid transition' do
+      let(:from) { :initial_state }
+      let(:to) { :third_state }
+
+      before { subject.stateholder.state = from }
+
+      it 'should not update state' do
+        expect(subject.stateholder.state).to eq from
+        subject.transition(to: to)
+        expect(subject.stateholder.state).to eq from
+      end
+
+      it 'should return false' do
+        expect(subject.transition(to: to)).to be false
+      end
+
+      context 'with failure policy' do
+        let(:failure) { double }
+
+        before { allow(failure).to receive(:call).and_return(true) }
+
+        it 'should still not update state' do
+          expect(subject.stateholder.state).to eq from
+          subject.transition(to: to, failure: failure)
+          expect(subject.stateholder.state).to eq from
+        end
+
+        it 'should still return false' do
+          expect(subject.transition(to: to, failure: failure)).to be false
+        end
+
+        it 'should call the failure policy' do
+          expect(failure).to receive(:call).and_return(true)
+          subject.transition(to: to, failure: failure)
+        end
+
+        it 'should call the failure policy with transition' do
+          expect(failure).to receive(:call).with(transition).and_return(true)
+          subject.transition(to: to, failure: failure)
+        end
+
+        context 'when policy is to raise an exception' do
+          before { expect(failure).to receive(:call).and_raise(Exception) }
+
+          it 'should raise an exception' do
+            expect { subject.transition(to: to, failure: failure) }.to raise_error Exception
+          end
+        end
+      end
+    end
+  end
+
+  describe '#states' do
+    it 'should respond to states' do
+      expect(subject).to respond_to :states
+    end
+
+    it 'should extract states from transitions' do
+      expect(subject.states.sort).to eq [
+        :initial_state,
+        :second_state,
+        :third_state
+      ].sort
+    end
+  end
+
+  describe '#transitions' do
+    it 'should respond to' do
+      expect(subject).to respond_to :transitions
+    end
+  end
+end

data/spec/lib/mutator/transition_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe Mutator::Transition do
+  subject { Mutator::Transition.new(to: to, from: from, machine: machine) }
+  let(:to) { :initial_state }
+  let(:from) { :second_state }
+  let(:machine) { Mutator::Stateholder.new(stateholder) }
+  let(:stateholder) { Stateholder.new }
+
+  describe '#initialize' do
+    it 'should not error' do
+      expect { subject }.to_not raise_error
+    end
+
+    context 'arguments' do
+      [:to, :from, :machine].each do |attr|
+        it "should require you to pass #{attr}" do
+          args = { to: :something, from: :something, machine: :something }
+          args.delete attr
+          expect { subject.class.new(args) }.to raise_error ArgumentError, "must provide #{attr}"
+        end
+      end
+    end
+  end
+
+  [:to, :from, :machine].each do |attr|
+    describe "##{attr}" do
+      it 'should be set to what it was passed' do
+        expect(subject.public_send(attr)).to eq public_send(attr)
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'transition is valid' do
+      let(:to) { :second_state }
+      let(:from) { :initial_state }
+
+      it 'should return the new state' do
+        expect(subject.call).to eq :second_state
+      end
+    end
+
+    context 'transition is invalid' do
+      let(:to) { :third_state }
+      let(:from) { :initial_state }
+
+      it 'should return the new state' do
+        expect(subject.call).to be nil
+      end
+    end
+  end
+
+  describe '#valid?' do
+    context 'valid transition' do
+      let(:to) { :second_state }
+      let(:from) { :initial_state }
+
+      it 'should be true' do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'invalid transition' do
+      let(:to) { :third_state }
+      let(:from) { :initial_state }
+
+      it 'should be false' do
+        expect(subject).to_not be_valid
+      end
+    end
+  end
+
+  describe '#stateholder' do
+    it 'should return the machine stateholder' do
+      expect(subject.stateholder).to eq machine.stateholder
+    end
+  end
+
+  shared_examples 'equal' do |method|
+    it 'should consider itself equal to another transition that is the same' do
+      transition1 = subject.class.new(to: to, from: from, machine: machine)
+      transition2 = subject.class.new(to: to, from: from, machine: machine)
+
+      expect(transition1.public_send(method, transition2)).to be true
+    end
+  end
+
+  describe '#==' do
+    it_should_behave_like 'equal', :==
+  end
+
+  describe '#eql?' do
+    it_should_behave_like 'equal', :eql?
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,4 @@
 require 'coveralls'
 Coveralls.wear!
+
+require 'mutator'

data/spec/support/test_classes.rb

@@ -0,0 +1,23 @@
+module Mutator
+  class Stateholder < Machine
+    def self.transitions
+      [
+        { from: [:initial_state], to: :second_state },
+        { from: [:second_state], to: :third_state }
+      ]
+    end
+  end
+end
+
+class Stateholder
+  include Mutator::Helpers
+
+  attr_writer :state
+
+  def state
+    @state ||= :initial_state
+  end
+
+  def self.where(*)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutator
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Eric Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
+date: 2014-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Yet another state machine gem. I didn't find one I liked, so I made one.
   I probably didn't look hard enough.
 email:
@@ -75,6 +103,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
@@ -87,7 +116,11 @@ files:
 - lib/mutator/transition.rb
 - lib/mutator/version.rb
 - mutator.gemspec
+- spec/lib/mutator/helpers_spec.rb
+- spec/lib/mutator/machine_spec.rb
+- spec/lib/mutator/transition_spec.rb
 - spec/spec_helper.rb
+- spec/support/test_classes.rb
 homepage: https://github.com/ericroberts/mutator
 licenses:
 - MIT
@@ -113,4 +146,8 @@ signing_key:
 specification_version: 4
 summary: Mutator is just another state machine gem.
 test_files:
+- spec/lib/mutator/helpers_spec.rb
+- spec/lib/mutator/machine_spec.rb
+- spec/lib/mutator/transition_spec.rb
 - spec/spec_helper.rb
+- spec/support/test_classes.rb