stamina-gui 0.5.0

data/CHANGELOG.md

@@ -0,0 +1,78 @@
+# 0.5.0 / FIX ME
+
+* Breaking features.
+
+  * Support for ruby 1.8.7 has been definitely removed.
+
+* Major enhancements
+
+  * The project has been split in different sub gems (core, induction and gui). This
+    implies a lot of internal changes, but the public API has not been affected. A main
+    'stamina' gem automatically includes all sub gems so previous behavior is guaranteed.
+
+* Minor enhancements
+    * Fixed a bug with bundler usage in main stamina binary
+    * adl2dot command now support samples as input in addition to automata. In that case,
+      the dot result models a PTA (prefix tree acceptor)
+    * Added --png to 'stamina adl2dot'
+
+# 0.4.0 / 2011-05-01
+
+* Major Enhancements
+
+    * Added Automaton#to_adl as an shortcut for Stamina::ADL::print_automaton(...)
+    * Added Sample#to_pta taken from Induction::Commons
+    * Added Automaton completion (all strings parsable) under Automaton#complete[!?]
+    * Added Automaton stripping (removal of unreachable states) under Automaton#strip[!]
+    * Added Automaton minimization (Hopcroft + Pitchies) under Automaton#minimize
+    * Added Abbadingo generators under Abbadingo::RandomDFA and Abbadingo::RandomSample
+    * Added a main 'stamina' command relying on Quickl. classiy/adl2dot commands become
+      subcommands of stamina itself (see stamina --help for a list of available commands).
+      Induction command (rpni and redblue) are now handled by a 'stamina infer' with
+      options.
+    * Error states and now correctly handled in ADL::parse and ADL::flush
+    * RedBlue has been renamed as BlueFringe everywhere (red_?blue -> blue_fringe)
+
+* Minnor Enhancements
+    * Added a few optimizations here and there
+
+* Bug fixes
+
+    * Fixed a bug in Automaton#depth when some states are unreachable
+
+# 0.3.1 / 2011-03-24
+
+* Major Enhancements
+
+    * Implemented the decoration algorithm of Damas10, allowing to decorate states
+      with information propagated from states to states until a fixpoint is reached.
+    * Added Automaton::Metrics module, automatically included, with useful metrics
+      like automaton depth, accepting ratio and so on.
+    * Added Scoring module and Classifier#classification_scoring(sample) method
+      with common measures from information retrieval.
+
+* On the devel side
+
+    * Moved specific automaton tests under test/stamina/automaton/...
+
+# 0.3.0 / 2011-03-24
+
+* On the devel side
+
+  * The project structure is now handled by Noe
+  * Ensures that tests are correctly executed under ruby 1.9.2
+
+
+# 0.2.2 / 2010-10-22
+
+* Major Enhancements
+
+  * Sample#<< does not detect inconsistencies anymore, to ensure a linear method instead of a quadratic one.
+
+* On the devel side
+
+  * Fixes a bug in Rakefile that lead to test failures under ruby 1.8.7
+
+# 0.2.1 / 2010-05-01
+
+* Main public version for the official competition, extracted from private SVN.

data/LICENCE.md

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2008-2009 University of Louvain
+(Universite catholique de Louvain-la-Neuve, Belgium)
+
+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/examples/0-reference/1-automaton-adl.rb

@@ -0,0 +1,52 @@
+code = <<-ADL
+# First, it allows line comments 'a la' ruby, that is, lines starting with '#'
+# are simply ignored. White spaces may also be inserted between the comment
+# symbol like
+      # this
+# Empty lines are also ignored:
+
+# Still about comments and white spaces: end-of-line comments are also supported
+# (see documentation on right later). Moreover, white spaces and tabs are allowed
+# at beginning and end of lines as well as between state and edge elements.
+
+# Next, the first (non comment or empty) line of the file must contain the number
+# of states then the number of edges of the automaton: (white spaces between them,
+# whitespace before and after are allowed) we refer to these two numbers as
+# state_count and edge_count respectively (here: five states and six edges)
+5 6
+
+# Then, we expect exactly state_count state definitions. A state definition is
+# composed of three informations: 1) a state identifier (any string), 2) 'true'
+# or 'false' for initial flag, 3) 'true' or 'false' for accepting flag. These
+# informations are simply separated by white spaces:
+0 true false                   # here a state with identifier 0
+                               # this state is initial and not accepting
+
+identified_state false true    # this kind of identifier is also allowed
+                               # this state is not initial but is accepting
+
+# other states below ...
+2 false false
+3 false true
+4 false false
+
+# Then, we expect exactly edge_count edge definitions. An edge definition is
+# simple as well: source and target state identifiers followed by a labeling
+# input symbol (any word).
+0 identified_state hello       # the first edge says hello from source
+                               # state 0 to state identified_state
+
+identified_state 2 w           # identified_state 'sends' w to state 2
+
+# and other edges below ...
+2 3 o
+3 4 r
+4 4 l
+4 0 d
+
+# This automaton grammar does not provide a way to define empty symbols
+# (something like '', which is interpreted for itself) nor does it provide an
+# epsilon predefined character. You'll have to post-process your automaton
+# yourself, sorry!
+ADL
+result = automaton(code)

data/examples/0-reference/2-sample-adl.rb

@@ -0,0 +1,56 @@
+code = <<-ADL
+# First, it allows line comments 'a la' ruby, that is, lines starting with '#'
+# are simply ignored. Whitespaces may also be inserted before the comment symbol
+# like
+      # this
+# Empty lines are also ignored:
+
+# Still about comments and whitespaces: end-of-line comments are NOT supported
+# because they would not allow using '#' as a input string symbol. Whitespaces
+# and tabs are allowed (and ignored) at begining and end of lines as well as
+# between input symbols (see later).
+
+# Next, a sample is a sequence of input strings, separated by newlines (aka
+# carriage return). An input string is simply a sequence of input symbols,
+# separated by whitespace(s) or tabs. Symbols are simple characters or words.
+# An input string is labeled as positive if its first symbol is '+', negative
+# if it's '-' and unlabeled of the first symbol is '?' ('+', '-' and '?' symbols
+# won't be not part of the input string itself). If the string does not start with one
+# of these symbols, it is considered as an error string and ADL raises an error.
+# '+', '-' and '?' anywhere else in the string count for themselve. So, positive,
+# negative and unlabeled strings respectively looks like:
++ a b a b
+- a a
+? a b
+
+# That's all ... here are some other examples and comments:
+
+# This is the positive empty string (negative empty string is a simple '-' line,
+# not shown here because it would create an inconsistent sample; unlabeled empty
+# string is simply the '?' line):
++
+
+# We've said earlier that words are accepted as input symbols, and we warn you
+# that the following strings are not equivalent (the first has two symbols only,
+# the second has ten symbols and the last has only one.
++ hello world
++ h e l l o w o r l d
++ helloworld
+
+# but whitespaces and tabs do not count, so the following positive string is already
+# part of this sample:
+        + h   e l l   o w   o r l    d
+
+# The following strings are supported: '+' and '-' count for themselve, expect
+# the first, and the last is part of a '+a' symbol.
++ a + b - a - b +a
+
+# A last example, to insist on comment rules: here all '#" count for themselve:
++ # a # b a b            # and all these words are symbols too !!
+
+# This sample grammar does not provide a way to define empty symbols
+# (something like '', which is interpreted for itself) nor does it provide an
+# epsilon predefined character. You'll have to post-process your sample
+# yourself, sorry!
+ADL
+result = sample(code)

data/examples/2-regular-languages/1-introduction.rb

@@ -0,0 +1,22 @@
+#
+# Stamina recognizes regular expressions thanks the `regular` function.
+#
+
+# Let's build a regular language
+abstar = regular("(a b)*")
+
+# More complex regular languages may be put on multiple lines
+complex = regular <<-LANG
+  (a b)+
+| a+
+| b
+LANG
+
+# Sometimes, it is useful to capture the universal regular language
+# over an alphabet, that is,
+univ = regular("(a | b | c | d | e)*")
+
+# Here is a friendly shortcut, very useful if the alphabet become
+# large
+univ2 = sigma_star('a'..'e')
+assert univ <=> univ2

data/examples/2-regular-languages/2-complement.rb

@@ -0,0 +1,14 @@
+abstar = regular("(a b)*")
+
+# The complement of a regular language language L is defined as
+# the set of strings not belonging to L
+complement = abstar**-1
+
+# The complement of the complement is the regular language itself
+compcomp = complement**-1
+assert abstar <=> compcomp
+
+# Also observe that the complement of a regular language can be
+# computed explicitly as the
+otherway = regular("(a | b)*") - abstar
+assert otherway <=> complement

data/examples/2-regular-languages/3-difference.rb

@@ -0,0 +1,5 @@
+ab_star = regular("(a b)*")
+
+# The difference of a regular language with itself is empty
+empty = (ab_star - ab_star)
+assert empty.empty?

data/examples/3-grammar-induction/1-introduction.rb

@@ -0,0 +1,34 @@
+#
+# This is the introduction example for Stamina induction algorithms
+#
+# Classical induction is aimed at learning a regular language from a
+# `positive` sample, under the control of a `negative` sample.
+#
+# Samples are commonly captured through a Prefix Tree Acceptor (PTA).
+# A PTA capturing both a positive and a negative sample is called an
+# Augmented PTA (APTA)
+#
+
+# a positive sample will be captured through a PTA
+# (accepting states capture positive strings)
+positive = sample <<-SAMPLE
+  +
+  + a
+  + b b
+  + b b a
+  + b a a b
+  + b a a a b a
+SAMPLE
+
+# a negative sample will be captured through a PTA
+# (no accepting states, but error states capturing negative
+# strings)
+negative = sample <<-SAMPLE
+  - b
+  - a b
+  - a b a
+SAMPLE
+
+# The union of samples is recognized as follows, and captured through
+# an APTA (observe that both accepting and error states are present)
+training = positive + negative

data/examples/3-grammar-induction/2-kernel.rb

@@ -0,0 +1,32 @@
+lang = automaton <<-ADL
+  3 5
+  0 true true
+  1 false false
+  2 false true
+  0 1 a
+  1 1 a
+  1 2 b
+  2 2 b
+  2 0 a
+ADL
+
+# In a canonical automaton A(lang) of language `lang`, the set of short prefixes
+# is the set of first strings in standard order, each leading to a particular
+# state of the canonical automaton. As a consequence, there are as many short
+# pre-fixes as states in A(lang). In other words, the short prefixes uniquely
+# identify the states of A(lang).
+prefixes = short_prefixes(lang)
+
+# The kernel of a language is made of its short prefixes extended by one symbol
+# together with the empty string. By construction, the short prefixes all belong
+# to the kernel. The kernel elements capture the transitions of the canonical
+# automaton A(lang). Indeed, they are obtained by adding one symbol to the short
+# pre-fixes which capture its states.
+kernel   = kernel(lang)
+
+characteristic = characteristic_sample(lang)
+
+# A characteristic sample is such that RPNI will find the target automaton if
+# invoked
+rpnied = rpni(characteristic)
+assert (regular(lang) - rpnied).empty?

data/examples/3-grammar-induction/3-characteristic-sample.rb

@@ -0,0 +1,49 @@
+target = automaton <<-ADL
+  3 5
+  0 true true
+  1 false false
+  2 false true
+  0 1 a
+  1 1 a
+  1 2 b
+  2 2 b
+  2 0 a
+ADL
+
+characteristic = sample <<-ADL
+  # Sp(L) - short prefixes
+  # ?
+  # ? a
+  # ? a b
+  #
+  # N(L) - kernel
+  # ?
+  # ? a
+  # ? a a
+  # ? a b
+  # ? a b b
+  # ? a b a
+  #
+  # these strings for the first condition of the characteristic
+  # sample specification
+  +
+  + a b
+  + a a b
+  + a b b
+  + a b a
+  # these strings for the second condition
+  - a
+  - b
+  - a a
+  + a b b a
+  - a b a b
+  - a a a
+  - b b
+  - b b b
+  + a b b b
+  - b a
+  - b a b
+ADL
+
+learned = rpni(characteristic)
+assert learned <=> target

data/lib/stamina-gui/stamina-gui.rb

@@ -0,0 +1 @@
+require_relative 'stamina/gui'

data/lib/stamina-gui/stamina/command/gui.rb

@@ -0,0 +1,19 @@
+module Stamina
+  class Command
+    #
+    # Launches the Stamina Web GUI
+    #
+    # SYNOPSIS
+    #   #{program_name} #{command_name}
+    #
+    class Gui < Quickl::Command(__FILE__, __LINE__)
+
+      # Command execution
+      def execute(args)
+        require_relative '../gui'
+        Stamina::Gui::App.run!
+      end
+
+    end # class Gui
+  end # class Command
+end # module Stamina

data/lib/stamina-gui/stamina/gui.rb

@@ -0,0 +1,2 @@
+require_relative "command/gui"
+require_relative "gui/app"

data/lib/stamina-gui/stamina/gui/app.rb

@@ -0,0 +1,69 @@
+require 'tmpdir'
+require 'json'
+require 'sinatra/base'
+require_relative 'examples'
+module Stamina
+  module Gui
+    class App < Sinatra::Base
+
+      ### business
+
+      def go_for(tempdir, src)
+        source = File.join(tempdir, "source.rb")
+        File.open(source, "w"){|io| io << src}
+        Stamina::Command::Run.run(["--all", "--gif", source])
+      end
+
+      ### file helpers
+
+      def self._(path)
+        File.expand_path(path, File.dirname(__FILE__))
+      end
+      def _(path); self.class._(path); end
+
+      set :public_folder, _('public')
+      set :views,      _('templates')
+      set :tmpdir,     Dir.mktmpdir("stamina-gui")
+
+      get '/' do
+        erb :index, :locals => {
+          :examples => Gui::Examples.new
+        }
+      end
+
+      # example handlers
+      get '/examples/:folder/:file' do
+        cache_control :no_cache
+        expires 0, :no_cache
+        send_file File.join(Gui::Examples::FOLDER,
+                            params[:folder],
+                            "#{params[:file]}.rb")
+      end
+
+      # THE go post service
+
+      post '/go' do
+        context = go_for(settings.tmpdir, params[:src])
+        content_type :json
+        context.collect{|k,v|
+          (k != :main and v.respond_to?(:to_dot)) ? k : nil
+        }.compact.to_json
+      end
+
+      # image results
+
+      get '/image/:name' do
+        cache_control :no_cache
+        expires 0, :no_cache
+        erb :image, :locals => { :name => params[:name] }
+      end
+
+      get '/automata/*' do
+        cache_control :no_cache
+        expires 0, :no_cache
+        send_file File.join(settings.tmpdir, params[:splat])
+      end
+
+    end # class App
+  end # module Gui
+end # module Stamina