dynflow 0.7.6 → 0.7.7

data/README.md

@@ -1,9 +1,16 @@
-![Dynflow](doc/images/logo.png)
+![Dynflow](doc/pages/source/images/logo-long.png)
 =======
 
-![Build](https://travis-ci.org/Dynflow/dynflow.svg?branch=master)
+![Build](https://img.shields.io/travis/Dynflow/dynflow/master.svg?style=flat)
+![Issues](https://img.shields.io/github/issues/Dynflow/dynflow.svg?style=flat)
+![Gem version](https://img.shields.io/gem/v/dynflow.svg?style=flat)
+![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)
 
-Dynflow [DYN(amic work)FLOW] is a workflow engine
+**Note:** *There is a project page and documentation being build in url <http://http://dynflow.github.io/>.
+It's still work in progress but you may find useful information there. It'll eventually replace 
+this README.*
+
+[Dynflow [DYN(amic work)FLOW]](http://dynflow.github.io/) is a workflow engine
 written in Ruby that allows to:
 
 * keep track of the progress of running process
@@ -29,6 +36,7 @@ implementations as well).
 
 ![Screenshot](doc/images/screenshot.png)
 
+* [Documentation](http://dynflow.github.io/documentation/) *in progress*
 * [Current status](#current-status)
 * [How it works](#how-it-works)
 * [Examples](#examples)

data/doc/pages/.gitignore

@@ -0,0 +1,7 @@
+.idea
+.sass-cache
+.bin
+.ruby-version
+public
+resources
+tmp

data/doc/pages/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'jekyll'
+gem 'pry'
+gem 'ruby-nuggets' # require by tags plugin
+
+gem 'pry'

data/doc/pages/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'rake'
+
+root = File.dirname __FILE__
+
+task :default => :publish
+
+def system(cmd)
+  puts ">> #{cmd}"
+  super cmd
+end
+
+desc 'push to Github'
+task :publish do
+  Dir.chdir(root) do
+    Dir.chdir(root + '/public') do
+      system 'git fetch --all'
+      system 'git reset --hard origin/master'
+    end
+    system 'jekyll build'
+    Dir.chdir(root + '/public') do
+      system 'git ac -m Update'
+      system 'git push'
+    end
+  end
+end

data/doc/pages/_config.yml

@@ -0,0 +1,38 @@
+---
+name: Dynflow
+title: Dynflow
+url: http://dynflow.github.io
+markdown: redcarpet
+highlighter: pygments
+
+source:       ./source
+destination:  ./public
+plugins:      ./plugins
+include:
+- .nojekyll
+
+tag_page_layout: tag_page
+tag_page_dir: tag
+
+permalink: /blog/:year/:month/:day/:title/
+
+favicon: /images/logo-square.png
+
+disqus_short_name: dynflow
+twitter_user: pitr_ch
+google_analytics_tracking_id: UA-60290609-1
+
+sass:
+  sass_dir: _sass
+  
+redcarpet:
+  extensions: 
+    - with_toc_data
+    - html_toc
+    - strikethrough
+
+plantuml:
+  plantuml_jar: .bin/plantuml.jar   # path to plantuml jar
+  tmp_folder: tmp                   # tmp folder to put generated image files
+  background_color: transparent     # [optional] UML image background color
+#  dot_exe: /usr/local/bin/dot      # [optional] path to Graphviz dot execution

data/doc/pages/plugins/alert_block.rb

@@ -0,0 +1,27 @@
+require_relative 'div_tag'
+
+module Jekyll
+  class AlertBlock < DivTag
+    def initialize(tag_name, markup, tokens)
+      @alert_type = tag_name.split('_').first
+      super tag_name, markup + ' alert alert-' + @alert_type, tokens
+    end
+
+    def tag
+      'div'
+    end
+
+    HEADER = { 'info'    => 'Note',
+               'warning' => 'Warning',
+               'danger'  => 'Danger' }
+
+    def render_content(context, content)
+      super context, "**#{HEADER[@alert_type]}** \n" + content
+    end
+  end
+end
+
+Liquid::Template.register_tag('info_block', Jekyll::AlertBlock)
+Liquid::Template.register_tag('warning_block', Jekyll::AlertBlock)
+Liquid::Template.register_tag('danger_block', Jekyll::AlertBlock)
+# Liquid::Template.register_tag('success_block', Jekyll::AlertBlock)

data/doc/pages/plugins/div_tag.rb

@@ -0,0 +1,24 @@
+module Jekyll
+  class DivTag < Liquid::Block
+    def render(context)
+      content            = super
+
+      <<-HTML.gsub(/^ +\|/, '')
+        |<#{tag} class="#{@markup}">
+        |  #{render_content context, content}
+        |</#{tag}>
+      HTML
+    end
+
+    def tag
+      @tag_name.split('_').first
+    end
+
+    def render_content(context, content)
+      context.registers[:site].converters.find { |c| c.is_a? Jekyll::Converters::Markdown }.convert(content)
+    end
+  end
+end
+
+Liquid::Template.register_tag('div_tag', Jekyll::DivTag)
+Liquid::Template.register_tag('span_tag', Jekyll::DivTag)

data/doc/pages/plugins/graphviz.rb

@@ -0,0 +1,121 @@
+# taken from https://raw.githubusercontent.com/kui/octopress-graphviz/master/graphviz_block.rb
+
+require 'open3'
+
+module Jekyll
+  class GraphvizBlock < Liquid::Block
+
+    DIV_CLASS_ATTR     = 'graphviz-wrapper'
+    DEFAULT_GRAPH_NAME = 'Graphviz'
+    DOT_OPTS           = '-Tsvg'
+    DOT_EXEC           = 'dot'
+    DOT_EXTS           = (ENV['PATHEXT'] || '.exe;.bat;.com').split(";")
+    DOT_EXTS.unshift ''
+    DOT_PATH = ENV['PATH'].split(File::PATH_SEPARATOR)
+                   .map { |a| File.join a, DOT_EXEC }
+                   .map { |a| DOT_EXTS.map { |ex| a+ex } }.flatten
+                   .find { |c| File.executable_real? c }
+    raise "not found a executable file: #{DOT_EXEC}" if DOT_PATH.nil?
+    DOT_CMD = "#{DOT_PATH} #{DOT_OPTS}"
+
+    def initialize(tag_name, markup, tokens)
+      super
+      @tag_name = tag_name
+
+      @title = markup or ""
+      @title.strip!
+
+      @src = ""
+    end
+
+    def render(context)
+      code  = super
+      title = if @title.empty? then
+                DEFAULT_GRAPH_NAME
+              else
+                @title
+              end
+
+      case @tag_name
+      when 'graphviz' then
+        render_graphviz code
+      when 'graph' then
+        render_graph 'graph', title, code
+      when 'digraph' then
+        render_graph 'digraph', title, code
+      else
+        raise "unknown liquid tag name: #{@tag_name}"
+      end
+    end
+
+    def render_graphviz(code)
+      @src = code
+      svg  = generate_svg code
+      filter_for_inline_svg svg
+    end
+
+    def filter_for_inline_svg(code)
+      code = remove_declarations code
+      code = remove_xmlns_attrs code
+      code = add_desc_attrs code
+      code = insert_desc_elements code
+      code = wrap_with_div code
+      code = code.gsub /<polygon fill="white" stroke="none"/, '<polygon fill="transparent" stroke="none"'
+      code
+    end
+
+    def generate_svg code
+      Open3.popen3(DOT_CMD) do |stdin, stdout, stderr|
+        stdout.binmode
+        stdin.print code
+        stdin.close
+
+        err = stderr.read
+        if not (err.nil? || err.strip.empty?)
+          raise "Error from #{DOT_CMD}:\n#{err}"
+        end
+
+        svg = stdout.read
+        svg.force_encoding 'UTF-8'
+
+        return svg
+      end
+    end
+
+    def remove_declarations(svg)
+      svg.sub(/<!DOCTYPE .+?>/im, '').sub(/<\?xml .+?\?>/im, '')
+    end
+
+    def remove_xmlns_attrs(svg)
+      svg.sub(%[xmlns="http://www.w3.org/2000/svg"], '')
+          .sub(%[xmlns:xlink="http://www.w3.org/1999/xlink"], '')
+    end
+
+    def add_desc_attrs(svg)
+      svg.sub!("<svg", %[<svg aria-label="#{CGI::escapeHTML @title}"])
+      svg.sub!("<svg", %[<svg role="img"])
+
+      return svg
+    end
+
+    def insert_desc_elements(svg)
+      inserted_elements = %[<title>#{CGI::escapeHTML @title}</title>\n]
+      inserted_elements << %[<desc>#{CGI::escapeHTML @src}</desc>\n]
+      svg.sub!(/(<svg [^>]*>)/, "\\1\n#{inserted_elements}")
+
+      return svg
+    end
+
+    def wrap_with_div(svg)
+      %[<div class="#{DIV_CLASS_ATTR}">#{svg}</div>]
+    end
+
+    def render_graph(type, title, code)
+      render_graphviz %[#{type} "#{title}" { #{code} }]
+    end
+  end
+end
+
+Liquid::Template.register_tag('graphviz', Jekyll::GraphvizBlock)
+Liquid::Template.register_tag('graph', Jekyll::GraphvizBlock)
+Liquid::Template.register_tag('digraph', Jekyll::GraphvizBlock)

data/doc/pages/plugins/plantuml.rb

@@ -0,0 +1,85 @@
+# Title: PlantUML Code Blocks for Jekyll
+# Author: YJ Park (yjpark@gmail.com)
+# https://github.com/yjpark/jekyll-plantuml
+# Description: Integrate PlantUML into Jekyll and Octopress.
+#
+# Syntax:
+# {% plantuml %}
+# plantuml code
+# {% endplantuml %}
+#
+require 'open3'
+require 'fileutils'
+
+module Jekyll
+
+  class PlantUMLBlock < Liquid::Block
+    attr_reader :config
+
+    def render(context)
+      site = context.registers[:site]
+      self.config = site.config['plantuml']
+
+      tmproot = File.expand_path(tmp_folder)
+      folder = "/images/plantuml/"
+      create_tmp_folder(tmproot, folder)
+
+      code = @nodelist.join + background_color
+      filename = Digest::MD5.hexdigest(code) + ".png"
+      filepath = tmproot + folder + filename
+      if !File.exist?(filepath)
+        plantuml_jar = File.expand_path(plantuml_jar_path)
+        cmd = "java -Djava.awt.headless=true -jar " + plantuml_jar + dot_cmd + " -pipe > " + filepath
+        result, status = Open3.capture2e(cmd, :stdin_data=>code)
+        Jekyll.logger.debug(filepath + " -->\t" + status.inspect() + "\t" + result)
+      end
+
+      site.static_files << Jekyll::StaticFile.new(site, tmproot, folder, filename)
+
+      # source = "<img class=\"img-thumbnail\" src='" + folder + filename + "'>"
+      source = "<img src='" + folder + filename + "'>"
+    end
+
+    private
+
+    def config=(cfg)
+      @config = cfg || Jekyll.logger.abort_with("Missing 'plantuml' configurations.")
+    end
+
+    def background_color
+      config['background_color'].nil? ? '' : " skinparam backgroundColor " + config['background_color']
+    end
+
+    def plantuml_jar_path
+      config['plantuml_jar'] || Jekyll.logger.abort_with("Missing configuration 'plantuml.plantuml_jar'.")
+    end
+
+    def tmp_folder
+      config['tmp_folder'] || Jekyll.logger.abort_with("Missing configuration 'plantuml.tmp_folder'.")
+    end
+
+    def dot_cmd
+      @dot_cmd ||= begin
+        dotpath = File.expand_path(config['dot_exe'] || '__NULL__')
+        if File.exist?(dotpath)
+          # Jekyll.logger.info("PlantUML: Use graphviz dot: " + dotpath)
+          " -graphvizdot " + dotpath
+        else
+          # Jekyll.logger.info("PlantUML: Assume graphviz dot is in PATH.")
+          ''
+        end
+      end
+    end
+
+    def create_tmp_folder(tmproot, folder)
+      folderpath = tmproot + folder
+      if !File.exist?(folderpath)
+        FileUtils::mkdir_p folderpath
+        Jekyll.logger.info("Create PlantUML image folder: " + folderpath)
+      end
+    end
+
+  end # PlantUMLBlock
+end
+
+Liquid::Template.register_tag('plantuml', Jekyll::PlantUMLBlock)

data/doc/pages/plugins/play.rb

@@ -0,0 +1,13 @@
+require 'pp'
+require 'pry'
+
+module Jekyll
+
+  class Play < Generator
+    def generate(site)
+      # pp site
+      # binding.pry
+    end
+
+  end
+end

data/doc/pages/plugins/tags.rb

@@ -0,0 +1,138 @@
+require 'nuggets/range/quantile'
+require 'erb'
+
+module Jekyll
+
+  class Tagger < Generator
+
+    safe true
+
+    attr_accessor :site
+
+    @types = [:page, :feed]
+
+    class << self; attr_accessor :types, :site; end
+
+    def generate(site)
+      self.class.site = self.site = site
+
+      generate_tag_pages
+      add_tag_cloud
+    end
+
+    private
+
+    # Generates a page per tag and adds them to all the pages of +site+.
+    # A <tt>tag_page_layout</tt> have to be defined in your <tt>_config.yml</tt>
+    # to use this.
+    def generate_tag_pages
+      active_tags.each { |tag, posts| new_tag(tag, posts) }
+    end
+
+    def new_tag(tag, posts)
+      self.class.types.each { |type|
+        if layout = site.config["tag_#{type}_layout"]
+          data = { 'layout' => layout, 'posts' => posts.sort.reverse!, 'tag' => tag, 'title' => tag }
+
+          name = yield data if block_given?
+          name ||= tag
+
+          tag_dir = site.config["tag_#{type}_dir"]
+          tag_dir = File.join(tag_dir, (pretty? ? name : ''))
+
+          page_name = "#{pretty? ? 'index' : name}#{site.layouts[data['layout']].ext}"
+
+          site.pages << TagPage.new(
+              site, site.source, tag_dir, page_name, data
+          )
+        end
+      }
+    end
+
+    def add_tag_cloud(num = 5, name = 'tag_data')
+      s, t = site, { name => calculate_tag_cloud(num) }
+      s.respond_to?(:add_payload) ? s.add_payload(t) : s.config.update(t)
+    end
+
+    # Calculates the css class of every tag for a tag cloud. The possible
+    # classes are: set-1..set-5.
+    #
+    # [[<TAG>, <CLASS>], ...]
+    def calculate_tag_cloud(num = 5)
+      range = 0
+
+      tags = active_tags.map { |tag, posts|
+        [tag.to_s, range < (size = posts.size) ? range = size : size]
+      }
+
+
+      range = 1..range
+
+      tags.sort!.map! { |tag, size| [tag, range.quantile(size, num)] }
+    end
+
+    def active_tags
+      return site.tags unless site.config["ignored_tags"]
+      site.tags.reject { |t| site.config["ignored_tags"].include? t[0] }
+    end
+
+    def pretty?
+      @pretty ||= (site.permalink_style == :pretty || site.config['tag_permalink_style'] == 'pretty')
+    end
+
+  end
+
+  class TagPage < Page
+
+    def initialize(site, base, dir, name, data = {})
+      self.content = data.delete('content') || ''
+      self.data    = data
+
+      super(site, base, dir[-1, 1] == '/' ? dir : '/' + dir, name)
+    end
+
+    def read_yaml(*)
+      # Do nothing
+    end
+
+  end
+
+  module Filters
+
+    def tag_cloud(site)
+      active_tag_data.map { |tag, set|
+        tag_link(tag, tag_url(tag), :class => "set-#{set} label label-default")
+      }.join(' ')
+    end
+
+    def tag_link(tag, url = tag_url(tag), html_opts = nil)
+      html_opts &&= ' ' << html_opts.map { |k, v| %Q{#{k}="#{v}"} }.join(' ')
+      %Q{<a href="#{url}"#{html_opts}>#{tag}</a>}
+    end
+
+    def tag_url(tag, type = :page, site = Tagger.site)
+      # FIXME generate full url for atom.xml page
+      url = File.join('', site.config["tag_#{type}_dir"], ERB::Util.u(tag))
+      site.permalink_style == :pretty || site.config['tag_permalink_style'] == 'pretty' ? url : url << '.html'
+    end
+
+    def tags(obj)
+      tags = obj['tags'].dup
+      tags.map! { |t| t.first } if tags.first.is_a?(Array)
+      tags.map! { |t| tag_link(t, tag_url(t), rel: 'tag', class: 'label label-default') if t.is_a?(String) }.compact!
+      tags.join(' ')
+    end
+
+    def keywords(obj)
+      return '' if not obj['tags']
+      tags = obj['tags'].dup
+      tags.join(',')
+    end
+
+    def active_tag_data(site = Tagger.site)
+      return site.config['tag_data'] unless site.config["ignored_tags"]
+      site.config["tag_data"].reject { |tag, set| site.config["ignored_tags"].include? tag }
+    end
+  end
+
+end