pione 0.2.2 → 0.3.0

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

@@ -0,0 +1,134 @@
+module Pione
+  module Lang
+    # LiteralParser is a set of parser atom for literal descriptions.
+    module LiteralParser
+      include Parslet
+
+      # +boolean+ matches +true+ or +false+.
+      rule(:boolean) { (keyword_true | keyword_false).as(:boolean) }
+
+      # +string+ matches strings.
+      rule(:string) {
+        content = (backslash >> any | dquote.absent? >> any).repeat
+
+        (dquote.as(:header) >> content.as(:content) >> dquote!).as(:string)
+      }
+
+      # +integer+ matches integer numbers.
+      rule(:integer) { number.as(:integer) }
+
+      # +float+ matches float numbers.
+      rule(:float) {
+        (number >> dot >> digit.repeat(1) >> (match('[eE]') >> number!).maybe).as(:float)
+      }
+
+      # +variable+ matches PIONE variables. Be careful there is a special variable "$*".
+      rule(:variable) {
+        (doller.as(:header) >> (asterisk | identifier).as(:name)).as(:variable)
+      }
+
+      # +data_expr+ matches data expressions.
+      rule(:data_expr) { (data_pattern | data_null).as(:data_expr) }
+
+      # +data_pattern+ matches data pattern expressions.
+      rule(:data_pattern) {
+        content = (backslash >> any | squote.absent? >> any).repeat
+
+        squote.as(:header) >> content.as(:pattern) >> squote!
+      }
+
+      # +data_null+ matches data null expression.
+      rule(:data_null) { keyword_null.as(:null) }
+
+      # +package_expr+ matches package expressions.
+      rule(:package_expr) {
+        (ampersand.as(:header) >> identifier.as(:identifier)).as(:package_expr)
+      }
+
+      # +rule_expr+ matches rule expressions.
+      rule(:rule_expr) {
+        (keywords >> identifier_tail_character.absent?).absent? >> identifier.as(:rule_expr)
+      }
+
+      # +ticket_expr+ matches ticket expression. Be careful tickets are not
+      # permitted with padding between "<" and ">". This is because we avoid
+      # conflicts with other operators.
+      rule(:ticket_expr) {
+        (less_than.as(:header) >> identifier.as(:name) >> greater_than).as(:ticket_expr)
+      }
+
+      # +parameter_set+ matches parameter sets.
+      #
+      # @example
+      #   {abc: "a"}
+      # @example
+      #   {a: 1, b: 2, c: 3}
+      rule(:parameter_set) {
+        (lbrace.as(:header) >> padded?(parameter_set_elements.maybe.as(:elements)) >> rbrace!).as(:parameter_set)
+      }
+
+      # +parameter_set_elements+ matches elements of parameter set.
+      #
+      # @example
+      #   a: 1, b: 2, c: 3
+      rule(:parameter_set_elements) {
+        parameter_set_element >> (padded?(comma) >> parameter_set_element).repeat
+      }
+
+      # +parameter_set_element+ matches each element of parameter set.
+      #
+      # @example
+      #   a: 1
+      rule(:parameter_set_element) {
+        (identifier.as(:key) >> padded?(colon!) >> expr!.as(:value)).as(:parameter_set_element)
+      }
+
+      # +feature+ matches all atomic features.
+      rule(:feature) {
+        ( requisite_feature |
+          blocking_feature |
+          preferred_feature |
+          possible_feature |
+          restrictive_feature |
+          empty_feature |
+          almighty_feature
+        ).as(:feature)
+      }
+
+      # +requisite_feature+ matches requisite features.
+      rule(:requisite_feature) {
+        (plus.as(:prefix) >> identifier.as(:name)).as(:requisite_feature)
+      }
+
+      # +blocking_feature+ matches blocking features.
+      rule(:blocking_feature) {
+        (minus.as(:prefix) >> identifier.as(:name)).as(:blocking_feature)
+      }
+
+      # +preferred_feature+ matches preferred features.
+      rule(:preferred_feature) {
+        (question.as(:prefix) >> identifier.as(:name)).as(:preferred_feature)
+      }
+
+      # +possible_feature+ matches possible features.
+      rule(:possible_feature) {
+        (hat.as(:prefix) >> identifier.as(:name)).as(:possible_feature)
+      }
+
+      # +restrictive_feature+ matches restrictive features.
+      rule(:restrictive_feature) {
+        (exclamation.as(:prefix) >> identifier.as(:name)).as(:restrictive_feature)
+      }
+
+      # +empty_feature+ matches empty features.
+      rule(:empty_feature) {
+        ((asterisk >> asterisk).absent? >> asterisk.as(:symbol)).as(:empty_feature)
+      }
+
+      # +almighty_feature+ matches almighty features.
+      rule(:almighty_feature) {
+        (asterisk >> asterisk).as(:symbol).as(:almighty_feature)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+module Pione
+  module Lang
+    # LiteralTransformer is a transformer for syntax tree of literals.
+    module LiteralTransformer
+      include Util::ParsletTransformerModule
+
+      # Tranform +boolean+ into Lang::BooleanSequence.
+      rule(:boolean => simple(:b)) do
+        Lang::BooleanSequence.of(b == "true") do |expr|
+          line, col = b.line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +string+ into Lang::StringSequence.
+      rule(:string => subtree(:tree)) do
+        # empty string if content is an empty list
+        content = tree[:content] == [] ? "" : tree[:content]
+        # make string sequence
+        Lang::StringSequence.of(Util::BackslashNotation.apply(content)).tap do |expr|
+          line, col = tree[:header].line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +integer+ as Lang::IntegerSequence.
+      rule(:integer => simple(:i)) do
+        Lang::IntegerSequence.of(i.to_i).tap do |expr|
+          line, col = i.line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +float+ as Lang::FloatSequence.
+      rule(:float => simple(:f)) do
+        Lang::FloatSequence.of(f.to_f).tap do |expr|
+          line, col = f.line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +variable+ as Lang::VariableSequence.
+      rule(:variable => subtree(:tree)) {
+        Lang::Variable.new(tree[:name].str).tap do |expr|
+          line, col = tree[:header].line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +data_expr+ as Lang::DataExprSequence.
+      rule(:data_expr => subtree(:tree)) {
+        if tree[:null]
+          val = Lang::DataExprNull.new
+        else
+          val = Lang::DataExpr.new(Util::BackslashNotation.apply(tree[:pattern].str))
+        end
+
+        Lang::DataExprSequence.of(val).tap do |expr|
+          line, col = (tree[:header] || tree[:null]).line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +:package_expr+ into Lang::PackageExprSequence.
+      rule(:package_expr => subtree(:tree)) {
+        Lang::PackageExprSequence.of(tree[:identifier].str).tap do |expr|
+          line, col = tree[:header].line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +rule_expr+ into Lang::RuleExprSequence.
+      rule(:rule_expr => simple(:name)) do
+        Lang::RuleExprSequence.of(name.str).tap do |expr|
+          line, col = name.line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +ticket_expr+ into TicketExprSequence.
+      rule(:ticket_expr => subtree(:tree)) {
+        Lang::TicketExprSequence.of(tree[:name].str).tap do |expr|
+          line, col = tree[:header].line_and_column
+          expr.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +:parameters+ as Lang::Paramters.
+      rule(:parameter_set => subtree(:tree)) {
+        elts = tree[:elements]
+        case elts
+        when nil
+          Lang::ParameterSetSequence.new
+        when Array
+          Lang::ParameterSetSequence.of(Hash[*elts.map{|e| [e.key, e.value]}.flatten(1)])
+        else
+          Lang::ParameterSetSequence.of({elts.key => elts.value})
+        end.tap do |params|
+          line, col = tree[:header].line_and_column
+          params.set_source_position(package_name, filename, line, col)
+        end
+      }
+
+      # Transform +:parameters_element+ as key and value pair.
+      rule(:parameter_set_element => subtree(:tree)) {
+        OpenStruct.new(key: tree[:key].str, value: tree[:value])
+      }
+
+      # Transform +feature+ into FeatureSequence.
+      rule(:feature => simple(:piece)) do
+        Lang::FeatureSequence.of(piece)
+      end
+
+      # Transform +requisite_feature+ into RequisiteFeature.
+      rule(:requisite_feature => subtree(:tree)) do
+        Lang::RequisiteFeature.new(tree[:name].str).tap do |feature|
+          line, col = tree[:prefix].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +blocking_feature+ into BlockingFeature.
+      rule(:blocking_feature => subtree(:tree)) do
+        Lang::BlockingFeature.new(tree[:name].str).tap do |feature|
+          line, col = tree[:prefix].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +preferred_feature+ into PreferredFeature.
+      rule(:preferred_feature => subtree(:tree)) do
+        Lang::PreferredFeature.new(tree[:name].str).tap do |feature|
+          line, col = tree[:prefix].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +possible_feature+ into PossibleFeature.
+      rule(:possible_feature => subtree(:tree)) do
+        Lang::PossibleFeature.new(tree[:name].str).tap do |feature|
+          line, col = tree[:prefix].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +restrictive_feature+ into RestrictiveFeature.
+      rule(:restrictive_feature => subtree(:tree)) do
+        Lang::RestrictiveFeature.new(tree[:name].str).tap do |feature|
+          line, col = tree[:prefix].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +empty_feature+ into EmptyFeature.
+      rule(:empty_feature => subtree(:tree)) do
+        Lang::EmptyFeature.new.tap do |feature|
+          line, col = tree[:symbol].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+
+      # Transform +almighty_feature+ into AlmightyFeature.
+      rule(:almighty_feature => subtree(:tree)) do
+        Lang::AlmightyFeature.new.tap do |feature|
+          line, col = tree[:symbol].line_and_column
+          feature.set_source_position(package_name, filename, line, col)
+        end
+      end
+    end
+  end
+end

data/lib/pione/lang/message.rb

@@ -0,0 +1,41 @@
+module Pione
+  module Lang
+    # Message represents method callers in PIONE language.
+    class Message < Expr
+      member :name
+      member :receiver
+      member :arguments
+
+      # Return PIONE model type of the message result according to type interface.
+      def pione_type(env)
+        if pione_method = receiver.pione_type.find_method(env, name, receiver, arguments)
+          pione_method.get_output_type(receiver)
+        else
+          raise MethodNotFound.new(name.to_s, receiver, arguments)
+        end
+      end
+
+      # Evaluate the application expression and returns application result.
+      def eval(env)
+        # evaluate the receiver in the environment
+        _receiver = receiver.eval(env)
+        if _receiver.is_a?(Variable)
+          _receiver = _receiver.eval(env)
+        end
+
+        # send a message to it
+        _receiver.call_pione_method(env, name, arguments)
+      end
+
+      def eval!(env)
+        eval(env).eval!(env)
+      end
+
+      # Convert to text string.
+      def textize
+        args = arguments.map {|arg| arg.textize}
+        "#%s{name: %s, receiver: %s, arguments: %s}" % [Message, name, receiver.textize, args]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+module Pione
+  module Lang
+    # OridinalSequence is a sequence that has an ordinal number index.
+    class OrdinalSequence < Sequence
+      index_type TypeInteger
+      member :separator, default: " "
+
+      class << self
+        # Build a sequence with arguments. The arguments can be values or pieces.
+        def of(*args)
+          # map objects to pieces and create a sequece with it
+          new(pieces: args.map {|arg| make_piece(arg)})
+        end
+
+        # Map pieces of the sequence by applying the block and build a new
+        # sequence with it.
+        def map(seq, &b)
+          of(*seq.pieces.map{|piece| b.call(piece)})
+        end
+
+        # Map pieces of two sequence and build a new sequence with it.
+        def map2(seq1, seq2, &b)
+          vals = seq1.pieces.map do |piece1|
+            seq2.pieces.map do |piece2|
+              b.call(piece1, piece2)
+            end
+          end.flatten
+          of(*vals)
+        end
+
+        def map3(seq1, seq2, seq3, &b)
+          vals = seq1.pieces.map do |piece1|
+            seq2.pieces.map do |piece2|
+              seq3.pieces.map do |piece3|
+                b.call(piece1, piece2, piece3)
+              end
+            end
+          end.flatten
+          of(*vals)
+        end
+
+        # Fold pieces with the init sequence.
+        def fold(init, seq, &b)
+          seq.pieces.inject(init) do |_seq, piece|
+            b.call(_seq, piece)
+          end
+        end
+
+        # Fold pieces of two sequences with the init sequence.
+        def fold2(init, seq1, seq2, &b)
+          seq1.pieces.inject(init) do |_seq1, piece1|
+            seq2.pieces.inject(_seq1) do |_seq2, piece2|
+              b.call(_seq2, piece1, piece2)
+            end
+          end
+        end
+
+        def make_piece(val)
+          if val.is_a?(Piece)
+            val
+          else
+            klass = piece_classes.first
+            klass.new({klass.members.first => val})
+          end
+        end
+      end
+
+      forward :class, :make_piece
+
+      # Return the sequecen with no pieces.
+      def empty
+        set(pieces: [])
+      end
+
+      # Map my pieces by applying the block.
+      def map(&b)
+        set(pieces: pieces.map{|piece| make_piece(b.call(piece))})
+      end
+
+      # Map by the sequence and build a new sequence of result piece based on self.
+      def map_by(seq, &b)
+        # build new pieces by applying the block
+        _pieces = seq.pieces.map {|piece| make_piece(b.call(piece))}
+
+        # create a new sequence
+        set(pieces: _pieces)
+      end
+
+      # Map my pieces and other pieces.
+      def map2(other, &b)
+        _pieces = pieces.map do |piece1|
+          other.pieces.map do |piece2|
+            make_piece(b.call(piece1, piece2))
+          end
+        end.flatten
+        set(pieces: _pieces)
+      end
+
+      def map3(other1, other2, &b)
+        _pieces = pieces.map do |piece1|
+          other1.pieces.map do |piece2|
+            other2.pieces.map do |piece3|
+              make_piece(b.call(piece1, piece2, piece3))
+            end
+          end
+        end.flatten
+        set(pieces: _pieces)
+      end
+
+      # Fold my pieces with initial sequence.
+      def fold(init, &b)
+        pieces.inject(init) {|_seq, piece| b.call(_seq, piece)}
+      end
+
+      # Fold my pieces and other pieces with initial sequence.
+      def fold2(init, other, &b)
+        pieces.inject(init) do |_seq1, piece1|
+          other.pieces.inject(_seq1) do |_seq2, piece2|
+            b.call(_seq2, piece1, piece2)
+          end
+        end
+      end
+
+      def inspect
+        "#%s%s" % [self.class.name.split("::").last, to_h.inspect]
+      end
+    end
+
+    TypeOrdinalSequence.instance_eval do
+      define_pione_method("==", [:receiver_type], TypeBoolean) do |env, rec, other|
+        if rec.pieces.size == other.pieces.size
+          rec.pieces.size.times.all? do |i|
+            rec.pieces[i] == other.pieces[i]
+          end.tap {|x| break BooleanSequence.of(x)}
+        else
+          BooleanSequence.of(false)
+        end
+      end
+
+      define_pione_method("==*", [:receiver_type], TypeBoolean) do |env, rec, other|
+        case [rec.distribution, other.distribution]
+        when [:each, :each]
+          rec.pieces.any? do |rec_piece|
+            other.pieces.any? {|other_piece| rec_piece == other_piece}
+          end.tap {|x| break BooleanSequence.of(x)}
+        when [:all, :each]
+          BooleanSequence.of(other.pieces.any? {|piece| rec.pieces == [piece]})
+        when [:each, :all]
+          BooleanSequence.of(rec.pieces.any? {|piece| other.pieces == [piece]})
+        when [:all, :all]
+          rec.call_pione_method(env, "==", [other])
+        end
+      end
+
+      define_pione_method("nth", [TypeInteger], :receiver_type) do |env, rec, index|
+        rec.map_by(index) {|piece| piece.value == 0 ? rec : rec.pieces[piece.value-1]}
+      end
+
+      define_pione_method("[]", [:index_type], :receiver_type) do |env, rec, index|
+        rec.call_pione_method(env, "nth", [index])
+      end
+
+      define_pione_method("reverse", [], :receiver_type) do |env, rec|
+        rec.set(pieces: rec.pieces.reverse)
+      end
+
+      define_pione_method("head", [], :receiver_type) do |env, rec|
+        rec.set(pieces: [rec.pieces[0]])
+      end
+
+      define_pione_method("tail", [], :receiver_type) do |env, rec|
+        # NOTE: #tail should fail when the sequence length is less than 1
+        rec.set(pieces: rec.pieces[1..-1])
+      end
+
+      define_pione_method("last", [], :receiver_type) do |env, rec|
+        rec.set(pieces: [rec.pieces[-1]])
+      end
+
+      define_pione_method("init", [], :receiver_type) do |env, rec|
+        # NOTE: #init should fail when the sequence length is less than 1
+        rec.set(pieces: rec.pieces[0..-2])
+      end
+
+      define_pione_method("type", [], TypeString) do |env, rec|
+        case rec
+        when StringSequence
+          "string"
+        when IntegerSequence
+          "integer"
+        when FloatSequence
+          "float"
+        when BooleanSequence
+          "boolean"
+        when DataExprSequence
+          "data-expr"
+        else
+          "undefined"
+        end.tap {|x| break StringSequence.of(x)}
+      end
+    end
+  end
+end