story-gen 0.0.1

data/lib/enumerable/empty.rb

@@ -0,0 +1,10 @@
+
+module Enumerable
+  
+  # @return [Boolean]
+  def empty?
+    each { |_| return false }
+    return true
+  end
+  
+end

data/lib/enumerable/lazy.rb

@@ -0,0 +1,10 @@
+
+module Enumerable
+  
+  if RUBY_VERSION <= '2.0.0' then
+    def lazy
+      self  # just for compatibility :-[
+    end
+  end
+
+end

data/lib/enumerable/new.rb

@@ -0,0 +1,30 @@
+
+module Enumerable
+  
+  # @param [Proc<Proc<Object, void>, void>] each
+  # @return [Enumerable] an {Enumerable} which has +each+ as implementation
+  #   of its {Enumerable#each}.
+  def self.new(&each)
+    ProcAsEnumerable.new(&each)
+  end
+  
+  private
+  
+  # @!visibility private
+  class ProcAsEnumerable
+    
+    include Enumerable
+    
+    # @param [Proc<Proc<Object, void>, void>] each
+    def initialize(&each)
+      @each = each
+    end
+    
+    # (see Enumerable#each)
+    def each(&block)
+      @each.(block)
+    end
+    
+  end
+
+end

data/lib/enumerable/sample.rb

@@ -0,0 +1,8 @@
+
+module Enumerable
+  
+  def sample
+    to_a.sample
+  end
+  
+end

data/lib/fact.rb

@@ -0,0 +1,333 @@
+require 'set'
+require 'enumerable/lazy'
+require 'enumerable/new'
+require 'hash/put'
+
+class Fact
+  
+  # @param [Object] relation_id
+  # @param [*(:'*' | Symbol | Object)] args
+  # @return [Fact]
+  def self.[](relation_id, *args)
+    select = []; remove = []; map = []; arg_names = []; can_add = true
+    begin
+      known_var_index = {}
+      args.zip(0...args.size).
+        each do |arg, i|
+          case arg
+          when :'*' then
+            can_add = false
+          when Symbol then
+            var = arg
+            if known_var_index.has_key? var then
+              select << (x = "arg_values[#{known_var_index[var]}] == arg_values[#{i}]")
+              remove << x
+            else
+              map << "arg_values[#{i}]"
+              arg_names << var
+              known_var_index[var] = i
+            end
+            can_add = false
+          when Object then
+            select << (x = "args[#{i}] == arg_values[#{i}]")
+            remove << x
+          end
+        end
+      select =
+        if select.empty?
+        then ""
+        else "select { |arg_values| #{select.join(" and ")} }."
+        end
+      remove =
+        if remove.empty? then ".clear"
+        else ".reject! { |arg_values| #{reject.join(" and ")} }"
+        end
+      map =
+        "map { |arg_values| [#{map.join(", ")}] }"
+    end
+    Fact.new(
+      arg_names,
+      eval(
+        "lambda do |context| "+
+          "context[relation_id]."+
+            "lazy."+
+            select +
+            map +
+        " end "
+      ),
+      if can_add then
+        lambda { |context| context[relation_id].add(args) }
+      else
+        nil
+      end,
+      eval("lambda { |context| context[relation_id]#{remove} }")
+    )
+  end
+  
+  # @!visibility private
+  def initialize(arg_names, arg_valuess_f, true_f = nil, false_f = nil)
+    @arg_names = arg_names
+    @arg_valuess_f = arg_valuess_f
+    @true_f = true_f
+    @false_f = false_f
+  end
+  
+  # @return [Array<Symbol>]
+  attr_reader :arg_names
+  
+  # @param [Context] context
+  # @return [Enumerable<Array<Object>>] values of named arguments passed to
+  #   {Fact::[]} which this {Fact} is {#true?} for (in the +context+).
+  def arg_valuess(context)
+    @arg_valuess_f.(context)
+  end
+  
+  # makes this {Fact} to be {#true?} in +context+.
+  # 
+  # It modifies +context+. It is not applicable to some {Fact}s.
+  # 
+  # @param [Context] context
+  # @return [void]
+  # 
+  def true!(context)
+    raise "not applicable" unless @true_f
+    @true_f.(context)
+  end
+  
+  # @param [Context] context
+  # @return [Boolean]
+  def true?(context)
+    not false?(context)
+  end
+  
+  # makes this {Fact} to be {#false?} in +context+.
+  # 
+  # It modifies +context+. It is not applicable to some {Fact}s.
+  # 
+  # @param [Context] context
+  # @return [void]
+  # 
+  def false!(context)
+    raise "not applicable" unless @false_f
+    @false_f.(context)
+  end
+  
+  # @param [Context] context
+  # @return [Boolean]
+  def false?(context)
+    arg_valuess.(context).empty?
+  end
+  
+  # -------------------
+  # @!group Combinators
+  # -------------------
+  
+  # @param [Fact, Fact::Not, Fact::Select] f2
+  # @return [Fact]
+  def & f2
+    case f2
+    when Fact::Select
+      if not (s = f2.arg_names - f1.arg_names).empty? then
+        raise "#{s.map(&:to_s).join(", ")} in the right part is/are not known in the left part"
+      end
+      Fact.new(
+        f1.arg_names,
+        lambda { |context| f1.arg_valuess(context).select(&f2.criteria) }
+      )
+    when Fact::Not
+      common_arg_names = f1.arg_names & f2.subfact.arg_names
+      if common_arg_names.empty? then
+        Fact.new(
+          f1.arg_names,
+          lambda do |context|
+            if f2.subfact.true?(context) then []
+            else f1.arg_valuess(context)
+            end
+          end
+        )
+      else
+        Fact.new(
+          f1.arg_names,
+          eval(
+            "lambda do |context| "+
+              "f1.arg_valuess(context).select do |f1_arg_values| "+
+                "not (" +
+                  "f2.subfact.arg_valuess(context).any? do |f2_subfact_arg_values| "+
+                    common_arg_names.
+                      map do |arg_name|
+                        "f1_arg_values[#{f1.arg_indexes[arg_name]}] == f2_subfact_arg_values[#{f2.subfact.arg_indexes[arg_name]}]"
+                      end.
+                      join(" and ") + " " +
+                  "end "+
+                ") "+
+              "end " +
+            "end "
+          )
+        )
+      end
+    when Fact
+      arg_names = f1.arg_names | f2.arg_names
+      select = []; map = []; begin
+        arg_names.each do |arg_name|
+          if f1.arg_indexes.key?(arg_name) and f2.arg_indexes.key?(arg_name) then
+            select << "f1_arg_values[#{f1.arg_indexes[arg_name]}] == f2_arg_values[#{f2.arg_indexes[arg_name]}]"
+            map << "f1_arg_values[#{f1.arg_indexes[arg_name]}]"
+          elsif f1.arg_indexes.key?(arg_name) then
+            map << "f1_arg_values[#{f1.arg_indexes[arg_name]}]"
+          elsif f2.arg_indexes.key?(arg_name) then
+            map << "f2_arg_values[#{f2.arg_indexes[arg_name]}]"
+          end
+        end
+        select =
+          if select.empty? then "true"
+          else "#{select.join(" and ")}"
+          end
+        map =
+          "[#{map.join(", ")}]"
+      end
+      Fact.new(
+        arg_names,
+        eval(
+          "lambda do |context| "+
+            "Enumerable.new do |block| "+
+              "f1.arg_valuess(context).each do |f1_arg_values| "+
+                "f2.arg_valuess(context).each do |f2_arg_values| "+
+                  "if #{select} then "+
+                    "block.(#{map}) "+
+                  "end "+
+                "end "+
+              "end "+
+            "end "+
+          "end "
+        )
+      )
+    end
+  end
+  
+  # @param [Fact] f2
+  # @return [Fact]
+  def | f2
+    arg_names = f1.arg_names | f2.arg_names
+    map1 = nil; map2 = nil; begin
+      map = lambda do |arg_indexes|
+        eval "lambda do |arg_values|
+          [#{
+            arg_names.map do |arg_name|
+              if arg_indexes.key?(arg_name) then
+                "arg_values[#{arg_indexes[arg_name]}]"
+              else
+                "nil"
+              end
+            end.
+            join(", ")
+          }]
+        end"
+      end
+      map1 = map.(f1.arg_indexes)
+      map2 = map.(f2.arg_indexes)
+    end
+    Fact.new(
+      arg_names,
+      lambda do |context|
+        Enumerable.new do |block|
+          f1.arg_valuess(context).map(&map1).each(&block)
+          f2.arg_valuess(context).map(&map2).each(&block)
+        end
+      end
+    )
+  end
+  
+  # @return [Fact::Not]
+  def !@
+    Fact::Not.new(self)
+  end
+  
+  class Not
+    
+    # @param [Fact] subfact
+    def initialize(subfact)
+      raise "#{Fact} is expected" unless subfact.is_a? Fact
+      @subfact = subfact
+    end
+    
+    # @return [Fact]
+    attr_reader :subfact
+    
+  end
+  
+  class Select
+    
+    # @param [*Symbol] arg_names
+    # @param [Proc<*Object, Boolean>] criteria
+    def initialize(*arg_names, &criteria)
+      @arg_names = arg_names
+      @criteria = criteria
+    end
+    
+    # @return [Array<Symbol>]
+    attr_reader :arg_names
+    
+    # @return [Proc<*Object, Boolean>]
+    attr_reader :criteria
+    
+  end
+  
+  # ----------
+  # @!endgroup
+  # ----------
+  
+  # 
+  class Context
+    
+    def initialize()
+      @arg_valuesss = Hash.new { |arg_valuesss, name| arg_valuesss[name] = Set.new }
+    end
+    
+    # @api private
+    # @note used by {Fact} only
+    # 
+    # @param [Object] relation_id
+    # @return [Set<Array<Object>>]
+    def [](relation_id)
+      @arg_valuesss[relation_id]
+    end
+    
+  end
+  
+  protected
+  
+  # @!visibility private
+  # 
+  # @return [Hash<Symbol, Integer>]
+  # 
+  def arg_indexes
+    arg_names.zip(0...arg_names.size).reduce({}) do |h, arg_name_and_arg_index|
+      arg_name, arg_index = *arg_name_and_arg_index
+      h.put(arg_name, arg_index)
+    end
+  end
+  
+  private
+  
+  def f1
+    self
+  end
+  
+end
+
+# ctx = Fact::Context.new
+# Fact["loves", "John", "Liza"].true!(ctx)
+# Fact["yiffs", "Sam", "Liza"].true!(ctx)
+# Fact["yiffs", "John", "Liza"].true!(ctx)
+# Fact["loves", "John", "Johanna"].true!(ctx)
+# p((Fact["loves", :x, :y] & Fact["yiffs", :x, :'*']).arg_valuess(ctx).to_a)
+# p((Fact["loves", :x, :y] | Fact["yiffs", :x, :y]).arg_valuess(ctx).to_a)
+# p((Fact["loves", :x, :y] & !Fact["yiffs", :'*', :y]).arg_valuess(ctx).to_a)
+# x = Fact["loves", :x, :y] & Fact::Select.new(:x, :y) { |x, y| x != "John" }
+# p x.arg_names
+# p x.arg_valuess(ctx).to_a
+# Fact["loves", "Kris", "Diana"].true!(ctx)
+# Fact["loves", "John", :'*'].false!(ctx)
+# p x.arg_names
+# p x.arg_valuess(ctx).to_a
+# Fact["loves", :x, :y].arg_valuess(ctx).to_a

data/lib/hash/put.rb

@@ -0,0 +1,14 @@
+
+class Hash
+  
+  # 
+  # Alias for {Hash#[]=}.
+  # 
+  # @return [Hash] self.
+  # 
+  def put(key, value)
+    self[key] = value
+    self
+  end
+  
+end

data/lib/object/map_.rb

@@ -0,0 +1,9 @@
+
+class Object
+  
+  # @return [Object] result of +f+ applied to self.
+  def map_(&f)
+    f.(self)
+  end
+  
+end

data/lib/object/to_rb.rb

@@ -0,0 +1,9 @@
+
+class Object
+  
+  # @return [String] a {String} x which {Kernel#eval}(x).equal?(self).
+  def to_rb
+    inspect
+  end
+  
+end

data/lib/parse.rb

@@ -0,0 +1,463 @@
+require 'strscan'
+require 'strscan/substr'
+
+# To disable YARD warnings:
+# @!parse
+#   class Exception
+#     def message
+#     end
+#   end
+#   class Array
+#   end
+#   class String
+#   end
+
+class Parse
+  
+  # 
+  # parses +text+.
+  # 
+  # @param [String] text
+  # @param [String] file file the +text+ is taken from.
+  # @raise [Parse::Error, IOError]
+  # @return [Object] what {#start} returns (non-nil).
+  # 
+  def call(text, file = "-")
+    @text = StringScanner.new(text)
+    @file = file
+    @most_probable_error = nil
+    @allow_errors = true
+    @rule_start_pos = nil
+    r = start()
+    if r.nil? or not @text.eos? then
+      if @most_probable_error
+      then raise @most_probable_error
+      else raise Error.new(Position.new(@text.pos, @text), "syntax error")
+      end
+    end
+    return r
+  end
+  
+  class Position
+    
+    include Comparable
+    
+    # @api private
+    # @note used by {Parse#pos} only
+    # @param [Integer] text_pos
+    # @param [StringScanner] text
+    # @param [String] file
+    def initialize(text_pos, text, file)
+      @text = text
+      @text_pos = text_pos
+      @file = file
+    end
+    
+    # @return [String]
+    attr_reader :file
+    
+    # @return [Integer]
+    def line
+      line_and_column[0]
+    end
+    
+    # @return [Integer]
+    def column
+      line_and_column[1]
+    end
+    
+    # @param [Object] other
+    # @return [-1, 0, 1, nil]
+    def <=> other
+      return nil unless other.is_a? Position and self.text.equal? other.text
+      self.text_pos <=> other.text_pos
+    end
+    
+    # @param [Object] other
+    # @return [Boolean]
+    def == other
+      (self <=> other) == 0
+    end
+    
+    # @!visibility private
+    attr_reader :text_pos
+    
+    # @!visibility private
+    attr_reader :text
+    
+    private
+    
+    def line_and_column
+      @line_and_column ||= begin
+        s = @text.substr(0, @text_pos)
+        lines = s.split("\n", -1).to_a
+        [
+          line = if lines.size == 0 then 0 else lines.size - 1 end,
+          column = (lines.last || "").size
+        ].tap do
+          @text = nil
+        end
+      end
+    end
+    
+  end
+  
+  class Error < Exception
+    
+    # @param [Position] pos
+    # @param [String] message
+    def initialize(pos, message)
+      super(message)
+      @pos = pos
+    end
+    
+    # @return [Position]
+    attr_reader :pos
+    
+    # @param [Error] other +self+.{#pos} must be equal to +other+.{#pos}.
+    # @return [Error] an {Error} with {Exception#message} combined from
+    #   {Exception#message}s of +self+ and +other+ (using "or" word).
+    def or other
+      raise "#{self.pos} == #{other.pos} is false" unless self.pos == other.pos
+      Error.new(pos, "#{self.message} or #{other.message}")
+    end
+    
+  end
+  
+  class Expected < Error
+    
+    # @param [Position] pos
+    # @param [String] what_1
+    # @param [*String] what_2_n
+    def initialize(pos, what_1, *what_2_n)
+      @what = [what_1, *what_2_n]
+      super(pos, "#{@what.join(", ")} expected")
+    end
+    
+    # (see Error#or)
+    def or other
+      if other.is_a? Expected
+        raise "#{self.pos} == #{other.pos} is false" unless self.pos == other.pos
+        Expected.new(pos, *(self.what + other.what).uniq)
+      else
+        super(other)
+      end
+    end
+    
+    protected
+    
+    # @!visibility private
+    # @return [Array<String>]
+    attr_reader :what
+    
+  end
+  
+  protected
+  
+  # @!method start()
+  #   @abstract
+  #   
+  #   Implementation of {#call}. Or the starting rule.
+  #   
+  #   @return [Object, nil] a result of parsing or nil if the parsing failed.
+  #   @raise [Parse::Error] if the parsing failed.
+  #   @raise [IOError]
+  #   
+  
+  # @return [Position] current {Position} in +text+ passed to {#call}.
+  def pos
+    Position.new(@text.pos, @text, @file)
+  end
+  
+  # 
+  # scans +arg+ in +text+ passed to {#call} starting from {#pos} and,
+  # if scanned successfully, advances {#pos} and returns the scanned
+  # sub-{String}. Otherwise it calls {#expected} and returns nil.
+  # 
+  # @param [String, Regexp] arg
+  # @return [String, nil]
+  # 
+  def scan(arg)
+    case arg
+    when Regexp then @text.scan(arg) or expected(pos, %(regexp "#{arg.source}"))
+    when String then @text.scan(Regexp.new(Regexp.escape(arg))) or expected(pos, %("#{arg}"))
+    end
+  end
+  
+  # defines method +name+ with body +body+. Inside +body+ {#rule_start_pos}
+  # is the value of {#pos} right before the defined method's call.
+  # 
+  # @param [Symbol] name
+  # @return [void]
+  # 
+  def self.rule(name, &body)
+    define_method(name) do
+      old_rule_start_pos = @rule_start_pos
+      @rule_start_pos = pos
+      begin
+        instance_eval(&body)
+      ensure
+        @rule_start_pos = old_rule_start_pos
+      end
+    end
+  end
+  
+  # See {Parse::rule}.
+  # 
+  # @return [Position]
+  # 
+  attr_reader :rule_start_pos
+  
+  # @param [ASTNode] node
+  # @return [ASTNode] +node+ which is
+  #   {ASTNode#initialize_pos}({#rule_start_pos})-ed.
+  def _1(node)
+    node.initialize_pos(rule_start_pos)
+  end
+  
+  # is {#pos} at the end of the text?
+  def end?
+    @text.eos?
+  end
+  
+  alias eos? end?
+  
+  # is {#pos} at the beginning of the text?
+  def begin?
+    @text.pos == 0
+  end
+  
+  # alias for {#_1} and {#_2}
+  def _(arg = nil, &block)
+    if arg
+    then _1(arg)
+    else _2(&block)
+    end
+  end
+  
+  # --------------------------
+  # @!group Parser Combinators
+  # --------------------------
+  
+  # calls +f+ and returns true.
+  # 
+  # @return [true]
+  def act(&f)
+    f.()
+    true
+  end
+  
+  #   
+  # calls +f+. If +f+ results in nil then it restores {#pos} to the
+  # value before the call.
+  # 
+  # @return what +f+ returns.
+  # 
+  def _2(&f)
+    old_text_pos = @text.pos
+    f.() or begin
+      @text.pos = old_text_pos
+      nil
+    end
+  end
+  
+  # calls +f+ using {#_2} many times until it returns nil.
+  # 
+  # @return [Array] an {Array} of non-nil results of +f+.
+  # 
+  def many(&f)
+    r = []
+    while true
+      f0 = _(&f)
+      if f0
+      then r.push(f0)
+      else break
+      end
+    end
+    r
+  end
+  
+  # calls +f+ using {#_2}.
+  # 
+  # @return [Array] an empty {Array} if +f+ results in nil and an {Array}
+  #   containing the single result of +f+ otherwise.
+  # 
+  def opt(&f)
+    [_(&f)].compact
+  end
+  
+  # The same as <code>f.() and many(&f)</code>.
+  # 
+  # @return [Array, nil] an {Array} of results of +f+ or nil if the first call
+  #   to +f+ returned nil.
+  # 
+  def one_or_more(&f)
+    f1 = f.() and f2_n = many(&f) and [f1, *f2_n]
+  end
+  
+  alias many1 one_or_more
+  
+  # @overload not_follows(*method_ids)
+  #   
+  #   calls methods specified by +method_ids+. If any of them returns non-nil
+  #   then this method returns nil, otherwise it returns true. The methods
+  #   are called inside {#no_errors}. {#pos} is restored after each method's
+  #   call.
+  #   
+  #   @param [Array<Symbol>] method_ids
+  #   @return [true, nil]
+  #   
+  # @overload not_follows(&f)
+  # 
+  #   calls +f+. If +f+ returns non-nil then this method returns nil,
+  #   otherwise it returns true. +f+ is called inside {#no_errors}.
+  #   {#pos} is restored after +f+'s call.
+  #   
+  #   @return [true, nil]
+  # 
+  def not_follows(*method_ids, &f)
+    if f then
+      if no_errors { _{ f.() } }
+      then nil
+      else true
+      end
+    else # if not method_ids.empty? then
+      if no_errors { method_ids.any? { |method_id| _{ __send__(method_id) } } }
+      then nil
+      else true
+      end
+    end
+  end
+  
+  # ----------
+  # @!endgroup
+  # ----------
+  
+  # --------------
+  # @!group Errors
+  # --------------
+  
+  # 
+  # sets {#most_probable_error} to +error+ if it is more probable than
+  # {#most_probable_error} or if {#most_probable_error} is nil.
+  # 
+  # @param [Error] error
+  # @return [nil]
+  # 
+  def error(error)
+    if @allow_errors then
+      if @most_probable_error.nil? or @most_probable_error.pos < error.pos then
+        @most_probable_error = error
+      elsif @most_probable_error and @most_probable_error.pos == error.pos then
+        @most_probable_error = @most_probable_error.or error
+      else
+        # do nothing
+      end
+    end
+    return nil
+  end
+  
+  # macro
+  def expected(pos, what_1, *what_2_n)
+    error(Expected.new(pos, what_1, *what_2_n))
+  end
+  
+  # macro
+  def expect(what_1, *what_2_n, &body)
+    p = pos and body.() or expected(p, what_1, *what_2_n)
+  end
+  
+  # calls +block+. Inside the +block+ {#error} has no effect.
+  # 
+  # @return what +block+ returns.
+  # 
+  def no_errors(&block)
+    old_allow_errors = @allow_errors
+    begin
+      @allow_errors = false
+      block.()
+    ensure
+      @allow_errors = old_allow_errors
+    end
+  end
+  
+  # @return [Error, nil]
+  attr_reader :most_probable_error
+  
+  # ----------
+  # @!endgroup
+  # ----------
+  
+end
+
+module ASTNode
+  
+  # macro
+  def self.new(*properties, &body)
+    (if properties.empty? then Class.new else Struct.new(*properties); end).tap do |c|
+      c.class_eval do
+        
+        include ASTNode
+        
+        # @return [Boolean]
+        def === other
+          self.class == other.class and
+          self.members.all? { |member| self.__send__(member) === other.__send__(member) }
+        end
+        
+        if properties.empty? then
+          # @return [Array<Symbol>]
+          def members
+            []
+          end
+        end
+        
+      end
+      c.class_eval(&body) if body
+    end
+  end
+  
+  # @param [Parse::Position] pos
+  # @return [self]
+  def initialize_pos(pos)
+    @pos = pos
+    self
+  end
+  
+  # @note {#initialize_pos} must be called before this method can be used.
+  # @return [Parse::Position]
+  def pos
+    raise "initialize_pos() must be called before this method can be used" unless @pos
+    @pos
+  end
+  
+end
+
+# Alias for {ASTNode#new}.
+def node(*properties, &body)
+  ASTNode.new(*properties, &body)
+end
+
+# class Calc < Parse
+#   
+#   Number = ASTNode.new :val
+#   
+#   rule :start do
+#     x1 = number and x2 = many { comma and number } and [x1, *x2]
+#   end
+#   
+#   rule :number do
+#     s = scan(/\d+/) and _(Number[s])
+#   end
+#   
+#   rule :comma do
+#     scan(",")
+#   end
+#   
+# end
+# 
+# begin
+#   p Calc.new.("10, 20", __FILE__)
+# rescue Parse::Error => e
+#   puts "error: #{e.pos.file}:#{e.pos.line}:#{e.pos.column}: #{e.message}"
+# end