just_state_machine 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c74ea95f48cdea857973b9cd65ff7985ef34f21
+  data.tar.gz: 0fa48156ccd7ef61c450855c053b2d362a5e34ee
+SHA512:
+  metadata.gz: 0ca6342ddbe7928a00f6afa8bc9adc5cb9ee09832e877c275f431a22e7a97e411e9d8913a8243b57213e3fa33956e4d4182af0e3168a56137231e2d64270a172
+  data.tar.gz: bfa61404cbf03c319c0e09ccf46ca01298ee8a1c12f6a2b17d26db169689bef2b3d03d1d764797eec1395810af7e4e45419461a2450ab90ef9329f97ed0a7f00

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.5
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jsm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 wendy0402
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,264 @@
+[![Gem Version](https://badge.fury.io/rb/jsm.svg)](https://badge.fury.io/rb/jsm)
+[![Code Climate](https://codeclimate.com/github/wendy0402/jsm/badges/gpa.svg)](https://codeclimate.com/github/wendy0402/jsm)
+# Jsm
+
+JSM is abbreviation of Just State Machine. The purpose is to simplify and increase the clarity of code related with state. JSM support validations before do transition. It help you to prevent unwanted transition. It also support integration with `ActiveModel` and `ActiveRecord`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jsm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jsm
+
+## Usage
+
+### State Machine Definition
+To use `JSM`, a state machine class need to be created. Define your state machine here, such as:
+* state
+* event
+* transition
+* state validation
+* attribute(the client state value)
+
+```ruby
+class UserStateMachine < Jsm::Base
+  attribute_name :title
+
+  state :beginner
+  state :intermediate
+  state :master
+
+  validate :intermediate do |user|
+	  (20..50).include?(user.current_level)
+  end
+
+  validate :master do |user|
+	  user.current_level > 50
+  end
+
+  event :upgrade_title do
+    transition from: [:beginner], to: :intermediate
+    transition from: [:intermediate], to: :master
+  end
+
+  event :downgrade_title do
+    transition from: :intermediate, to: :beginner
+    transition from: :master, to: :intermediate
+  end
+end
+```
+
+### Client
+To use the state machine definition specify it as below
+```ruby
+class User
+  include Jsm::Client
+  jsm_use UserStateMachine # your state machine class here
+
+  attr_accessor :title # same with attribute_name in UserStateMachine
+  #your code here
+end
+```
+**note**: Client class should have instance variable same with `attribute_name` specified in state machine class.
+
+This also provides you with a couple of public methods(based on event) for instances of the class `User`:
+```ruby
+user = User.new
+user.upgrade_title # run event confirm, return true/ false
+user.upgrade_title! # run event confirm, raise error Jsm::IllegalTransitionError if failed
+user.can_upgrade_title? # check if can run event successfully, return true/false
+
+user.downgrade_title
+user.downgrade_title!
+user.can_downgrade_title?
+```
+
+### Validation
+This is useful, when you want to allow transition to a specified state allowed when it pass the validation. Validation should return true if passed validation and false if failed.
+**note**: Dont forget to define the state first, because if not then Jsm will raise error `Jsm::InvalidStateError`. This is to prevent typo when add new validation
+``` ruby
+class UserStateMachine < Jsm::Base
+# many codes here
+
+  state :intermediate
+  validate :intermediate do |user|
+    (20..50).include?(user.current_level)
+  end
+# many codes here
+end
+```
+
+### Event
+when an event is triggered, it run `validate`. If passed, then it run `transition`. In the event of having multiple transitions, the first transition that successfully completes will stop other transitions to be executed.
+```ruby
+class UserStateMachine < Jsm::Base
+  attribute_name :level
+
+  state :beginner
+  state :intermediate
+  state :master
+
+  event :upgrade_title do
+    transition from: [:beginner], to: :intermediate
+    transition from: [:intermediate], to: :master
+  end
+
+  event :downgrade_title do
+    transition from: :intermediate, to: :beginner
+    transition from: :master, to: :intermediate
+  end
+end
+
+# Client Class
+class User
+  include Jsm::Client
+  jsm_use UserStateMachine # your state machine class here
+
+  attr_accessor :title # same with attribute_name in UserStateMachine
+  def initialize
+	  @title = :beginner
+	  @level = 1
+  end
+  #your code here
+end
+
+user = User.new
+user.title # :beginner
+user.upgrade_title # true
+user.title # :intermediate
+```
+
+## Active Model Integration
+```ruby
+class UserStateMachine < Jsm::Base
+  attribute_name :title
+
+  state :unconfirmed
+  state :beginner
+  state :intermediate
+  state :master
+
+  validate :intermediate do |user|
+    unless (20..50).include?(user.current_level)
+      user.errors.add(:title, 'is not between 20 and 50')
+    end
+  end
+
+  validate :master do |user|
+    unless user.current_level > 50
+     user.errors.add(:title, 'have not reached 50')
+    end
+  end
+
+  event :upgrade_title do
+    transition from: [:beginner], to: :intermediate
+    transition from: [:intermediate], to: :master
+  end
+
+  event :downgrade_title do
+    transition from: :intermediate, to: :beginner
+    transition from: :master, to: :intermediate
+  end
+end
+
+# Client Class
+class User
+  include ActiveModel::Model
+  include Jsm::Client
+  include Jsm::Client::ActiveModel
+  jsm_use UserStateMachine # your state machine class here
+
+  attr_accessor :title # same with attribute_name in UserStateMachine
+  attr_accessor :level
+  def initialize
+	@title = :beginner
+	@level = 1
+  end
+  #your code here
+end
+```
+
+`Jsm`  support `ActiveModel`. In the `client` class include the `Jsm::Client::ActiveModel`.  when run an event. It will auto saved the object.
+
+### Validation
+It also support validation from `ActiveModel` . Validation checked based on `errors` value in the `instance`. you can add an error to the errors object. This will prevent the state from being changed
+```
+user = User.new
+user.level # 1
+user.level = 18
+user.upgrade_title # false
+user.errors[:title] # ["is not between 20 and 50"]
+```
+## ActiveRecord Integration
+```ruby
+class UserStateMachine < Jsm::Base
+  attribute_name :title
+
+  state :unconfirmed
+  state :beginner
+  state :intermediate
+  state :master
+
+  validate :intermediate do |user|
+    unless (20..50).include?(user.current_level)
+      user.errors.add(:title, 'is not between 20 and 50')
+    end
+  end
+
+  validate :master do |user|
+    unless user.current_level > 50
+     errors.add(:title, 'have not reached 50')
+    end
+  end
+
+  event :upgrade_title do
+    transition from: [:beginner], to: :intermediate
+    transition from: [:intermediate], to: :master
+  end
+
+  event :downgrade_title do
+    transition from: :intermediate, to: :beginner
+    transition from: :master, to: :intermediate
+  end
+end
+
+# Client Class
+class User
+  include ActiveModel::Model
+  include Jsm::Client
+  include Jsm::Client::ActiveModel
+  jsm_use UserStateMachine # your state machine class here
+
+  attr_accessor :title # same with attribute_name in UserStateMachine
+  attr_accessor :level
+  def initialize
+	@title = :beginner
+	@level = 1
+  end
+  #your code here
+end
+```
+`Jsm`  support `ActiveRecord`. In the `client` class include the `Jsm::Client::ActiveRecord`.  It also support `ActiveRecord` Validation. The behavior is same with `ActiveModel` client.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wendy0402/jsm. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "jsm"
+Dir[File.expand_path("../../examples/**/*.rb",__FILE__)].each{ |f| require f }
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/active_record_state_machine.rb

@@ -0,0 +1,59 @@
+require 'active_record'
+class ActiveRecordSM < Jsm::Base
+  attribute_name :relationship
+
+  state "single"
+  state "in_relationship"
+  state "married"
+  state "divorced"
+  state "widowed"
+
+  event :start_dating do
+    transition from: "single", to: "in_relationship"
+  end
+
+  event :marry do
+    transition from: ["single", "in_relationship"], to: "married"
+  end
+
+  event :cheating do
+    transition from: "in_relationship", to: "single"
+    transition from: "married", to: "divorced"
+  end
+
+  event :divorce do
+    transition from: "married", to: "divorced"
+  end
+
+  validate "married" do |user|
+    unless user.approved_by_parents
+      user.errors.add(:approved_by_parents, 'can not marry, you havent been approved')
+    end
+  end
+end
+
+ActiveRecord::Base.configurations = {
+  'db1' => {
+    :adapter  => 'sqlite3',
+    :encoding => 'utf8',
+    :database => ':memory:',
+  }
+}
+ActiveRecord::Base.establish_connection(:db1)
+
+class UserAR < ActiveRecord::Base
+  include Jsm::Client
+  include Jsm::Client::ActiveRecord
+  self.table_name = 'users'
+
+  validates_presence_of :age
+  jsm_use ActiveRecordSM
+end
+
+UserAR.connection.drop_table('users') if UserAR.connection.table_exists?(:users)
+UserAR.connection.create_table :users do |a|
+  a.string :relationship
+  a.string :name
+  a.boolean :approved_by_parents
+  a.text :age
+end

data/examples/simple_state_machine.rb

@@ -0,0 +1,34 @@
+class UserStateMachine < Jsm::Base
+  attribute_name :relationship
+
+  state :single
+  state :in_relationship
+  state :married
+  state :divorced
+  state :widowed
+
+  event :start_dating do
+    transition from: :single, to: :in_relationship
+  end
+
+  event :marry do
+    transition from: [:single, :in_relationship], to: :married
+  end
+
+  event :cheating do
+    transition from: :in_relationship, to: :single
+    transition from: :married, to: :divorced
+  end
+
+  event :divorce do
+    transition from: :married, to: :divorced
+  end
+end
+
+
+class UserBasic
+  include Jsm::Client
+  jsm_use UserStateMachine
+
+  attr_accessor :relationship
+end

data/jsm.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "just_state_machine"
+  spec.version       = Jsm::VERSION
+  spec.authors       = ["wendy0402"]
+  spec.email         = ["wendykurniawan92@gmail.com"]
+
+  spec.summary       = "Just State Machine, State Machine That support custom validations, it also known with Jsm"
+  spec.description   = "Just StateMachine"
+  spec.homepage      = "https://github.com/wendy0402/jsm"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-doc"
+  spec.add_development_dependency "looksee"
+  spec.add_development_dependency "activerecord", "~> 4.1"
+  spec.add_development_dependency "sqlite3"
+end

data/lib/jsm.rb

@@ -0,0 +1,20 @@
+module Jsm
+  require "jsm/version"
+  require "jsm/states"
+  require "jsm/event"
+  require "jsm/exceptions"
+  require "jsm/machines"
+  require "jsm/base"
+  require "jsm/client"
+  require "jsm/client/active_model"
+  require "jsm/client/active_record"
+  require "jsm/client_extension"
+  require "jsm/validator"
+  require "jsm/validators"
+
+  module EventExecutor
+    require "jsm/event_executor/base"
+    require "jsm/event_executor/active_model"
+    require "jsm/event_executor/active_record"
+  end
+end

data/lib/jsm/base.rb

@@ -0,0 +1,71 @@
+# this module used as extension for state machine class
+# The DSL is built to define the state, event, and transition that happen
+class Jsm::Base
+
+  # define attribute name of state attribute in the client class
+  def self.attribute_name(attribute_name = nil)
+    if attribute_name.nil?
+      @attribute_name
+    else
+      @attribute_name = attribute_name
+    end
+  end
+
+  # add new state to class
+  # example
+  # state :x
+  # state :y
+  def self.state(name, params = {})
+    @states ||= Jsm::States.new
+    @states.add_state(name, initial: params[:initial])
+  end
+
+  # list of all states
+  def self.states
+    @states.list
+  end
+
+  # add new event to the class and add its transition
+  # example:
+  # event :do_this do
+  # transition from: :x, to: :y
+  # transition from: [:j, :g], to: :z
+  def self.event(name, &block)
+    @events ||= {}
+    if !@events[name].nil?
+      raise Jsm::InvalidEventError, "event #{name} has been registered"
+    end
+
+    @events[name] = Jsm::Event.new(name, states: @states, &block)
+  end
+
+  # get list of all events
+  def self.events
+    @events
+  end
+
+  # add validation of a state(when changes to the targeted state, check whether passed this validation or not)
+  # example:
+  # state :y
+  # validate :y do |obj|
+  #   obj.name == 'testMe'
+  # end
+  def self.validate(state_name, &block)
+    unless @states.has_state?(state_name)
+      raise Jsm::InvalidStateError, "there is no state y"
+    end
+
+    @validators ||= Jsm::Validators.new
+    @validators.add_validator(state_name, Jsm::Validator.new(:state, state_name, &block))
+  end
+
+  # list all validators that exist
+  def self.validators
+    @validators
+  end
+
+  def initialize(klass)
+    @klass = klass
+    Jsm::ClientExtension.decorate(@klass, state_machine: self.class)
+  end
+end

data/lib/jsm/client.rb

@@ -0,0 +1,46 @@
+module Jsm::Client
+  def self.included(base)
+    base.extend ClassMethods
+    base.send(:include, InstanceMethods)
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      base.class_eval <<-EOFILE, __FILE__, __LINE__
+        private :jsm_set_state
+      EOFILE
+    end
+
+    def state_machine
+      self.class.respond_to?(:state_machine) ? self.class.state_machine : nil
+    end
+
+    # able to get current state from here instead check from the targeted attribute
+    def current_state
+      attr_state = state_machine.attribute_name
+      instance_variable_get("@#{attr_state}".to_sym)
+    end
+
+    # used for set new state by JSM
+    def jsm_set_state(val)
+      attr_state = state_machine.attribute_name
+      instance_variable_set("@#{attr_state}".to_sym, val)
+    end
+  end
+
+  module ClassMethods
+    def jsm_use(state_machine)
+      self.class_eval <<-EODEF, __FILE__, __LINE__
+        def self.state_machine
+          #{state_machine}
+        end
+      EODEF
+      Jsm::Machines.add_machines(self, state_machine.new(self))
+    end
+
+    #define type of event executor to be used
+    def jsm_event_executor
+      Jsm::EventExecutor::Base
+    end
+  end
+end

data/lib/jsm/client/active_model.rb

@@ -0,0 +1,24 @@
+module Jsm::Client::ActiveModel
+  def self.included(base)
+    base.extend ClassMethods
+    base.send(:include, InstanceMethods)
+  end
+
+  module InstanceMethods
+    def current_state
+      attr_state = state_machine.attribute_name
+      send(attr_state)
+    end
+
+    def jsm_set_state(val)
+      attr_state = state_machine.attribute_name
+      send("#{attr_state}=", val)
+    end
+  end
+
+  module ClassMethods
+    def jsm_event_executor
+      Jsm::EventExecutor::ActiveModel
+    end
+  end
+end

data/lib/jsm/client/active_record.rb

@@ -0,0 +1,13 @@
+module Jsm::Client::ActiveRecord
+  def self.included(base)
+    base.extend ClassMethods
+    # Basically ActiveModel and ActiveRecord almost have the same behavior for its instance
+    base.send(:include, Jsm::Client::ActiveModel::InstanceMethods)
+  end
+
+  module ClassMethods
+    def jsm_event_executor
+      Jsm::EventExecutor::ActiveRecord
+    end
+  end
+end

data/lib/jsm/client_extension.rb

@@ -0,0 +1,67 @@
+# Jsm::ClientExtension define all custom methods for the model that use the state machine class
+# E.g: Define method for states
+class Jsm::ClientExtension
+  def self.decorate(klass, params = {})
+    client_extension = new(klass, params)
+    client_extension.define_states_method
+    client_extension.define_event_method
+  end
+
+  attr_reader :klass, :state_machine, :event_executor
+  def initialize(klass, params = {})
+    @klass = klass
+    @state_machine = params[:state_machine]
+    @event_executor = klass.jsm_event_executor.new(validators: @state_machine.validators)
+    unless @state_machine.attribute_name
+      raise Jsm::NoAttributeError, "please assign the attribute_name first in class #{@state_machine.name}"
+    end
+  end
+
+  # define method for all states to check status equal with a states
+  # e.g: states: [:x, :y]
+  # it will define method `x?` and `y?`
+  def define_states_method
+    state_machine.states.each do |state|
+      state_name = state.name
+      klass.send(:define_method, "#{state_name}?".to_sym) do
+        self.current_state == state_name
+      end
+    end
+  end
+
+  # define all event that has been defined
+  # it consists of 3 types of method:
+  # * method to check whether can do event( e.g: can_married? )
+  # * method to run an event and return bollean( e.g: married )
+  # * method to run an event and raise error if failed( e.g: married! )
+  def define_event_method
+    state_machine.events.each do |event_name, event|
+      event.attribute_name = state_machine.attribute_name
+      define_can_event_method(event_name, event)
+      define_event_execution_method(event_name, event)
+      define_event_execution_method!(event_name, event)
+    end
+  end
+
+  private
+  def define_can_event_method(event_name, event)
+    executor = event_executor
+    klass.send(:define_method, "can_#{event_name}?") do
+      executor.can_be_executed?(event, self)
+    end
+  end
+
+  def define_event_execution_method(event_name, event)
+    executor = event_executor
+    klass.send(:define_method, "#{event_name}") do
+      executor.execute(event, self)
+    end
+  end
+
+  def define_event_execution_method!(event_name, event)
+    executor = event_executor
+    klass.send(:define_method, "#{event_name}!") do
+      executor.execute!(event, self)
+    end
+  end
+end

data/lib/jsm/event.rb

@@ -0,0 +1,88 @@
+# Jsm::Event handle event related task registered by the main module.
+# It do transition process from one state to another state
+class Jsm::Event
+  attr_reader :name, :states, :transitions
+  attr_accessor :attribute_name
+
+  ::Jsm::Transition = Struct.new(:from, :to)
+  def initialize(name, params = {}, &block)
+    @name = name
+    @states = params[:states]
+    @transitions = []
+    instance_eval(&block) if block_given?
+  end
+
+  # register a transition into the. When Event is executed,
+  # these transitions is transitioning an object into `to` state,
+  # if their current state match with one of the `from` state.
+  # the argument input is params `from` and params `to`.
+  # Both params should be exist
+  def transition(params = {})
+    validate_params(params)
+    validate_state_transition(params)
+    from = params[:from].is_a?(Array) ? params[:from] : [params[:from]]
+    transition = Jsm::Transition.new(from, params[:to])
+    @transitions.push(transition)
+  end
+
+
+  # execute the event, and do a transition
+  # if the object current state match with the from state of a transition
+  def execute(object)
+    transition = can_be_transitioning_to(object)
+    if transition
+      change_state_obj(object, transition.to)
+      true
+    else
+      false
+    end
+  end
+
+  # check when running this event, which transitions can change the state of object state
+  # return the transition object
+  def can_be_transitioning_to(object)
+    transitions.find{ |transition| transition.from.include?(obj_state(object)) }
+  end
+
+  # method to check whether this event can be executed
+  def can_be_executed?(object)
+    from_states = transitions.map(&:from).flatten
+    from_states.include?(object.current_state)
+  end
+
+  private
+
+  def obj_state(object)
+    object.current_state
+  end
+
+  def change_state_obj(object, to_state)
+    object.send("jsm_set_state", to_state)
+  end
+
+  def validate_params(params = {})
+    from = params[:from]
+    if (from.respond_to?(:empty) && from.empty?) || !from
+      raise ArgumentError, "transition is invalid, missing required parameter from"
+    end
+
+    to = params[:to]
+
+    if (to.respond_to?(:empty) && to.empty?) || !to
+      raise ArgumentError, "transition is invalid, missing required parameter to"
+    end
+  end
+
+  def validate_state_transition(params = {})
+    from = Array(params[:from])
+    to = params[:to]
+    invalid_state = from.select {|state_name| !states.has_state?(state_name) }
+    unless invalid_state.empty?
+      raise Jsm::InvalidTransitionError, "parameter from is invalid. there is no state #{invalid_state.join(', ')} in list"
+    end
+
+    unless states.has_state?(to)
+      raise Jsm::InvalidTransitionError, "parameter to is invalid. there is no state #{to} in list"
+    end
+  end
+end

data/lib/jsm/event_executor/active_model.rb

@@ -0,0 +1,25 @@
+class Jsm::EventExecutor::ActiveModel < Jsm::EventExecutor::Base
+  # it execute event for the object.
+  # If transition failed or invalid by validation toward the object,
+  # then it will return false
+  def execute(event, obj)
+    if can_be_executed?(event, obj)
+      event.execute(obj)
+    else
+      false
+    end
+  end
+
+  # check if the obj possible to execute the event
+  def can_be_executed?(event, obj)
+    state = event.can_be_transitioning_to(obj)
+    attribute_name = obj.class.state_machine.attribute_name
+    obj.valid?
+    if state
+      validators.validate(state.to, obj)
+    else
+      obj.errors.add(attribute_name, 'no transitions match')
+    end
+    obj.errors.empty?
+  end
+end

data/lib/jsm/event_executor/active_record.rb

@@ -0,0 +1,16 @@
+class Jsm::EventExecutor::ActiveRecord < Jsm::EventExecutor::ActiveModel
+  def execute(event, obj)
+    if can_be_executed?(event, obj)
+      result = false
+      # do transaction to prevent shit happen
+      ActiveRecord::Base.transaction do
+        obj.class.lock
+        event.execute(obj)
+        result = obj.save
+      end
+      result
+    else
+      false
+    end
+  end
+end

data/lib/jsm/event_executor/base.rb

@@ -0,0 +1,29 @@
+# this class is the base for adapter
+# it can be extended for ActiveRecord adapter
+class Jsm::EventExecutor::Base
+  attr_reader :validators
+  def initialize(params = {})
+    @validators = params[:validators] || Jsm::Validators.new
+  end
+
+  # it execute event for the object.
+  # If transition failed or invalid by validation toward the object,
+  # then it will return false
+  def execute(event, obj)
+    can_be_executed?(event, obj) ? event.execute(obj) : false
+  end
+
+  # check if the obj possible to execute the event(passed the validation and can do transition)
+  def can_be_executed?(event, obj)
+    state = event.can_be_transitioning_to(obj)
+    !!state && validators.validate(state.to, obj)
+  end
+
+  # same with execute, but if its failed raise error
+  def execute!(event, obj)
+    unless execute(event, obj)
+      raise Jsm::IllegalTransitionError, "there is no matching transitions or invalid, Cant do event #{event.name}"
+    end
+    true
+  end
+end

data/lib/jsm/exceptions.rb

@@ -0,0 +1,9 @@
+class Jsm::NotUniqueStateError < StandardError; end
+class Jsm::InvalidStateError < StandardError; end
+
+class Jsm::InvalidTransitionError < StandardError; end
+class Jsm::IllegalTransitionError < StandardError;end
+
+class Jsm::InvalidEventError < StandardError;end
+
+class Jsm::NoAttributeError < StandardError;end

data/lib/jsm/machines.rb

@@ -0,0 +1,10 @@
+class Jsm::Machines
+  def self.add_machines(klass, state_machine)
+    @@machines ||= {}
+    @@machines[klass.to_s] = state_machine
+  end
+
+  def self.machines
+    @@machines ||= {}
+  end
+end

data/lib/jsm/states.rb

@@ -0,0 +1,35 @@
+# Jsm::States job is to collect all states
+class Jsm::States
+  attr_reader :list
+  ::Jsm::State = Struct.new(:name, :initial)
+
+  def initialize
+    @list = []
+  end
+
+  # register new state into the list
+  # @param state_name
+  def add_state(state_name, params = {})
+    initial = params.fetch(:initial) { false }
+    if !state_unique?(state_name)
+      raise Jsm::NotUniqueStateError, "state #{state_name} has been defined"
+    end
+
+    state = create_state(state_name, initial)
+    list.push(state)
+  end
+
+  def has_state?(state_name)
+    list.any? { |state| state.name == state_name}
+  end
+
+  private
+
+  def create_state(state_name, initial)
+    Jsm::State.new(state_name, initial)
+  end
+
+  def state_unique?(state_name)
+    list.all? {|state| state.name != state_name }
+  end
+end

data/lib/jsm/validator.rb

@@ -0,0 +1,12 @@
+class Jsm::Validator
+  attr_reader :type, :name
+  def initialize(type, name, &block)
+    @type = type
+    @name = name
+    @block = block
+  end
+
+  def validate(obj)
+    @block.call(obj)
+  end
+end

data/lib/jsm/validators.rb

@@ -0,0 +1,17 @@
+class Jsm::Validators
+  def initialize
+    @list =  Hash.new { |validators, state| validators[state] = [] }
+  end
+
+  def add_validator(name, validator)
+    @list[name].push(validator)
+  end
+
+  def [](name)
+    @list[name]
+  end
+
+  def validate(name, obj)
+    @list[name].all? { |validator| validator.validate(obj) }
+  end
+end

data/lib/jsm/version.rb

@@ -0,0 +1,3 @@
+module Jsm
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: just_state_machine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- wendy0402
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  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: looksee
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: Just StateMachine
+email:
+- wendykurniawan92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/active_record_state_machine.rb
+- examples/simple_state_machine.rb
+- jsm.gemspec
+- lib/jsm.rb
+- lib/jsm/base.rb
+- lib/jsm/client.rb
+- lib/jsm/client/active_model.rb
+- lib/jsm/client/active_record.rb
+- lib/jsm/client_extension.rb
+- lib/jsm/event.rb
+- lib/jsm/event_executor/active_model.rb
+- lib/jsm/event_executor/active_record.rb
+- lib/jsm/event_executor/base.rb
+- lib/jsm/exceptions.rb
+- lib/jsm/machines.rb
+- lib/jsm/states.rb
+- lib/jsm/validator.rb
+- lib/jsm/validators.rb
+- lib/jsm/version.rb
+homepage: https://github.com/wendy0402/jsm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Just State Machine, State Machine That support custom validations, it also
+  known with Jsm
+test_files: []
+has_rdoc: