ex_machina 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 65774af491192a74ddda0683c63af42d4de122a1
+  data.tar.gz: 8e22de0cc6d23b9d20dc755e3dbab298efd2a9e4
+SHA512:
+  metadata.gz: e50f7e90615c99ef72b6bddfecffdfcfc4df135d8f550ff0656092e1398eec8fc975c725a7110204c19e7294c134be5724273d26c2ba3c5c11c0c54932bce341
+  data.tar.gz: 77e6132fe89cb046378a284e77147529fbf5114c71a99e3f07a3a9e3b6b51e4c646c290023fd5a30b44c7ba9dd216f1757a22fa7ed62c6426e746f923f6f7083

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Rodrigo Panachi
+
+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,41 @@
+# ExMachina
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ex_machina`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ex_machina'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ex_machina
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ex_machina. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://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,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ex_machina"
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ex_machina.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ex_machina/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ex_machina"
+  spec.version       = ExMachina::VERSION
+  spec.authors       = ["Rodrigo Panachi"]
+  spec.email         = ["rpanachi@gmail.com"]
+
+  spec.summary       = %q{A simple and OOP implementation of StateMachine}
+  spec.homepage      = "https://github.com/rpanachi/ex_machina"
+  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.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/ex_machina/event/runner.rb

@@ -0,0 +1,139 @@
+module ExMachina
+  module Event
+    class Runner
+
+      STATUSES = [
+        SUCCESS = :success,
+        FAILURE = :failure,
+        ERROR   = :error,
+        SKIPPED = :skipped
+      ].freeze
+
+      attr_accessor :previous, :current
+      attr_accessor :result
+
+      attr_reader :event, :transition
+
+      def initialize(event, transition)
+        @event      = event
+        @transition = transition
+      end
+
+      def running?
+        @running
+      end
+
+      def start!
+        @run      = false
+        @running  = true
+        @result   = nil
+        @previous = event.status
+        @current  = nil
+      end
+
+      def finish!(value)
+        return result unless running?
+
+        @running = false
+        @ran     = true
+
+        if value == true
+          success!
+        elsif value == false
+          failure!
+        elsif value == :skipped
+          skipped!
+        elsif value == :error
+          error!
+        else
+          @result = value
+        end
+      end
+      def run?
+        !!@ran
+      end
+
+      def success?
+        result == :success
+      end
+      def success!
+        @current = transition.to
+        finish!(@result = :success)
+      end
+
+      def failure?
+        result == :failure
+      end
+      def failure!
+        @current = @previous
+        finish!(@result = :failure)
+      end
+
+      def skipped!
+        finish!(@result = :skipped)
+      end
+      def skipped?
+        result == :skipped
+      end
+
+      def error!(exception)
+        # TODO handle exception
+        finish!(@result = :error)
+      end
+      def error?
+        result == :error
+      end
+
+      def eligible?
+        if transition.conditional?
+          invoke(event, transition.do_if, self) ||
+            invoke(event, transition.do_unless, self)
+        else
+          true
+        end
+      end
+
+      def run
+        start!
+
+        return skipped! unless eligible?
+
+        invoke(event, transition.do_before, self)
+        begin
+          call = invoke(event, :call, self)
+          invoke(event, transition.do_after, self)
+          finish!(call)
+        rescue StandardError => ex
+          error!(ex)
+        end
+
+        if success?
+          invoke(event, :change_status, self)
+          invoke(event, transition.do_success, self)
+        elsif failure?
+          invoke(event, transition.do_failure, self)
+        end
+
+        call
+      end
+
+      def invoke(context, meth, *args)
+        return if meth.nil?
+
+        if meth.respond_to?(:call)
+          all_args    = Array([context, *args])
+          meth_params = meth.parameters
+          meth_args   = *all_args.first(meth_params.size)
+
+          meth.call(*meth_args)
+
+        elsif context.respond_to?(meth)
+          meth_params = context.method(meth).parameters
+          meth_args   = *args.first(meth_params.size)
+
+          context.send(meth, *meth_args)
+        end
+      end
+    end
+  end
+end

data/lib/ex_machina/event/transition.rb

@@ -0,0 +1,42 @@
+module ExMachina
+  module Event
+    class Transition
+
+      attr_reader :from, :to
+      attr_reader :do_if, :do_unless, :do_before, :do_after, :do_success, :do_failure
+
+      attr_accessor :previous, :current, :context, :result
+
+      def initialize(options)
+        @from    = Array(options.fetch(:from)).map { |status| normalize(status) }
+        @to      = normalize(options.fetch(:to))
+
+        # optional args
+        @do_if      = options[:if]
+        @do_unless  = options[:unless]
+        @do_before  = options[:before]
+        @do_after   = options[:after]
+        @do_success = options[:success]
+        @do_failure = options[:failure]
+      end
+
+      def from?(status)
+        from.include?(normalize(status))
+      end
+
+      def to?(status)
+        Array(to).include?(normalize(status))
+      end
+
+      def conditional?
+        !do_if.nil? || !do_unless.nil?
+      end
+
+      private
+
+      def normalize(status)
+        status.to_s.to_sym
+      end
+    end
+  end
+end

data/lib/ex_machina/event/validations.rb

@@ -0,0 +1,22 @@
+module ExMachina
+  module Event
+    module Validations
+      def errors
+        @errors ||= []
+      end
+      def valid?
+        errors.empty?
+      end
+      def validate
+        errors.clear
+
+        unless transitions.any?
+          errors << "No transitions defined from '#{status}' status"
+        end
+      end
+      def error_messages
+        errors.join(", ")
+      end
+    end
+  end
+end

data/lib/ex_machina/event.rb

@@ -0,0 +1,92 @@
+require "ex_machina/event/transition"
+require "ex_machina/event/runner"
+require "ex_machina/event/validations"
+
+module ExMachina
+  module Event
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+      base.include(Validations)
+    end
+
+    module ClassMethods
+      def transitions
+        @transitions ||= []
+      end
+      def transition(*args)
+        transitions << Transition.new(*args)
+      end
+      def fire(context)
+        self.new(context).fire
+      end
+      def fire!(context)
+        self.new(context).fire!
+      end
+      def can_fire?(context)
+        self.new(context).can_fire?
+      end
+      def event
+        self.name.demodulize.underscore
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def transitions
+        self.class
+          .transitions
+          .select { |transition| transition.from?(status) }
+      end
+
+      def status
+        context.status
+      end
+
+      def change_status(execution)
+        context.status = execution.current.to_s
+        context.save
+      end
+
+      def fire
+        validate
+        return unless can_fire?
+
+        result = false
+        within_transaction do
+          transitions.each do |transition|
+            runner = Runner.new(self, transition)
+            result = runner.run
+
+            break result unless runner.skipped?
+          end
+        end
+        result
+      end
+
+      def fire!
+        raise error_messages unless can_fire?
+        fire
+      end
+
+      def can_fire?
+        validate
+        valid?
+      end
+
+      def call
+        raise NotImplementedError, "method 'call' must be implemented on event class"
+      end
+
+      def within_transaction(&block)
+        # TODO implement strategy for transaction
+        DB.transaction(&block)
+      end
+    end
+  end
+end

data/lib/ex_machina/eventable.rb

@@ -0,0 +1,33 @@
+module ExMachina
+  module Eventable
+    def self.included(base)
+      base.extend ClassMethods
+      base.include InstanceMethods
+    end
+
+    module ClassMethods
+      def events
+        @events ||= []
+      end
+      def has_events(*event_classes)
+        event_classes.each do |event_class|
+          events << event_class
+
+          define_method "#{event_class.event}" do
+            event_class.fire(self)
+          end
+          define_method "#{event_class.event}!" do
+            event_class.fire!(self)
+          end
+          define_method "can_#{event_class.event}?" do
+            event_class.can_fire?(self)
+          end
+          events << event_class
+        end
+      end
+    end
+
+    module InstanceMethods
+    end
+  end
+end

data/lib/ex_machina/version.rb

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

data/lib/ex_machina.rb

@@ -0,0 +1,6 @@
+require "ex_machina/version"
+require "ex_machina/event"
+require "ex_machina/eventable"
+
+module ExMachina
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: ex_machina
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rodrigo Panachi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- rpanachi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ex_machina.gemspec
+- lib/ex_machina.rb
+- lib/ex_machina/event.rb
+- lib/ex_machina/event/runner.rb
+- lib/ex_machina/event/transition.rb
+- lib/ex_machina/event/validations.rb
+- lib/ex_machina/eventable.rb
+- lib/ex_machina/version.rb
+homepage: https://github.com/rpanachi/ex_machina
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A simple and OOP implementation of StateMachine
+test_files: []