simple_states 1.1.0.rc11 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6a512e5ed006c4dfb377e88a4797cd88d9ca32a
-  data.tar.gz: 89037f2bdec8d744e84d3cb3206c875b03816641
+  metadata.gz: 627c1d0bd3ec1db9f71afc51615e7a1c5d8ee194
+  data.tar.gz: ca2532ece2327f549c0c113dcd09155f4df8b578
 SHA512:
-  metadata.gz: dc32ade2ccd98a78da1403536cc076bb609df4544740bd883f693d9d5386ed1dace6d56e0245eccf4e107e84429afddaa40d5307dc636400edf8d99f1378476d
-  data.tar.gz: 53065cfa84dbc9e4a4921f4477d2ce4f0c30cedcd5228e9037c6c392a683ee4e7d2de8263140786325c326c5f680d981272611793977cfd150fc6b740ca4a5e0
+  metadata.gz: e8295626ea865b2d3e1bfdac8e6ef2e4a5c50100ac3c0168fb68e183a03a3a8d591dfc578713d6ecae618a6ccdd9973f329068fbddde3f1039fd5ab95fd29939
+  data.tar.gz: c6a2062e68a1f7814a3b40634eb7aefcdb3e567bc444dd95b15c8ec2b4adcca3e03526c01829946104572f0ff3fbd29ffd9dc73aa5c38da6fad7c38fa11a8718

data/Gemfile

@@ -1,7 +1,6 @@
 source 'https://rubygems.org'
 
-gemspec
-
 group :test do
-  gem 'minitest'
+  gem 'rspec'
+  gem 'mocha'
 end

data/Gemfile.lock

@@ -1,37 +1,31 @@
-PATH
-  remote: .
-  specs:
-    simple_states (1.1.0.rc9)
-      activesupport
-
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.2.4)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    i18n (0.7.0)
-    json (1.8.3)
-    metaclass (0.0.1)
-    minitest (5.8.0)
-    mocha (0.14.0)
+    diff-lcs (1.2.5)
+    metaclass (0.0.4)
+    mocha (1.1.0)
       metaclass (~> 0.0.1)
-    rake (0.9.6)
-    test_declarative (0.0.5)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
 
 PLATFORMS
   java
   ruby
 
 DEPENDENCIES
-  minitest
   mocha
-  rake (~> 0.9.2)
-  simple_states!
-  test_declarative
+  rspec
+
+BUNDLED WITH
+   1.10.6

data/lib/simple_states.rb

@@ -1,66 +1,42 @@
-require 'active_support/core_ext/object/try'
+require 'simple_states/states'
 
 module SimpleStates
-  class TransitionException < RuntimeError; end
-
-  autoload :Event,  'simple_states/event'
-  autoload :States, 'simple_states/states'
+  class Error < RuntimeError; end
 
   class << self
-    def included(base)
-      base.extend(SimpleStates::ClassMethods)
-      define_accessors(base, :state_names, :state_options, :initial_state, :events)
-      set_defaults(base)
-    end
-
-    def define_accessors(base, *names)
-      base.singleton_class.send(:attr_accessor, *names)
-      base.public_class_method(*names + names.map { |name| "#{name}=".to_sym })
-    end
-
-    def set_defaults(base)
-      base.after_initialize(:init_state) if base.respond_to?(:after_initialize)
-      base.initial_state = :created
-      base.state_names = []
-      base.state_options = {}
-      base.events = []
+    def included(const)
+      states = const.const_set(:States, States.new)
+      const.send(:prepend, states) if const.respond_to?(:prepend)
+      const.extend(ClassMethods)
+      const.initial_state = :created
+      const.after_initialize(:init_state) if const.respond_to?(:after_initialize)
     end
   end
 
   module ClassMethods
-    def new(*)
-      super.tap { |object| States.init(object) }
-    end
+    attr_accessor :initial_state
 
-    def allocate
-      super.tap { |object| States.init(object) }
-    end
-
-    def states(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      self.initial_state = options.delete(:initial).to_sym if options.key?(:initial)
-      self.state_options = options
-      add_states(*[self.initial_state].concat(args))
+    def new(*)
+      super.tap { |object| object.init_state }
     end
 
-    def add_states(*names)
-      self.state_names = self.state_names.concat(names.compact.map(&:to_sym)).uniq
+    def event(name, opts = {})
+      method = name == :all ? :update_events : :define_event
+      self::States.send(method, name, opts)
     end
 
-    def event(name, options = {})
-      add_states(options[:to], *options[:from])
-      self.events << [name, options]
+    def state?(state)
+      states.include?(state)
     end
 
-    def states_module
-      const_defined?(*args) ? self::StatesProxy : const_set(:StatesProxy, Module.new)
+    def states
+      [initial_state] + self::States.states
     end
   end
 
-  attr_reader :past_states
-
   def init_state
-    self.state = self.class.initial_state if state.nil?
+    singleton_class.send(:include, self.class::States) unless self.class.respond_to?(:prepend)
+    self.state = self.class.initial_state if self.state.nil?
   end
 
   def state=(state)
@@ -68,23 +44,27 @@ module SimpleStates
   end
 
   def state
-    super.try(:to_sym)
+    state = super
+    state.to_sym if state
   end
 
-  def reset_state
-    self.state = self.class.initial_state
-    self.class.events.map { |*args| Event.new(*args).reset(self) }
+  def state?(state)
+    self.state.to_sym == state.to_sym
   end
 
-  def past_states
-    @past_states ||= []
+  def reset_state
+    self.state = self.class.initial_state
+    self.class::States.events.map { |_, event| event.reset(self) }
   end
 
-  def state?(state, include_past = false)
-    include_past ? was_state?(state) : self.state.try(:to_sym) == state.to_sym
+  def respond_to?(name)
+    state = name.to_s[0..-2].to_sym
+    name.to_s[-1] == '?' && self.class.state?(state) || super
   end
 
-  def was_state?(state)
-    past_states.concat([self.state.try(:to_sym)]).compact.include?(state.to_sym)
+  def method_missing(name, *args)
+    state = name.to_s[0..-2].to_sym
+    return super unless name.to_s[-1] == '?' && self.class.state?(state)
+    state?(state)
   end
 end

data/lib/simple_states/event.rb

@@ -1,112 +1,81 @@
-require 'active_support/core_ext/module/delegation'
-
 module SimpleStates
-  class Event
-    attr_accessor :name, :options
-
-    def initialize(name, options = {})
-      @name    = name
-      @options = options
+  class Event < Struct.new(:name, :opts)
+    MSGS = {
+      invalid_state: 'If multiple target states are defined, then a valid target state must be passed as an attribute ({ state: :state }). %p given, known states: %p.',
+      unknown_state: 'Unknown state %p for %p for event %p. Known states are: %p'
+    }
+
+    def call(obj, data, opts)
+      return false if not ordered?(obj, data) or not applies?(obj, data)
+
+      run_callbacks(:before, obj, data)
+      set_attrs(obj, data)
+      yield
+      obj.save! if opts[:save]
+
+      raise_unknown_state(obj, data) unless known_state?(obj)
+      run_callbacks(:after, obj, data)
+      obj.save! if opts[:save]
+      true
     end
 
-    def call(object, *args)
-      return false if skip?(object, args) || !set_state?(object, args)
-
-      raise_invalid_transition(object) unless can_transition?(object)
-      run_callbacks(object, :before, args)
-      set_state(object, args)
-
-      yield.tap do
-        raise_unknown_target_state(object) unless known_target_state?(object)
-        run_callbacks(object, :after, args)
-        object.save! if save?
-      end
+    def reset(obj)
+      Array(opts[:to]).each { |state| set_attr(obj, :"#{state}_at", nil) }
     end
 
-    def reset(object)
-      write_attr(object, :"#{target_state}_at", nil)
-    end
-
-    protected
-
-      def save?
-        options[:save]
-      end
-
-      def skip?(object, args)
-        result = false
-        result ||= !send_methods(object, options[:if], args) if options[:if]
-        result ||= send_methods(object, options[:unless], args) if options[:unless]
-        result
-      end
-
-      def can_transition?(object)
-        !options[:from] || object.state && Array(options[:from]).include?(object.state.to_sym)
-      end
-
-      def run_callbacks(object, type, args)
-        object.save! if save?
-        send_methods(object, options[type], args)
-      end
-
-      def set_state(object, args)
-        data  = args.last.is_a?(Hash) ? args.last : {}
-        state = data[:state].try(:to_sym) || target_state
-        object.past_states << object.state.to_sym if object.state
-        object.state = state.to_sym
-        write_attrs(object, data)
-      end
+    private
 
-      def write_attrs(object, data)
-        data = { :"#{target_state}_at" => Time.now.utc }.merge(data)
-        data.each { |key, value| write_attr(object, key, value) }
+      def run_callbacks(type, obj, data)
+        send_methods(opts[type], obj, data)
       end
 
-      def write_attr(object, key, value)
-        object.send(:"#{key}=", value) if object.respond_to?(:"#{key}=") && object.respond_to?(key) && object.send(key).nil?
+      def set_attrs(obj, data)
+        attrs = { :"#{target_state(data)}_at" => Time.now.utc }.merge(data)
+        attrs.each { |key, value| set_attr(obj, key, value) }
+        obj.state = target_state(data)
       end
 
-      def set_state?(object, args)
-        data  = args.last.is_a?(Hash) ? args.last : {}
-        state = data[:state].try(:to_sym) || target_state
-        return true unless object.class.state_options[:ordered]
-        states = object.class.state_names
-        lft, rgt = states.index(object.state.try(:to_sym)), states.index(state)
-        lft.nil? || rgt.nil? || lft <= rgt
+      def set_attr(obj, key, value)
+        obj.send(:"#{key}=", value) if obj.respond_to?(:"#{key}=")
       end
 
-      def target_state
-        options[:to] || "#{name}ed".sub(/eed$/, 'ed').to_sym
+      def ordered?(obj, data)
+        states = obj.class.states
+        states.index(obj.state).to_i <= states.index(target_state(data)).to_i
       end
 
-      def send_methods(object, methods, args)
-        Array(methods).inject(false) { |result, method| result | send_method(object, method, args) } if methods
+      def applies?(obj, data)
+        result = opts[:if].nil? || send_methods(opts[:if], obj, data)
+        result and opts[:unless].nil? || !send_methods(opts[:unless], obj, data)
       end
 
-      def send_method(object, method, args)
-        arity = self.arity(object, method)
-        args = [name].concat(args)
-        object.send method, *args.slice(0, arity < 0 ? args.size : arity)
+      def target_state(data)
+        to = Array(opts[:to])
+        return to.first if to.size == 1
+        state = data[:state].to_sym if data[:state]
+        to.include?(state) ? state : raise_invalid_state(data)
       end
 
-      def arity(object, method)
-        object.class.instance_method(method).arity rescue 0
+      def send_methods(names, obj, data)
+        Array(names).inject(false) do |result, name|
+          result | send_method(name, obj, data)
+        end
       end
 
-      def now
-        Time.respond_to?(:zone) && Time.zone ? Time.zone.now : Time.now.utc
+      def send_method(name, obj, data)
+        obj.send(name, *[self.name, data].slice(0, obj.method(name).arity.abs))
       end
 
-      def known_target_state?(object)
-        object.state && object.class.state_names.include?(object.state.to_sym)
+      def known_state?(obj)
+        obj.class.states.include?(obj.state)
       end
 
-      def raise_invalid_transition(object)
-        raise TransitionException, "#{object.inspect} can not receive event #{name.inspect} while in state #{object.state.inspect}."
+      def raise_invalid_state(data)
+        raise Error, MSGS[:invalid_state] % [data[:state], Array(opts[:to])]
       end
 
-      def raise_unknown_target_state(object)
-        raise TransitionException, "unknown target state #{object.state.inspect} for #{object.inspect} for event #{name.inspect}. known states are #{object.class.states.inspect}"
+      def raise_unknown_state(obj, data)
+        raise Error, MSGS[:unknown_state] % [obj.state, obj, name, obj.class.states]
       end
   end
 end

data/lib/simple_states/helpers.rb

@@ -0,0 +1,7 @@
+module SimpleStates
+  module Helpers
+    def to_past(string)
+      "#{string}ed".sub(/eed$/, 'ed')
+    end
+  end
+end

data/lib/simple_states/states.rb

@@ -1,65 +1,41 @@
+require 'simple_states/event'
+require 'simple_states/helpers'
+
 module SimpleStates
   class States < Module
-    class << self
-      def init(object)
-        object.class.state_names = [object.class.initial_state] if object.class.state_names.empty?
-        respond_to?(:prepend) ? prepend_module(object.class) : include_module(object)
-        object.init_state unless object.singleton_class.respond_to?(:after_initialize)
-      end
-
-      def prepend_module(const)
-        const.prepend(module_for(const)) unless const.const_defined?(:StatesProxy)
-      end
-
-      def include_module(object)
-        object.singleton_class.send(:include, module_for(object.class))
-      end
-
-      def module_for(const)
-        args = [:StatesProxy].concat(const.method(:const_defined?).arity != 1 ? [false] : [])
-        const.const_defined?(*args) ? const::StatesProxy : const.const_set(:StatesProxy, create_module(const))
-      end
-
-      def create_module(const)
-        new.tap do |mod|
-          merge_events(const.events).each { |event| define_event(mod, event) }
-          const.state_names.each { |name| define_state(mod, name) }
-        end
-      end
-
-      def define_event(const, (name, options))
-        const.send(:define_method, name) do |*args|
-          event = args.first.is_a?(Event) ? args.shift : Event.new(name, options)
-          event.call(self, *args) { defined?(super) ? super(*args) : true }
-        end
+    include Helpers
 
-        const.send(:define_method, :"#{name}!") do |*args|
-          send(name, Event.new(name, options.merge(save: true)), *args)
-        end
-      end
+    def events
+      @events ||= {}
+    end
 
-      def define_state(const, state)
-        const.send(:define_method, :"#{state}?") do |*args|
-          defined?(super) ? super() : state?(state, *args)
-        end
+    def states
+      events.values.map { |event| event.opts[:to] }.flatten.compact
+    end
 
-        const.send(:define_method, :"was_#{state}?") do |*args|
-          defined?(super) ? super() : was_state?(state, *args)
+    def define_event(name, opts)
+      events[name] = Event.new(name, { to: to_past(name).to_sym }.merge(opts))
+
+      send(:define_method, name) do |data = {}, opts = {}|
+        self.class::States.events[name].call(self, data, opts) do
+          if method(name).respond_to?(:super_method)
+            supa = method(name).super_method
+            supa.call(*[name, data].slice(0, supa.arity.abs)) if supa
+          elsif defined?(super)
+            super(name, data)
+          end
         end
       end
 
-      def merge_events(events)
-        return events unless other_ix = events.index { |event| event.first == :all }
-        other = events.slice!(other_ix)
-        events.each_with_index do |event, ix|
-          merge_event(event, other, ix < other_ix)
-        end
-        merge_events(events)
+      send(:define_method, :"#{name}!") do |data = {}|
+        send(name, data, save: true)
       end
+    end
 
-      def merge_event(event, other, append = true)
-        other.last.each do |key, value|
-          event.last[key] = [event.last[key]].send(append ? :push : :unshift, value).compact.flatten
+    def update_events(_, opts)
+      events.values.each do |event|
+        opts.each do |key, value|
+          event.opts[key] = Array(event.opts[key]).concat(Array(value))
         end
       end
     end

data/lib/simple_states/version.rb

@@ -1,3 +1,3 @@
 module SimpleStates
-  VERSION = '1.1.0.rc11'
+  VERSION = '2.0.0'
 end

data/simple_states.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.name         = "simple_states"
   s.version      = SimpleStates::VERSION
   s.authors      = ["Sven Fuchs"]
-  s.email        = "svenfuchs@artweb-design.de"
+  s.email        = "me@svenfuchs.com"
   s.homepage     = "https://github.com/svenfuchs/simple_states"
   s.licenses     = ['MIT']
   s.summary      = "[summary]"
@@ -17,10 +17,4 @@ Gem::Specification.new do |s|
   s.platform     = Gem::Platform::RUBY
   s.require_path = 'lib'
   s.rubyforge_project = '[none]'
-
-  s.add_dependency 'activesupport'
-
-  s.add_development_dependency 'rake', '~> 0.9.2'
-  s.add_development_dependency 'test_declarative'
-  s.add_development_dependency 'mocha'
 end

metadata

@@ -1,73 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: simple_states
 version: !ruby/object:Gem::Version
-  version: 1.1.0.rc11
+  version: 2.0.0
 platform: ruby
 authors:
 - Sven Fuchs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-10 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.2
-- !ruby/object:Gem::Dependency
-  name: test_declarative
-  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: mocha
-  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'
+date: 2015-11-01 00:00:00.000000000 Z
+dependencies: []
 description: "[description]"
-email: svenfuchs@artweb-design.de
+email: me@svenfuchs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -80,6 +24,7 @@ files:
 - Rakefile
 - lib/simple_states.rb
 - lib/simple_states/event.rb
+- lib/simple_states/helpers.rb
 - lib/simple_states/states.rb
 - lib/simple_states/version.rb
 - simple_states.gemspec
@@ -98,9 +43,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: "[none]"
 rubygems_version: 2.4.5