pione 0.2.2 → 0.3.0

data/lib/pione/model/string.rb

@@ -1,127 +0,0 @@
-module Pione
-  module Model
-    # PioneString is a string value in PIONE system.
-    class PioneString < Value
-      # Evaluate the object with the variable table.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        self.class.new(vtable.expand(@value))
-      end
-
-      # Return true if the value includes variables.
-      #
-      # @return [Boolean]
-      #   true if the value includes variables
-      def include_variable?
-        VariableTable.check_include_variable(@value)
-      end
-
-      # Return a sequence that contains self.
-      #
-      # @return [StringSequence]
-      #   a sequence
-      def to_seq
-        StringSequence.new([self])
-      end
-
-      # @api private
-      def textize
-        "\"%s\"" % [@value]
-      end
-    end
-
-    class StringSequence < OrdinalSequence
-      set_pione_model_type TypeString
-      set_element_class PioneString
-      set_shortname "StrSeq"
-
-      def value
-        @value ||= @elements.map{|elt| elt.value}.join
-      end
-
-      def set_annotation_type(type)
-        self.class.new(@elements, @attribute.merge(annotation_type: type))
-      end
-    end
-
-    TypeString.instance_eval do
-      define_pione_method("+", [TypeString], TypeString) do |vtable, rec, other|
-        raise Model::AttributeError.new(other.attribute) unless rec.attribute == other.attribute
-        rec.elements.map do |rec_elt|
-          other.elements.map do |other_elt|
-            PioneString.new(rec_elt.value + other_elt.value)
-          end
-        end.flatten.tap {|x| break StringSequence.new(x, rec.attribute)}
-      end
-
-      define_pione_method("as_string", [], TypeString) do |vtable, rec|
-        rec
-      end
-
-      define_pione_method("as_integer", [], TypeInteger) do |vtable, rec|
-        sequential_map1(TypeInteger, rec) do |elt|
-          elt.value.to_i
-        end
-      end
-
-      define_pione_method("as_float", [], TypeFloat) do |vtable, rec|
-        sequential_map1(TypeFloat, rec) do |elt|
-          elt.value.to_f
-        end
-      end
-
-      define_pione_method("as_data_expr", [], TypeDataExpr) do |vtable, rec|
-        # FIXME
-        DataExpr.new(rec.elements.map{|elt| elt.value}.join(":")).to_seq
-      end
-
-      define_pione_method("count", [], TypeInteger) do |vtable, rec|
-        sequential_map1(TypeInteger, rec) do |elt|
-          elt.value.size
-        end
-      end
-
-      define_pione_method("include?", [TypeString], TypeBoolean) do |vtable, rec, target|
-        sequential_map2(TypeBoolean, rec, target) do |rec_elt, target_elt|
-          rec_elt.value.include?(target_elt.value)
-        end
-      end
-
-      define_pione_method("substring",
-        [TypeInteger, TypeInteger],
-        TypeString) do |vtable, rec, nth, len|
-        sequential_map2(TypeString, nth, len) do |nth_elt, len_elt|
-          rec.value[nth_elt.value-1, len_elt.value]
-        end
-      end
-
-      # insert : (pos : integer) -> (other : string) -> string
-      define_pione_method("insert", [TypeInteger, TypeString], TypeString) do |vtable, rec, pos, other|
-        sequential_map3(TypeString, rec, pos, other) do |rec_elt, pos_elt, other_elt|
-          rec_elt.value.clone.insert(pos_elt.value-1, other_elt.value)
-        end
-      end
-
-      # join : string
-      define_pione_method("join", [], TypeString) do |vtable, rec|
-        rec.call_pione_method(vtable, "join", PioneString.new(rec.separator).to_seq)
-      end
-
-      # join : (sep : string) -> string
-      define_pione_method("join", [TypeString], TypeString) do |vtable, rec, sep|
-        sequential_map1(TypeString, sep) do |sep_elt|
-          rec.elements.map{|elt| elt.value}.join(sep_elt.value)
-        end
-      end
-
-      # author : string
-      define_pione_method("author", [], TypeString) do |vtable, rec|
-        rec.set_annotation_type(:author)
-      end
-    end
-  end
-end

data/lib/pione/model/ticket-expr.rb

@@ -1,71 +0,0 @@
-module Pione
-  module Model
-    # TicketExpr is a ticket expression as alternative input or output
-    # conditions of rules for serial processing.
-    #
-    # @example Serial process of rule A and B by tickets in PIONE flow rule
-    #   Rule Main
-    #     input '*.in'
-    #     output '*.out'
-    #   Flow
-    #     rule A ==> <T>
-    #     <T> ==> rule B
-    #   End
-    class TicketExpr < Element
-      # ticket name
-      attr_reader :name
-
-      # @param name [String]
-      #   ticket name
-      def initialize(name)
-        @name = name
-      end
-
-      def eval(vtable)
-        self
-      end
-
-      def include_variable?
-        false
-      end
-
-      def textize
-        "<%s>" % [@names]
-      end
-
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @name == other.name
-      end
-      alias :eql? :"=="
-
-      def hash
-        @name.hash
-      end
-    end
-
-    class TicketExprSequence < OrdinalSequence
-      set_pione_model_type TypeTicketExpr
-      set_element_class TicketExpr
-      set_shortname "TSeq"
-
-      # Get ticket names of all elements in the sequence.
-      #
-      # @return [Array<String>]
-      #   ticket names
-      def names
-        @elements.map {|elt| elt.name}
-      end
-    end
-
-    TypeTicketExpr.instance_eval do
-      define_pione_method("==>", [TypeRuleExpr], TypeRuleExpr) do |vtable, rec, other|
-        other.add_input_ticket_expr(rec)
-      end
-
-      define_pione_method("as_string", [], TypeString) do |vtable, rec|
-        rec.textize
-      end
-    end
-  end
-end

data/lib/pione/model/variable-table.rb

@@ -1,344 +0,0 @@
-module Pione
-  module Model
-    # UnboundVariableError represents an unknown variable reference.
-    class UnboundVariableError < StandardError
-      attr_reader :variable
-
-      # Create an error.
-      #
-      # @param variable [Variable]
-      #   unbound variable
-      def initialize(variable)
-        @variable = variable
-      end
-
-      # @api private
-      def message
-        "Refferred unbound variable '%s' in the context." % @variable.name
-      end
-    end
-
-    # VariableBindingError represents an error that you try to bind different value
-    # to a variable.
-    class VariableBindingError < StandardError
-      attr_reader :variable
-      attr_reader :new_value
-      attr_reader :old_value
-
-      # Create an error.
-      #
-      # @param variable [Variable]
-      #   double bound variable
-      # @param new_value [BasicModel]
-      #   new value
-      # @param old_value [BasicModel]
-      #   old value
-      def initialize(variable, new_value, old_value)
-        @variable = variable
-        @new_value = new_value
-        @old_value = old_value
-      end
-
-      # @api private
-      def message
-        args = [
-          @new_value.textize,
-          @variable.name,
-          @old_value.textize,
-          @variable.line,
-          @variable.column
-        ]
-        message = [
-          "Try to bind the value '%s' as variable %s, ",
-          "but already bound the value '%s'",
-          "(line: %s, column: %s)"
-        ] % args
-      end
-    end
-
-    # VariableTable represents variable tables for rule context.
-    class VariableTable < BasicModel
-      # Return empty variable table.
-      #
-      # @return [VariableTable]
-      #   empty variable table
-      def self.empty
-        new
-      end
-
-      # Create a vairable table.
-      #
-      # @param table [Hash{Variable => BasicModel}]
-      #   initial values for the variable table
-      def initialize(table={})
-        @table = table.to_hash.dup
-        super()
-      end
-
-      # Return the variable table as hash.
-      #
-      # @return [Hash{Variable => BasicModel}]
-      #   hash form of the variable table
-      def to_hash
-        @table
-      end
-
-      # Return the parameters form.
-      #
-      # @return [Parameters]
-      #   parameters form of the variable table
-      def to_params
-        Parameters.new(to_hash)
-      end
-
-      # Return true if the table is empty.
-      #
-      # @return [Boolean]
-      #   true if the table is empty
-      def empty?
-        @table.empty?
-      end
-
-      # Gets the variable value and evaluates the value if the value is not
-      # atomic.
-      #
-      # @param var [Variable]
-      #   table key to get the value
-      # @return [BasicModel]
-      #   the value
-      def get(var)
-        check_argument_type(var, Variable)
-        val = @table[var]
-        case val
-        when Variable
-          next_val = get(val)
-          return next_val.nil? ? val : next_val
-        when BasicModel
-          return not(val.atomic?) ? val.eval(self) : val
-        end
-        return val
-      end
-
-      # Set a new variable. This method raises an exception when the variable has
-      # its value already.
-      #
-      # @param variable [Variable]
-      #   table key
-      # @param new_value [BasicModel]
-      #   new value
-      # @return [VariableTable]
-      #   new variable table
-      def set(variable, new_value)
-        check_argument_type(variable, Variable)
-        check_argument_type(new_value, BasicModel)
-        if old_value = @table[variable]
-          unless old_value.nil? or old_value.void? or new_value == old_value
-            raise VariableBindingError.new(variable, new_value, old_value)
-          end
-        end
-        @table[variable] = new_value
-        return self
-      end
-
-      # Set a variable. This method overrides old variable value.
-      #
-      # @param variable [Variable]
-      #   table key
-      # @param new_value [BasicModel]
-      #   new value
-      # @return [void]
-      def set!(variable, new_value)
-        check_argument_type(variable, Variable)
-        check_argument_type(new_value, BasicModel)
-        @table[variable] = new_value
-      end
-
-      # Expand variables in the string.
-      #
-      # @param str [String]
-      #   string
-      # @return [String]
-      #   expanded string
-      def expand(str)
-        variables = to_hash
-        new_str = str.to_s.gsub(/\{(\$.+?)\}/) do
-          expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse($1))
-          expr.eval(self).call_pione_method(self, "textize").first.value
-        end
-        new_str.gsub(/\<\?\s*(.+?)\s*\?\>/) do
-          expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse($1))
-          expr.eval(self).call_pione_method(self, "textize").first.value
-        end
-      end
-
-      # Return key variables of the table.
-      #
-      # @return [Array<Variable>]
-      #   variable as table keys
-      def variables
-        @table.keys
-      end
-
-      # FIXME
-      # Return true if the string includes variables.
-      #
-      # @param str [String]
-      #   target string
-      # @return [Boolean]
-      #   true if the string includes variables
-      def self.check_include_variable(str)
-        str = str.to_s
-        return true if /\{\$(.+?)\}/.match(str)
-        str.gsub(/\<\?\s*(.+?)\s*\?\>/) do
-          expr = DocumentTransformer.new.apply(DocumentParser.new.expr.parse($1))
-          return true if expr.include_variable?
-        end
-        return false
-      end
-
-      # Return true if table's values include variables.
-      #
-      # @return [Boolean]
-      #   true if table's values include variables
-      def include_variable?
-        # FIXME
-        @table.values.any?{|val| val.include_variable?}
-      end
-
-      # Make input auto-variables.
-      #
-      # @param input_exprs [Array<DataExpr>]
-      #   input expressions
-      # @param input_tuples [Array<Expr>]
-      #   input tuples
-      # @return [void]
-      def make_input_auto_variables(input_exprs, input_tuples)
-        set(Variable.new("INPUT"), Variable.new("I"))
-        input_exprs.each_with_index do |expr, index|
-          make_io_auto_variables(:input, expr, input_tuples[index], index+1)
-        end
-      end
-
-      # Make output auto-variables.
-      #
-      # @param output_exprs [Array<DataExpr>]
-      #   output expressions
-      # @param output_tuples [Array<DataExpr>]
-      #   output tuples
-      # @return [void]
-      def make_output_auto_variables(output_exprs, output_tuples)
-        set(Variable.new("OUTPUT"), Variable.new("O"))
-        output_exprs.each_with_index do |expr, index|
-          make_io_auto_variables(:output, expr, output_tuples[index], index+1)
-        end
-      end
-
-      # @api private
-      def ==(other)
-        return false unless other.kind_of?(self.class)
-        @table == other.to_hash
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @table.hash
-      end
-
-      # Make input or output auto variables.
-      #
-      # @api private
-      def make_io_auto_variables(type, expr, data, index)
-        expr = expr.eval(self)
-        prefix = (type == :input ? "I" : "O")
-        case expr.distribution
-        when :all
-          make_io_auto_variables_by_all(type, prefix, expr, data, index)
-        when :each
-          make_io_auto_variables_by_each(prefix, expr, data, index)
-        end
-      end
-
-      # Make input/output auto variables by data expression with each
-      # distribution.
-      #
-      # @param prefix [String]
-      #   "I" or "O"
-      # @param expr [DataExpr]
-      #   data expression
-      # @param tuple [DataTuple]
-      #   data tuple
-      # @param index [Integer]
-      #   index number of the input/output
-      # @return [void]
-      def make_io_auto_variables_by_each(prefix, expr, tuple, index)
-        return if tuple.nil?
-
-        # variable
-        var = Variable.new(prefix)
-
-        # matched data
-        md = expr.first.match(tuple.name).to_a
-
-        # setup data expression sequence
-        seq = get(var) || KeyedSequence.empty
-        data_expr = DataExpr.new(tuple.name, location: tuple.location, matched_data: md)
-
-        # update variable table
-        set!(var, seq.put(PioneInteger.new(index), data_expr))
-
-        # set the special variable if index is 1
-        if prefix == 'I' && index == 1
-          set(Variable.new("*"), StringSequence.new([PioneString.new(md[1])], separator: DataExpr::SEPARATOR))
-        end
-      end
-
-      # Make input/output auto variables by data expression with all
-      # distribution.
-      #
-      # @param prefix [String]
-      #   "I" or "O"
-      # @param expr [DataExpr]
-      #   data expression
-      # @param tuple [DataTuple]
-      #   data tuple
-      # @param index [Integer]
-      #   index number of the input/output
-      # @return [void]
-      def make_io_auto_variables_by_all(type, prefix, expr, tuples, index)
-        # FIXME: output
-        return if type == :output
-
-        # variable
-        var = Variable.new(prefix)
-
-        # setup data expression sequence(this is $I/$O)
-        seq = get(var) || KeyedSequence.empty(separator: DataExpr::SEPARATOR)
-
-        asterisk = []
-
-        # convert each tuples
-        matched_seq = tuples.inject(seq) do |_seq, tuple|
-          # matched data
-          md = expr.first.match(tuple.name).to_a
-          asterisk << md[1]
-
-          # make a date expression
-          data_expr = DataExpr.new(tuple.name, location: tuple.location, matched_data: md)
-
-          # put it with index
-          _seq.put(PioneInteger.new(index), data_expr)
-        end
-
-        # set special variable if index equals 1
-        if prefix == 'I' && index == 1
-          strs = asterisk.map{|str| PioneString.new(str)}
-          set(Variable.new("*"), StringSequence.new(strs, separator: DataExpr::SEPARATOR))
-        end
-
-        # update sequence
-        set!(var, matched_seq)
-      end
-    end
-  end
-end