story-gen 0.0.1

data/README.md

@@ -0,0 +1,259 @@
+Story Generator
+===============
+
+Generate stories from descriptions written in Story Description Language (see below)!
+
+Install
+-------
+
+Story Generator is a Ruby Gem, so simply install it with `gem install story-gen`. Of course you also need [Ruby](https://www.ruby-lang.org) >= 1.9.3!
+
+Usage
+-----
+
+    story file.sdl
+    
+Read story description from "file.sdl", generate a story and write it to stdout.
+    
+    story -c -n MyStory -o file.rb file.sdl
+
+Read story description from "file.sdl" and write a class MyStory to "file.rb". The class MyStory subclasses Story (see docs) and can be used like this: `MyStory.new.write()`.
+    
+    story --help
+
+More help on `story`.
+
+Story Description Language (SDL)
+--------------------------------
+
+A simple story:
+
+    "Hello, world!"
+    
+It just prints "Hello, world!". No escape sequences for you, thus, for example, to start a new chapter you need to write something like this:
+
+    "
+    Chapter I
+    ---------
+    "
+
+You may use single quotes as well:
+
+    'Hello, world!'
+
+Comments:
+
+    "Hello, world!" (note: a comment, "literal" style)
+    /* a comment, C style */
+
+A story is based on Facts. To state a Fact just write it:
+
+    "John" loves "Liza"
+
+In the Fact expression you may use english and russian words (except keywords, see below), characters from "#№@$%^/-", integer numbers (e.g., `18`) and arbitrary double- or single-quoted strings (`"..."` or `'...'`). Trailing commas are ignored (`xxx yyy zzz,` is the same as `xxx yyy zzz`). The words are case-insensitive (so `loves` and `Loves` mean the same), quoted strings are case-sensitive (so `"John"`≠`"JOHN"`).
+
+Let's state some Facts:
+
+    "John" is a boy;
+    "Sam" is a boy;
+    "Liza" is a girl;
+    "Sabrina" is a girl;
+    "John" loves "Liza";
+
+Statements in the story are separated with a semicolon (";"). The semicolon is optional if its absence does not cause an ambiguity, so the following is valid too:
+
+    "John" is a boy;
+    "Sam" is a boy;
+    "Liza" is a girl;
+    "Sabrina" is a girl;
+    "John" loves "Liza"
+
+What can Facts be used for? You may form conditions with them:
+
+    If X is a boy then "Let's meet " X;
+
+Here `X` is a variable. Variable names consist of underscores ("_") and capital letters only (e.g., `LONG_VARIABLE_NAME`). You may only capture quoted strings or numbers as variables, so the following condition is invalid:
+
+    If "John" A "Liza" then ...  /* ERROR! */
+
+You may use the captured variables in the statement after `then` keyword.
+
+To print the captured variable you just write it along with some quoted string: 
+
+    "Let's meet " X;
+
+But wait... We have two boys! What does `if` choose as `X` then? The answer is: random. If there are several combinations of variables which fit the condition then a random combination is chosen.
+
+You may form complex Fact expressions using `and`, `or` and `not` keywords and parentheses:
+
+    If X is a boy and Y is a girl then X" meets "Y"!"
+    
+    If (X is a boy) and (Y is a girl) then X" meets "Y"!"
+    
+    If X is a boy and Y is a girl and not X loves Y then
+      X" meets "Y"!"
+
+The `not` keyword may also be written inside the Fact:
+
+    If X is a boy and Y is a girl and X not loves Y then
+      X" meets "Y"!"
+
+Not all combinations of `and`, `or` and `not` are available, though. Use common sense to find out which one are. For example, this is an error:
+
+    If X is not a boy then "How can I determine "X"?"  /* ERROR! */
+
+You may also compare variables in the condition:
+
+    If X is a boy and Y is a boy and X != Y then
+      X" and "Y" are two different boys!"
+
+There are limitations on the comparison: the comparison must be after the `and` keyword and all variables must be mentioned in the left part of `and`.
+
+You may use `=`, `!=`, `<>`, `<=`, `<`, `>` and `>=` as comparison operators. Take types of the comparands into account, though!
+
+You may use asterisk ("*") instead of the variable to avoid capturing:
+
+    If X is a boy and X not loves * then
+      X" is a lonely boy."
+
+You may combine several `if`-s with `or` keyword:
+
+    If X is a boy then
+      "We have found a boy "X"!"
+    or if Y is a girl then
+      "We have found a girl "Y"!"
+
+Or combine `if`-s with some statement:
+
+    If X is a boy then
+      "We know a boy "X"!"
+    or if Y is a girl then
+      "We know a girl "Y"!"
+    or
+      "We do not know anyone."
+
+This is like a classical `if ... else if ... else ...` but if multiple conditions are true then random one is chosen (instead of the first one, like in the classical `if-else`). The last `or` is the same as `else` in the classical `if-else` - it is chosen if all conditions are false.
+
+You may use captured variables to state a Fact:
+
+    If X is a boy and Y is a girl then
+      X loves Y
+
+You may set the Fact false:
+
+    If X loves Y then
+      X not loves Y
+    
+Set multiple Facts false:
+
+    If X is a boy then
+      X not loves *
+    
+To combine several statements into one use a colon (":") with the final dot ("."):
+
+    If X is a boy then:
+      "Let's meet " X "!";
+      X " is a boy!".
+
+or parentheses:
+    
+    If X is a boy then (
+      "Let's meet " X "!";
+      X " is a boy!";
+    )
+
+There are other statements you can use:
+
+- "While":
+    
+  <pre><code>
+  While &lt;fact expression&gt; [,] &lt;statement&gt;
+  </code></pre>
+
+  Here &lt;fact expression&gt; is the same as in `if` statement except that you may use `not` in top level:
+  
+  <pre><code>
+  While X not loves *:
+    If X is a boy Y is a girl then X loves Y.
+  </code></pre>
+
+  The variables from &lt;fact expression&gt; are not available in &lt;statement&gt;
+
+- "Repeat n times":
+    
+  <pre><code>
+  10 times "Hello!"         (note: print "Hello!" 10 times)
+  10...20 times "Hello!"    (note: random number between 10 and 20 is
+                            chosen)
+  X times "Hello!"          (note: the value of the captured variable X
+                            is used)
+  X...Y times "Hello!"      (note: the value between two captured variables
+                            is used)
+  </code></pre>
+    
+- "For all":
+    
+  <pre><code>
+  For all &lt;fact expression&gt; [,] &lt;statement&gt;
+  </code></pre>
+    
+  &lt;statement&gt; is executed for all combinations of variables in &lt;fact expression&gt;. The &lt;fact expression&gt; is like in `if` statement.
+  
+- Ruby code:
+  
+  <pre><code>
+  ```puts(x); puts(y)```
+  </code></pre>
+  
+  Inside the code you can access the captured variables by their lowercase names:
+    
+  <pre><code>
+  If X loves Y then
+    ```puts(x); puts(y)```
+  </code></pre>
+
+- "Either ... or ...":
+  
+  <pre><code>
+  either &lt;statement&gt; [,]
+  or &lt;statement&gt; [,]
+  or &lt;statement&gt;
+  ...
+  </code></pre>
+    
+  A random &lt;statement&gt; is chosen and executed.
+
+### Notes ###
+
+`(note: ...)` comment may have nested parentheses:
+
+    (note: this is a comment (with nested parentheses)!)
+
+Top-level statements may also be delimited with dot ("."):
+
+    "John" is a boy.
+    "Sam" is a boy.
+    "Liza" is a girl.
+    "Sabrina" is a girl.
+    "John" loves "Liza".
+
+"If" statement may include a comma before `then` and `or`:
+    
+    If X is a boy, then "we know "X,
+    or if Y is a girl, then "we know "Y
+
+There is another form of the statements combination:
+
+    if X is a boy then:
+      - "We know "X;
+      - X" is a good boy";
+      - X" is glad to meet you".
+
+Keywords `if`, `either`, `or`, `for` (in `for all`) and `while` may start with a capital letter: `If`, `Either` etc.
+
+You may also use russian keywords! ;)
+
+Examples
+--------
+
+See them in "sample" directory!

data/bin/story

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+require 'story/compile'
+require 'optparse'
+
+$output_file = nil
+$input_file = nil
+$story_class_name = nil
+$process = lambda do |story_class_code, output|
+  # execute the story
+  story_class = eval story_class_code
+  story = story_class.new
+  begin
+    story.write(output)
+  rescue Story::Error => e
+    abort "error: #{e.pos.file}:#{e.pos.line+1}:#{e.pos.column+1}: #{e.message}"
+  end
+end
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename(__FILE__)} [options] [file]"
+  opts.separator ""
+  opts.separator "If `file' is omitted then the story is read from stdin."
+  opts.separator ""
+  opts.separator "Options:"
+  opts.on "-c", "--compile", "Compile only, do not execute the story" do
+    $process = lambda do |story_class_code, output|
+      output.write story_class_code
+    end
+  end
+  opts.on "-o", "--output FILE", "Write to FILE instead of stdout" do |file|
+    $output_file = file
+  end
+  opts.on "-n", "--class NAME", "Produce a class named NAME inheriting Story",
+                                "instead of an anonymous class" do |name|
+    $story_class_name = name
+  end
+  opts.on "-r", "--show-relations", "Show relations mentioned in the story" do
+    $process = lambda do |story_class_code, output|
+      story_class = eval story_class_code
+      story = story_class.new
+      story.relations.each { |relation| output.puts relation }
+    end
+  end
+  opts.on "-h", "--help", "Show this message and exit" do
+    puts opts
+    exit
+  end
+end.parse!
+if not ARGV.empty? then $input_file = ARGV.shift; end
+abort "unknown argument: #{ARGV.first}" unless ARGV.empty?
+
+begin
+  input_text =
+    if $input_file
+    then File.read($input_file)
+    else STDIN.read
+    end
+  story_class_code =
+    begin
+      Story.compile(input_text, $input_file || "-")
+    rescue Parse::Error => e
+      abort "error: #{e.pos.file}:#{e.pos.line+1}:#{e.pos.column+1}: #{e.message}"
+    end
+  if $story_class_name then
+    story_class_code = <<-CODE
+      #{$story_class_name} = begin
+        #{story_class_code}
+      end
+    CODE
+  end
+  output =
+    if $output_file
+    then File.open($output_file, "w")
+    else STDOUT
+    end
+  begin
+    $process.(story_class_code, output)
+  ensure
+    output.close()
+  end
+rescue IOError => e
+  abort "error: #{e.message}"
+end

data/gem.gemspec

@@ -0,0 +1,13 @@
+
+Gem::Specification.new do |s|
+  s.name        = 'story-gen'
+  s.version     = '0.0.1'
+  s.date        = '2016-01-10'
+  s.summary     = "Story generator"
+  s.description = "Generate stories from descriptions based on Facts!"
+  s.authors     = ["Various Furriness"]
+  s.email       = 'various.furriness@gmail.com'
+  s.files       = Dir["lib/**/*.rb"] + ["README.md", "gem.gemspec"] + Dir["sample/*"]
+  s.executables = Dir["bin/*"].map { |f| File.basename(f) }
+  s.license     = 'MIT'
+end

data/lib/any.rb

@@ -0,0 +1,11 @@
+
+# To disable YARD warnings:
+# @!parse
+#   class Object
+#     def === other; end
+#   end
+
+# @return [Object] an {Object} which is {Object#===} to anything.
+def any
+  Object
+end

data/lib/array/case_equal_fixed.rb

@@ -0,0 +1,9 @@
+
+class Array
+  
+  def === other
+    self.size == other.size and
+      self.zip(other).all? { |e1, e2| e1 === e2 }
+  end
+  
+end

data/lib/array/chomp.rb

@@ -0,0 +1,21 @@
+
+class Array
+  
+  # if +item+ == {Array#last} then {Array#pop}s it; otherwise do nothing
+  # 
+  # @return [self]
+  # 
+  def chomp!(item)
+    self.pop if item == self.last
+    return self
+  end
+  
+  # @return [Array] copy of this {Array} processed as per {#chomp!}.
+  def chomp(item)
+    self.dup.chomp!(item)
+  end
+  
+end
+
+# p [1, 2, 3].chomp(3)
+# p [1, 2, 3].chomp(2)

data/lib/array/separate.rb

@@ -0,0 +1,10 @@
+
+class Array
+  
+  # @param [Object, nil] separator
+  # @return [Array] [self_1, separator, self_2, separator, ..., self_n].
+  def separate(separator)
+    (self.map { |item| [item, separator] }.reduce(:concat) or [1])[0...-1]
+  end
+  
+end

data/lib/array/to_h.rb

@@ -0,0 +1,9 @@
+
+class Array
+  
+  # @return [Hash]
+  def to_h
+    self.reduce({}) { |h, e| h[e.first] = e.last; h }
+  end
+  
+end

data/lib/code.rb

@@ -0,0 +1,123 @@
+
+class Code
+  
+  # @api private
+  # @note used by {Code}, {::code}, {::non_code} only.
+  # 
+  # @param [Array<String, NonCodePart>] parts
+  # @param [Object, nil] metadata
+  # 
+  def initialize(parts, metadata = nil)
+    @parts = parts
+    @metadata = metadata
+  end
+  
+  # @overload + str
+  #   @param [String] str
+  #   @return [Code]
+  # @overload + code
+  #   @param [Code] code
+  #   @return [Code]
+  def + arg
+    case arg
+    when String then self + Code.new([arg])
+    when Code then Code.new(self.parts + arg.parts)
+    end
+  end
+  
+  # @overload << str
+  #   Appends +str+ to self.
+  #   @param [String] str
+  #   @return [self]
+  # @overload << code
+  #   Appends +str+ to self.
+  #   @param [Code] code
+  #   @return [self]
+  def << arg
+    case arg
+    when String then self << Code.new([arg])
+    when Code then @parts.concat(arg.parts); self
+    end
+  end
+  
+  # @overload metadata(obj)
+  #   @param [Object] obj
+  #   @return [Code] a {Code} with +obj+ attached to it. The +obj+ can later
+  #     be retrieved with {#metadata}().
+  # @overload metadata
+  #   @return [Object, nil] an {Object} attached to this {Code} with
+  #     {#metadata}(obj) or nil if no {Object} is attached.
+  def metadata(*args)
+    if args.empty?
+    then @metadata
+    else Code.new(@parts, args.first)
+    end
+  end
+  
+  # @yieldparam [Object] part
+  # @yieldreturn [String]
+  # @return [Code] a {Code} with {#non_code_parts} mapped by the passed block.
+  def map_non_code_parts(&f)
+    Code.new(
+      @parts.map do |part|
+        case part
+        when String then part
+        when NonCodePart then f.(part.data)
+        end
+      end
+    )
+  end
+  
+  # @return [Enumerable<Object>] non-code parts of this {Code} introduced
+  #   with {::non_code}. See also {#map_non_code_parts}.
+  def non_code_parts
+    @parts.select { |part| part.is_a? NonCodePart }.map(&:data)
+  end
+  
+  # @return [String]
+  def to_s
+    raise "non-code part: #{x.inspect}" if @parts.find { |part| part.is_a? NonCodePart }
+    @parts.join
+  end
+  
+  # @return [String]
+  def inspect
+    Inspectable.new(@parts, @metadata).inspect
+  end
+  
+  # @api private
+  # @note used by {Code}, {::non_code} only.
+  NonCodePart = Struct.new :data
+  
+  protected
+  
+  # @!visibility private
+  attr_reader :parts
+  
+  private
+  
+  # @!visibility private
+  Inspectable = Struct.new :parts, :metadata
+  
+end
+
+# @overload code
+#   @return [Code] an empty {Code}.
+# @overload code(str)
+#   @param [String] str
+#   @return [Code] +str+ converted to {Code}.
+def code(str = nil)
+  if str
+  then Code.new([str])
+  else Code.new([])
+  end
+end
+
+# @param [Object] data
+# @return [Code] a {Code} consisting of the single non-code part +data+.
+#   See also {Code#non_code_parts}.
+def non_code(data)
+  Code.new([Code::NonCodePart.new(data)])
+end
+
+alias __non_code__ non_code