simple_states 0.0.1

data/Gemfile

@@ -0,0 +1,14 @@
+source :rubygems
+
+gemspec
+
+group :test do
+  platforms :mri_18 do
+    gem "require_relative", "~> 1.0.1"
+    gem 'ruby-debug'
+  end
+
+  platforms :mri_19 do
+    gem 'ruby-debug19', :platforms => :mri_19 unless RUBY_VERSION == '1.9.3'
+  end
+end

data/Gemfile.lock

@@ -0,0 +1,48 @@
+PATH
+  remote: .
+  specs:
+    simple_states (0.0.1)
+      activesupport
+      hashr (~> 0.0.10)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.9)
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.4)
+    hashr (0.0.10)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    mocha (0.9.12)
+    rbx-require-relative (0.0.5)
+    require_relative (1.0.2)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    test_declarative (0.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  require_relative (~> 1.0.1)
+  ruby-debug
+  ruby-debug19
+  simple_states!
+  test_declarative

data/LICENSE

@@ -0,0 +1,21 @@
+MIT LICENSE
+
+Copyright (c)  Sven Fuchs <svenfuchs@artweb-design.de>
+
+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/NOTES.md

@@ -0,0 +1 @@
+make it so that callbacks can be cancelled by returning false, maybe look into activesupport callbacks?

data/README.md

@@ -0,0 +1,5 @@
+# simple\_states
+
+A super-slim (~200 loc) statemachine-like support library focussed on use in Travis CI.
+
+More docs coming soon, checkout the tests.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/lib/simple_states.rb

@@ -0,0 +1,70 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/object/try'
+
+module SimpleStates
+  class TransitionException < RuntimeError; end
+
+  autoload :Event,  'simple_states/event'
+  autoload :States, 'simple_states/states'
+
+  extend ActiveSupport::Concern
+
+  included do
+    class_inheritable_accessor :state_names, :initial_state, :events
+    self.initial_state = :created
+    self.events = []
+  end
+
+  module ClassMethods
+    def new(*)
+      super.tap { |object| States.init(object) }
+    end
+
+    def allocate
+      super.tap { |object| States.init(object) }
+    end
+
+    def states(*args)
+      if args.empty?
+        self.state_names ||= add_states(self.initial_state)
+      else
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        self.initial_state = options[:initial].to_sym if options.key?(:initial)
+        add_states(*[self.initial_state].concat(args))
+      end
+    end
+
+    def add_states(*states)
+      self.state_names = (self.state_names || []).concat(states.compact.map(&:to_sym)).uniq
+    end
+
+    def event(name, options = {})
+      add_states(options[:from], options[:to])
+      self.events << Event.new(name, options)
+    end
+  end
+
+  attr_reader :past_states
+
+  def past_states
+    @past_states ||= []
+  end
+
+  def state?(state, include_past = false)
+    include_past ? was_state?(state) : self.state.try(:to_sym) == state.to_sym
+  end
+
+  def was_state?(state)
+    past_states.concat([self.state.try(:to_sym)]).compact.include?(state.to_sym)
+  end
+
+  def respond_to?(method, include_private = false)
+    method.to_s =~ /(was_|^)(#{self.class.states.join('|')})\?$/ && self.class.state_names.include?($2.to_sym) || super
+  end
+
+  def method_missing(method, *args, &block)
+    method.to_s =~ /(was_|^)(#{self.class.states.join('|')})\?$/ ? send(:"#{$1}state?", $2, *args) : super
+  end
+end

data/lib/simple_states/event.rb

@@ -0,0 +1,87 @@
+require 'active_support/core_ext/module/delegation'
+require 'hashr'
+
+module SimpleStates
+  class Event
+    attr_accessor :name, :options
+
+    def initialize(name, options = {})
+      @name    = name
+      @options = Hashr.new(options) do
+        def except
+          self[:except]
+        end
+      end
+    end
+
+    def saving
+      @saving = true
+      yield.tap { @saving = false }
+    end
+
+    def call(object, *args)
+      return if skip?(object, args)
+
+      raise_invalid_transition(object) unless can_transition?(object)
+      run_callbacks(object, :before, args)
+
+      yield.tap do
+        set_state(object)
+        run_callbacks(object, :after, args)
+        object.save! if @saving
+      end
+    end
+
+    def merge(other)
+      other.options.each do |key, value|
+        options[key] = [options[key], value].compact unless key == :to
+      end
+    end
+
+    protected
+
+      def skip?(object, args)
+        result = false
+        result ||= !send_methods(object, options.if, args) if options.if?
+        result ||= send_methods(object, options.except, args) if options.except?
+        result
+      end
+
+      def can_transition?(object)
+        object.state && Array(options.from).include?(object.state)
+      end
+
+      def raise_invalid_transition(object)
+        raise TransitionException, "#{object.inspect} can not receive event #{name.inspect} while in state #{object.state.inspect}."
+      end
+
+      def run_callbacks(object, type, args)
+        send_methods(object, options.send(type), args)
+      end
+
+      def set_state(object)
+        if state = options.to
+          object.past_states << object.state if object.state
+          object.state = state.to_sym
+          object.send(:"#{state}_at=", Time.now) if object.respond_to?(:"#{state}_at=")
+          object.save! if @saving
+        end
+      end
+
+      def send_methods(object, methods, args)
+        Array(methods).inject(false) { |result, method| result | send_method(object, method, args) } if methods
+      end
+
+      def send_method(object, method, args)
+        object.send method, *case arity = self.arity(object, method)
+          when 0;  []
+          when -1; [name].concat(args)
+          else;    [name].concat(args).slice(0..arity - 1)
+        end
+      end
+
+      def arity(object, method)
+        object.class.instance_method(method).arity rescue 0
+      end
+  end
+end

data/lib/simple_states/states.rb

@@ -0,0 +1,45 @@
+module SimpleStates
+  class States < Module
+    class << self
+      def init(object)
+        object.singleton_class.send(:include, proxy_for(object.class))
+        if object.singleton_class.respond_to?(:after_initialize)
+          object.singleton_class.after_initialize { self.state = self.class.initial_state if state.blank? }
+        else
+          object.state = object.class.initial_state
+        end
+      end
+
+      def proxy_for(klass)
+        klass.const_defined?(:States, false) ? klass::States : klass.const_set(:States, new(klass.events))
+      end
+    end
+
+    def initialize(events)
+      merge_events(events).each do |event|
+        define_event(event)
+      end
+    end
+
+    protected
+
+      def define_event(event)
+        define_method(event.name) do |*args|
+          event.send(:call, self, *args) do
+            super(*args) if self.class.method_defined?(event.name)
+          end
+        end
+
+        define_method(:"#{event.name}!") do |*args|
+          event.saving do
+            send(event.name, *args)
+          end
+        end
+      end
+
+      def merge_events(events)
+        merges, events = *events.partition { |event| event.name == :all }
+        events.each { |event| merges.each { |merge| event.merge(merge) } }
+      end
+  end
+end

data/lib/simple_states/version.rb

@@ -0,0 +1,3 @@
+module SimpleStates
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: simple_states
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70306211479800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70306211479800
+- !ruby/object:Gem::Dependency
+  name: hashr
+  requirement: &70306211479060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *70306211479060
+- !ruby/object:Gem::Dependency
+  name: test_declarative
+  requirement: &70306211478360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70306211478360
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70306211477140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70306211477140
+description: ! '[description]'
+email: svenfuchs@artweb-design.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/simple_states/event.rb
+- lib/simple_states/states.rb
+- lib/simple_states/version.rb
+- lib/simple_states.rb
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- NOTES.md
+- Rakefile
+- README.md
+homepage: https://github.com/svenfuchs/simple_states
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ! '[none]'
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: ! '[summary]'
+test_files: []