pione 0.2.2 → 0.3.0

data/lib/pione/model/variable.rb

@@ -1,116 +0,0 @@
-module Pione
-  module Model
-    # Variable represent variable name objects. A variable object can evaluates
-    # its value with the variable table.
-    class Variable < Callable
-      set_pione_model_type TypeSequence
-
-      # variable name
-      attr_reader :name
-
-      # true if the variable is user parameter
-      attr_reader :user_param
-
-      # parameter tyep
-      attr_reader :param_type
-
-      # Create a variable with name.
-      #
-      # @param name [String]
-      #   variable name
-      def initialize(name)
-        @name = name.to_s
-        @toplevel = nil
-        @user_param = nil
-        @param_type = nil
-        super()
-      end
-
-      # Evaluate self variable name in the table and returns it. Return self if
-      # the variable name is unbound in the table.
-      #
-      # @param vtable [VariableTable]
-      #   variable table for evaluation
-      # @return [BasicModel]
-      #   evaluation result
-      def eval(vtable)
-        val = vtable.get(self)
-        raise UnboundVariableError.new(self) if val.nil?
-        return val
-      end
-
-      # Return true because variable is a variable.
-      #
-      # @return [Boolean]
-      #   true
-      def include_variable?
-        true
-      end
-
-      # Set truth of toplevel variable.
-      def set_toplevel(b)
-        @toplevel = b
-      end
-
-      # Set truth of user parameter.
-      def set_user_param(b)
-        @user_param = b
-      end
-
-      # Set the parameter type.
-      #
-      # @param type [Symbol]
-      #   :advanced or :basic
-      def set_param_type(type)
-        @param_type = type
-      end
-
-      # Return true if the variable is defined in toplevel.
-      #
-      # @return [Boolean]
-      #   true if the variable is defined in toplevel
-      def toplevel?
-        @toplevel
-      end
-
-      # @api private
-      def textize
-        "$%s" % @name
-      end
-
-      # Compare with other variable.
-      #
-      # @api private
-      def <=>(other)
-        unless other.kind_of?(self.class)
-          raise ArgumentError.new(other)
-        end
-        @name <=> other.name
-      end
-
-      # Return true if other is a variable object which name is same as myself.
-      #
-      # @api private
-      def ==(other)
-        other.kind_of?(self.class) && @name == other.name
-      end
-      alias :eql? :"=="
-
-      # @api private
-      def hash
-        @name.hash
-      end
-
-      # @api private
-      def inspect
-        "#<Variable %s>" % @name.inspect
-      end
-      alias :to_s :inspect
-    end
-
-    # class VariableSequence < Sequence
-    #   set_pione_model_type TypeSequence
-    #   set_element_class Variable
-    # end
-  end
-end

data/lib/pione/parser.rb

@@ -1,14 +0,0 @@
-module Pione
-  # Parser is a namespace for PIONE parsers.
-  module Parser; end
-end
-
-require 'pione/parser/parslet-extension'
-require 'pione/parser/common-parser'
-require 'pione/parser/literal-parser'
-require 'pione/parser/feature-expr-parser'
-require 'pione/parser/expr-parser'
-require 'pione/parser/flow-element-parser'
-require 'pione/parser/block-parser'
-require 'pione/parser/rule-definition-parser'
-require 'pione/parser/document-parser'

data/lib/pione/parser/block-parser.rb

@@ -1,107 +0,0 @@
-module Pione
-  module Parser
-    # BlockParser is a set of parsers for rule block.
-    module BlockParser
-      include Parslet
-      include SyntaxError
-      include CommonParser
-      include LiteralParser
-      include ExprParser
-      include FlowElementParser
-
-      # @!method block
-      #   +block+ parser matches all blocks of PIONE.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +block+ parser
-      rule(:block) {
-        flow_block |
-        action_block |
-        empty_block |
-        syntax_error("block not found", [:block])
-      }
-
-      # @!method flow_block
-      #   +flow_block+ parser matches flow block.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +flow_block+ parser
-      #   @example
-      #     Flow
-      #       rule A
-      #       if $X
-      #         rule B
-      #       end
-      #     End
-      rule(:flow_block) {
-        ( flow_block_begin_line >>
-          (flow_element.repeat(1) |
-            syntax_error("flow elements not found", [:flow_element])) >>
-          (block_end_line |
-            syntax_error("block end not found", [:keyword_End]))
-         ).as(:flow_block)
-      }
-
-      # @!method action_block
-      #   +action_block+ parser matches action block.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +action_block+ parser
-      #   @example
-      #     Action
-      #       echo "abc" > out.txt
-      #     End
-      rule(:action_block) {
-        ( action_block_begin_line >>
-          ( (block_end_line.absent? >> any).repeat(1).as(:content) |
-            syntax_error("empty action block", [])) >>
-          ( block_end_line |
-            syntax_error("block end not found", [:keyword_End]))
-        ).as(:action_block)
-      }
-
-      # @!method empty_block
-      #   +empty_block+ parser matches empty block.
-      #   @return [Parslet::Atoms::Entity]
-      #     +empty_block+ parser
-      #   @example
-      #     End
-      rule(:empty_block) {
-        block_end_line.as(:empty_block)
-      }
-
-      # @!method flow_block_begin_line
-      #   +flow_block_begin_line+ parser matches flow block heading.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +flow_block_begin_line+ parser
-      #   @example
-      #     Flow
-      rule(:flow_block_begin_line) {
-        space? >> keyword_Flow >> str('-').repeat >> line_end
-      }
-
-      # @!method action_block_begin_line
-      #   +flow_block_begin_line+ parser matches action block heading.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +action_block_begin_line+ parser
-      #   @example
-      #     Action
-      rule(:action_block_begin_line) {
-        space? >> keyword_Action.as(:key) >> str('-').repeat >> line_end
-      }
-
-      # @!method block_end_line
-      #   +block_end_line+ parser matches block end keyword.
-      #
-      #   @return [Parslet::Atoms::Entity]
-      #     +block_end_line+ parser
-      #   @example
-      #     End
-      rule(:block_end_line) {
-        space? >> str('-').repeat >> keyword_End >> line_end
-      }
-    end
-  end
-end

data/lib/pione/parser/common-parser.rb

@@ -1,173 +0,0 @@
-module Pione
-  module Parser
-    # CommonParser is a set of symbols, keywords, and utility parsers.
-    module CommonParser
-      include Parslet
-
-      #
-      # symbols
-      #
-
-      SYMBOLS = {
-        :squote => '\'',
-        :dquote => '"',
-        :backslash => "\\",
-        :dot => '.',
-        :comma => ',',
-        :lparen => '(',
-        :rparen =>')',
-        :lbrace => '{',
-        :rbrace => '}',
-        :slash => '/',
-        :plus => '+',
-        :minus => '-',
-        :question => '?',
-        :vbar => '|',
-        :ampersand => '&',
-        :doller => '$',
-        :colon => ':',
-        :equals => '=',
-        :exclamation => '!',
-        :less_than => '<',
-        :greater_than => '>',
-        :asterisk => '*',
-        :percent => '%',
-        :atmark => '@',
-        :hat => '^',
-        :sharp => '#',
-        :lsbracket => '[',
-        :rsbracket => ']'
-      }
-
-      # make symbols
-      SYMBOLS.each do |key, val|
-        rule(key) { str(val) }
-      end
-
-      # @!attribute [r] symbols
-      #   +symbols+ matches all symbols in PIONE document.
-      #   @return [Parslet::Atoms::Entity] +symbols+ atom
-      rule(:symbols) {
-        SYMBOLS.keys.inject(nil) do |res, elt|
-          res ? res | send(elt) : send(elt)
-        end
-      }
-
-      #
-      # keywords
-      #
-
-      KEYWORDS = {
-        :keyword_Rule => 'Rule',
-        :keyword_Flow => 'Flow',
-        :keyword_Action => 'Action',
-        :keyword_End => 'End',
-        :keyword_input => 'input',
-        :keyword_output => 'output',
-        :keyword_param => 'param',
-        :keyword_Param => 'Param',
-        :keyword_basic => 'basic',
-        :keyword_Basic => 'Basic',
-        :keyword_advanced => 'advanced',
-        :keyword_Advanced =>  'Advanced',
-        :keyword_feature => 'feature',
-        :keyword_rule => 'rule',
-        :keyword_if => 'if',
-        :keyword_else => 'else',
-        :keyword_case => 'case',
-        :keyword_when => 'when',
-        :keyword_end => 'end',
-        :keyword_package => 'package',
-        :keyword_require => 'require',
-        :keyword_true => 'true',
-        :keyword_false => 'false',
-        :keyword_and => 'and',
-        :keyword_or => 'or',
-        :keyword_null => 'null',
-        :keyword_constraint => 'constraint'
-      }
-
-      # make keywords
-      KEYWORDS.each do |key, val|
-        rule(key) { str(val) }
-      end
-
-      #
-      # utilities
-      #
-
-      # @!attribute [r] identifier
-      #   +identifier+ matches any sequences excluding space, symbols, and
-      #     line end.
-      #   @return [Parslet::Atoms::Entity] +identifier+ atom
-      rule(:identifier) {
-        ((space | symbols | line_end).absent? >> any).repeat(1) >> question.maybe
-      }
-
-      # @!attribute [r] digit
-      #   +digit+ matches 0-9.
-      #   @return [Parslet::Atoms::Entity] +digit+ atom
-      rule(:digit) { match('[0-9]') }
-
-      # @!method space
-      #
-      # Return +space+ parser. +space+ matches sequences of space character,
-      # tab, or comment.
-      #
-      # @return [Parslet::Atoms::Entity] +space+ atom
-      rule(:space) {
-        ( match("[ \t]") |
-          str("#") >> ((str("\n") | any.absent?).absent? >> any).repeat
-        ).repeat(1)
-      }
-
-      # @!method space?
-      #
-      # Return +space?+ parser. +space?+ matches +space+ or empty.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +space?+ parser
-      rule(:space?) { space.maybe }
-
-      # @!method pad
-      #
-      # Return +pad+ parser. +pad+ matches sequences of space character, tab,
-      # newline, or comment.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +pad+ parser
-      rule(:pad) {
-        ( match("[ \t\n]") |
-          str("#") >> ((str("\n") | any.absent?).absent? >> any).repeat
-        ).repeat(1)
-      }
-
-      # @!method pad?
-      #
-      # Return +pad?+ parser. +pad?+ matches +pad+ or empty.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +pad?+ parser
-      rule(:pad?) { pad.maybe }
-
-      # @!attribute [r] line_end
-      #   +line_end+ matches a space sequence until line end.
-      #   @return [Parslet::Atoms::Entity] +line_end+ atom
-      rule(:line_end) { space? >> (str("\n") | any.absent?) }
-
-      # @!attribute [r] empty_lines
-      #   +empty_line+ matches empty lines.
-      #   @return [Parslet::Atoms::Entity] +empty_line+ atom
-      rule(:empty_lines) {
-        (space? >> str("\n")).repeat(1) >>
-        (space? >> any.absent?).maybe
-      }
-
-      # @!attribute [r] empty_lines?
-      #   +empty_lines?+ matches empty lines or empty.
-      #   @return [Parslet::Atoms::Entity] empty_line? atom
-      rule(:empty_lines?) { empty_lines.maybe }
-    end
-  end
-end
-

data/lib/pione/parser/document-parser.rb

@@ -1,141 +0,0 @@
-module Pione
-  module Parser
-    # DocumentParser is a parser for PIONE rule document.
-    class DocumentParser < Parslet::Parser
-      include CommonParser
-      include LiteralParser
-      include FeatureExprParser
-      include ExprParser
-      include FlowElementParser
-      include BlockParser
-      include RuleDefinitionParser
-
-      #
-      # root
-      #
-
-      root(:toplevel_elements)
-
-      # @!method toplevel_elements
-      #
-      # Return +toplevel_elements+ parser. This is root parser for reading a
-      # document.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +toplevel_elements+ parser
-      rule(:toplevel_elements) {
-        (empty_lines? >> space? >> toplevel_element >> empty_lines?).repeat
-      }
-
-      # @!method toplevel_element
-      #
-      # Return +toplevel_element+ parser.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +toplevel_element+ parser
-      #
-      # @example
-      #   # document toplevel assignment
-      #   DocumentParser.toplevel_element.parse("$X := 1")
-      # @example
-      #   # define rule
-      #   DocumentParser.new.toplevel_element.parse <<TXT
-      #     Rule Main
-      #       input '*.txt'
-      #       ...
-      #     Flow
-      #       rule SubRule
-      #       ...
-      #     End
-      #   TXT
-      # @example
-      #   # you can write any expressions in toplevel but it is ignored
-      #   DocumentParser.new.toplevel_element.parse("1 + 1")
-      rule(:toplevel_element) {
-        rule_definition |
-        param_block |
-        param_line.as(:toplevel_param_line) |
-        assignment_line.as(:toplevel_assignment_line) |
-        expr_line |
-        annotation_line
-      }
-
-      #
-      # document statement
-      #
-
-      rule(:document_statements) {
-        document_statement.repeat.as(:document_statements)
-      }
-
-      # document_statement
-      rule(:document_statement) {
-        package_line |
-        require_line
-      }
-
-      # @!method assignment_line
-      #
-      # Return +assignment_line+ parser.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +assignment_line+ parser
-      #
-      # @example
-      #   DocumentParser.new.assignment_line("$X := 1")
-      rule(:assignment_line) {
-        space? >> assignment >> line_end
-      }
-
-      # @!method param_block
-      #
-      # Return +param_block+ parser.
-      #
-      # @return [Parslet::Atoms::Entity]
-      #   +param block+ parser
-      #
-      # @example
-      #   DocumentParser.new.param_block <<TXT
-      #     Param
-      #       $X := 1
-      #       $Y := 2
-      #       $Z := 3
-      #     End
-      #   TXT
-      rule(:param_block) {
-        ( space? >>
-          ((keyword_Basic | keyword_Advanced).as(:param_type) >> space).maybe >>
-          keyword_Param >>
-          line_end >>
-          (assignment_line | pad).repeat.as(:in_block_assignments) >>
-          (keyword_End | syntax_error("it should be block end", :keyword_End)) >>
-          line_end
-        ).as(:param_block)
-      }
-
-      # package_line
-      rule(:package_line) {
-        ( space? >>
-          keyword_package >>
-          space >>
-          package_name >>
-          line_end
-        ).as(:package)
-      }
-
-      # require_line
-      rule(:require_line) {
-        ( space? >>
-          keyword_require >>
-          space >>
-          package_name >>
-          line_end
-        ).as(:require)
-      }
-
-      rule(:expr_line) {
-        space? >> expr >> line_end
-      }
-    end
-  end
-end