text: #    Copyright (c) 2015 Mirantis, Inc.
  #
  #    Licensed under the Apache License, Version 2.0 (the "License"); you may
  #    not use this file except in compliance with the License. You may obtain
  #    a copy of the License at
  #
  #         http://www.apache.org/licenses/LICENSE-2.0
  #
  #    Unless required by applicable law or agreed to in writing, software
  #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  #    License for the specific language governing permissions and limitations
  #    under the License.
  
  import collections
  import re
  import uuid
  
  from ply import lex
  from ply import yacc
  
  from yaql.language import exceptions
  from yaql.language import expressions
  from yaql.language import lexer
  from yaql.language import parser
  from yaql.language import utils
  
  
  OperatorType = collections.namedtuple('OperatorType', [
      'PREFIX_UNARY', 'SUFFIX_UNARY',
      'BINARY_LEFT_ASSOCIATIVE', 'BINARY_RIGHT_ASSOCIATIVE',
      'NAME_VALUE_PAIR'
  ])(
      PREFIX_UNARY='PREFIX_UNARY',
      SUFFIX_UNARY='SUFFIX_UNARY',
      BINARY_LEFT_ASSOCIATIVE='BINARY_LEFT_ASSOCIATIVE',
      BINARY_RIGHT_ASSOCIATIVE='BINARY_RIGHT_ASSOCIATIVE',
      NAME_VALUE_PAIR='NAME_VALUE_PAIR'
  )
  
  
  class YaqlOperators(object):
      def __init__(self, operators, name_value_op=None):
          self.operators = operators
          self.name_value_op = name_value_op
  
  
  class YaqlEngine(object):
      def __init__(self, ply_lexer, ply_parser, options, factory):
          self._lexer = ply_lexer
          self._parser = ply_parser
          self._options = utils.FrozenDict(options or {})
          self._factory = factory
  
      @property
      def lexer(self):
          return self._lexer
  
      @property
      def parser(self):
          return self._parser
  
      @property
      def options(self):
          return self._options
  
      @property
      def factory(self):
          return self._factory
  
      def __call__(self, expression, options=None):
          if options:
              return self.copy(options)(expression)
  
          return expressions.Statement(
              self.parser.parse(expression, lexer=self.lexer), self)
  
      def copy(self, options):
          opt = dict(self._options)
          opt.update(options)
          return YaqlEngine(self._lexer, self._parser, opt, self._factory)
  
  
  class YaqlFactory(object):
      def __init__(self, keyword_operator='=>', allow_delegates=False):
          self._keyword_operator = keyword_operator
          self._allow_delegates = allow_delegates
          self.operators = self._standard_operators()
          if keyword_operator:
              self.operators.insert(0, (keyword_operator,
                                        OperatorType.NAME_VALUE_PAIR))
  
      @property
      def keyword_operator(self):
          return self._keyword_operator
  
      @property
      def allow_delegates(self):
          return self._allow_delegates
  
      # noinspection PyMethodMayBeStatic
      def _standard_operators(self):
          return [
              ('.', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('?.', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('[]', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('{}', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('+', OperatorType.PREFIX_UNARY),
              ('-', OperatorType.PREFIX_UNARY),
              (),
              ('=~', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('!~', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('*', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('/', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('mod', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('+', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('-', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('>', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('<', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('>=', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('<=', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              ('!=', OperatorType.BINARY_LEFT_ASSOCIATIVE, 'not_equal'),
              ('=', OperatorType.BINARY_LEFT_ASSOCIATIVE, 'equal'),
              ('in', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('not', OperatorType.PREFIX_UNARY),
              (),
              ('and', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('or', OperatorType.BINARY_LEFT_ASSOCIATIVE),
              (),
              ('->', OperatorType.BINARY_RIGHT_ASSOCIATIVE),
          ]
  
      def insert_operator(self, existing_operator, existing_operator_binary,
                          new_operator, new_operator_type, create_group,
                          new_operator_alias=None):
          binary_types = (OperatorType.BINARY_RIGHT_ASSOCIATIVE,
                          OperatorType.BINARY_LEFT_ASSOCIATIVE)
          unary_types = (OperatorType.PREFIX_UNARY, OperatorType.SUFFIX_UNARY)
          position = 0
          if existing_operator is not None:
              position = -1
              for i, t in enumerate(self.operators):
                  if len(t) < 2 or t[0] != existing_operator:
                      continue
                  if existing_operator_binary and t[1] not in binary_types:
                      continue
                  if not existing_operator_binary and t[1] not in unary_types:
                      continue
                  position = i
                  break
              if position < 0:
                  raise ValueError('Operator {0} is not found'.format(
                      existing_operator))
              while position < len(self.operators) and len(
                      self.operators[position]) > 1:
                  position += 1
          if create_group:
              if position == len(self.operators):
                  self.operators.append(())
                  position += 1
              else:
                  while position < len(self.operators) and len(
                          self.operators[position]) < 2:
                      position += 1
                  self.operators.insert(position, ())
          self.operators.insert(
              position, (new_operator, new_operator_type, new_operator_alias))
  
      @staticmethod
      def _name_generator():
          value = 1
          while True:
              t = value
              chars = []
              while t:
                  chars.append(chr(ord('A') + t % 26))
                  t //= 26
              yield ''.join(chars)
              value += 1
  
      def _build_operator_table(self, name_generator):
          operators = {}
          name_value_op = None
          precedence = 1
          for record in self.operators:
              if not record:
                  precedence += 1
                  continue
              up, bp, name, alias = operators.get(record[0], (0, 0, '', None))
              if record[1] == OperatorType.NAME_VALUE_PAIR:
                  if name_value_op is not None:
                      raise exceptions.InvalidOperatorTableException(record[0])
                  name_value_op = record[0]
                  continue
              if record[1] == OperatorType.PREFIX_UNARY:
                  if up:
                      raise exceptions.InvalidOperatorTableException(record[0])
                  up = precedence
              elif record[1] == OperatorType.SUFFIX_UNARY:
                  if up:
                      raise exceptions.InvalidOperatorTableException(record[0])
                  up = -precedence
              elif record[1] == OperatorType.BINARY_LEFT_ASSOCIATIVE:
                  if bp:
                      raise exceptions.InvalidOperatorTableException(record[0])
                  bp = precedence
              elif record[1] == OperatorType.BINARY_RIGHT_ASSOCIATIVE:
                  if bp:
                      raise exceptions.InvalidOperatorTableException(record[0])
                  bp = -precedence
              if record[0] == '[]':
                  name = 'INDEXER'
              elif record[0] == '{}':
                  name = 'MAP'
              else:
                  name = name or 'OP_' + next(name_generator)
              operators[record[0]] = (
                  up, bp, name, record[2] if len(record) > 2 else None)
          return YaqlOperators(operators, name_value_op)
  
      # noinspection PyMethodMayBeStatic
      def _create_lexer(self, operators):
          return lexer.Lexer(operators)
  
      # noinspection PyMethodMayBeStatic
      def _create_parser(self, lexer_rules, operators):
          return parser.Parser(lexer_rules, operators, self)
  
      def create(self, options=None):
          names = self._name_generator()
          operators = self._build_operator_table(names)
          lexer_rules = self._create_lexer(operators)
          ply_lexer = lex.lex(object=lexer_rules,
                              reflags=re.UNICODE | re.VERBOSE)
          ply_parser = yacc.yacc(
              module=self._create_parser(lexer_rules, operators),
              debug=False if not options else options.get('yaql.debug', False),
              tabmodule='m' + uuid.uuid4().hex, write_tables=False)
  
          return YaqlEngine(ply_lexer, ply_parser, options, self)
  