libis-workflow-mongoid 2.0.beta.13-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f7cd89f49cbe129eb23fb80e198faa04fb78fd6
+  data.tar.gz: da74e5eadbcda157fe4cb3643806398a35971a4a
+SHA512:
+  metadata.gz: 18456535f45deb883997f265b568ed638b9d0c1f0354dda2659664769137abf90f49704f8cd88b22aca9511357410ccb46323f24582abf29eb6e5e10db200311
+  data.tar.gz: 78c5fe4f27a5a140baf5bd0b5fb6965e5807a176dff500790e92975b03853153012b9699a8458774ad64dbe7e582dd38a5feaf64ad948fcc830c56d234f4e42e

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.idea
+projectFilesBackup
+spec/data

data/.travis/create_users.js

@@ -0,0 +1,31 @@
+db = db.getSiblingDB("admin");
+
+db.createUser(
+    {
+        "user"  : "useradmin",
+        "pwd"   : "useradmin",
+        "roles" : [
+            {
+                "role" : "userAdminAnyDatabase",
+                "db"   : "admin"
+            }
+        ]
+    }
+);
+
+db.auth("useradmin", "useradmin");
+
+db = db.getSiblingDB("workflow_test");
+
+db.createUser(
+    {
+        "user"  : "test",
+        "pwd"   : "abc123",
+        "roles" : [
+            {
+                "role" : "readWriteAnyDatabase",
+                "db"   : "admin"
+            }
+        ]
+    }
+);

data/.travis/db_prepare.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+OLD_DIR=`pwd`
+cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null
+# Creates not-authorized problems on MongoDB 3.0.2 on my machine
+# Using authorization-less code for now. To be investigated later ...
+# mongo create_users.js
+cd "${OLD_DIR}"

data/.travis.yml

@@ -0,0 +1,45 @@
+language: ruby
+sudo: false
+bundler_args: --without development
+cache: bundler
+
+rvm:
+  - 2.1.7
+  - 2.2.3
+  - ruby-head
+  - jruby-9.0.1.0
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - oraclejdk8
+matrix:
+  exclude:
+    - rvm: 2.1.7
+      jdk: oraclejdk7
+    - rvm: 2.1.7
+      jdk: oraclejdk8
+    - rvm: 2.2.3
+      jdk: oraclejdk7
+    - rvm: 2.2.3
+      jdk: oraclejdk8
+    - rvm: ruby-head
+      jdk: oraclejdk7
+    - rvm: ruby-head
+      jdk: oraclejdk8
+  allow_failures:
+    - rvm: ruby-head
+branches:
+  only:
+      - master
+env:
+  global:
+    - MONGODB_VERSION=3.2.0
+    - JRUBY_OPTS="-Xcli.debug=true --debug"
+before_install:
+  - wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-$MONGODB_VERSION.tgz
+  - tar xfz mongodb-linux-x86_64-$MONGODB_VERSION.tgz
+  - export PATH=`pwd`/mongodb-linux-x86_64-$MONGODB_VERSION/bin:$PATH
+  - mkdir -p data/db
+  - mongod --dbpath=data/db &> /dev/null &
+  - sleep 3
+before_script: ./.travis/db_prepare.sh

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gemspec name: 'libis-workflow-mongoid', development_group: :test
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 LIBIS
+
+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,8 @@
+
+[![Build Status](https://travis-ci.org/libis/workflow-mongoid.svg?branch=master)](https://travis-ci.org/libis/workflow-mongoid)
+[![Coverage Status](https://coveralls.io/repos/libis/workflow-mongoid/badge.png)](https://coveralls.io/r/libis/workflow-monoid)
+
+workflow-mongoid
+================
+
+Mongoid persistence for the workflow framework

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+desc 'run tests'
+task :default => :spec

data/lib/libis/workflow/mongoid/base.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require 'mongoid'
+require 'mongoid/document'
+# require 'mongoid_indifferent_access'
+require_relative 'sequence'
+
+require 'active_support/core_ext/object/deep_dup'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      module Base
+
+        def self.included(klass)
+          klass.class_eval do
+            include ::Mongoid::Document
+            include ::Mongoid::Timestamps::Created::Short
+            # include ::Mongoid::Extensions::Hash::IndifferentAccess
+            include ::Libis::Workflow::Mongoid::Sequence
+            field :_id, type: Integer, overwrite: true
+            sequence :_id
+            index c_at: 1
+          end
+        end
+
+        def dup
+          new_obj = self.class.new
+          new_obj.copy_attributes(self)
+        end
+
+        def info
+          self.attributes.deep_dup.reject { |k,v| v.blank? || volatile_attributes.include?(k) }.to_hash
+        end
+
+        protected
+
+        def volatile_attributes
+          %w'_id c_at'
+        end
+        private
+
+        def copy_attributes(other)
+          self.set(
+              other.attributes.reject do |k, _|
+                %W(_id c_at).include? k.to_s
+              end.each_with_object({}) do |(k, v), h|
+                h[k] = v.duplicable? ? v.dup : v
+              end
+          )
+          self
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/config.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'singleton'
+require 'mongoid'
+
+require 'libis/workflow/config'
+require 'libis/workflow/mongoid/run'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      # noinspection RubyConstantNamingConvention
+      Config = ::Libis::Workflow::Config
+
+      Config.define_singleton_method(:database_connect) do |config_file = './mongoid.yml', environment = nil|
+        # noinspection RubyResolve
+        instance.database_connect(config_file, environment)
+      end
+
+      Config.send(:define_method, :database_connect) do |config_file = './mongoid.yml', environment = nil|
+        ::Mongoid.load! config_file, environment
+        ::Mongo::Logger.logger.level = Logger::ERROR
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/dynamic.rb

@@ -0,0 +1,32 @@
+require 'mongoid'
+require 'mongoid/document'
+
+module Libis
+  module Workflow
+    module Mongoid
+      module Dynamic
+        def self.included(klass)
+          klass.class_eval do
+            include ::Mongoid::Document
+            include ::Mongoid::Attributes::Dynamic
+            include ::Libis::Workflow::Mongoid::Sequence
+            field :_id, type: Integer, overwrite: true
+            sequence :_id
+            index _id: 1
+
+            def has_key?(key)
+              self.attributes.has_key?(key.to_s) || self.attributes.has_key?(key.to_sym)
+            end
+
+            def each(&block)
+              self.attributes.reject { |k,_| k == '_id' }.each(&block)
+            end
+
+          end
+        end
+
+
+      end
+    end
+  end
+end

data/lib/libis/workflow/mongoid/job.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'libis/workflow/base/job'
+require 'libis/workflow/mongoid/base'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      module Job
+
+        def self.included(klass)
+          klass.class_eval do
+            include ::Libis::Workflow::Base::Job
+            include ::Libis::Workflow::Mongoid::Base
+
+            store_in collection: 'workflow_jobs'
+
+            field :name, type: String
+            field :description, type: String
+            field :input, type: Hash, default: -> { Hash.new }
+            field :run_object, type: String
+
+            index({name: 1}, {unique: 1})
+
+            def klass.run_class(run_klass)
+              has_many :runs, inverse_of: :job, class_name: run_klass.to_s,
+                       dependent: :destroy, autosave: true, order: :c_at.asc
+            end
+
+            def klass.workflow_class(workflow_klass)
+              belongs_to :workflow, inverse_of: :jobs, class_name: workflow_klass.to_s
+            end
+
+            # def create_run_object
+            #   # noinspection RubyResolve
+            #   self.runs.build
+            # end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/workflow/mongoid/log_entry.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require 'libis-workflow'
+require 'libis/workflow/mongoid/base'
+
+require 'mongoid/extensions/time_with_zone'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      class LogEntry
+        include Libis::Workflow::Mongoid::Base
+
+        store_in collection: 'log'
+
+        field :severity, type: String
+        field :task, type: String, default: '*UNKNOWN*'
+        field :code, type: Integer
+        field :message, type: String
+        field :status, type: String
+
+        belongs_to :logger, polymorphic: true
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/run.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+require 'fileutils'
+
+require 'libis/workflow/base/run'
+require 'libis/workflow/mongoid/work_item_base'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      module Run
+        # extend ActiveSupport::Concern
+
+        def self.included(klass)
+          klass.class_eval do
+            include ::Libis::Workflow::Base::Run
+            include ::Libis::Workflow::Mongoid::WorkItemBase
+
+            store_in collection: 'workflow_runs'
+
+            field :start_date, type: Time, default: -> { Time.now }
+
+            set_callback(:destroy, :before) do |document|
+              document.items.each { |item| item.destroy }
+              wd = document.work_dir
+              FileUtils.rmtree wd if wd && !wd.blank? && Dir.exist?(wd)
+            end
+
+            index start_date: 1
+
+            def klass.job_class(job_klass)
+              belongs_to :job, inverse_of: :runs, class_name: job_klass.to_s
+            end
+
+            def klass.item_class(item_klass)
+              has_many :items, inverse_of: :run, class_name: item_klass.to_s,
+                       dependent: :destroy, autosave: true, order: :c_at.asc
+            end
+          end
+        end
+
+        def run
+          self.tasks = []
+          self.items = []
+          # noinspection RubySuperCallWithoutSuperclassInspection
+          super
+        end
+
+        # Add a child work item
+        #
+        # @param [Libis::Workflow::Mongoid::WorkItem] item to be added to the child list :items
+        def add_item(item)
+          # noinspection RubyResolve
+          item.run = self
+          super
+        end
+
+        alias_method :<<, :add_item
+
+        def parent
+          nil
+        end
+
+        def parent=(_)
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/sequence.rb

@@ -0,0 +1,79 @@
+#require 'mongoid/fields/validators/macro'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      # Include this module to add automatic sequence feature (also works for _id field, so SQL-Like autoincrement primary key can easily be simulated)
+      # usage:
+      # class KlassName
+      #   include Mongoid::Document
+      #   include LIBIS::Mongoid::Sequence
+      # ...
+      #   field :number, :type=>Integer
+      #   sequence :number
+      # ...
+      # Note: only tested on Mongoid 3.x and 4.x
+      module Sequence
+        extend ActiveSupport::Concern
+
+        #noinspection ALL
+        module ClassMethods
+
+          def sequence(_field, prefix = nil)
+            # REPLACE FIELD DEFAULT VALUE
+            _field = _field.to_s
+            options = fields[_field].options.merge(
+                default: lambda {
+                  self.class.set_from_sequence(_field, prefix)
+                },
+                pre_processed: false,
+                overwrite: true
+            )
+            (options.keys - ::Mongoid::Fields::Validators::Macro::OPTIONS).each { |key| options.delete key }
+            field(_field, options)
+          end
+
+          def set_from_sequence(_field, prefix)
+            # Increase the sequence value and also avoids conflicts
+            catch(:value) do
+              value = nil
+              begin
+                value = seq_upsert(counter_id(_field), {'$inc' => {'value' => 1}}).send('[]', 'value')
+                value = "#{prefix.is_a?(Proc) ? instance_eval(prefix.call) : prefix}_#{value}" if prefix
+              end until self.where(_field => value).count == 0
+              throw :value, value
+            end
+          end
+
+          def reset_sequence(_field, value = 0)
+            seq_upsert(counter_id(_field), {'$set' => {'value' => value}})
+          end
+
+          protected
+
+          def counter_id(_field)
+            #"#{self.name.underscore}##{_field}"
+            "#{collection_name.to_s}##{_field}"
+          end
+
+          def sequences
+            # mongo_session["#{self.collection_name.to_s}__seq"]
+            mongo_client["__sequences__"]
+          end
+
+          def seq_upsert(counter_id, change)
+            sequences.find_one_and_update({_id: counter_id},
+                                          change,
+                                          upsert: true,
+                                          return_document: :after
+            )
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/version.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Libis
+  module Workflow
+    module Mongoid
+      VERSION = '2.0.beta.13' unless const_defined? :VERSION # the guard is against a redefinition warning that happens on Travis
+    end
+  end
+end

data/lib/libis/workflow/mongoid/work_item.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+require 'libis/workflow/mongoid/work_item_base'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      module WorkItem
+
+        def self.included(klass)
+          klass.class_eval do
+            include Libis::Workflow::Mongoid::WorkItemBase
+
+            store_in collection: 'workflow_items'
+
+            has_many :items, inverse_of: :parent, class_name: klass.to_s,
+                     dependent: :destroy, autosave: true, order: :_id.asc
+            belongs_to :parent, inverse_of: :items, class_name: klass.to_s
+
+            set_callback(:destroy, :before) do |document|
+              document.items.each { |item| item.destroy! }
+            end
+
+            def klass.run_class(run_klass)
+              belongs_to :run, inverse_of: :items, class_name: run_klass.to_s
+            end
+
+          end
+        end
+
+        def get_parent
+          self.parent || self.run
+        end
+
+      end
+
+    end
+  end
+end

data/lib/libis/workflow/mongoid/work_item_base.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+require 'libis-workflow'
+require_relative 'dynamic'
+
+module Libis
+  module Workflow
+    module Mongoid
+
+      module WorkItemBase
+
+        class Options
+          include Libis::Workflow::Mongoid::Dynamic
+          embedded_in :work_item, class_name: Libis::Workflow::Mongoid::WorkItemBase.to_s
+        end
+
+        class Properties
+          include Libis::Workflow::Mongoid::Dynamic
+          embedded_in :work_item, class_name: Libis::Workflow::Mongoid::WorkItemBase.to_s
+        end
+
+        class Summary
+          include Libis::Workflow::Mongoid::Dynamic
+          embedded_in :work_item, class_name: Libis::Workflow::Mongoid::WorkItemBase.to_s
+        end
+
+        def self.included(klass)
+          klass.class_eval do
+            include Libis::Workflow::Base::WorkItem
+            include Libis::Workflow::Mongoid::Base
+
+            embeds_one :options, class_name: Libis::Workflow::Mongoid::WorkItemBase::Options.to_s
+            embeds_one :properties, class_name: Libis::Workflow::Mongoid::WorkItemBase::Properties.to_s
+            embeds_one :summary, class_name: Libis::Workflow::Mongoid::WorkItemBase::Summary.to_s
+
+            has_many :logs, as: :logger, class_name: Libis::Workflow::Mongoid::LogEntry.to_s,
+                     dependent: :destroy, autosave: true, order: :_id.asc do
+              def log_history
+                where(:status.exists => false)
+              end
+
+              def status_log
+                where(:status.exists => true)
+              end
+            end
+
+            # def destroy
+            #   # noinspection RubyResolve
+            #   self.logs.each { |log| log.destroy }
+            # end
+
+            set_callback(:destroy, :before) do |document|
+              # noinspection RubyResolve
+              document.logs.each { |log| log.destroy! }
+            end
+
+            set_callback(:initialize, :after) do |document|
+              document.options = {}
+              document.properties = {}
+              document.summary = {}
+            end
+
+          end
+
+        end
+
+        def each
+          self.items.each { |item| yield item }
+        end
+
+        def get_items
+          self.items.to_a
+        end
+
+        def item_count
+          self.items.count
+        end
+
+        alias_method :count, :item_count
+        alias_method :size, :item_count
+
+        def log_history
+          # noinspection RubyResolve
+          self.logs.log_history.all || []
+        end
+
+        def status_log
+          # noinspection RubyResolve
+          self.logs.status_log.all || []
+        end
+
+        protected
+
+        def add_log_entry(msg)
+          # noinspection RubyResolve
+          self.logs.build(msg)
+        end
+
+        def add_status_log(info)
+          # noinspection RubyResolve
+          self.logs.build(info)
+        end
+
+      end
+
+    end
+  end
+end