simpleflow 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Eric Abouaf
+
+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.rdoc

@@ -0,0 +1,83 @@
+= simpleflow
+
+* http://github.com/neyric/simpleflow
+
+== DESCRIPTION:
+
+Simple workflow execution
+
+== FEATURES/PROBLEMS:
+
+
+== SYNOPSIS:
+
+
+result = Simpleflow::run({
+
+		"modules" => [
+			{
+				"name" => "MyCustomModule",
+				"value" => {
+						"test"=>"blabla"
+				}
+			}
+		],
+
+		"wires" => []
+
+	}, {}, true, lambda { |name|
+	...
+	}
+)
+
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+sudo gem install simpleflow
+
+
+== TODO
+
+* loops not implemented
+* conditional not implemented
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Eric Abouaf
+
+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/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "simpleflow"
+    gem.summary = %Q{Simple workflow execution}
+    gem.description = %Q{Simpleflow has a simple engine that executes modules in a loop. The workflows are declarative, which means that you can static-check them and safely run user workflows. Modules are created easily in ruby so you can quickly write wrappers around libraires.}
+    gem.email = "eric.abouaf@gmail.com"
+    gem.homepage = "http://github.com/neyric/simpleflow"
+    gem.authors = ["neyric"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simpleflow #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/init.rb

@@ -0,0 +1,2 @@
+# For Rails plugin install
+require 'simpleflow'

data/lib/simpleflow.rb

@@ -0,0 +1,175 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+Dir["#{File.dirname(__FILE__)}/simpleflow/*.rb"].each { |f| load(f) }
+
+module Simpleflow
+  VERSION = '0.0.1'
+
+	
+  module Modules
+		# For Composed modules
+    def self.input(params)
+			inputName = params["input"]["name"]
+		  if params.keys.include?(inputName)
+				{"out" => params[inputName] }
+			else
+				{"out" => params["input"]["value"] }
+			end
+    end
+    
+    # For Composed modules
+    def self.output(params)
+      {"out" => params["in"] }
+    end
+    
+    # Comment do nothing and return nothing
+    def self.comment(params)
+      {}
+    end
+	end
+
+
+	def self.run(config, params = {}, debug = false, find_method = nil)
+		
+    wires = config["wires"] || []
+    modules = config["modules"] || []
+        
+		# Store the results of each sub-module
+    execValues = {} 
+
+		# list all of the modules that we can execute
+    moduleIdsToExecute = [] 
+
+		# List all already executed modules
+    executedModules = []
+
+
+    firstTimeInLoop = true
+    moreModulesToRun = false
+    while moreModulesToRun or firstTimeInLoop do
+        firstTimeInLoop = false
+      
+        # Recalculate all modules that can be executed :
+        mId = 0
+        modules.each { |m2|
+          if !moduleIdsToExecute.include?(mId) and !executedModules.include?(mId) # don't re-execute modules
+            mayEval = true
+            # runnable if all wires which target is this mId have a source output evaluated.
+            wires.each { |w|
+              if w["tgt"]["moduleId"] == mId
+                if !execValues[ w["src"]["moduleId"] ]
+                  mayEval = false
+                end
+              end
+            }            
+            moduleIdsToExecute << mId if mayEval
+          end  
+          mId += 1
+        }
+      
+        if moduleIdsToExecute.size == 0
+          moreModulesToRun = false
+        else
+          moreModulesToRun = true
+          
+            moduleId = moduleIdsToExecute.shift
+            m = modules[moduleId]
+        
+            # Build the parameters for the execution
+            p = {}
+            # params passed to the run method
+            params.each { |k,v| p[k] = v }
+
+            # default form values
+            m["value"].each { |k,v| p[k] = v }
+
+						
+						puts "Wires: "+wires.inspect
+
+            # incoming wire params
+            wires.each { |w|
+              if w["tgt"]["moduleId"] == moduleId
+	
+								puts "Incoming wire: "+w.inspect
+	
+								key =  w["tgt"]["terminal"]
+								val = execValues[ w["src"]["moduleId"] ][ w["src"]["terminal"] ]
+	
+								# We simply want to do p[key] = val,
+								# except that key might look like   "myvar[1][firstname]"
+								# which mean we have to store this val in p["myvar"][1]["firstname"] instead
+								push_to = p					
+								pathItems = key.scan(/\[([^\]]*)\]/).map { |i| i[0].match(/\d+/) ? i[0].to_i : i[0] }
+								if pathItems.size > 0
+									push_to = push_to[key.match(/^([^\[]*)/)[0]]
+								end
+								if pathItems.size > 1
+									0.upto(pathItems.size-2) { |i| push_to = push_to[  pathItems[i]  ] }
+								end
+								if pathItems.size > 0
+									key = pathItems.last
+								end
+                push_to[key] = val
+
+              end
+            }
+
+
+            puts "\n Starting "+m["name"]+" MODULE with : "+p.inspect
+        
+            # Execute Ruby base modules
+            if !Modules.methods.index( m["name"] ).nil?
+							begin
+              	execValues[moduleId] = Modules.send( m["name"].to_sym, p)
+							rescue Exception => e
+								puts "Simpleflow "+e.message
+							end
+
+            else
+              # Try to execute composed module
+							if find_method
+								w = find_method.call(m["name"])
+								if !w
+									raise "Module "+m["name"]+" not found !"
+								end
+	              execValues[moduleId] = Simpleflow.run(w, p, false, find_method)
+							else
+								raise "Module "+m["name"]+" not found !"
+							end
+															
+            end
+        
+						puts "\n Finished "+m["name"]+" MODULE with : "+execValues[moduleId].inspect
+            
+
+            # Mark this modules as executed
+            executedModules.push(moduleId)
+      
+        end
+        
+    end  
+    
+    # Return internal execution values if debug mode
+    return execValues if debug
+ 
+    
+    # OUTPUTS 
+	  outputValues = {}
+    moduleIndex = 0
+	  modules.each { |m|
+	    if m["name"] == "output"
+	      wires.each { |w|
+	        if w["tgt"]["moduleId"] == moduleIndex and execValues[w["src"]["moduleId"]]
+	          outputValues[m["value"]["name"]] = execValues[w["src"]["moduleId"]][ w["src"]["terminal"] ]
+          end
+        }
+      end
+      moduleIndex += 1
+    }
+    return outputValues
+		
+	end
+	
+	
+end

data/lib/simpleflow/dns_resolve.rb

@@ -0,0 +1,16 @@
+module Simpleflow
+  module Modules
+
+	  def self.getIpsFromDomain(params)
+		  require 'resolv'
+  
+	    hosts = []
+	    dns = Resolv::DNS.new
+	    dns.getresources(params["domain"], Resolv::DNS::Resource::IN::A).collect do |r| 
+	       hosts << r.address.to_s
+	    end
+	    { "hosts" => hosts }
+	  end
+
+	end
+end

data/lib/simpleflow/http.rb

@@ -0,0 +1,104 @@
+module Simpleflow
+  module Modules
+    			
+			# HTTP
+						
+			# TODO: proxy 
+			# TODO: timeout
+			# TODO: additional headers
+			# TODO: allow cookies
+			# TODO: whether or not to follow redirects
+			
+			
+			def self.HTTP(params)
+	
+        require 'net/http'
+				require 'net/https'
+        require 'uri'
+        require 'cgi'
+
+
+					require 'yajl'
+
+        uri = URI.parse(params["url"])
+				path = uri.request_uri
+					
+				# Parameters / Body
+				body = nil
+				
+				# Raw request
+				httpClass = case params["method"]
+				   when "GET" then Net::HTTP::Get
+				   when "PUT" then Net::HTTP::Put
+					 when "POST" then Net::HTTP::Post
+				   when "DELETE" then  Net::HTTP::Delete
+				   when "OPTIONS" then Net::HTTP::Options
+				end
+				raw_request = httpClass.new(path)
+
+				case params["method"]
+				   when "GET" , "DELETE"  
+							path += "?"+ params["urlparams"].map { |p| p[0].to_s+"="+CGI::escape(p[1].to_s) }.join('&')
+							raw_request = httpClass.new(path)
+				   when "PUT" , "POST" 
+							body = case params["encoding"]
+								when "application/json" then 
+									raw_request["content-type"] = "application/json"
+									params["urlparams"].to_json
+								when "application/xml" then 
+										raw_request["content-type"] = "application/xml"
+										params["urlparams"].to_xml
+								when "application/x-www-form-urlencoded" then 
+										raw_request["content-type"] = "application/x-www-form-urlencoded"
+										params["urlparams"].map { |p| p[0].to_s+"="+CGI::escape(p[1].to_s) }.join('&')
+							end
+				end
+				
+				raw_request.body = body if body
+				
+				# Basic Auth
+				raw_request.basic_auth(uri.user, uri.password) if uri.user
+					
+				# HTTPS
+			  http = Net::HTTP.new(uri.host, uri.port) 
+				http.use_ssl = true if uri.scheme == "https"
+				
+				
+				# Perform 
+			  res = http.start{ |h| h.request(raw_request) }
+			
+				o = res.body
+			
+				case res
+			  	when Net::HTTPSuccess then
+			     
+						# Parsing
+						puts "HTTP res content-type : "+res.content_type
+						
+						if (res.content_type == "application/xml") or (res.content_type == "text/xml")
+							o = Hash.from_xml(res.body)
+						elsif res.content_type == "application/json"
+							
+							parser = Yajl::Parser.new
+			        o = parser.parse(res.body)
+			
+						else 
+							o = res.body
+						end
+						
+		        { "out" => o }
+
+					when Net::HTTPRedirection then
+
+						{ "out" => res.error! }
+
+					else
+						
+						{ "out" => res.error! }
+						
+				end
+			
+      end
+
+   end       
+end

data/lib/simpleflow/json.rb

@@ -0,0 +1,11 @@
+module Simpleflow
+  module Modules
+    
+      def self.JSONparse(params)
+				require 'yajl'
+				parser = Yajl::Parser.new
+        { "out" => parser.parse(params["in"]) }
+      end
+
+	end
+end

data/lib/simpleflow/jsonpath.rb

@@ -0,0 +1,24 @@
+module Simpleflow
+  module Modules
+
+    # JSONPath module
+    # cf http://github.com/bruce/jsonpath
+    def self.JSONPath(params)
+				require 'jsonpath'
+				
+				begin
+					out = JSONPath.lookup( params["in"], params["path"])
+				rescue Exception => e
+					out = {:error => e.message}
+				end
+				
+				if params["firstonly"]
+					out = out[0]
+				end
+				
+        { "out" =>  out }
+    end
+		
+
+	end
+end

data/lib/simpleflow/liquid.rb

@@ -0,0 +1,12 @@
+module Simpleflow
+  module Modules
+ 
+    # Liquid Templating
+    def self.liquid(params)
+			require 'liquid'
+			r = Liquid::Template.parse(params["template"]).render 'params' => params["in"]
+			{ "out" => r }
+    end
+
+  end
+end

data/lib/simpleflow/object_builder.rb

@@ -0,0 +1,14 @@
+module Simpleflow
+  module Modules
+		
+   
+      def self.ObjectBuilder(params)
+					o = {}
+          params["items"].each { |v|
+							o[v[0]] = v[1]
+        	}
+        { "out" => o }
+      end
+
+	end
+end

data/lib/simpleflow/ping.rb

@@ -0,0 +1,12 @@
+
+module Simpleflow
+  module Modules
+    
+		# Ping
+		def self.ping(params)
+			require 'ping'
+			{ "out" => Ping.pingecho(params["hostname"], params["timeout"], params["service"]) }
+		end
+
+  end
+end

data/lib/simpleflow/string_builder.rb

@@ -0,0 +1,17 @@
+module Simpleflow
+  module Modules
+		
+   
+      def self.StringBuilder(params)
+        list = params["liste"].dup
+        params.each { |k,v|
+          if !k.index('[').nil?
+            index = k.split('[')[1].split(']')[0].to_i
+            list[index]=v
+          end
+        }
+        { "out" => list.join() }
+      end
+
+	end
+end

data/lib/simpleflow/urlencode.rb

@@ -0,0 +1,10 @@
+module Simpleflow
+  module Modules
+
+	  def self.urlencode(params)
+		  require 'cgi'
+	    { "out" => CGI::escape(params["in"]) }
+	  end
+
+	end
+end

data/lib/simpleflow/yql.rb

@@ -0,0 +1,75 @@
+module Simpleflow
+  module Modules
+    
+
+##############################
+# Keep ME !!! The advantage of this version is that we can look the response of YQL to check if 
+# there is an error and format it to a Simpleflow error ! (like invalid YQL query...)
+##############################
+			
+      # def self.YQL(params)
+      # 
+      # 				require 'yajl'
+      # 				require 'cgi'
+      # 	
+      # 				if !params["query"].is_a?(String)
+      # 					return { "out" => "Error: expecting query as a string"}
+      # 				elsif params["query"] == ""
+      # 					return { "out" => "Error: empty query"}
+      # 				end
+      # 				
+      #         require 'net/http'
+      #         require 'uri'
+      #         url = URI.parse('http://query.yahooapis.com')
+      #         res = Net::HTTP.start(url.host, url.port) { |http|
+      #           http.get('/v1/public/yql?q='+CGI::escape(params["query"])+'&format=json')
+      #         }
+      # 
+      # 				 parser = Yajl::Parser.new
+      # 				 hash = parser.parse(res.body)
+      # 
+      #         { "out" => hash }
+      #       end
+
+			def self.YQL(params)
+				Simpleflow.run({
+					"modules" => [
+
+						{
+							"name" => "input",
+							"value" => {
+								"input" => { "value" => 'show tables' , "name" => "query" }
+							}
+						},
+
+						{
+							"name" => "HTTP",
+							"value" => {
+									"method"=>"GET",
+									"url"=> 'http://query.yahooapis.com/v1/public/yql',
+									"urlparams"=>[
+										["format","json"],
+										["q", 		""], # the [1,1] element is wired
+										["env", "store://datatables.org/alltableswithkeys"]
+									]
+							}
+						},
+
+						{	"name" => "output","value" => {"in" => '', "name" => "out"}	}
+
+					],
+					"wires" => [
+						{
+							"src" => {"moduleId" => 0 , "terminal" => "out"},
+							"tgt" => {"moduleId" => 1 , "terminal" => "urlparams[1][1]"}
+						},
+						{
+							"src" => {"moduleId" => 1 , "terminal" => "out"},
+							"tgt" => {"moduleId" => 2 , "terminal" => "in"}
+						}
+					]
+				}, params)
+			end
+
+	end
+end

data/simpleflow.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simpleflow}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["neyric"]
+  s.date = %q{2010-08-27}
+  s.description = %q{Simpleflow has a simple engine that executes modules in a loop. The workflows are declarative, which means that you can static-check them and safely run user workflows. Modules are created easily in ruby so you can quickly write wrappers around libraires.}
+  s.email = %q{eric.abouaf@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/simpleflow.rb",
+     "lib/simpleflow/dns_resolve.rb",
+     "lib/simpleflow/http.rb",
+     "lib/simpleflow/json.rb",
+     "lib/simpleflow/jsonpath.rb",
+     "lib/simpleflow/liquid.rb",
+     "lib/simpleflow/object_builder.rb",
+     "lib/simpleflow/ping.rb",
+     "lib/simpleflow/string_builder.rb",
+     "lib/simpleflow/urlencode.rb",
+     "lib/simpleflow/yql.rb",
+     "simpleflow.gemspec",
+     "test/helper.rb",
+     "test/test_simpleflow.rb"
+  ]
+  s.homepage = %q{http://github.com/neyric/simpleflow}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Simple workflow execution}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_simpleflow.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'simpleflow'
+
+class Test::Unit::TestCase
+end

data/test/test_simpleflow.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestSimpleflow < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_empty_run
+	
+		result = Simpleflow::run({
+			"modules" => [],
+			"wires" => []
+		})
+	
+    assert_equal Hash, result.class
+		assert_equal 0, result.keys.size
+
+  end
+
+
+	def test_YQL_debug
+		
+		result = Simpleflow::run({
+			"modules" => [
+				{
+					"name" => "YQL",
+					"value" => {
+							"query"=>"select * from feed where url='http://rss.news.yahoo.com/rss/topstories' limit 2"
+					}
+				}
+			],
+			"wires" => []
+		}, {}, true)
+	
+		#puts result.inspect
+		#assert result
+		# TODO:
+    #assert_equal Hash, result.class
+		#assert_equal 0, result.keys.size
+		
+		
+	end
+
+
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: simpleflow
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- neyric
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-27 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Simpleflow has a simple engine that executes modules in a loop. The workflows are declarative, which means that you can static-check them and safely run user workflows. Modules are created easily in ruby so you can quickly write wrappers around libraires.
+email: eric.abouaf@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- lib/simpleflow.rb
+- lib/simpleflow/dns_resolve.rb
+- lib/simpleflow/http.rb
+- lib/simpleflow/json.rb
+- lib/simpleflow/jsonpath.rb
+- lib/simpleflow/liquid.rb
+- lib/simpleflow/object_builder.rb
+- lib/simpleflow/ping.rb
+- lib/simpleflow/string_builder.rb
+- lib/simpleflow/urlencode.rb
+- lib/simpleflow/yql.rb
+- simpleflow.gemspec
+- test/helper.rb
+- test/test_simpleflow.rb
+has_rdoc: true
+homepage: http://github.com/neyric/simpleflow
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple workflow execution
+test_files: 
+- test/helper.rb
+- test/test_simpleflow.rb