taskflow-mongoid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f6207e24297a546ecaf6ac571ef038ff85df29d
+  data.tar.gz: 897ccc7e04641d6506b106ce269513b85498bb44
+SHA512:
+  metadata.gz: 62153a6ef8a35f7840b01d3fdd4cb7466c5bce59a6a7bc53763b4dc0a0f15628d07f016f88964148ca844fb62b9f67c1b1a13fec644b9d32086ddd93eeeec6a6
+  data.tar.gz: 0910446837c77db561162c8ccbb20bc4e6c506d4ca466526caf0969163ec34a14eb65a8804619f280a8f85c05efa7933c8503021aa1b9c6b9bb11470e6ffa6f1

data/.gitignore

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

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in taskflow.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 qujianping
+
+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,158 @@
+# Taskflow
+
+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/taskflow`. 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 'taskflow-mongoid',:require=>'taskflow'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install taskflow-mongoid
+
+## Usage
+
+example:
+```ruby
+class PlayFlow < Taskflow::Flow
+    NAME = "Play FLow"
+    def configure
+        t1 = run PendingTask, params: input, name: 'pending-task'
+        t2 = run OkTask,after: t1,name: 'ok-task'
+        t3 = run AlwaysFailTask,after: t1,name: 'always-fail-task'
+        t4 = run RetryPassTask,after: t1,name: 'retry-pass-task'
+        t5 = run OkTask,after: t4,name: 'just-play-task'
+        run SummaryTask,after: [t2,t3,t5],name: 'summary-task'
+        run OkTask,params: {love: 3},name: 'finished-task'
+    end
+end
+class PendingTask < Taskflow::Task
+    def go(logger)
+        logger.info "I got input paramter: #{input}"
+        logger.info 'first step,then suspend'
+        if data[:who]
+            logger.info "cool, #{data[:who]} wake me up!"
+            tflogger.info 'Pending task wake up'
+            set_output :reason=>'you are cool'
+        else
+            logger.info 'I would suspended now, wake for your wakeup.'
+            suspend
+        end
+    end
+end
+class OkTask < Taskflow::Task
+    def go(logger)
+        set_output "result"=>(rand 10)
+        logger.info "#{self.name} finished"
+    end
+end
+class AlwaysFailTask < Taskflow::Task
+    def go(logger)
+        logger.info 'I would always fail, pls skip me'
+        raise 'Ops, always fail!!!'
+    end
+end
+class SummaryTask < Taskflow::Task
+    def go(logger)
+        logger.info 'get upstream output'
+        upstream.each do |task|
+            logger.info "Upstream task[#{task.name}]: #{task.output}"
+        end
+    end
+end
+
+class RetryPassTask < Taskflow::Task
+    def go(logger)
+        if data.empty?
+            set_data :success_next_time=>true
+            raise 'fail, please retry'
+        else
+            logger.info 'second time ok'
+        end
+        logger.info 'retry succeed'
+    end
+end
+```
+Then schedule taskflow like below:
+
+```ruby
+f=Taskflow::Flow.launch 'PlayFlow',:params=>{word: 'hello'},:launched_by=>'Jason',:workflow_description=>'desc'
+# find PendingTask
+t=f.tasks.where(state: 'paused',result: 'suspend').first
+t.wakeup :who=>'Tom'
+# find AlwaysFailTask
+t=f.tasks.find_by name: 'always-fail-task'
+puts t.error
+# {"class"=>"RuntimeError", "message"=>"Ops, always fail!!!", "backtrace"=>["/U..."]}
+t.skip
+t=f.tasks.find_by name: 'retry-pass-task'
+t.resume
+# wait for while
+puts f.state # => stopped
+# and we can check the log of taskflow itself
+puts f.logger.records
+
+# all sidekiq log
+Taskflow::Worker JID-905f46ac2a14b79329cc2526 INFO: start
+Taskflow::Worker JID-905f46ac2a14b79329cc2526 INFO: I got input paramter: {"word"=>"hello"}
+Taskflow::Worker JID-905f46ac2a14b79329cc2526 INFO: first step,then suspend
+Taskflow::Worker JID-905f46ac2a14b79329cc2526 INFO: I would suspended now, wake for your wakeup.
+Taskflow::Worker JID-905f46ac2a14b79329cc2526 INFO: done: 0.034 sec
+Taskflow::Worker JID-cdcba34bc5f4746d0f0b68ad INFO: start
+Taskflow::Worker JID-cdcba34bc5f4746d0f0b68ad INFO: I got input paramter: {"word"=>"hello"}
+Taskflow::Worker JID-cdcba34bc5f4746d0f0b68ad INFO: first step,then suspend
+Taskflow::Worker JID-cdcba34bc5f4746d0f0b68ad INFO: cool, Tom wake me up!
+Taskflow::Worker JID-cdcba34bc5f4746d0f0b68ad INFO: done: 0.059 sec
+Taskflow::Worker JID-2167fefe864f5de18ca7341e INFO: start
+Taskflow::Worker JID-f1131d60a2d7530953f346ec INFO: start
+Taskflow::Worker JID-259ef2694a65e235cf010b1e INFO: start
+Taskflow::Worker JID-259ef2694a65e235cf010b1e INFO: I would always fail, pls skip me
+Taskflow::Worker JID-2167fefe864f5de18ca7341e INFO: ok-task finished
+Taskflow::Worker JID-259ef2694a65e235cf010b1e INFO: done: 0.077 sec
+Taskflow::Worker JID-2167fefe864f5de18ca7341e INFO: done: 0.083 sec
+Taskflow::Worker JID-f1131d60a2d7530953f346ec INFO: done: 0.084 sec
+Taskflow::Worker JID-2d4f24491b84a68334cebaab INFO: start
+Taskflow::Worker JID-2d4f24491b84a68334cebaab INFO: done: 0.022 sec
+Taskflow::Worker JID-6312d5b0e1c66602bf04372e INFO: start
+Taskflow::Worker JID-6312d5b0e1c66602bf04372e INFO: second time ok
+Taskflow::Worker JID-6312d5b0e1c66602bf04372e INFO: retry succeed
+Taskflow::Worker JID-6312d5b0e1c66602bf04372e INFO: done: 0.027 sec
+Taskflow::Worker JID-dda69c567c7009219f6237b6 INFO: start
+Taskflow::Worker JID-dda69c567c7009219f6237b6 INFO: just-play-task finished
+Taskflow::Worker JID-dda69c567c7009219f6237b6 INFO: done: 0.032 sec
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: start
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: get upstream output
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: Upstream task[ok-task]: {"result"=>4}
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: Upstream task[always-fail-task]: {}
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: Upstream task[just-play-task]: {"result"=>0}
+Taskflow::Worker JID-7163d1fa16a685d016642a6b INFO: done: 0.03 sec
+Taskflow::Worker JID-d7d0c92da5ab820bc1f66651 INFO: start
+Taskflow::Worker JID-d7d0c92da5ab820bc1f66651 INFO: finished-task finished
+Taskflow::Worker JID-d7d0c92da5ab820bc1f66651 INFO: done: 0.021 sec
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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]/taskflow. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](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 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "taskflow"
+
+# 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,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/taskflow.rb

@@ -0,0 +1,11 @@
+require "taskflow/version"
+require 'active_support/core_ext/hash/indifferent_access'
+require 'taskflow/flow'
+require 'taskflow/task'
+require 'taskflow/worker'
+require 'taskflow/logger'
+require 'taskflow/record'
+
+module Taskflow
+    # Your code goes here...
+end

data/lib/taskflow/flow.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+class Taskflow::Flow
+    include ::Mongoid::Document
+
+    field :name, type: String
+    field :klass, type: String, default: -> { self.class.to_s }
+    field :state, type: String, default: 'pending'
+    field :category, type: String, default: 'simple'
+    field :result, type: String
+    field :launched_by, type: String
+    field :halt_by, type: String
+    field :input,type: Hash
+    field :progress,type: Float, default: 0
+    field :started_at, type: Time
+    field :ended_at, type: Time
+    field :next_config, type: Hash
+
+    after_create :configure_tasks
+
+    has_many :tasks, :class_name=>'Taskflow::Task',:inverse_of=>:flow,:dependent => :destroy
+    has_one :logger,:class_name=>'Taskflow::Logger',:inverse_of=>:flow, :dependent => :destroy
+
+    class << self
+
+        # opts support :params,
+        def can_launch?(klass,opts={})
+            opts = HashWithIndifferentAccess.new opts
+            !Taskflow::Flow.ne(state: 'stopped').where(klass: klass,input: opts[:params]).exists?
+        end
+
+        def launch(klass,opts={})
+            opts = HashWithIndifferentAccess.new opts
+            flow_klass = Kernel.const_get klass
+            name = flow_klass.const_get 'NAME'
+            opts[:launched_by] ||= 'task-flow-engine'
+            flow = flow_klass.create name: name,input: opts[:params],launched_by: opts[:launched_by]
+            if opts[:next_workflow_config]
+                flow.update next_config: opts[:next_workflow_config]
+            end
+            flow.create_logger name: name,description: opts[:workflow_description]
+            flow.schedule
+        end
+    end
+
+    def running_steps
+        self.tasks.in(state: ['running','paused'])
+    end
+
+    # opts support :name,:params
+    def run(klass,opts={})
+        obj = {
+            klass: klass.to_s,
+            name: opts[:name] || klass.to_s,
+            input: opts[:params],
+            index: self.tasks.size + 1
+        }
+        task = klass.create obj.select{|k,v| v }
+        if opts[:before]
+            task.downstream << opts[:before]
+        end
+        if opts[:after]
+            task.upstream << opts[:after]
+        end
+        if opts[:before].nil? && opts[:after].nil? && self.tasks.last
+            self.tasks.last.downstream << task
+        end
+        self.tasks << task
+        task
+    end
+
+    def stop!(user_id=nil)
+        percent = self.tasks.map(&:progress).sum / self.tasks.size
+        self.update_attributes! progress: percent,halt_by: user_id,ended_at: Time.now, state: 'stopped',result: 'warning'
+    end
+
+    def resume
+        self.tasks.where(state: 'paused',result: 'error').each do |task|
+            task.resume
+        end
+    end
+
+    def schedule
+        return if self.halt_by || self.state == 'stopped'
+        self.update_attributes! state: 'running',started_at: Time.now if self.state == 'pending'
+        task_list = []
+        self.reload.tasks.where(state: 'pending').each do |task|
+            # 上游全部完成
+            if task.upstream.empty? || task.upstream.all?{|t| %w(skipped stopped).include? t.state }
+                task_list << task.id.to_s
+            end
+        end
+        task_list.each{|tid| Taskflow::Worker.perform_async self.id.to_s,tid }
+        self
+    end
+
+    private
+    def configure_tasks
+        begin
+            configure
+            sort_index  1,[]
+        rescue=>exception
+            self.destroy
+            raise exception
+        end
+        reload
+    end
+
+    def sort_index(i,scanned)
+        queue = self.tasks.nin(id: scanned).select{|t| t.upstream.empty? || t.upstream.all?{|upt| scanned.include?(upt.id.to_s)}}
+        return if queue.empty?
+        queue.each do |task|
+            task.update_attributes index: i
+            scanned << task.id.to_s
+        end
+        sort_index i + 1,scanned
+    end
+end

data/lib/taskflow/logger.rb

@@ -0,0 +1,51 @@
+class Taskflow::Logger
+    include ::Mongoid::Document
+    belongs_to :flow, :class_name=>'Taskflow::Flow',:inverse_of=>:logger
+
+    field :name, type: String
+    field :description, type: String
+    field :created_at, type: Time, default: ->{ Time.now }
+
+    embeds_many :records,:class_name=>'Taskflow::Record',:inverse_of=>:logger
+
+    def log(content,options={})
+        raise 'Need step id to write a log' if options[:step_id].nil? && @step_id.nil?
+        options[:step_id] ||= @step_id
+        options[:writer] ||= @writer
+        @step_id ||= options[:step_id]
+        @writer ||= options[:writer]
+        options.merge! :content=>content
+        record = self.records.last
+        if record && options.all?{|k,v| record.send(k) == v }
+            record.update_attributes! written_at: Time.now
+        else
+            self.records.create options
+        end
+    end
+
+    def info(content,options={})
+        options.merge!(:level=>'INFO')
+        self.log content,options
+    end
+
+    def error(content,options={})
+        options.merge!(:level=>'ERROR')
+        self.log content,options
+    end
+
+    def fatal(content,options={})
+        options.merge!(:level=>'FATAL')
+        self.log content,options
+    end
+
+    def warning(content,options={})
+        options.merge!(:level=>'WARNING')
+        self.log content,options
+    end
+
+    def debug(content,options={})
+        options.merge!(:level=>'DEBUG')
+        self.log content,options
+    end
+
+end

data/lib/taskflow/record.rb

@@ -0,0 +1,11 @@
+class Taskflow::Record
+    include ::Mongoid::Document
+    embedded_in :logger,:class_name=>'Taskflow::Logger',:inverse_of=>:records
+
+    field :step_id, type: Integer
+    field :writer, type: String
+    field :written_at, type: Time, default: ->{ Time.now }
+    field :level, type: String, default:  'INFO'
+    field :content, type: String
+    field :tags, type: Hash, default: {}
+end

data/lib/taskflow/task.rb

@@ -0,0 +1,98 @@
+# coding: utf-8
+class Taskflow::Task
+    include ::Mongoid::Document
+
+    field :index, type: Integer, default: 1
+    field :name, type: String
+    field :klass, type: String, default: -> { self.class.to_s }
+    # all aviable states: :pending, :running, :paused, :stopped, :skipped
+    field :state, type: String, default: 'pending'
+    field :result,type: String
+
+    field :started_at, type: Time
+    field :ended_at, type: Time
+
+    field :output,type: Hash, default: {}
+    # task flow params would be set here
+    field :input,type: Hash, default: {}
+    field :error, type: Hash
+
+    field :progress, type: Float, default: 0
+
+    # tmp data, would be wipe out after task finished
+    field :data, type: Hash, default: {}
+
+    # do not save myself in up or downstream
+    before_save :remove_self_in_stream
+
+    has_and_belongs_to_many :downstream, :class_name=>'Taskflow::Task',:inverse_of=>:upstream
+    has_and_belongs_to_many :upstream, :class_name=>'Taskflow::Task',:inverse_of=>:downstream
+
+    belongs_to :flow,:class_name=>'Taskflow::Flow',:inverse_of=>:tasks
+
+    def go(sidekiq_logger)
+    end
+
+    def resume
+        if self.state == 'paused' && self.result == 'error'
+            self.flow.update_attributes! state: 'running'
+            Taskflow::Worker.perform_async self.flow.id.to_s,self.id.to_s
+        end
+    end
+
+    def wakeup(arguments={})
+        self.reload
+        if self.state == 'paused' && self.result == 'suspend'
+            self.data = self.data.merge arguments
+            self.result = nil
+            self.save
+            Taskflow::Worker.perform_async self.flow.id.to_s,self.id.to_s
+        end
+    end
+
+    def skip
+        self.reload
+        if self.state == 'paused'
+            self.update_attributes! state: 'skipped'
+            Taskflow::Worker.perform_async self.flow.id.to_s,self.id.to_s
+        end
+    end
+
+    private
+
+    def remove_self_in_stream
+        downstream.delete self if downstream.include? self
+        upstream.delete self if upstream.include? self
+    end
+
+    def suspend
+        throw :control,:suspend
+    end
+
+    def tflogger
+        @tflogger ||= (
+            _logger = flow.logger
+            _logger.instance_variable_set '@step_id',self.index
+            _logger.instance_variable_set '@writer',self.name
+            _logger
+        )
+    end
+
+    def method_missing(name,*args)
+        if /^(set|append|clear)_(input|output|data)$/ =~ name.to_s
+            act,fd = name.to_s.split '_'
+            if act == 'set'
+                return false unless args.first
+                self.update_attributes! "#{fd}"=>args.first
+            elsif act == 'append'
+                return false unless args.first
+                self.update_attributes! "#{fd}"=>self.send("#{fd}").merge(args.first)
+            else
+                self.update_attributes! "#{fd}"=>{}
+            end
+        else
+            super
+        end
+    end
+
+end

data/lib/taskflow/version.rb

@@ -0,0 +1,3 @@
+module Taskflow
+  VERSION = "0.1.0"
+end

data/lib/taskflow/worker.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+class Taskflow::Worker
+    include ::Sidekiq::Worker
+    sidekiq_options :retry => false
+
+    def perform(task_flow_id,job_id,opts={})
+        flow = Taskflow::Flow.find task_flow_id
+        task = Taskflow::Task.find job_id
+        begin
+            reason = catch :control do
+                check_flow_state flow
+                check_task_state task
+                task.update_attributes! state: 'running',started_at: Time.now,ended_at: nil, progress: 0.5,output: {},error: nil,result: nil
+                task.go logger
+            end
+            case reason
+            when :flow_halt
+                flow.update_attributes! ended_at: Time.now unless flow.ended_at
+            when :suspend
+                task.update_attributes! result: 'suspend',state: 'paused'
+            when :skip
+                task.update_attributes! state: 'skipped',data: {}
+            when :already_running,:already_stopped
+                return
+            else
+                task.update_attributes! data: {},ended_at: Time.now,progress: 1,state: 'stopped',result: 'success'
+            end
+        rescue=>exception
+            task.error = {
+                class: exception.class.to_s,
+                        message: exception.to_s,
+                        backtrace: exception.backtrace
+                    }
+                    task.state = 'paused'
+                    task.result = 'error'
+                    task.ended_at = Time.now
+                    task.save
+                end
+                update_flow flow.reload
+                flow.schedule
+                end
+
+                private
+                def check_flow_state(flow)
+                    if flow.state == 'stopped' || flow.halt_by
+                        throw :control, :flow_halt
+                    end
+                end
+                def check_task_state(task)
+                    case task.state
+                    when 'pending'
+                        task.update_attributes state: 'running'
+                    when 'running'
+                        throw :control, :already_running
+                    when 'paused'
+                        throw :control, :suspend if task.result == 'suspend'
+                    when 'stopped'
+                        throw :control, :already_stopped
+                    when 'skipped'
+                        throw :control,:skip
+                    else
+                        raise "Unkown task state #{task.state}"
+                    end
+                end
+
+                def update_flow(flow)
+                    return if flow.halt_by || flow.state == 'stopped'
+                    flow.progress = flow.tasks.map(&:progress).sum / flow.tasks.size
+                    if flow.halt_by
+                        flow.state = 'stopped'
+                    elsif flow.tasks.all?{|t| %w(stopped skipped).include? t.state }
+                        flow.state = 'stopped'
+                    elsif flow.tasks.any?{|t| t.state == 'paused' }
+                        flow.state = 'paused'
+                        flow.result = flow.tasks.find_by(state: 'paused').result
+                    else
+                        flow.state = 'running'
+                    end
+                    if flow.state == 'stopped'
+                        flow.result = flow.tasks.all?{|t| t.result == 'success' } ? 'success' : 'warning'
+                        flow.ended_at = Time.now
+                        if flow.next_config
+                            logger.info "Auto boot next flow, #{flow.next_config}"
+                            Taskflow::Flow.launch flow.next_config[:name],flow.next_config[:config]
+                        end
+                    end
+                    flow.save
+                end
+
+                end

data/taskflow.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'taskflow/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "taskflow-mongoid"
+  spec.version       = Taskflow::VERSION
+  spec.authors       = ["qujianping"]
+  spec.email         = ["qjpcpu@gmail.com"]
+
+  spec.summary       = %q{Easy task flow based on sidekiq.}
+  spec.description   = %q{Easy task flow based on sidekiq.}
+  spec.homepage      = "https://github.com/qjpcpu/taskflow-mongoid"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  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.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "sidekiq","~> 3.3"
+  spec.add_runtime_dependency "mongoid","~> 4.0"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: taskflow-mongoid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- qujianping
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-07-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.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Easy task flow based on sidekiq.
+email:
+- qjpcpu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/taskflow.rb
+- lib/taskflow/flow.rb
+- lib/taskflow/logger.rb
+- lib/taskflow/record.rb
+- lib/taskflow/task.rb
+- lib/taskflow/version.rb
+- lib/taskflow/worker.rb
+- taskflow.gemspec
+homepage: https://github.com/qjpcpu/taskflow-mongoid
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Easy task flow based on sidekiq.
+test_files: []