celluloid-fsm 0.9.0.pre10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95bf4a47e617d073a6f9a4ccddaa820da5cff216
+  data.tar.gz: 4e3ab9b7568ae69898d19b82d0723b3ade820989
+SHA512:
+  metadata.gz: a1cc6f16e95919b1949066b09abb115aee4de991b5faecb2969a57a43cdae36690c3143470e1d8fc1cd4db2d9a62f7f4285a1e6e32eb4eb1a126ff1bc2265712
+  data.tar.gz: 42c0a75d46875962b645c05108768a45a0e41a0d4bcb791fc887ad826809cce473290972ccfe1216d785823808a22b61edb5af0dceeb23d132a3a7769f649bc3

data/.env-ci

@@ -0,0 +1,4 @@
+CELLULOID_SPECS_LOG_STRATEGY=stderr
+CELLULOID_SPECS_LOG_LEVEL=3
+CELLULOID_SPECS_LOG_FILE=../../log/ci.log
+CELLULOID_SPECS_LOG_SYNC=false

data/.env-dev

@@ -0,0 +1,4 @@
+CELLULOID_SPECS_LOG_STRATEGY=single
+CELLULOID_SPECS_LOG_FILE=../../log/test.log
+CELLULOID_SPECS_LOG_LEVEL=0
+CELLULOID_SPECS_LOG_SYNC=true

data/.gitignore

@@ -0,0 +1,9 @@
+coverage/
+rdoc/
+doc/
+pkg/
+tmp/
+.yardoc
+.bundle
+Gemfile.lock
+log

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "culture"]
+	path = culture
+	url = http://github.com/celluloid/culture.git

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--format documentation
+--order random
+--warnings
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_from:
+  - culture/rubocop/rubocop.yml

data/.travis.yml

@@ -0,0 +1,34 @@
+script: rake ci
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.2.2
+  - jruby
+  - ruby-head
+  - jruby-head
+  - rbx-2
+
+# TODO: Put these back:
+# * CELLULOID_TASK_CLASS=Fibered
+# * CELLULOID_TASK_CLASS=Threaded
+# For right now the imporant thing is to test BACKPORTED mode:
+
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - env: CELLULOID_BACKPORTED=true
+
+env:
+  matrix:
+    - CELLULOID_BACKPORTED=true
+    - CELLULOID_BACKPORTED=false
+  global:
+    - NUMBER_OF_PROCESSORS=2 CELLULOID_CONFIG_FILE=.env-ci
+
+notifications:
+  irc: "irc.freenode.org#celluloid"
+
+sudo: false
+install: bundle install --retry=3 --without=development

data/CHANGES.md

@@ -0,0 +1,4 @@
+0.8.5 (2015-04-11)
+-----
+
+* Initial release of separated gem, extracted from Celluloid.

data/Gemfile

@@ -0,0 +1,24 @@
+require File.expand_path("../culture/sync", __FILE__)
+source 'https://rubygems.org'
+
+gemspec development_group: :gem_build_tools
+
+group :development do
+  gem 'pry'
+  # gem 'guard'
+  # gem 'guard-rspec'
+  # gem 'rb-fsevent', '~> 0.9.1' if RUBY_PLATFORM =~ /darwin/
+end
+
+group :test do
+  gem 'dotenv', '~> 2.0'
+  gem 'nenv'
+  gem 'benchmark_suite'
+  gem 'rspec', '~> 3.2'
+end
+
+group :gem_build_tools do
+  gem 'rake'
+end
+
+Celluloid::Sync.gems(self)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Celluloid
+
+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,4 @@
+# Celluloid::FSM
+---
+
+* Prerelease gem.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+
+Dir['tasks/**/*.rake'].each { |task| load task }
+
+default_tasks = ['spec']
+default_tasks << 'rubocop' unless ENV['CI']
+task default: default_tasks
+
+task ci: %w(spec benchmark)

data/celluloid-fsm.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../culture/sync", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name         = 'celluloid-fsm'
+  gem.version      = '0.9.0.pre10'
+  gem.platform     = Gem::Platform::RUBY
+  gem.summary      = 'Celluloid Finite State Machines'
+  gem.description  = 'Simple finite state machines with integrated Celluloid timeout support.'
+  gem.licenses     = ['MIT']
+
+  gem.authors      = ["Tony Arcieri", "Tim Carey-Smith", "digitalextremist //"]
+  gem.email        = ['tony.arcieri@gmail.com', 'code@extremist.digital']
+  gem.homepage     = 'https://github.com/celluloid/celluloid-fsm'
+
+  gem.required_ruby_version     = '>= 1.9.2'
+  gem.required_rubygems_version = '>= 1.3.6'
+
+  gem.files        = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|examples|spec|features)/}) }
+  gem.require_path = 'lib'
+
+  Celluloid::Sync.gems(gem)
+end

data/lib/celluloid/fsm.rb

@@ -0,0 +1,187 @@
+require 'celluloid' unless defined? Celluloid
+
+module Celluloid
+  # Simple finite state machines with integrated Celluloid timeout support
+  # Inspired by Erlang's gen_fsm (http://www.erlang.org/doc/man/gen_fsm.html)
+  #
+  # Basic usage:
+  #
+  #     class MyMachine
+  #       include Celluloid::FSM # NOTE: this does NOT pull in the Celluloid module
+  #     end
+  #
+  # Inside an actor:
+  #
+  #     #
+  #     machine = MyMachine.new(current_actor)
+  module FSM
+    class UnattachedError < Celluloid::Error; end # Not attached to an actor
+
+    DEFAULT_STATE = :default # Default state name unless one is explicitly set
+
+    # Included hook to extend class methods
+    def self.included(klass)
+      klass.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      # Obtain or set the default state
+      # Passing a state name sets the default state
+      def default_state(new_default = nil)
+        if new_default
+          @default_state = new_default.to_sym
+        else
+          defined?(@default_state) ? @default_state : DEFAULT_STATE
+        end
+      end
+
+      # Obtain the valid states for this FSM
+      def states
+        @states ||= {}
+      end
+
+      # Declare an FSM state and optionally provide a callback block to fire
+      # Options:
+      # * to: a state or array of states this state can transition to
+      def state(*args, &block)
+        if args.last.is_a? Hash
+          # Stringify keys :/
+          options = args.pop.each_with_object({}) { |(k,v), h| h[k.to_s] = v }
+        else
+          options = {}
+        end
+
+        args.each do |name|
+          name = name.to_sym
+          default_state name if options['default']
+          states[name] = State.new(name, options['to'], &block)
+        end
+      end
+    end
+
+    attr_reader :actor
+
+    # Be kind and call super if you must redefine initialize
+    def initialize(actor = nil)
+      @state = self.class.default_state
+      @delayed_transition = nil
+      @actor = actor
+      @actor ||= Celluloid.current_actor if Celluloid.actor?
+    end
+
+    # Obtain the current state of the FSM
+    attr_reader :state
+
+    # Attach this FSM to an actor. This allows FSMs to wait for and initiate
+    # events in the context of a particular actor
+    def attach(actor)
+      @actor = actor
+    end
+    alias_method :actor=, :attach
+
+    # Transition to another state
+    # Options:
+    # * delay: don't transition immediately, wait the given number of seconds.
+    #          This will return a Celluloid::Timer object you can use to
+    #          cancel the pending state transition.
+    #
+    # Note: making additional state transitions will cancel delayed transitions
+    def transition(state_name, options = {})
+      new_state = validate_and_sanitize_new_state(state_name)
+      return unless new_state
+
+      if handle_delayed_transitions(new_state, options[:delay])
+        return @delayed_transition
+      end
+
+      transition_with_callbacks!(new_state)
+    end
+
+    # Immediate state transition with no sanity checks, or callbacks. "Dangerous!"
+    def transition!(state_name)
+      @state = state_name
+    end
+
+    protected
+
+    def validate_and_sanitize_new_state(state_name)
+      state_name = state_name.to_sym
+
+      return if current_state_name == state_name
+
+      if current_state and not current_state.valid_transition? state_name
+        valid = current_state.transitions.map(&:to_s).join(", ")
+        raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
+      end
+
+      new_state = states[state_name]
+
+      unless new_state
+        return if state_name == default_state
+        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
+      end
+
+      new_state
+    end
+
+    def transition_with_callbacks!(state_name)
+      transition! state_name.name
+      state_name.call(self)
+    end
+
+    def states
+      self.class.states
+    end
+
+    def default_state
+      self.class.default_state
+    end
+
+    def current_state
+      states[@state]
+    end
+
+    def current_state_name
+      current_state && current_state.name || ''
+    end
+
+    def handle_delayed_transitions(new_state, delay)
+      if delay
+        raise UnattachedError, "can't delay unless attached" unless @actor
+        @delayed_transition.cancel if @delayed_transition
+
+        @delayed_transition = @actor.after(delay) do
+          transition_with_callbacks!(new_state)
+        end
+
+        return @delayed_transition
+      end
+
+      return unless defined?(@delayed_transition) and @delayed_transition
+      @delayed_transition.cancel
+      @delayed_transition = nil
+    end
+
+    # FSM states as declared by Celluloid::FSM.state
+    class State
+      attr_reader :name, :transitions
+
+      def initialize(name, transitions = nil, &block)
+        @name, @block = name, block
+        @transitions = nil
+        @transitions = Array(transitions).map(&:to_sym) if transitions
+      end
+
+      def call(obj)
+        obj.instance_eval(&@block) if @block
+      end
+
+      def valid_transition?(new_state)
+        # All transitions are allowed unless expressly
+        return true unless @transitions
+
+        @transitions.include? new_state.to_sym
+      end
+    end
+  end
+end

data/tasks/benchmarks.rake

@@ -0,0 +1,16 @@
+require 'timeout'
+
+desc "Run Celluloid benchmarks"
+task :benchmark do
+  begin
+    Timeout.timeout(120) do
+      glob = File.expand_path("../../benchmarks/*.rb", __FILE__)
+      Dir[glob].each { |benchmark| load benchmark }
+    end
+  rescue Exception, Timeout::Error => ex
+    puts "ERROR: Couldn't complete benchmark: #{ex.class}: #{ex}"
+    puts "  #{ex.backtrace.join("\n  ")}"
+
+    exit 1 unless ENV['CI'] # Hax for running benchmarks on Travis
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,7 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end

data/tasks/rubocop.rake

@@ -0,0 +1,4 @@
+unless ENV['CI']
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-fsm
+version: !ruby/object:Gem::Version
+  version: 0.9.0.pre10
+platform: ruby
+authors:
+- Tony Arcieri
+- Tim Carey-Smith
+- digitalextremist //
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: coveralls
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-essentials
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-supervision
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-pool
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-extras
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: timers
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rubocop
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec-log_split
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple finite state machines with integrated Celluloid timeout support.
+email:
+- tony.arcieri@gmail.com
+- code@extremist.digital
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .env-ci
+- .env-dev
+- .gitignore
+- .gitmodules
+- .rspec
+- .rubocop.yml
+- .travis.yml
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- celluloid-fsm.gemspec
+- lib/celluloid/fsm.rb
+- tasks/benchmarks.rake
+- tasks/rspec.rake
+- tasks/rubocop.rake
+homepage: https://github.com/celluloid/celluloid-fsm
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.6
+signing_key:
+specification_version: 4
+summary: Celluloid Finite State Machines
+test_files: []