cequel_stateful_enum 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3a756dda6366a683accf33e3c848cfe9593b689
+  data.tar.gz: 443654533689d282e506c30085f0d65e442b87d8
+SHA512:
+  metadata.gz: 5a5fb6eedcbf1eef21bdcc3dea6dcab39f2eb3f51bde0452fcfe3ff5926b3fb0d2dbc65d17ad81cb95521682130efc7bb05607829c73f03966f722ec1ab4258d
+  data.tar.gz: cda07ca03c09476e88aba710d33a291a42091d60595e89870e6f289513510052f48e66e35720f37bf9407885e96dd49d27943ea1183188ad67fe7a16bca7327e

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Akira Matsuda
+
+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,115 @@
+# CequelStatefulEnum
+
+cequel_stateful_enum is a simple state machine gem built on top of [Cequel](https://github.com/cequel/cequel)'s built-in enum column.
+This gem is totally based on [stateful_enum](https://github.com/amatsuda/stateful_enum) gem for ActiveRecord. Huge thanks to Akira Matsuda!
+This gem in not depends on Rails.
+
+
+## Installation
+
+Add this line to your app's Gemfile:
+
+```ruby
+gem 'cequel_stateful_enum'
+```
+
+And bundle.
+
+
+## Usage
+
+The cequel_stateful_enum gem extends Cequel's `column` definition to take a block with a similar DSL to the [state_machine](https://github.com/pluginaweek/state_machine) gem.
+
+Example:
+```ruby
+class Bug
+  include Cequel::Record
+
+  column :status, :enum, values: { unassigned: 0, assigned: 1, resolved: 2, closed: 3 } do
+    event :assign do
+      transition :unassigned => :assigned
+    end
+
+    event :resolve do
+      before do
+        self.resolved_at = Time.now
+      end
+
+      transition [:unassigned, :assigned] => :resolved
+    end
+
+    event :close do
+      transition all - [:closed] => :closed
+
+      after :notify_author_about_status
+
+      after do
+        BugCache.remove_from_open_cache(self)
+      end
+    end
+  end
+
+  # ...
+
+end
+```
+
+### Defining the States
+
+Just call the Cequel's `column` method with `:enum` type. The only difference from the original method is that our `column` call takes a block.
+
+### Defining the Events
+
+You can declare events through `event` method inside of an `column` block. Then cequel_stateful_enum defines the following methods per each event:
+
+**An instance method to fire the event**
+
+```ruby
+@bug.assign # does nothing and returns false if a valid transition for the current state is not defined
+```
+
+**An instance method with `!` to fire the event**
+```ruby
+@bug.assign! # raises if a valid transition for the current state is not defined
+```
+
+**A predicate method that returns if the event is fireable**
+```ruby
+@bug.can_assign? # returns if the `assign` event can be called on this bug or not and all `if` and `unless` conditions are met
+```
+
+### Defining the Transitions
+
+You can define state transitions through `transition` method inside of an `event` block.
+
+There are a few important details to note regarding this feature:
+
+* The `transition` method takes a Hash each key of which is state "from" transitions to the Hash value.
+* The "from" states and the "to" states should both be given in Symbols.
+* The "from" state can be multiple states, in which case the key can be given as an Array of states, as shown in the usage example.
+* The "from" state can be `all` that means all defined states.
+
+### :if and :unless Condition
+
+The `transition` method takes an `:if` and/or `:unless` option as a Proc or Symbol.
+
+Example:
+```ruby
+event :assign do
+  transition :unassigned => :assigned, if: -> { assigned_to.any? }, unless: :blocked?
+end
+```
+
+### Event Hooks
+
+You can define `before` and `after` event hooks inside of an `event` block as shown in the example above. Symbols and Proc objects are supported.
+
+
+## Contributing
+
+Pull requests are welcome on GitHub at https://github.com/Xanders/cequel_stateful_enum.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/cequel_stateful_enum.gemspec

@@ -0,0 +1,19 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cequel_stateful_enum'
+  spec.version       = '1.0.0'
+  spec.authors       = ['Xanders', 'Akira Matsuda']
+  spec.email         = ['necropolis@inbox.ru', 'ronnie@dio.jp']
+
+  spec.summary       = 'A state machine plugin on top of Cequel'
+  spec.homepage      = 'https://github.com/Xanders/cequel_stateful_enum'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'cequel'
+  spec.add_development_dependency 'rspec'
+end

data/lib/cequel_stateful_enum.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'cequel'
+require 'cequel_stateful_enum/machine'
+
+module CequelStatefulEnum
+  module Extension
+    #   column :status, :enum, values: { opened: 1, closed: 2 } do
+    #     event :close do
+    #       transition :opened => :closed
+    #     end
+    #   end
+    def column(name, type, options = {}, &block)
+      super
+
+      if type == :enum && block
+        states = options[:values]
+        states = states.keys if states.is_a?(Hash)
+        CequelStatefulEnum::Machine.new(self, name, states, &block)
+      end
+    end
+  end
+end
+
+Cequel::Record::Properties::ClassMethods.prepend CequelStatefulEnum::Extension

data/lib/cequel_stateful_enum/machine.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module CequelStatefulEnum
+  Error = Class.new(RuntimeError)
+  DefinitionError = Class.new(Error)
+  WorkflowError = Class.new(Error)
+  StateError = Class.new(WorkflowError)
+  ConditionError = Class.new(WorkflowError)
+
+  class Machine
+    def initialize(model, column, states, &block)
+      @model, @column, @states, @event_names = model, column, states, []
+      instance_eval(&block)
+    end
+
+    def event(name, &block)
+      raise DefinitionError, "event #{name} has already been defined" if @event_names.include? name
+      Event.new @model, @column, @states, name, &block
+      @event_names << name
+    end
+
+    class Event
+      def initialize(model, column, states, name, &block)
+        can = "can_#{name}?"
+        raise DefinitionError, "one of the #{name}, #{name}! or #{can} methods already defined" if ([name, "#{name}!", can] & model.instance_methods).any?
+
+        @states, @name, @transitions, @before, @after = states, name, {}, [], []
+        instance_eval(&block) if block
+
+        transitions, before, after = @transitions, @before, @after
+
+        # defining event methods
+        model.class_eval do
+          define_method name do |danger = false|
+            next false unless send(can, danger)
+            to = transitions[send(column).to_sym].first
+            before.each { |callback| instance_eval(&callback) }
+            send("#{column}=", to)
+            after.each { |callback| instance_eval(&callback) }
+            true
+          end
+
+          define_method "#{name}!" do
+            send(name, true)
+          end
+
+          define_method can do |danger = false|
+            from = send(column).to_sym
+            to, condition = transitions[from]
+            if !to
+              raise StateError, "can't fire #{name} event from state #{from}" if danger
+              false
+            elsif condition && !instance_exec(&condition)
+              raise ConditionError, "conditions for #{name} event does not met" if danger
+              false
+            else
+              true
+            end
+          end
+        end
+      end
+
+      def transition(transitions)
+        condition = transitions.delete(:if)
+        unless condition.nil? || condition.is_a?(Symbol) || condition.respond_to?(:call)
+          raise ArgumentError, "`if` condition can be nil, Symbol or callable object, but #{condition.class} given"
+        end
+        if condition.is_a?(Symbol)
+          symbol = condition
+          condition = -> { send(symbol) }
+        end
+        if unless_condition = transitions.delete(:unless)
+          unless unless_condition.nil? || unless_condition.is_a?(Symbol) || unless_condition.respond_to?(:call)
+            raise ArgumentError, "`unless` condition can be nil, Symbol or callable object, but #{unless_condition.class} given"
+          end
+          if unless_condition.is_a?(Symbol)
+            symbol = unless_condition
+            unless_condition = -> { send(symbol) }
+          end
+          condition = if condition
+            if_condition = condition
+            -> { instance_exec(&if_condition) && !instance_exec(&unless_condition) }
+          else
+            -> { !instance_exec(&unless_condition) }
+          end
+        end
+
+        transitions.each_pair do |froms, to|
+          raise DefinitionError, "undefined state #{to}" unless @states.include? to
+          Array(froms).each do |from|
+            raise DefinitionError, "undefined state #{from}" unless @states.include? from
+            raise DefinitionError, "duplicate entry: transition from #{from} to #{@transitions[from].first} has already been defined" if @transitions[from]
+            @transitions[from] = [to, condition]
+          end
+        end
+      end
+
+      def all
+        @states
+      end
+
+      def before(symbol = nil, &block)
+        raise ArgumentError, 'use Symbol or block for `before` callback' unless block_given? ? symbol.nil? : symbol.is_a?(Symbol)
+        block ||= -> { send(symbol) }
+        @before.push(block)
+      end
+
+      def after(symbol = nil, &block)
+        raise ArgumentError, 'use Symbol or block for `after` callback' unless block_given? ? symbol.nil? : symbol.is_a?(Symbol)
+        block ||= -> { send(symbol) }
+        @after.push(block)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: cequel_stateful_enum
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Xanders
+- Akira Matsuda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cequel
+  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: 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'
+description: 
+email:
+- necropolis@inbox.ru
+- ronnie@dio.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- cequel_stateful_enum.gemspec
+- lib/cequel_stateful_enum.rb
+- lib/cequel_stateful_enum/machine.rb
+homepage: https://github.com/Xanders/cequel_stateful_enum
+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.6.8
+signing_key: 
+specification_version: 4
+summary: A state machine plugin on top of Cequel
+test_files: []