story-gen 0.0.1

data/lib/story.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+require 'enumerable/empty'
+require 'enumerable/sample'
+
+# To remove YARD warnings:
+# @!parse
+#   class Proc
+#   end
+
+class Story
+  
+  # @param [IO] out
+  # @return [void]
+  # @raise [Story::Error]
+  def write(out = STDOUT)
+    @out = out
+    write0()
+  end
+  
+  # @!method relations
+  #   @abstract
+  #   @return [Array<String>] relations mentioned in this {Story}.
+  
+  Position = Struct.new :file, :line, :column
+  
+  class Error < Exception
+    
+    # @param [Story::Position] pos
+    # @param [String] message
+    def initialize(pos, message)
+      super(message)
+      @pos = pos
+    end
+    
+    # @return [Story::Position]
+    attr_reader :pos
+    
+  end
+  
+  protected
+  
+  # @!method write0
+  #   @abstract
+  #   
+  #   Implementation of {#write}.
+  #   
+  #   @return [void]
+  #   @raise [Story::Error]
+  
+  # chooses a random non-empty {Enumerable} from +enumerable_and_action_s+,
+  # then chooses a random {Array} from that {Enumerable} and calls
+  # the appropriate {Proc}, passing the chosen {Array} as its *parameters.
+  # Or calls +else_action+ if all of the {Enumerable}s are empty.
+  # 
+  # @param [Array<Enumerable<Array<Object>>, Proc>] enumerable_and_action_s
+  # @param [Proc<*Object>] else_action
+  # @return [void]
+  # 
+  def if_(enumerable_and_action_s, else_action)
+    x = enumerable_and_action_s.
+      map do |enumerable_and_action|
+        enumerable, action = *enumerable_and_action
+        [enumerable.sample, action]
+      end.
+      reject do |sample, action|
+        sample.nil?
+      end.
+      sample
+    if x.nil? then
+      else_action.() if else_action
+    else
+      data, action = *x
+      action.(*data)
+    end
+  end
+  
+  # writes +msg+ to +out+ passed to {#write}.
+  # 
+  # @param [String] msg
+  # @return [void]
+  def tell(msg)
+    @out.write(msg)
+  end
+  
+  def must_be(x, clazz)
+    raise "#{x.inspect} is not #{if /^[aeiou]/ === clazz.to_s.downcase then "an" else "a" end} #{clazz}" unless x.is_a? clazz
+  end
+  
+end

data/lib/story/compile.rb

@@ -0,0 +1,926 @@
+# encoding: UTF-8
+require 'parse'
+require 'code'
+require 'string/ru_downcase'
+require 'object/to_rb'
+require 'array/case_equal_fixed'
+require 'array/to_h'
+require 'array/chomp'
+require 'any'
+
+# To remove YARD warnings:
+# @!parse
+#   class Class
+#   end
+#   module Kernel
+#     def eval(str)
+#     end
+#   end
+
+class Story
+  
+  # @param [String] text
+  # @param [String] file a file the +text+ is taken from.
+  # @return [String] a {String} which {Kernel#eval}s to a {Class} which
+  #   inherits {Story}.
+  # @raise [Parse::Error]
+  def self.compile(text, file = "-")
+    #
+    c = Parse.new.(text, file).to_code
+    # 
+    relation_id_to_var_arg_valuesss_var = Hash.new do |h, relation_id|
+      h[relation_id] = "@#{INTERNAL_VAR_PREFIX}var_arg_valuesss#{h.size}"
+    end
+    #
+    c = c.map_non_code_parts do |part|
+      if part.is_a? VarArgValuesssVar
+        relation_id_to_var_arg_valuesss_var[part.relation_id]
+      else
+        raise "unknown non-code part type: #{part.inspect}"
+      end
+    end
+    #
+    relation_ids_code = relation_id_to_var_arg_valuesss_var.keys.
+      map { |relation_id| relation_id.join(" ") }.
+      sort.
+      to_rb
+    #
+    init_var_arg_valuesss_vars = relation_id_to_var_arg_valuesss_var.
+      map do |relation_id, var|
+        "#{var} = Set.new  # #{relation_id}\n"
+      end.
+      join_code
+    #
+    c = code <<
+      "require 'enumerable/empty'\n"<<
+      "require 'enumerable/lazy'\n"<<
+      "require 'set'\n"<<
+      "require 'story'\n"<<
+      "require 'enumerable/new'\n"<<
+      "\n"<<
+      "Class.new(Story) do\n"<<
+        "def relations\n"<<
+          relation_ids_code << "\n"<<
+        "end\n"<<
+        "protected\n"<<
+        "def write0(io = STDOUT)\n"<<
+          init_var_arg_valuesss_vars << "\n"<<
+          c << "\n"<<
+        "end\n"<<
+      "end\n"
+    #
+    c.to_s
+  end
+  
+  private
+  
+  INTERNAL_VAR_PREFIX = "__internal__"
+  
+  # @!visibility private
+  class ::Array
+    
+    # @param [Code, String] delimiter
+    # @return [Code]
+    def join_code(delimiter = "")
+      self.reduce do |r, self_i|
+        code << r << delimiter << self_i
+      end or
+      code
+    end
+    
+  end
+  
+  # @!visibility private
+  module ::ASTNode
+    
+    INTERNAL_VAR_PREFIX = Story::INTERNAL_VAR_PREFIX
+    
+    protected
+    
+    # macro
+    def internal_var(base_name)
+      "#{INTERNAL_VAR_PREFIX}#{base_name}"
+    end
+    
+    # wraps result of +f+ to:
+    #   
+    #   (
+    #     begin
+    #       (f result)
+    #     rescue Exception => e
+    #       raise Story::Error.new(pos, e.message)
+    #     end
+    #   )
+    # 
+    # Here +e+ is some internal variable (see {INTERNAL_VAR_PREFIX}) and
+    # +pos+ is converted to {Story::Position}.
+    # 
+    # @param [Parse::Position] pos
+    # @yieldreturn [Code]
+    # @return [Code]
+    #   
+    def at(pos, &f)
+      e = internal_var(:e)
+      code << "(begin\n" <<
+        f.() << "\n" <<
+      "rescue Exception => #{e}\n" <<
+        "raise Story::Error.new(Story::Position.new(#{pos.file.to_rb}, #{pos.line.to_rb}, #{pos.column.to_rb}), #{e}.message)\n" <<
+      "end)"
+    end
+    
+  end
+  
+  # @!visibility private
+  VarArgValuesssVar = Struct.new :relation_id, :pos
+  
+  Var = ASTNode.new :name, :original_name do
+    
+    alias name_super name
+    
+    def name
+      raise Parse::Error.new(pos, "variables with names starting with `#{ASTNode::INTERNAL_VAR_PREFIX}' are reserved for internal use") if name_super.start_with? ASTNode::INTERNAL_VAR_PREFIX
+      name_super
+    end
+    
+    def == other
+      self.class == other.class and
+      self.name == other.name
+    end
+    
+    def === other
+      self.class == other.class and
+      self.name === other.name
+    end
+    
+    def hash
+      name.hash
+    end
+    
+  end
+  
+  Asterisk = ASTNode.new
+  
+  # @!visibility private
+  module Statement
+  end
+  
+  Statement::Tell = ASTNode.new :parts do
+    
+    def to_code
+      code << "(begin\n" <<
+        parts.map do |part|
+          code << "print(" <<
+            case part
+            when String then part.to_rb
+            when Var then at(part.pos) { part.name }
+            end <<
+          ")"
+        end.join_code("\n") << "\n" <<
+      "end)"
+    end
+    
+  end
+  
+  Statement::SetFact = ASTNode.new :subexpr do
+    
+    def to_code
+      # 
+      var_arg_valuess = internal_var(:var_arg_valuess)
+      # 
+      case subexpr
+      when FactExpr::Not then
+        args = subexpr.subexpr.args
+        reject = args.zip(0...args.size).
+          map do |arg, i|
+            case arg
+            when Asterisk then
+              nil
+            when Var then
+              "#{at(arg.pos) { arg.name }} == #{var_arg_valuess}[#{i}]"
+            else
+              "#{arg.to_rb} == #{var_arg_valuess}[#{i}]"
+            end
+          end.
+          compact
+        reject =
+          if reject.empty?
+          then ".clear()"
+          else ".reject! { |#{var_arg_valuess}| #{reject.join(" and ")} }"
+          end
+        code <<
+          non_code(VarArgValuesssVar[subexpr.subexpr.relation_id, pos]) <<
+          reject
+      else
+        args = subexpr.args
+        code <<
+          non_code(VarArgValuesssVar[subexpr.relation_id, pos]) <<
+          ".add([" <<
+            args.zip(0...args.size).
+              map do |arg, i|
+                case arg
+                when Asterisk then
+                  raise Parse::Error.new(arg.pos, "not supported")
+                when Var then
+                  at(arg.pos) { arg.name }
+                else
+                  arg.to_rb
+                end
+              end.
+              join_code(", ") <<
+          "])"
+      end
+    end
+    
+  end
+  
+  Statement::If = ASTNode.new :condition_and_then_s, :else_ do
+    
+    def to_code
+      code << "if_(\n"<<
+        "[\n" <<
+          condition_and_then_s.map do |condition, then_|
+            code << "[\n" <<
+              condition.to_code << ",\n" <<
+              "lambda do |" << condition.var_args.map(&:name).join_code(", ") << "|\n" <<
+                then_.to_code << "\n" <<
+              "end\n" <<
+            "]"
+          end.join_code(",\n") << "\n" <<
+        "],\n" <<
+        if else_ then
+          code << "lambda { " << else_.to_code << " }\n"
+        else
+          "nil\n"
+        end <<
+      ")"
+    end
+    
+  end
+  
+  Statement::Compound = ASTNode.new :statements do
+    
+    def to_code
+      code << "(begin\n" <<
+        statements.map { |statement| statement.to_code << "\n" }.reduce(:<<) <<
+      "end)"
+    end
+    
+  end
+  
+  Statement::While = ASTNode.new :condition, :body do
+    
+    def to_code
+      o =
+        case condition
+        when FactExpr::Not then code << "while " << condition.subexpr.to_code << ".empty?"
+        else code << "until " << condition.to_code << ".empty?"
+        end
+      code << "(" << o << "\n" <<
+        body.to_code << "\n" <<
+      "end)"
+    end
+    
+  end
+  
+  Statement::ForAll = ASTNode.new :fact_expr, :body do
+    
+    def to_code
+      ignored = internal_var(:ignored)
+      code << "(" << fact_expr.to_code << ".\n" <<
+        "to_a.\n" <<
+        "each do |" << fact_expr.var_args.map(&:name).join_code(", ") << ", " << ignored << " = nil|\n" <<
+          body.to_code << "\n" <<
+        "end)"
+    end
+    
+  end
+  
+  Statement::NTimes = ASTNode.new :range_begin, :range_end, :body do
+    
+    def to_code
+      n_code =
+        if range_begin == range_end
+        then to_code_(range_begin)
+        else code << "rand(" << to_code_(range_begin) << ".." << to_code_(range_end) << ")"
+        end
+      code << "(" << n_code << ".times do\n" <<
+        body.to_code << "\n" <<
+      "end)"
+    end
+    
+    private
+    
+    def to_code_(range_part)
+      case range_part
+      when Integer then range_part.to_rb
+      when Var then at(range_part.pos) { code << "(must_be(" << range_part.name << ", Integer); " << range_part.name << ")" }
+      else raise Parse::Error.new(pos, "what?")
+      end
+    end
+    
+  end
+  
+  Statement::Or = ASTNode.new :substatements do
+    
+    def to_code
+      code << "[\n" <<
+        substatements.
+          map { |substatement| code << "lambda { " << substatement.to_code << " }" }.
+          join_code(",\n") << "\n" <<
+      "].sample.()"
+    end
+    
+  end
+  
+  Statement::Code = ASTNode.new :body do
+    
+    def to_code
+      at(pos) { body }
+    end
+    
+  end
+  
+  Program = ASTNode.new :statements do
+    
+    def to_code
+      statements.
+        map { |statement| statement.to_code << "\n" }.
+        reduce(:<<)
+    end
+    
+  end
+  
+  # @!visibility private
+  module FactExpr
+    
+    # @method to_code
+    #   @abstract
+    #   @return [Code] a {Code} which evaluates to "var arg valuess" -
+    #     {Enumerable} of values of {Var} arguments ({Enumerable} of
+    #     {Array}s of {Object}s).
+    
+    # @return [Array<Story::Var>] {Var} args attached to {#to_code} with
+    #   {#with_var_args}.
+    def var_args
+      self.to_code.metadata or raise "no var args attached to #{self.to_code.inspect}"
+    end
+    
+    # @return [Hash<Story::Var, Integer>] {#var_args} along with their indexes.
+    def var_args_indexes
+      (var_args).zip(0...var_args.size).to_h
+    end
+    
+    protected
+    
+    # @param [Array<Story::Var>] var_args
+    # @param [Code] code
+    # @return [Code] +code+ with +var_args+ attached to it as {Code#metadata}.
+    def with_var_args(var_args, code)
+      code.metadata(var_args)
+    end
+        
+  end
+  
+  FactExpr::Primary = ASTNode.new :relation_id, :args do
+    
+    include FactExpr
+    
+    def to_code
+      var_arg_valuess = internal_var(:var_arg_valuess)
+      select = []; map = []; begin
+        known_var_index = {}
+        args.zip(0...args.size).each do |arg, i|
+          case arg
+          when Asterisk then
+            # do nothing
+          when Var then
+            var = arg
+            if known_var_index.has_key? var then
+              select << "#{var_arg_valuess}[#{known_var_index[var]}] == #{var_arg_valuess}[#{i}]"
+            else
+              map << "#{var_arg_valuess}[#{i}]"
+              known_var_index[var] = i
+            end
+          else
+            select << "#{arg.to_rb} == #{var_arg_valuess}[#{i}]"
+          end
+        end
+        select =
+          if select.empty?
+          then ""
+          else ".select { |#{var_arg_valuess}| #{select.join(" and ")} }"
+          end
+        map =
+          ".map { |#{var_arg_valuess}| [#{map.join(", ")}] }"
+      end
+      with_var_args(
+        args.select { |arg| arg.is_a? Var },
+        code << "(" <<
+          non_code(VarArgValuesssVar[relation_id, pos]) <<
+            select <<
+            map <<
+        ")"
+      )
+    end
+    
+  end
+  
+  FactExpr::Not = ASTNode.new :subexpr do
+    
+    include FactExpr
+    
+    def to_code
+      raise Parse::Error.new(pos, "not supported")
+    end
+    
+  end
+  
+  FactExpr::And = ASTNode.new :e1, :e2 do
+    
+    include FactExpr
+    
+    def to_code
+      #
+      var_arg_valuess = internal_var(:var_arg_valuess)
+      var_arg_valuess1 = internal_var(:var_arg_valuess1)
+      var_arg_valuess2 = internal_var(:var_arg_valuess2)
+      block = internal_var(:block)
+      #
+      case [e1, e2]
+      when [any, FactExpr::Not]
+        common_var_args = e1.var_args & e2.subexpr.var_args
+        if common_var_args.empty? then
+          with_var_args(
+            e1.var_args,
+            code << "("<<
+              "if " << e2.subexpr.to_code << ".empty? "<<
+              "then " << e1.to_code << " "<<
+              "else [] "<<
+              "end"<<
+            ")"
+          )
+        else
+          condition = common_var_args.
+            map do |var_arg|
+              "#{var_arg_valuess1}[#{e1.var_args_indexes[var_arg]}] == #{var_arg_valuess2}[#{e2.subexpr.var_args_indexes[var_arg]}]"
+            end.
+            join(" and ")
+          with_var_args(
+            e1.var_args,
+            code << "(" <<
+              e1.to_code << ".select do |#{var_arg_valuess1}| "<<
+                "not (" << e2.subexpr.to_code << ".any? { |#{var_arg_valuess2}| " << condition << " }) " <<
+              "end" <<
+            ")"
+          )
+        end
+      when [any, FactExpr::Select]
+        [e2.e1, e2.e2].
+          select { |operand| operand.is_a? Var }.
+          each do |e2_var_arg|
+            if not e1.var_args.include? e2_var_arg then
+              raise Parse::Error.new(e2_var_arg.pos, "#{e2_var_arg.original_name} is not known in the left part")
+            end
+          end
+        to_code = lambda do |operand|
+          case operand
+          when Var then "#{var_arg_valuess}[#{e1.var_args_indexes[operand]}]"
+          else operand.to_rb
+          end
+        end
+        rb_op =
+          case e2.op
+          when "==", "!=", "<=", ">=", "<", ">" then e2.op
+          when "<>" then "!="
+          when "=" then "=="
+          end
+        with_var_args(
+          e1.var_args,
+          code << "(" <<
+            e1.to_code << ".select do |#{var_arg_valuess}| "<<
+              at(e2.pos) { to_code.(e2.e1) << rb_op << to_code.(e2.e2) } << " "<<
+            "end " <<
+          ")"
+        )
+      when [any, any]
+        var_args = e1.var_args | e2.var_args
+        select = []; map = []; begin
+          var_args.each do |var_arg|
+            if e1.var_args.include?(var_arg) and e2.var_args.include?(var_arg) then
+              select << "#{var_arg_valuess1}[#{e1.var_args_indexes[var_arg]}] == #{var_arg_valuess2}[#{e2.var_args_indexes[var_arg]}]"
+              map << "#{var_arg_valuess1}[#{e1.var_args_indexes[var_arg]}]"
+            elsif e1.var_args.include?(var_arg) then
+              map << "#{var_arg_valuess1}[#{e1.var_args_indexes[var_arg]}]"
+            elsif e2.var_args.include?(var_arg) then
+              map << "#{var_arg_valuess2}[#{e2.var_args_indexes[var_arg]}]"
+            end
+          end
+          select =
+            if select.empty?
+            then "true"
+            else "#{select.join(" and ")}"
+            end
+          map =
+            "[#{map.join(", ")}]"
+        end
+        with_var_args(
+          var_args,
+          code << "(" <<
+            "Enumerable.new do |#{block}| "<<
+              e1.to_code << ".each do |#{var_arg_valuess1}| "<<
+                e2.to_code << ".each do |#{var_arg_valuess2}| "<<
+                  "if #{select} then "<<
+                    "#{block}.(#{map}) "<<
+                  "end "<<
+                "end "<<
+              "end "<<
+            "end"<<
+          ")"
+        )
+      end
+    end
+    
+  end
+  
+  FactExpr::Select = ASTNode.new :e1, :op, :e2
+  
+  FactExpr::Or = ASTNode.new :e1, :e2 do
+    
+    include FactExpr
+    
+    def to_code
+      # 
+      var_arg_valuess = internal_var(:var_arg_valuess)
+      block = internal_var(:block)
+      # 
+      var_args = e1.var_args | e2.var_args
+      enum_var_arg_valuess = lambda do |e|
+        new_var_arg_valuess = var_args.map do |var_arg|
+          if (index = e.var_args_indexes[var_arg])
+          then "#{var_arg_valuess}[#{index}]"
+          else "nil"
+          end
+        end
+        e.to_code << ".map { |#{var_arg_valuess}| [#{new_var_arg_valuess.join(", ")}] }.each(&#{block})\n"
+      end
+      with_var_args(
+        var_args,
+        code << "(" <<
+          "Enumerable.new do |#{block}| "<<
+            enum_var_arg_valuess.(e1) <<
+            enum_var_arg_valuess.(e2) <<
+          "end" <<
+        ")"
+      )
+    end
+    
+  end
+  
+  # @!visibility private
+  class Parse < ::Parse
+    
+    # --------------
+    # @!group Syntax
+    # --------------
+    
+    rule :start do
+      no_errors { wsc } and
+      ss = many {
+        s = statement and opt { _{ semicolon } or _{ dot } } and s
+      } and
+      Program[ss]
+    end
+    
+    rule :statement do
+      _{ statement_or } or
+      _{ statement_if } or
+      _{ statement_while } or
+      _{ statement_for_all } or
+      _{ statement_n_times } or
+      _{ statement_code } or
+      _{ statement_set_fact } or
+      _{ statement_tell } or
+      _{ statement_compound }
+    end
+    
+    rule :statement_tell do
+      parts = many1 {
+        _{ string } or _{ var }
+      } and
+      _(Statement::Tell[parts])
+    end
+    
+    rule :statement_set_fact do
+      f = fact_expr_primary and _(Statement::SetFact[f])
+    end
+    
+    rule :statement_if do
+      if_then = lambda {
+        _if_ and c = fact_expr and opt { comma } and _then_ and s = statement and [c, s]
+      }
+      or_delimiter = lambda {
+        opt { _{ comma } or _{ semicolon } or _{ dot } } and _or_
+      }
+      #
+      c_and_s1 = if_then.() and
+      c_and_sn = many { or_delimiter.() and if_then.() } and
+      else_a = opt { or_delimiter.() and statement } and
+      _(Statement::If[[c_and_s1, *c_and_sn], else_a.first])
+    end
+    
+    rule :statement_while do
+      _while_ and f = fact_expr and opt { comma } and s = statement and
+      _(Statement::While[f, s])
+    end
+    
+    rule :statement_for_all do
+      _for_ and all and f = fact_expr and opt { comma } and s = statement and
+      _(Statement::ForAll[f, s])
+    end
+    
+    rule :statement_n_times do
+      val = lambda {
+        _{ number } or _{ var }
+      }
+      #
+      range_begin = range_end = val.() and opt { ellipsis and range_end = val.() } and times and s = statement and
+      _(Statement::NTimes[range_begin, range_end, s])
+    end
+    
+    rule :statement_or do
+      _or_ and s1 = statement and
+      ss = many { opt { comma } and _or_ and statement } and
+      Statement::Or[[s1, *ss]]
+    end
+    
+    rule :statement_code do
+      c = _code_ and
+      act {
+        begin
+          RubyVM::InstructionSequence.compile(c)
+        rescue SyntaxError => e
+          raise Parse::Error.new(rule_start_pos, e.message)
+        end
+      } and
+      _(Statement::Code[c])
+    end
+    
+    rule :statement_compound do
+      body = lambda {
+        ss = many {
+          opt { dash } and s = statement and opt { semicolon } and s
+        } and
+        _(Statement::Compound[ss])
+      }
+      #
+      _{
+        colon and b = body.() and dot and b
+      } or
+      _{
+        lparen and b = body.() and rparen and b
+      }
+    end
+    
+    rule :fact_expr do
+      fact_expr110
+    end
+    
+    rule :fact_expr110 do
+      f = fact_expr100 and
+      many { _or_ and f2 = fact_expr100 and f = _(FactExpr::Or[f, f2]) } and
+      f
+    end
+    
+    rule :fact_expr100 do
+      f = fact_expr90 and
+      many { _and_ and f2 = fact_expr90 and f = _(FactExpr::And[f, f2]) } and
+      f
+    end
+    
+    rule :fact_expr90 do
+      _{ fact_expr80 } or
+      _{ _not_ and f = fact_expr90 and _(FactExpr::Not[f]) }
+    end
+    
+    rule :fact_expr80 do
+      _{ lparen and f = fact_expr110 and rparen and f } or
+      _{ fact_expr_select } or
+      _{ fact_expr_primary }
+    end
+    
+    rule :fact_expr_select do
+      #
+      operand = lambda { _{ var } or _{ value } }
+      #
+      v1 = operand.() and op = comparison_op and v2 = operand.() and
+      _(FactExpr::Select[v1, op, v2])
+    end
+    
+    rule :fact_expr_primary do
+      relation_id = []
+      args = []
+      negated = false
+      # 
+      one_or_more {
+        _{ s = (_{dash} or _{other_char}) and act { relation_id << s } } or
+        _{ a = asterisk and act { args << a; relation_id << :* } } or
+        _{ _not_ and act { negated = !negated } } or
+        _{ v = value and act { args << v; relation_id << :* } } or
+        _{ v = var and act { args << v; relation_id << :* } } or
+        _{ w = word and act { relation_id << w.ru_downcase } }
+      } and
+#       act { relation_id.chomp!(",") } and
+      # this is not a "statement_tell" and
+      not relation_id.all? { |p| p == :* } and
+      e = _(FactExpr::Primary[relation_id, args]) and
+      if negated then _(FactExpr::Not[e]); else e; end
+    end
+    
+    rule :value do
+      _{ string } or
+      _{ number }
+    end
+    
+    # ----------
+    # @!endgroup
+    # ----------
+    
+    # ------------------------
+    # @!group Lexical Analysis
+    # ------------------------
+    
+    # macro  
+    def self.token(method_id, human_readable_description, &body)
+      rule method_id do
+        expect(human_readable_description) {
+          no_errors {
+            r = instance_eval(&body) and wsc and r
+          }
+        }
+      end
+    end
+    
+    # macro
+    def self.simple_token(method_id, str)
+      token method_id, "`#{str}'" do
+        scan(str)
+      end
+    end
+    
+    simple_token :lparen, "("
+    simple_token :rparen, ")"
+    simple_token :comma, ","
+    simple_token :semicolon, ";"
+    simple_token :colon, ":"
+    simple_token :dot, "."
+    simple_token :dash, "-"
+    simple_token :ellipsis, "..."
+    
+    token :comparison_op, "comparison operator" do
+      scan(/=|!=|<>|<=|>=|<|>/)
+    end
+    
+    token :asterisk, "`*'" do
+      scan("*") and _(Asterisk.new)
+    end
+    
+    token :other_char, "any of `#№@$%^/'" do
+      scan(/[\#\№\@\$\%\^\/]/)
+    end
+    
+    token :_for_, "`for'" do
+      t = word_ and /^([Ff]or|[Дд]ля)$/ === t
+    end
+    
+    token :all, "`all'" do
+      t = word_ and /^(all|всех)$/ === t
+    end
+    
+    token :_while_, "`while'" do
+      t = word_ and /^([Ww]hile|[Пп]ока)$/ === t
+    end
+    
+    token :_then_, "`then'" do
+      t = word_ and /^(then|то)$/ === t
+    end
+    
+    token :_if_, "`if'" do
+      t = word_ and /^([Ii]f|[Ее]сли)$/ === t
+    end
+    
+    token :_not_, "`not'" do
+      t = word_ and /^(not|не)$/ === t
+    end
+    
+    token :_or_, "`or'" do
+      t = word_ and /^([Ee]ither|[Oo]r|[Ии]ли|[Лл]ибо)$/ === t
+    end
+    
+    token :_and_, "`and'" do
+      t = word_ and /^(and|и)$/ === t
+    end
+    
+    token :times, "`times'" do
+      t = word_ and /^(times|раза?)$/ === t
+    end
+    
+    token :number, "number" do
+      n = scan(/\d+/) and n.to_i
+    end
+    
+    token :string, "string" do
+      _{
+        scan('"') and
+        s = scan(/[^"]*/) and
+        (scan('"') or raise Error.new(rule_start_pos, "`\"' missing at the end")) and
+        s
+      } or
+      _{
+        scan("'") and
+        s = scan(/[^']*/) and
+        (scan("'") or raise Error.new(rule_start_pos, %(<<'>> missing at the end))) and
+        s
+      }
+    end
+    
+    token :_code_, "code" do
+      p = pos and
+      scan("```") and c = scan(/((?!```).)*/m) and (scan("```") or raise Parse::Error.new(p, "\"```\" missing at the end")) and
+      c
+    end
+    
+    token :var, "variable" do
+      n = word_ and
+      /^[_A-ZА-ЯЁ][_A-ZА-ЯЁ0-9]*$/ === n and
+      _(Var[n.ru_downcase, n])
+    end
+    
+    token :word, "word" do
+      not_follows(
+        :_not_, :_and_, :_or_, :_if_, :_then_, :var, :_while_, :_for_, :all,
+        :times
+      ) and
+      word_
+    end
+    
+    rule :word_ do
+      scan(/[a-zA-Zа-яёА-ЯЁ_](['\-]?[a-zA-Zа-яёА-ЯЁ0-9_]+)*/)
+    end
+    
+    rule :whitespace_and_comments do
+      many {
+        _{ ws } or
+        _{
+          p = pos and
+          scan("/*") and scan(/((?!\*\/).)*/m) and (scan("*/") or raise Error.new(p, "`*/' missing at the end"))
+        } or
+        _{
+          p = pos and
+          scan("(") and ws_opt and scan(/note|прим.|примечание/) and ws_opt and scan(":") and
+          note_comment_body and
+          (scan(")") or raise Error.new(p, "`)' missing at the end"))
+        }
+      }
+    end
+    
+    alias wsc whitespace_and_comments
+    
+    rule :whitespace do
+      scan(/\s+/)
+    end
+    
+    alias ws whitespace
+    
+    rule :whitespace_opt do
+      opt { ws }
+    end
+    
+    alias ws_opt whitespace_opt
+    
+    rule :note_comment_body do
+      many {
+        _{ scan(/[^\(\)]+/m) } or
+        _{ p = pos and scan("(") and note_comment_body and (scan(")") or raise Error.new(p, "`)' missing at the end")) }
+      }
+    end
+    
+    # ----------
+    # @!endgroup
+    # ----------
+    
+  end
+  
+end
+
+# begin
+#   puts Story.compile(<<-STORY)
+#     
+#     ```puts(a)```
+#     Either "John" loves "Liza",
+#     or ("Hello, world, again!"; "John" kisses "Liza";).
+#   STORY
+# rescue Parse::Error => e
+#   puts "error: #{e.pos.file}:#{e.pos.line}:#{e.pos.column}: #{e.message}"
+# # rescue Story::Error => e
+# #   puts "error: #{e.pos.file}:#{e.pos.line}:#{e.pos.column}: #{e.message}"
+# end