stamina-core 0.5.0

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

@@ -0,0 +1,38 @@
+module Stamina
+  #
+  # Stamina - A Ruby Automaton & Induction Toolkit
+  #
+  # SYNOPSIS
+  #   #{program_name} [--version] [--help] COMMAND [cmd opts] ARGS...
+  #
+  # OPTIONS
+  # #{summarized_options}
+  #
+  # COMMANDS
+  # #{summarized_subcommands}
+  #
+  # See '#{program_name} help COMMAND' for more information on a specific command.
+  #
+  class Command < ::Quickl::Delegator(__FILE__, __LINE__)
+
+    # Install options
+    options do |opt|
+
+      # Show the help and exit
+      opt.on_tail("--help", "Show help") do
+        raise Quickl::Help
+      end
+
+      # Show version and exit
+      opt.on_tail("--version", "Show version") do
+        raise Quickl::Exit, "#{program_name} #{VERSION} (c) 2010-2011, Bernard Lambeau"
+      end
+
+    end
+
+  end # class Command
+end # module Stamina
+require_relative 'command/robustness'
+require_relative 'command/help'
+require_relative 'command/adl2dot'
+require_relative 'command/run'

data/lib/stamina-core/stamina/command/adl2dot.rb

@@ -0,0 +1,82 @@
+module Stamina
+  class Command
+    #
+    # Prints an automaton expressed in ADL in dot (or gif) format
+    #
+    # SYNOPSIS
+    #   #{program_name} #{command_name} automaton.adl
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class Adl2dot < Quickl::Command(__FILE__, __LINE__)
+      include Robustness
+
+      attr_reader :output_format
+
+      # Install options
+      options do |opt|
+
+        @output_file = nil
+        opt.on("-o", "--output=OUTPUT",
+               "Flush result output file") do |value|
+          @output_file = assert_writable_file(value)
+        end
+
+        @output_format = "dot"
+        opt.on("-g", "--gif",
+               "Generates a gif file instead of a dot one") do
+          @output_format = "gif"
+        end
+
+        opt.on("--png",
+               "Generates a png file instead of a dot one") do
+          @output_format = "png"
+        end
+
+      end # options
+
+      def output_file(infile)
+        @output_file || "#{File.basename(infile || 'stdin.adl', '.adl')}.#{output_format}"
+      end
+
+      # Command execution
+      def execute(args)
+        raise Quickl::Help unless args.size <= 1
+
+        # Loads the target automaton
+        input = if args.size == 1
+          File.read assert_readable_file(args.first)
+        else
+          $stdin.readlines.join("\n")
+        end
+
+        begin
+          automaton = Stamina::ADL::parse_automaton(input)
+        rescue ADL::ParseError
+          sample = Stamina::ADL::parse_sample(input)
+          automaton = sample.to_pta
+        end
+
+        # create a file for the dot output
+        if output_format == 'dot'
+          dotfile = output_file(args.first)
+        else
+          require 'tempfile'
+          dotfile = Tempfile.new("stamina").path
+        end
+
+        # Flush automaton inside it
+        File.open(dotfile, 'w') do |f|
+          f << automaton.to_dot
+        end
+
+        # if gif output, use dot to convert it
+        unless output_format == 'dot'
+          `dot -T#{output_format} -o #{output_file(args.first)} #{dotfile}`
+        end
+      end
+
+    end # class Adl2dot
+  end # class Command
+end # module Stamina

data/lib/stamina-core/stamina/command/help.rb

@@ -0,0 +1,23 @@
+module Stamina
+  class Command
+    #
+    # Show help about a specific command
+    #
+    # SYNOPSIS
+    #   #{program_name} #{command_name} COMMAND
+    #
+    class Help < Quickl::Command(__FILE__, __LINE__)
+
+      # Let NoSuchCommandError be passed to higher stage
+      no_react_to Quickl::NoSuchCommand
+
+      # Command execution
+      def execute(args)
+        sup = Quickl.super_command(self)
+        sub = (args.size != 1) ? sup : Quickl.sub_command!(sup, args.first)
+        puts Quickl.help(sub)
+      end
+
+    end # class Help
+  end # class Command
+end # module Stamina

data/lib/stamina-core/stamina/command/robustness.rb

@@ -0,0 +1,21 @@
+module Stamina
+  class Command
+    module Robustness
+
+      # Checks that a given file is readable or raises a Quickl::IOAccessError
+      def assert_readable_file(file)
+        raise Quickl::IOAccessError, "File #{file} does not exists" unless File.exists?(file)
+        raise Quickl::IOAccessError, "File #{file} cannot be read"  unless File.readable?(file)
+        file
+      end
+
+      # Checks that a given file is writable or raises a Quickl::IOAccessError
+      def assert_writable_file(file)
+        raise Quickl::IOAccessError, "File #{file} cannot be written" \
+          unless not(File.exists?(file)) or File.writable?(file)
+        file
+      end
+
+    end # module Robustness
+  end # class Command
+end # module Stamina

data/lib/stamina-core/stamina/command/run.rb

@@ -0,0 +1,84 @@
+module Stamina
+  class Command
+    #
+    # Run a file with the Stamina Engine
+    #
+    # SYNOPSIS
+    #   stamina #{command_name} FILE
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class Run < Quickl::Command(__FILE__, __LINE__)
+      include Robustness
+
+      attr_accessor :output
+      attr_accessor :images
+
+      # Install options
+      options do |opt|
+
+        @output = [:main]
+        opt.on("--output=x,y,z", Array,
+               "Output specified variables only") do |args|
+          self.output = args.collect{|v| v.to_sym}
+        end
+        opt.on("--all",
+               "Output all variables") do
+          self.output = nil
+        end
+
+        @images = []
+        opt.on('--gif') do
+          self.images << :gif
+        end
+        opt.on('--png') do
+          self.images << :png
+        end
+        opt.on('--dot') do
+          self.images << :dot
+        end
+
+      end # options
+
+      # Command execution
+      def execute(args)
+        raise Quickl::Help unless args.size == 1
+        assert_readable_file(file = args.first)
+        context = Stamina::Engine.execute(File.read(file), file)
+        do_output(context, File.dirname(file))
+        context
+      end
+
+      private
+
+      def do_output(context, dir)
+        self.output ||= context.vars
+        self.output.each do |varname|
+          varvalue = context[varname]
+
+          # textual output
+          puts "# #{varname} ###########################################"
+          puts varvalue.respond_to?(:to_adl) ? varvalue.to_adl : varvalue
+          puts
+
+          # image output
+          if varvalue.respond_to?(:to_dot)
+            output_images(varname, varvalue, dir)
+          end
+        end
+      end
+
+      def output_images(varname, varvalue, dir)
+        images.each do |format|
+          output_file = File.join(dir, "#{varname}.#{format}")
+          puts cmd = "dot -q -T#{format} -o#{output_file}"
+          IO::popen(cmd, "w") do |io|
+            io << varvalue.to_dot
+          end
+        end
+      end
+
+    end # class Run
+  end # class Command
+end # module Stamina

data/lib/stamina-core/stamina/core.rb

@@ -0,0 +1,11 @@
+require_relative 'version'
+require_relative 'loader'
+require_relative 'errors'
+require_relative 'ext/math'
+require_relative 'markable'
+require_relative 'adl'
+require_relative 'automaton'
+require_relative 'utils'
+require_relative 'dsl'
+require_relative 'engine'
+require_relative 'command'

data/lib/stamina-core/stamina/dsl.rb

@@ -0,0 +1,6 @@
+module Stamina
+  module Dsl
+    require_relative 'dsl/core'
+    require_relative 'dsl/automata'
+  end # module Dsl
+end # module Stamina

data/lib/stamina-core/stamina/dsl/automata.rb

@@ -0,0 +1,23 @@
+module Stamina
+  module Dsl
+    module Automata
+
+      #
+      # Coerces `arg` to an automaton
+      #
+      def automaton(arg)
+        Automaton.coerce(arg)
+      end
+
+      #
+      # Computes the synchronous composition of many automata
+      #
+      def compose(*args)
+        automata = args.collect{|a| automaton(a)}
+        Stamina::Automaton::Compose.execute(automata)
+      end
+
+    end # module Automata
+    include Automata
+  end # module Dsl
+end # module Stamina

data/lib/stamina-core/stamina/dsl/core.rb

@@ -0,0 +1,14 @@
+module Stamina
+  module Dsl
+    module Core
+
+      def assert(x, msg = nil)
+        raise Stamina::AssertionError,
+              "Assertion failed: #{msg || 'no message provided'}",
+              caller unless x
+      end
+
+    end # module Core
+    include Core
+  end # module Dsl
+end # module Stamina

data/lib/stamina-core/stamina/engine.rb

@@ -0,0 +1,32 @@
+require_relative 'engine/context'
+module Stamina
+  class Engine
+
+    def initialize
+      extend(Stamina::Dsl)
+    end
+
+    def execute_binding
+      binding
+    end
+
+    def execute(code, file = nil)
+      code = <<-EOF
+        main = begin
+          #{code}
+        end
+        Context.new(local_variables, binding)
+      EOF
+      if file
+        eval(code, execute_binding, file)
+      else
+        eval(code, execute_binding)
+      end
+    end
+
+    def self.execute(*args)
+      new.execute(*args)
+    end
+
+  end # class Engine
+end # module Stamina

data/lib/stamina-core/stamina/engine/context.rb

@@ -0,0 +1,35 @@
+module Stamina
+  class Engine
+    class Context
+      include Enumerable
+
+      attr_reader :vars, :binding
+
+      def initialize(vars, binding)
+        @vars = vars.collect{|v| v.to_sym}
+        @binding = binding
+      end
+
+      def each
+        vars.each do |key|
+          yield(key, self[key])
+        end
+      end
+
+      def [](name)
+        binding.eval(name.to_s)
+      end
+
+      def to_h
+        Hash[collect{|k,v| [k,v]}]
+      end
+
+      def to_s
+        collect{|k,v|
+          "#{k}: #{v}"
+        }.join("\n")
+      end
+
+    end # class Context
+  end # class Engine
+end # module Stamina

data/lib/stamina-core/stamina/errors.rb

@@ -0,0 +1,26 @@
+module Stamina
+
+  # Raised when an algorithm explicitely abords something
+  class Abord < StandardError; end
+
+  # Main class of all stamina errors.
+  class StaminaError < StandardError; end
+
+  # Raised when an assertion fails.
+  class AssertionError < StandardError; end
+
+  # Raised by samples implementations and other induction algorithms
+  # when a sample is inconsistent (same string labeled as being both
+  # positive and negative)
+  class InconsistencyError < StaminaError; end
+
+  # Specific errors of the ADL module.
+  module ADL
+
+    # Raised by the ADL module when an automaton, string or sample
+    # format is violated at parsing time.
+    class ParseError < StaminaError; end
+
+  end
+
+end # module Stamina

data/lib/stamina-core/stamina/ext/math.rb

@@ -0,0 +1,19 @@
+if RUBY_VERSION < "1.9"
+
+  def Math.log2( x )
+    Math.log( x ) / Math.log( 2 )
+  end
+
+  def Math.logn( x, n )
+    Math.log( x ) / Math.log( n )
+  end
+
+end
+
+def Math.max(i, j)
+  i > j ? i : j
+end
+
+def Math.min(i, j)
+  i < j ? i : j
+end

data/lib/stamina-core/stamina/loader.rb

@@ -0,0 +1,3 @@
+require "quickl"
+require "citrus"
+require "sinatra"

data/lib/stamina-core/stamina/markable.rb

@@ -0,0 +1,42 @@
+module Stamina
+  #
+  # Allows any object to be markable with user-data.
+  #
+  # This module is expected to be included by classes that want to implement the
+  # Markable design pattern. Moreover, if the instances of the including class
+  # respond to <tt>state_changed</tt>, this method is automatically invoked when
+  # marks change. This method is used by <tt>automaton</tt> in order to make it
+  # possible to track changes and check modified automata for consistency.
+  #
+  # == Detailed API
+  module Markable
+
+    #
+    # Returns user-value associated to _key_, nil if no such key in user-data.
+    #
+    def [](key) @data[key] end
+
+    #
+    # Associates _value_ to _key_ in user-data. Overrides previous value if
+    # present.
+    #
+    def []=(key,value)
+      oldvalue = @data[key]
+      @data[key] = value
+      state_changed(:loaded_pair, [key,oldvalue,value]) if self.respond_to? :state_changed
+    end
+
+    # Removes a mark
+    def remove_mark(key)
+      oldvalue = @data[key]
+      @data.delete(key)
+      state_changed(:loaded_pair, [key,oldvalue,nil]) if self.respond_to? :state_changed
+    end
+
+    # Extracts the copy of attributes which can subsequently be modified.
+    def data
+      @data.nil? ? {} : @data.dup
+    end
+
+  end # module Markable
+end # module Stamina