pione 0.2.2 → 0.3.0

data/lib/pione/lang/float.rb

@@ -0,0 +1,104 @@
+module Pione
+  module Lang
+    # PioneFloat represents float values in PIONE system.
+    class PioneFloat < SimplePiece
+      piece_type_name "Float"
+    end
+
+    class FloatSequence < OrdinalSequence
+      pione_type TypeFloat
+      piece_class PioneFloat
+
+      def value
+        @value ||= pieces.inject(0.0){|f, piece| f + piece.value}
+      end
+    end
+
+    TypeFloat.instance_eval do
+      define_pione_method(">", [TypeFloat], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value > other_piece.value
+        end
+      end
+
+      define_pione_method(">=", [TypeFloat], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value >= other_piece.value
+        end
+      end
+
+      define_pione_method("<", [TypeFloat], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value < other_piece.value
+        end
+      end
+
+      define_pione_method("<=", [TypeFloat], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value <= other_piece.value
+        end
+      end
+
+      define_pione_method("+", [TypeFloat], TypeFloat) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value + other_piece.value
+        end
+      end
+
+      define_pione_method("-", [TypeFloat], TypeFloat) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value - other_piece.value
+        end
+      end
+
+      define_pione_method("*", [TypeFloat], TypeFloat) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value * other_piece.value
+        end
+      end
+
+      define_pione_method("%", [TypeFloat], TypeFloat) do |env, rec, other|
+        # TODO: zero division error
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value % other_piece.value
+        end
+      end
+
+      define_pione_method("/", [TypeFloat], TypeFloat) do |env, rec, other|
+        # TODO: zero division error
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value / other_piece.value
+        end
+      end
+
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        StringSequence.map(rec) {|piece| piece.value.to_s}
+      end
+
+      # Convert to integer(by truncate).
+      define_pione_method("as_integer", [], TypeInteger) do |env, rec|
+        IntegerSequence.map(rec) {|piece| piece.value.truncate}
+      end
+
+      # Return the receiver as is.
+      define_pione_method("as_float", [], TypeFloat) do |env, rec|
+        rec
+      end
+
+      # sin : float
+      define_pione_method("sin", [], TypeFloat) do |env, rec|
+        rec.map {|piece| Math.sin(piece.value)}
+      end
+
+      # cos : float
+      define_pione_method("cos", [], TypeFloat) do |env, rec|
+        rec.map {|piece| Math.cos(piece.value)}
+      end
+
+      # abs : float
+      define_pione_method("abs", [], TypeFloat) do |env, rec|
+        rec.map {|piece| piece.value.abs}
+      end
+    end
+  end
+end

data/lib/pione/lang/integer.rb

@@ -0,0 +1,159 @@
+module Pione
+  module Lang
+    # PioneInteger represents integer value in PIONE system.
+    class PioneInteger < SimplePiece
+      piece_type_name "Integer"
+    end
+
+    # IntegerSequence is a sequence of PIONE integer.
+    class IntegerSequence < OrdinalSequence
+      pione_type TypeInteger
+      piece_class PioneInteger
+
+      def textize
+        "(%s/i)" % pieces.map {|piece| piece.value}.join("|")
+      end
+    end
+
+    TypeInteger.instance_eval do
+      define_pione_method(">", [TypeInteger], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value > other_piece.value
+        end
+      end
+
+      define_pione_method(">=", [TypeInteger], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value >= other_piece.value
+        end
+      end
+
+      define_pione_method("<", [TypeInteger], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value < other_piece.value
+        end
+      end
+
+      define_pione_method("<=", [TypeInteger], TypeBoolean) do |env, rec, other|
+        BooleanSequence.map2(rec, other) do |rec_piece, other_piece|
+          rec_piece.value <= other_piece.value
+        end
+      end
+
+      define_pione_method("+", [TypeInteger], TypeInteger) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value + other_piece.value
+        end
+      end
+
+      define_pione_method("-", [TypeInteger], TypeInteger) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value - other_piece.value
+        end
+      end
+
+      define_pione_method("*", [TypeInteger], TypeInteger) do |env, rec, other|
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value * other_piece.value
+        end
+      end
+
+      define_pione_method("%", [TypeInteger], TypeInteger) do |env, rec, other|
+        # TODO: zero division error
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value % other_piece.value
+        end
+      end
+
+      define_pione_method("/", [TypeInteger], TypeInteger) do |env, rec, other|
+        # TODO: zero division error
+        rec.map2(other) do |rec_piece, other_piece|
+          rec_piece.value / other_piece.value
+        end
+      end
+
+      # Convert to integer.
+      define_pione_method("as_string", [], TypeString) do |env, rec|
+        StringSequence.map(rec) {|piece| piece.value.to_s}
+      end
+
+      # Return itself.
+      define_pione_method("as_integer", [], TypeInteger) do |env, rec|
+        rec
+      end
+
+      # Convert to float.
+      define_pione_method("as_float", [], TypeFloat) do |env, rec|
+        FloatSequence.map(rec) {|piece| piece.value.to_f}
+      end
+
+      # Return the next number.
+      define_pione_method("next", [], TypeInteger) do |env, rec|
+        rec.map {|piece| piece.value.next}
+      end
+
+      # Return the previous number.
+      define_pione_method("prev", [], TypeInteger) do |env, rec|
+        rec.map {|piece| piece.value.pred}
+      end
+
+      # Return true if it is even.
+      define_pione_method("even?", [], TypeBoolean) do |env, rec|
+        BooleanSequence.map(rec) {|piece| piece.value.even?}
+      end
+
+      # Return true if it is odd.
+      define_pione_method("odd?", [], TypeBoolean) do |env, rec|
+        BooleanSequence.map(rec) {|piece| piece.value.odd?}
+      end
+
+      # upto : *integer -> *integer
+      define_pione_method("upto", [TypeInteger], TypeInteger) do |env, rec, max|
+        rec.fold2(IntegerSequence.new, max) do |seq, rec_piece, max_piece|
+          if rec_piece.value <= max_piece.value
+            rec_piece.value.upto(max_piece.value).inject(seq) do |_seq, i|
+              _seq.push(PioneInteger.new(value: i))
+            end
+          else
+            seq
+          end
+        end
+      end
+
+      # downto : integer -> integer
+      define_pione_method("downto", [TypeInteger], TypeInteger) do |env, rec, min|
+        rec.fold2(IntegerSequence.new, min) do |seq, rec_piece, min_piece|
+          if rec_piece.value >= min_piece.value
+            rec_piece.value.downto(min_piece .value).inject(seq) do |_seq, i|
+              _seq.push(PioneInteger.new(value: i))
+            end
+          else
+            seq
+          end
+        end
+      end
+
+      # max : integer
+      define_pione_method("max", [], TypeInteger) do |env, rec|
+        rec.fold(rec.empty) do |seq, piece|
+          if seq.pieces.size == 0 or seq.pieces.first.value < piece.value
+            seq.set(pieces: [piece])
+          else
+            seq
+          end
+        end
+      end
+
+      # min : integer
+      define_pione_method("min", [], TypeInteger) do |env, rec|
+        rec.fold(rec.empty) do |seq, piece|
+          if seq.pieces.size == 0 or seq.pieces.first.value > piece.value
+            seq.set(pieces: [piece])
+          else
+            seq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pione/lang/interpolator-parser.rb

@@ -0,0 +1,44 @@
+module Pione
+  module Lang
+    # InterpolatorParser is a parser for handling embeded expression in strings.
+    class InterpolatorParser < Parslet::Parser
+      include Util::ParsletParserExtension
+      include CommonParser
+      include LiteralParser
+      include ExprParser
+
+      #
+      # root
+      #
+      root(:interpolators)
+
+      # +interpolator+ matches interpolation parts.
+      rule(:interpolator) { embeded_variable | embeded_expr | narrative }
+      rule(:interpolators) { interpolator.repeat.as(:interpolators) }
+
+      # +embeded_variable+ matches embeded expressions with variable heading.
+      rule(:embeded_variable) {
+        start_embeded_variable >> padded?(expr!).as(:embeded_expr) >> end_embeded_variable!
+      }
+      rule(:start_embeded_variable) { str("{") >> variable.present? }
+      rule(:end_embeded_variable) { str("}") }
+      rule(:end_embeded_variable!) { end_embeded_variable.or_error("should be '}'") }
+
+      # +embeded_expr+ matches arbitrary embeded expressions.
+      rule(:embeded_expr) {
+        start_embeded_expr >> padded?(expr!).as(:embeded_expr) >> end_embeded_expr!
+      }
+      rule(:start_embeded_expr) { str("<?") }
+      rule(:end_embeded_expr) { str("?>") }
+      rule(:end_embeded_expr!) { end_embeded_expr.or_error("should be '?>'") }
+
+      # +start_symbol+ matches start symbols of embeded expressions.
+      rule(:start_symbol) { start_embeded_variable | start_embeded_expr }
+
+      # +narrative+ matches other than embeded expressions.
+      rule(:narrative) {
+        (start_symbol.absent? >> any).repeat(1).as(:narrative)
+      }
+    end
+  end
+end

data/lib/pione/lang/interpolator-transformer.rb

@@ -0,0 +1,13 @@
+module Pione
+  module Lang
+    # InterpolatorTransformer is a transformer for PIONE embeded expressions.
+    class InterpolatorTransformer < Parslet::Transform
+      include LiteralTransformer
+      include ExprTransformer
+
+      rule(:interpolators => sequence(:list)) { list }
+      rule(:embeded_expr => simple(:expr)) { expr }
+      rule(:narrative => simple(:str)) { str.to_s }
+    end
+  end
+end

data/lib/pione/lang/keyed-sequence.rb

@@ -0,0 +1,98 @@
+module Pione
+  module Lang
+    # KeyedSequence is a sequence that have key and value pairs.
+    class KeyedSequence < Sequence
+      pione_type TypeKeyedSequence
+
+      member :pieces, default: {}
+      member :piece_type
+
+      # Concatenate the sequence and another one.
+      #
+      # @param other [Sequence]
+      #   other sequence
+      # @return [Sequence]
+      #   a new sequence that have members of self and other
+      def concat(other)
+        set(pieces: pieces.merge(other.pieces))
+      end
+      alias :+ :concat
+
+      # Get the element by the key.
+      def get(key)
+        pieces[key] || (raise IndexError.new(key))
+      end
+
+      # Put the element to the sequecence.
+      def put(key, val)
+        raise ArgumentError.new(key) unless key.kind_of?(Sequence)
+        raise ArgumentError.new(val) unless val.kind_of?(Sequence)
+        begin
+          set(pieces: pieces.merge({key => get(key) + val}))
+        rescue IndexError
+          set(pieces: pieces.merge({key => val}))
+        end
+      end
+
+      # Iterate each elements.
+      def each
+        if block_given?
+          pieces.each {|key, val| yield set(pieces: {key => val})}
+        else
+          Enumerator.new(self, :each)
+        end
+      end
+
+      def index_type
+        pieces.keys.first.pione_type
+      end
+
+      def element_type
+        pieces.values.first.pione_type
+      end
+
+      def eval(env)
+        _pieces = pieces.inject({}) do |_pieces, (key, val)|
+          _pieces.update({key => val.map{|v| v.eval(env)}})
+        end
+        set(pieces: _pieces)
+      end
+
+      def textize
+        inspect
+      end
+
+      def inspect
+        name = "KeyedSequence"
+        content = pieces.map {|key, val| "%s:(%s)" % [key.pieces.first.value, val.textize]}.join(",")
+        "#<%s [%s]>" % [name, content]
+      end
+
+      def textize
+        content = pieces.map {|key, val| "%s=>%s" % [key.textize, val.textize]}.join(",")
+        "<%s>" % content
+      end
+    end
+
+    TypeKeyedSequence.instance_eval do
+      define_pione_method("keys", [], :index_type) do |env, rec|
+        rec.pieces.keys.inject{|s1, s2| s1 + s2}
+      end
+
+      define_pione_method("values", [], :element_type) do |env, rec|
+        rec.pieces.values.inject{|s1, s2| s1 + s2}
+      end
+
+      # [] : index_type -> element_type
+      define_pione_method("[]", [:index_type], :element_type) do |env, rec, index|
+        index.pieces.map do |index_elt|
+          rec.pieces[index.set(pieces: [index_elt])] || (raise IndexError.new(index_elt))
+        end.inject{|res, seq| res + seq}
+      end
+
+      define_pione_method("textize", [], TypeString) do |env, rec|
+        rec.call_pione_method(env, "values", []).call_pione_method(env, "textize", [])
+      end
+    end
+  end
+end

data/lib/pione/lang/lang-exception.rb

@@ -0,0 +1,224 @@
+module Pione
+  module Lang
+    class LangError < StandardError; end
+
+    # EnvironmentError is raised when the environment is something bad.
+    class EnvironmentError < LangError; end
+
+    # StructuralError is raised when there is an unexpected expression in a model
+    # structure.
+    class StructuralError < LangError
+      def initialize(expected, pos)
+        @expected = expected
+        @pos = pos
+      end
+
+      def message
+        name = @expected.name
+        pos = @pos.format
+        "the expression should be %s(%s)" % [name, pos]
+      end
+    end
+
+    # ContextError is raised when contexts have unacceptable elements or we try
+    # to composite different contexts.
+    class ContextError < LangError
+      def initialize(declaration_or_context, context)
+        @obj = declaration_or_context
+        @context = context
+      end
+
+      def context_type
+        case @context
+        when ConditionalBranchContext
+          "conditional branch context"
+        when ParamContext
+          "parameter context"
+        when RuleConditionContext
+          "rule condition contexxt"
+        when FlowContext
+          "flow context"
+        when PackageContext
+          "package context"
+        when LiteralContext
+          "literal context"
+        else
+          raise ArgumentError.new(self)
+        end
+      end
+
+      def message
+        name = @obj.class.name
+        pos = @obj.pos.format
+        "%s is not acceptable for %s%s" % [name, context_type, pos]
+      end
+    end
+
+    # ParamError is raised when undefined parameter is specified.
+    class ParamError < LangError
+      def initialize(name, package_id)
+        @name = name
+        @package_id = package_id
+      end
+
+      def message
+        "parameter %s is not declared in package %s" % [@name, @package_id]
+      end
+    end
+
+    #
+    # declaration errors
+    #
+
+    class DeclarationError < LangError
+      def initialize(declaration)
+        @declaration = declaration
+      end
+    end
+
+    # ParamDeclarationError is raised when parameter declaration is something
+    # bad.
+    class ParamDeclarationError < DeclarationError
+    end
+
+    #
+    # Binding errors
+    #
+
+    class BindingError < LangError
+      def name
+        case @ref
+        when Variable
+          "variable $%s" % @ref.name
+        when RuleExpr
+          "rule %s" % @ref.name
+        when PackageExpr
+          "package &%s" % @ref.name
+        end
+      end
+    end
+
+    # UnboundError is raised when unbound variable, rule, or package was referred.
+    class UnboundError < BindingError
+      def initialize(ref)
+        @ref = ref
+      end
+
+      def message
+        case @ref
+        when Variable, RuleExpr
+          "%s in package %s is unbound%s" % [name, @ref.package_id, @ref.pos.format]
+        when PackageExpr
+          "package &%s is unknown" % @ref.package_id
+        end
+      end
+    end
+
+    # RebindError is raised when we try to rebind some value in variable table,
+    # param table, or rule table.
+    class RebindError < BindingError
+      def initialize(ref)
+        @ref = ref
+      end
+
+      def message
+        "try to rebind %s in package &%s%s" % [name, @ref.package_id, @ref.pos.format]
+      end
+    end
+
+    # CircularReferenceError is raised when variable or rule reference loop was deteced.
+    class CircularReferenceError < BindingError
+      def initialize(ref)
+        @ref = ref
+      end
+
+      def message
+        "reference of %s in package &%s made loop%s" % [name, @ref.package_id, @ref.pos.format]
+      end
+    end
+
+    #
+    # Others
+    #
+    class IndexError < StandardError
+      def initialize(index)
+        @index = index
+      end
+
+      def message
+        "index is out of range: %s" % [@index.inspect]
+      end
+    end
+
+    #
+    # expressions
+    #
+
+    # LangTypeError represents type mismatch error in PIONE language.
+    class LangTypeError < StandardError
+      def initialize(obj, type)
+        @obj = obj
+        @type = type
+      end
+
+      def message
+        args = [
+          @type.name,
+          @obj.pione_type.name,
+          @obj.line,
+          @obj.column
+        ]
+        "expected %s, but got %s(line: %s, column: %s)" % args
+      end
+    end
+
+    # MethodNotFound is an exception class for the case of method missing.
+    class MethodNotFound < StandardError
+      attr_reader :name
+      attr_reader :receiver
+      attr_reader :arguments
+
+      # Creates an exception.
+      # @param name [String]
+      #   method name
+      # @param receiver [Callable]
+      #   method reciever
+      # @param arguments [Array<Callable>]
+      #   method arguments
+      def initialize(name, receiver, arguments)
+        @name = name
+        @receiver = receiver
+        @arguments = arguments
+      end
+
+      def message
+        rec_type = @receiver.pione_type
+        arg_types = @arguments.map{|arg| arg.pione_type}.join(" -> ")
+        "PIONE method \"%s\" is not found: %s. %s" % [@name, rec_type, arg_types]
+      end
+    end
+
+    #
+    # parser
+    #
+
+    # ParserError is raised when the parser finds syntax error.
+    class ParserError < Parslet::ParseFailed
+      # Creates an error.
+      def initialize(str, expected, source)
+        @str = str
+        @expected = expected
+        @source = source
+        super(str)
+      end
+
+      def message
+        line, column = @source.line_and_column
+        left = @source.consume(@source.chars_left).str.split("\n").first
+        "%s(line: %s, column: %s): %s" % [@str, line, column, left]
+      end
+    end
+
+  end
+end
+