sfp 0.2.1 → 0.3.4

data/.gitignore

@@ -1,2 +1,3 @@
+.DS_Store
 *.gem
 *.swp

data/README.md

@@ -1,21 +1,12 @@
 SFP Parser and Planner for Ruby
 ===============================
 - Author: Herry (herry13@gmail.com)
-- Version: 0.2.1
+- Version: 0.3.4
 - License: [BSD License](https://github.com/herry13/sfp-ruby/blob/master/LICENSE)
 
-A Ruby gem that provides a Ruby interface to parse SFP language. It also provides
-a Ruby interface for a solver to generate a workflow for a planning task written
-in SFP language. For execution, it provides two execution framework:
-- Bash
-	- there is no representation of SFP schema or object
-	- a SFP procedure is a Bash script file
-	- SFP namespaces are represented by subdirectories of *modules* directory
-- Ruby ( *under-development* )
-	- a SFP schema is represented by a Ruby class
-	- a SFP object is an instance of Ruby class
-	- a SFP procedure is a Ruby method
-	- SFP namespaces are represented by a tree of Hash data structure
+A Ruby gem that provides a Ruby interface to parse [SFP language](https://github.com/herry13/nuri/wiki/SFP-language), a declarative language to specify a planning task.
+
+Click [here](https://github.com/herry13/nuri/wiki/SFP-language), for more details about SFP language.
 
 This is a spin-out project from [Nuri](https://github.com/herry13/nuri).
 
@@ -33,31 +24,16 @@ Requirements
 	- antlr3
 	- json
 
-
-Supporting Platforms
---------------------
-- Linux (x86, arm)
-- MacOS X
+Tested on: MacOS X 10.8, Ubuntu 12.04, Scientific Linux 6, Debian Wheeze Raspberry
 
 
-To use as a command line to solve a planning task
--------------------------------------------------
+To use as a command line
+------------------------
 - parse a SFP file, and then print the output in JSON
 
 		$ sfp --json <sfp-file>
 
-- solve a planning task, and then print the plan in JSON
-
-		$ sfp <sfp-file>
-
-The planning task must be written in [SFP language](https://github.com/herry13/nuri/wiki/SFP-language).
-
-
-To generate a parallel (partial-order) plan
--------------------------------------------
-- use option **--parallel** to generate a partial order plan
-
-		$ sfp --parallel <sfp-file>
+To solve a planning task, you can use [sfplanner](https://github.com/herry13/sfplanner)/
 
 
 To use as Ruby library
@@ -71,9 +47,8 @@ To use as Ruby library
 		# Determine the home directory of your SFP file.
 		home_dir = File.expand_path(File.dirname("my_file.sfp"))
 
-		# Create Sfp::Parser object; pass the home and root directory so the parser
-		# can find the included files.
-		parser = Sfp::Parser.new({:home_dir => home_dir, :root_dir => '/'})
+		# Create Sfp::Parser object
+		parser = Sfp::Parser.new({:home_dir => "./"})
 
 		# Parse the file.
 		parser.parse(File.read("my_file.sfp"))
@@ -81,40 +56,11 @@ To use as Ruby library
 		# Get the result in Hash data structure
 		result = parser.root
 
-- to solve a planning task: create a Sfp::Planner object, and then pass the file's path:
-
-		# Create Sfp::Planner object.
-		planner = Sfp::Planner.new
-
-		# Solve a planning task written in "my_file.sfp", then print
-		# the result in JSON.
-		puts planner.solve({:file => "my_file.sfp", :json => true})
-
 
-To solve planning task and execute it using Bash scripts
---------------------------------------------------------
-Parse a SFP file, print the plan in JSON, and then execute the plan by
-invoking Bash scripts in directory **modules**. *Note*: the namespaces are
-represented by directories e.g. executing procedure *$.a.b.foo* will be
-invoking a Bash script *modules/a/b/foo*.
 
-	$ sfp --solve-execute <sfp-file>
-
-
-To execute previously generated plan file in JSON format
---------------------------------------------------------
-If you have generated a plan saved in a file, then you could execute the plan by
-invoking Bash scripts in directory **modules**. *Note*: the namespaces are
-represented by directories e.g. executing procedure *$.a.b.foo* will be
-invoking a Bash script *modules/a/b/foo*.
-
-	$ sfp --execute <plan-file>
-
-
-
-Example
--------
-- Create file **types.sfp** that holds required schemas:
+Example of Planning Task
+------------------------
+- Create file **types.sfp** to hold required schemas:
 
 		schema Service {
 			running is false
@@ -146,8 +92,8 @@ Example
 		}
 
   In this file, we have two schemas that model our domain. First, schema
-  **Service** with an attribute **running*, procedure **start** that
-  changes **running**'s value from **false** to *true*, and procedure
+  **Service** with an attribute **running**, procedure **start** that
+  changes **running**'s value from **false** to **true**, and procedure
   **stop** that changes **running**'s value from **true** to **false**.
   
   We also have schema **Client** with an attribute **refer**, which is
@@ -155,7 +101,7 @@ Example
   **redirect** that changes the value of **refer** with any instance if
   **Service**.
 
-- Create file **task.sfp** that holds the task:
+- Create file **task.sfp** to hold the task:
 
 		include "types.sfp"
 		
@@ -237,18 +183,24 @@ Example
 
   This workflow is sequential that has 3 procedures. If you executes
   the workflow in given order, it will achieves the goal state as well
-  as perserves the global constraints during the changes.
+  as perserves the global constraints during the execution.
 
 - To generate and execute the plan using Bash framework, we invoke **sfp**
-  command with an option *--exec-bash* and with an argument the path of
+  command with an option *--solve-execute* and with an argument the path of
   the task file:
 
-		$ sfp --solve-execute task,sfp
+		$ sfp --solve-execute task.sfp
 
   It will generate and execute the plan by invoking the Bash scripts in
   the current directory (or as specified in environment variable SFP_HOME)
   in the following sequence:
-	1. *modules/b/start*
-	2. *modules/pc/redirect "$.b"*
-	3. *modules/a/stop*
+
+		./modules/b/start
+		./modules/pc/redirect "$.b"
+		./modules/a/stop
+
+- If you save the plan in a file e.g. **plan.json**, you could execute it
+  later using option *--execute*
+
+		$ sfp --execute plan.json
 

data/bin/sfp

@@ -4,93 +4,27 @@ libdir = File.expand_path(File.dirname(__FILE__))
 require "#{libdir}/../lib/sfp"
 
 opts = Trollop::options do
-	version "sfp 0.2.1 (c) 2013 Herry"
+	version "sfp 0.3.4 (c) 2013 Herry"
 	banner <<-EOS
-Parse a SFP file, solve the planning task, and print the plan (if found) in JSON format.
+Parse a SFP file and print the result in JSON format.
 
 Usage:
-       sfp [options] <file>
-
-where [options] are:
+       sfp <file>
 EOS
 
-	opt :parallel, "generate a parallel (partial-order) plan, instead of sequential"
-	opt :json, "parse a SFP file and print it in JSON format"
-	opt :solve_execute, "parse a SFP File, solve the planning task, " +
-	                    "and execute the plan with given execution framework"
-	opt :bash, "set Bash as the execution framework", :default => true
-	opt :execute, "execute a plan in given file"
+	opt :pretty, "Print the result in pretty JSON format.", :default => false
 end
 
-if opts[:json]
-	home_dir = File.expand_path(File.dirname(ARGV[0]))
+def parse(filepath)
+	home_dir = File.expand_path(File.dirname(filepath))
 	parser = Sfp::Parser.new({:home_dir => home_dir})
-	parser.parse(File.read(ARGV[0]))
-	puts parser.to_json({:pretty => true})
-
-elsif opts[:solve_execute]
-	abort "There is no available execution framework!" if not opts[:bash]
-
-	planner = Sfp::Planner.new
-	plan = planner.solve({:file => ARGV[0], :parallel => opts[:parallel]})
-	puts "Plan: #{plan.inspect}"
-	executor = Sfp::BashExecutor.new
-	puts "Execution:"
-	executor.execute_plan({:plan => plan, :print_output => true})
-
-elsif opts[:execute]
-	abort "There is no available execution framework!" if not opts[:bash]
-
-	plan = JSON.parse(File.read(ARGV[0]))
-	executor = Sfp::BashExecutor.new
-	executor.execute_plan({:plan => plan, :print_output => true})
-
-elsif ARGV.length > 0
-	planner = Sfp::Planner.new
-	puts planner.solve({:file => ARGV[0], :pretty_json => true, :parallel => opts[:parallel]})
-
-else
-	Trollop::help
-
+	parser.parse(File.read(filepath))
+	parser
 end
 
-=begin
-# application mode
-if ARGV.length > 1 and (ARGV[0] == '-p' or ARGV[0] == '-json')
-	home_dir = File.expand_path(File.dirname(ARGV[1]))
-	parser = Sfp::Parser.new({:home_dir => home_dir})
-	parser.parse(File.read(ARGV[1]))
-	puts parser.to_json({:pretty => true})
-
-elsif ARGV.length > 1 and ARGV[0] == '--exec-ruby'
-	planner = Sfp::Planner.new
-	plan = planner.solve({:file => ARGV[1]})
-	puts plan.inspect
-	executor = Sfp::RubyExecutor.new
-	executor.execute_plan({:plan => plan})
-
-elsif ARGV.length > 1 and ARGV[0] == '--exec-bash'
-	planner = Sfp::Planner.new
-	plan = planner.solve({:file => ARGV[1]})
-	puts "Plan: #{plan.inspect}"
-	executor = Sfp::BashExecutor.new
-	puts "Execution:"
-	executor.execute_plan({:plan => plan, :print_output => true})
-
-elsif ARGV.length > 0
-	planner = Sfp::Planner.new
-	puts planner.solve({:file => ARGV[0], :pretty_json => true})
-
+filepath = ARGV[0].to_s
+if filepath != ''
+	puts parse(filepath).to_json({:pretty => opts[:pretty]})
 else
-	puts "Usage: #{$0} [options] <file>
-
-options:
-   <none>        parse a SFP file and solve the planning task
-   -p, -json     parse a SFP file and print it in JSON format
-   -x
-   --exec-bash   parse a SFP file, solve the planning task, and
-                 execute the plan with Sfp::BashExecutor
-
-"
+	Trollop::help
 end
-=end