ESBify 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/ESBify.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ESBify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ESBify"
+  s.version     = ESBify::VERSION
+  s.authors     = ["Jakub Hampl"]
+  s.email       = ["honitom@seznam.cz"]
+  s.homepage    = "https://github.com/gampleman/esbify"
+  s.summary     = %q{Generates proper XML files for the ESB framework from a DSL.}
+  s.description = %q{Generates proper XML files for the ESB framework from a DSL.}
+
+  s.rubyforge_project = "ESBify"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rake"
+  s.add_runtime_dependency "builder"
+  s.add_runtime_dependency "erubis"
+end

data/Gemfile

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

data/README.md

@@ -0,0 +1,107 @@
+# ESBify
+
+ESBify is a simple DSL for creating the necessary XML files for the ESB framework.
+
+## Instalation ##
+
+    $ gem install esbify
+  
+should do the trick provided you have a recent enough installation of Ruby. Run
+
+    $ esbify -h
+    
+to list basic usage.
+
+## Syntax
+
+    !expectations
+    
+    name:       may_not_have_bangs
+    condition:  played(P1, duel, P2) | responded(P1, bang, P2, duel) | played(P1, indians, P2)
+    phi:        requires_bang_response(P2)
+    test_plus:  lost_life(P2)
+    test_minus: played(P2, bang, P3) | responded(P2, bang, P3, _)
+    rho_plus:
+      + has_no_bangs
+    rho_minus:
+      - has_no_bangs
+    
+    ----------
+    
+    name:       has_no_bangs
+    condition:  requires_bang_response℗ | has_no_bangs(P)
+    phi:        has_no_bangs_phi(P)
+    test_minus: draw(P, X)
+    rho_minus:
+      - has_no_bangs
+    
+    
+    # comment 
+    
+    !behaviors
+    
+    name:   JI plans
+    jason:  has_no_bangs(P)
+    action: card_expectation(P, bang, 0)
+
+
+
+### Headers
+
+`!expectation`, `!behavior`, `!strategy`
+
+Are possible headers saying that the following code will be of that particular type. 
+
+### Expectations
+
+### Behaviors
+
+`name` is an identifier and isn't particularly useful. When omitted, a random number will be used.
+
+`ctl` is a [computation tree logic](http://en.wikipedia.org/wiki/Computation_tree_logic).
+
+The syntax of CTL formulas recognized by NUSMV is as follows:
+
+`ctl_expr` =
+
+
+`simple_expr`               | a simple boolean expression
+---------------             | -------
+`( ctl_expr )`              |
+`! ctl_expr`                | logical not
+`ctl_expr & ctl_expr`       | logical and
+`ctl_expr xor ctl_expr`     | logical exclusive or
+`ctl_expr xnor ctl_expr`    | logical NOT exclusive or
+`ctl_expr -> ctl_expr`      | logical implies
+`ctl_expr <-> ctl_expr`     | logical equivalence
+`EG ctl_expr`               | exists globally
+`EX ctl_expr`               | exists next state
+`EF ctl_expr`               | exists finally
+`AG ctl_expr`               | forall globally
+`AX ctl_expr`               | for all next state
+`AF ctl_expr`               | for all finally
+`E [ ctl_expr U ctl_expr ]` | exists until
+`A [ ctl_expr U ctl_expr ]` | forall until
+
+- `EX p` is true in a state s if there exists a state s′ such that a transition goes from s to s′
+and p is true in s′.
+- AX p is true in a states iff or all states s′ wherethereisatransitionfromstos′,pistrue
+in s′.
+- EF p is true in a state s0 if there exists a series of transitions s0 → s1, s1 → s2, ...,
+sn−1 →sn suchthatpistrueinsn.
+- AF pistrueinastates0 ifforallseriesoftransitionss0 → s1,s1 → s2,...,sn−1 → sn
+p is true in sn.
+- EG p is true in a state s0 if there exists an infinite series of transitions s0 → s1, s1 → s2,
+... such that p is true in every si.
+- AG pistrueinastates0 ifforallinfiniteseriesoftransitionss0 →s1,s1 →s2,... p
+is true in every si.
+- E[p U q] is true in a state s0 if there exists a series of transitions s0 → s1, s1 → s2,
+..., sn−1 → sn such that p is true in every state from s0 to sn−1 and q is true in state sn.
+- A[p U q]istrueinastates0 ifforallseriesoftransitionss0 → s1,s1 → s2,...,
+sn−1 → sn p is true in every state from s0 to sn−1 and q is true in state sn. A CTL formula is true if it is true in all initial states.
+
+---
+
+`jason` is a logic inside the ASL agent.
+
+Both `ctl` and `jason` need to be true to execute `action`, which is a ASL belief that will be added to the agent's belief base.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/esbify

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require "optparse"
+require File.dirname(__FILE__) + "/../lib/ESBify"
+
+
+
+options = {stdout: false, expectations: "./Expectations.xml", behaviors: "./Behaviours.xml", filter: /.*/, only: %w[expectations behaviors strategies], context: {}}
+OptionParser.new do |opts|
+  opts.banner = "Usage: esbify [options] FILES..."
+  
+  opts.on("-e", "--expectations FILE", "Output Expectations to FILE") do |v|
+    options[:expectations] = v
+  end
+  
+  opts.on("-b", "--behaviors FILE", "Output Behaviours to FILE") do |v|
+    options[:behaviors] = v
+  end
+  
+  opts.on("--[no-]stdout", "Print to STDOUT") do |v|
+    options[:stdout] = v
+  end
+  
+  opts.on("-f", "--filter REGEXP", "When printing out expectations, only print those matching this regexp.") do |v|
+    options[:filter] = Regexp.new(v)
+  end
+  
+  opts.on("--only expectations,behaviors,strategies", Array, "Only generate these files") do |v|
+    raise ArgumentError unless v.all?{|o| %w[expectations behaviors strategies].include?(o)}
+    options[:only] = v
+  end
+  
+  opts.on("--context HASH_OR_PATH", "A path to a ruby class or a hash of values that will be passed to ERB", "The ruby class should have a underscored filename and CamelCased classname. ") do |v|
+    if v =~ /\:|=>/
+      options[:context] = eval(v, binding)
+    else
+      require v
+      name = v.gsub(/(_|^)./){|a| a.chars.to_a.last.upcase}
+      const = Object.const_defined?(name) ? Object.const_get(name) : Object.const_missing(name)
+      options[:context] = const.new
+    end
+  end
+  
+  opts.on_tail("-h", "--help [README]", "Call -h with README to view the readme file") do |t|
+    if t == "README"
+      puts File.read(File.dirname(__FILE__) + "/../README.md")
+    else
+      puts opts
+    end
+    exit
+  end
+  
+  opts.on_tail("-v", "--version", "Show version") do
+    puts ESBify::VERSION
+    exit
+  end
+  
+end.parse!
+
+parser = ESBify::Parser.new options[:context]
+
+ARGV.each do |f|
+  parser.parse_file! f
+end
+
+if options[:stdout]
+  puts parser.expectations if options[:only].include?("expectations")
+  puts parser.behaviors if options[:only].include?("behaviors")
+else
+  File.open(options[:expectations], "w") {|f| f << parser.expectations } if options[:only].include?("expectations")
+  File.open(options[:behaviors], "w") {|f| f << parser.behaviors } if options[:only].include?("behaviors")
+end
+
+puts parser.expectation.names.grep(options[:filter]).join(",")

data/lib/ESBify/base.rb

@@ -0,0 +1,27 @@
+require "builder"
+class ESBify::Base
+  def initialize
+    @data = []
+  end
+
+  def defaults
+    
+  end
+
+  def <<(sects)
+    @data += sects.map do |sect|
+      defaults.merge(sect)
+    end
+  end
+
+  def to_xml_partial
+    b = Builder::XmlMarkup.new indent: 2, margin: 1
+    @data.each do |sect|
+      xml_section(b, sect)
+    end
+    #puts b.inspect
+    "\n" + b.target!
+  end  
+  
+  
+end

data/lib/ESBify/behavior.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/base"
+
+class ESBify::Behavior < ::ESBify::Base
+  
+  def defaults
+    {
+      "name" => rand(1000),
+      "ctl" => "",
+      "jason" => "",
+      "action" => "",
+    }
+  end
+  
+  
+  def xml_section(b, sect)
+    b.behaviour name: sect["name"] do |b|
+      b.condition do |b|
+        b.ctl sect["ctl"]
+        b.jason sect["jason"]
+      end
+      b.action sect["action"]
+    end 
+  end
+  
+  
+  def to_xml
+    b = Builder::XmlMarkup.new indent: 2
+    b.instruct!
+    b.declare! :DOCTYPE, :BehaviourSet, :SYSTEM, "esb-ji-jason/behaviours.dtd"
+    b.BehaviourSet do |b|
+      b << to_xml_partial
+    end # ExpectationSet
+  end
+ 
+end
+  

data/lib/ESBify/expectation.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + "/base"
+module ESBify
+  class Expectation < ::ESBify::Base
+    attr_reader :names
+    
+    def defaults
+      {
+        "agent" => "self",
+        "name" => rand(1000),
+        "condition" => "true",
+        "phi" => "",
+        "test_plus" => "",
+        "test_minus" => "",
+        "rho_plus" => {
+          "addSet" => [],
+          "remSet" => []
+        },
+        "rho_minus" => {
+          "addSet" => [],
+          "remSet" => []
+        }
+      }
+    end
+    
+    def <<(sects)
+      @names ||= []
+      @data += sects.map do |sect|
+        sect["rho_plus"] = parse_mods(sect["rho_plus"]) if sect["rho_plus"]
+        sect["rho_minus"] = parse_mods(sect["rho_minus"]) if sect["rho_minus"]
+        @names << sect["name"] if sect["name"]
+        defaults.merge(sect)
+      end
+    end
+    
+    def parse_mods(str)
+      add_set = []
+      rem_set = []
+      str.scan(/^\s*(\+|\-)\s*(.+)\s*$/).each do |sym, str|
+        if sym == "+"
+          add_set << str
+        else
+          rem_set << str
+        end
+      end
+      {"addSet" => add_set, "remSet" => rem_set}
+    end
+    
+    def to_xml
+      b = Builder::XmlMarkup.new indent: 2
+      b.instruct!
+      b.declare! :DOCTYPE, :ExpectationSet, :SYSTEM, "esb-ji-jason/ExpectationSet.dtd"
+      b.ExpectationSet do |b|
+        b << to_xml_partial
+      end # ExpectationSet
+    end
+   
+    def xml_section(b, sect)
+      b.tag! "expectation" do |b|
+        sect.each do |k,v|
+          if v.is_a?(Array) || v.is_a?(Hash)
+            b.tag! k do |b|
+              b.tag! "addSet" do |b|
+                v["addSet"].each {|el| b.name(el) }
+              end
+              b.tag! "remSet" do |b|
+                v["remSet"].each {|el| b.name(el) }
+              end
+            end 
+          else
+            b.tag! k, v
+          end
+        end
+      end # base
+    end
+   
+   
+  end
+  
+end

data/lib/ESBify/parser.rb

@@ -0,0 +1,69 @@
+require 'erubis'
+require File.dirname(__FILE__) + "/expectation"
+require File.dirname(__FILE__) + "/behavior"
+#require "./behavior"
+#require "./strategy"
+
+class ESBify::Parser
+  
+  attr_reader :expectation
+  
+  def initialize(context = {})
+    @expectation = ::ESBify::Expectation.new
+    @behavior = ::ESBify::Behavior.new
+    #@strategy = ::ESBify::Strategy.new
+    
+    @context = context
+  end
+  
+  
+  def expectations
+    @expectation.to_xml
+  end
+  
+  def behaviors
+    @behavior.to_xml
+  end
+  
+  def strategies
+    @strategy.to_xml
+  end
+  
+  def parse_file!(path)
+    parse! File.read(path)
+  end
+  
+  def parse!(str)
+    # Remove comments
+    str = str.split("\n").map{|l| l.split('#').first }.join("\n")
+    str = Erubis::Eruby.new(str).evaluate(@context)
+    str.split(/\!(?=(?:expectation|behaviou?r|strateg(?:y|ie))s?\n)/).each do |section|
+      next if section =~ /\A\s*\z/m
+      m = section.match /\A(expectation|behaviou?r|strateg(?:y|ie))s?/
+      txt = str.split("\n")
+      txt.shift
+      txt.join("\n")
+      sect = parse_section(section)
+      case m[1]
+      when /expectations?/
+        @expectation << sect
+      when /behaviou?rs?/
+        @behavior << sect
+      when /strateg(?:y|ie)s?/
+        @strategy << sect
+      else
+        raise ArgumentError
+      end
+    end
+    
+  end
+  
+  
+  def parse_section(str)
+    segs = str.split(/\s*\n---+\s*\n\s*/m)
+    segs.map do |seg|
+      ms = seg.scan /(?:^|\n)([\w_]+)\s*\:\s*(.+?)(?=(?:\n[\w_]+\s*\:|\z))/m
+      Hash[*ms.flatten.map(&:strip)]
+    end
+  end
+end

data/lib/ESBify/strategy.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + "/base"
+
+class ESBify::Strategy < ::ESBify::Base
+  
+  # TODO: There can be more then one transstatement per element, use lists for this
+  
+  def defaults
+    {
+      "main" => "",
+      "expectation" => ""
+    }
+  end
+  
+  
+  def xml_section(b, sect)
+    b.main do |b|
+      b.transStatement sect["main"]
+    end
+    b.expectation do |b|
+      b.transStatement sect["expectation"]
+    end
+  end
+  
+  
+  def to_xml
+    b = Builder::XmlMarkup.new indent: 2
+    b.instruct!
+    b.declare! :DOCTYPE, :BehaviourSet, :SYSTEM, "esb-ji-jason/behaviours.dtd"
+    b.strategy do |b|
+      b << to_xml_partial
+    end
+  end
+ 
+end
+  

data/lib/ESBify/version.rb

@@ -0,0 +1,3 @@
+module ESBify
+  VERSION = "0.0.1"
+end

data/lib/ESBify.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/ESBify/version"
+
+module ESBify
+  # Your code goes here...
+end
+require File.dirname(__FILE__) + "/ESBify/parser"

data/test.esb

@@ -0,0 +1,9 @@
+!expectation
+name: test
+
+---
+
+condition: played(1) & played(2)
+----
+name: has_no_bangs
+condition: requires_bang_response(P) | has_no_bangs(P)

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: ESBify
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jakub Hampl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-02 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70235824010600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235824010600
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: &70235824010160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70235824010160
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: &70235824009740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70235824009740
+description: Generates proper XML files for the ESB framework from a DSL.
+email:
+- honitom@seznam.cz
+executables:
+- esbify
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- ESBify.gemspec
+- Gemfile
+- README.md
+- Rakefile
+- bin/esbify
+- lib/ESBify.rb
+- lib/ESBify/base.rb
+- lib/ESBify/behavior.rb
+- lib/ESBify/expectation.rb
+- lib/ESBify/parser.rb
+- lib/ESBify/strategy.rb
+- lib/ESBify/version.rb
+- test.esb
+homepage: https://github.com/gampleman/esbify
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1658457591522309798
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1658457591522309798
+requirements: []
+rubyforge_project: ESBify
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Generates proper XML files for the ESB framework from a DSL.
+test_files: []