sapling-dialogue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5aaa32f64d5d1e66ff4d8418c48067f2e8a4c283
+  data.tar.gz: ddd847cc2912019b12de02680dd35282d7108be3
+SHA512:
+  metadata.gz: 798eb921d6a9b8774de8c0353a38b4e7201aebeee83badb67047c3e9f14f2d82886b470f797f1709f977d88c17584299ffbd12f23db74ed1597d5b7434c6c43e
+  data.tar.gz: fb7ac1db708b798f8599d758ada08c7176fcd94a0ef94955ff3871793ce1b0d0776e00def90f255a94afd465df4e0f4b333983f43f3a0c110a0d5be61025589d

data/bin/sapling

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'sapling'
+
+Sapling.start(ARGV)

data/lib/sapling.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'yaml'
+
+Dir[File.join(__dir__, 'sapling', '*.rb')].each { |file| require file }
+
+# The main Sapling interface.
+class Sapling < Thor
+  desc 'read TREE', 'Load and traverse the TREE'
+  def read(tree)
+    exit unless verify_tree(tree)
+    puts 'Welcome to Sapling, a Dialogue Tree Utility.'
+    speaker = Dialogue::Speaker.new(YAML.load_file(tree), false)
+    speaker.conversation
+  end
+
+  desc 'edit TREE', 'Edit a new or existing TREE'
+  def edit(tree = '')
+    puts 'Welcome to Sapling, a Dialogue Tree Utility.'
+    if !tree.empty?
+      puts "Loading tree: #{tree}"
+      exit unless verify_tree(tree)
+      gardner = Planter::Spade.new(YAML.load_file(tree, false))
+    else
+      puts 'Creating a new tree!'
+      gardner = Planter::Spade.new(SKELETON_TREE)
+    end
+    gardner.plant
+  end
+
+  desc 'serve TREE', 'Load TREE in a web-based interface'
+  def serve(tree)
+    exit unless verify_tree(tree)
+    puts 'Sinatra will be cool.'
+  end
+
+  desc 'export TREE', 'Save a portable HTML version of TREE'
+  def export(tree)
+    exit unless verify_tree(tree)
+    puts 'Cool feature, bro!'
+  end
+end

data/lib/sapling/dialogue.rb

@@ -0,0 +1,110 @@
+require_relative './gardner'
+
+# Dialogue is the module for traversing an existing tree.
+module Dialogue
+
+  # Format and display the trunk
+  #
+  # @param trunk [Hash] The trunk hash
+  # @param debug [Boolean] The status of showing debug information
+  def self.display_trunk(trunk, debug=false)
+    40.times { print "-" }
+    puts "\n[ Trunk ]\n" if debug
+    puts "\n#{trunk["trunk"]}"
+    40.times { print "-" }
+    puts "\n"
+  end
+
+  # Format and display a branch and the options
+  #
+  # @param branch [Hash] A branch data set
+  # @param branch_no [Integer] The branch number
+  # @param debug [Boolean] Status of showing debug information
+  def self.display_branch(branch, branch_no, debug=false)
+    puts "\n[ Branch: #{branch_no} ]" if debug
+    puts "\n#{branch["desc"]}\n\n"
+
+    branch["options"].each_pair do |k,v|
+      puts "\t#{k}: #{v.keys[0]}"
+      puts "\t\t[ Goes to branch #{v.values[0]} ]\n" if debug
+    end
+  end
+
+  # Speaker holds the functionality for going through a dialogue tree.
+  class Speaker
+    # The file, which should be a dialogue tree YAML file.
+    attr_accessor :file
+    # Status of verbose/debug mode. True = on; false = off.
+    attr_accessor :debug
+
+    def initialize(file="", debug=false)
+      @file = file
+      @debug = debug
+    end
+
+    # Conversation handles navigating the tree, until the option to end is
+    # reached.
+    def conversation()
+      tree = Gardner.prune_trunk(@file)
+
+      Dialogue.display_trunk(tree[0], false)
+      branches = Gardner.prune_branches(tree[1])
+
+      next_branch = 1
+      until next_branch == 0 do
+        next_branch = talk(branches[next_branch], next_branch)
+      end
+
+      puts "\n#{branches[0]["desc"]}"
+      exit
+    end
+
+    # Talk displays a branch, the options, and prompts for a response.
+    #
+    # @param branch [Hash] A branch data set
+    # @param branch_no [Integer] The branch number
+    # @return [Integer] The number of the next branch
+    def talk(branch, branch_no)
+      # If there are no options on this branch, we assume it's a terminal
+      # branch. Return 0, and end the program.
+      if branch["options"].empty?
+        puts "\n#{branch["desc"]}\n\n"
+        return 0
+      end
+
+      Dialogue.display_branch(branch, branch_no, @debug)
+
+      response = get_response(branch)
+
+      unless response == 0
+        puts "\n"
+        10.times { print "*" }
+        puts "\n(Your choice: #{branch["options"][response].keys[0]})"
+        response = branch["options"][response].values[0].to_i
+      end
+
+      return response
+    end
+
+    # Get a response for the displayed branch
+    #
+    # @param branch [Hash] A branch data set
+    # @return [Integer] the next branch
+    def get_response(branch)
+      valid_options = branch["options"].keys.join(", ")
+
+      print "\n[#{valid_options}]> "
+      STDOUT.flush
+      response = STDIN.gets.chomp.to_i
+
+      until branch["options"].keys.include?(response) or response == 0
+        print "[## Invalid options. "
+        print "Valid options are #{valid_options}, or 0 to exit."
+        print "\n[#{valid_options}]> "
+        response = STDIN.gets.chomp.to_i
+      end
+
+      return response
+    end
+  end
+end

data/lib/sapling/gardner.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+# Gardner is the module for working with a dialogue tree file
+module Gardner
+
+  # Parse the tree array into an array of numbered branches, and ordered leaves.
+  #
+  # @param tree [Array] The dialogue tree
+  # @return [Array] An array of numbered branches, with numbered leaves
+  def self.prune_branches(tree)
+    branches = { 0 => { "desc" => "Thanks for using Sapling!" } }
+    tree.each do |b|
+      branches[b["branch"]["number"]] = {
+        "desc" => b["branch"]["text"],
+        "options" => prune_leaves(b["branch"]["leaf"]) }
+    end
+
+    return branches
+  end
+
+  # Parse the leaves of a branch into a numbered hash of options.
+  #
+  # @param leaves [Array] The option of leaf hashes
+  # @return [Hash] A numbered hash of options
+  def self.prune_leaves(leaves)
+    x = 1
+    options = {}
+
+    return options if leaves.nil?
+
+    leaves.each do |l|
+      options[x] = { l["text"] => l["branch"] }
+      x += 1
+    end
+
+    return options
+  end
+
+  # Parse the trunk of the tree.
+  #
+  # @param tree [Hash] The entire tree
+  # @return [Array] The trunk, and the remainder of the tree
+  def self.prune_trunk(tree)
+    trunk = tree.shift
+
+    return [trunk,tree]
+  end
+end

data/lib/sapling/planter.rb

@@ -0,0 +1,210 @@
+require_relative './dialogue'
+require_relative './gardner'
+require_relative './utility'
+
+# Planter is the module for creating or editing a tree.
+module Planter
+
+  # In-memory tree
+  class Plot
+
+    # The tree, trunk, and branches
+    attr_accessor :tree, :trunk, :branches
+
+    # Edit the trunk of the tree
+    def edit_trunk
+      puts "Current Trunk:\n"
+      Dialogue.display_trunk(@trunk, true)
+      print "\n[ =EDITING= ](CTRL-C to abort)> "
+      STDOUT.flush
+      begin
+        new_trunk = STDIN.gets.to_s
+      rescue Interrupt
+        puts "\n**Aborting edit**\n\n"
+        new_trunk = @trunk["trunk"]
+      end
+      @trunk["trunk"] = new_trunk
+    end
+
+    # Edit a branch on the tree
+    #
+    # @param branch [Integer] The number of the branch to be edited.
+    def edit_branch(branch_no)
+      puts "Current Branch:\n"
+      Dialogue.display_branch(@branches[branch_no], branch_no, true)
+      print "\n[ =EDITING= ](CTRL-C to abort)> "
+      STDOUT.flush
+      begin
+        new_branch = STDIN.gets.to_s
+      rescue Interrupt
+        puts "\n**Aborting edit**\n\n"
+        new_branch = @branches[branch_no]["desc"]
+      end
+      @branches[branch_no]["desc"] = new_branch
+    end
+
+    # Edit a leaf on a branch, grasshopper
+    #
+    # @param branch [Integer] The number of the branch to be edited.
+    # @param leaf [Hash] The leaf hash to be edited.
+    def edit_leaf(branch, leaf)
+
+    end
+  end
+
+  # Utilities for editing specific parts of a tree.
+  class Spade
+
+    # The file we parse into a tree
+    attr_writer :file
+
+    def initialize(file)
+      @file = file
+    end
+
+    # Establish and populate a new Plot (in-memory tree), then control the flow
+    # of editing the Plot
+    def plant
+      @plot = Plot.new
+      @plot.tree = @file
+      @plot.trunk = @file.shift
+      @plot.branches = Gardner.prune_branches(@file)
+
+      next_branch = dig(1)
+      until next_branch == 0 do
+        next_branch = dig(next_branch)
+      end
+
+      puts "\n#{@plot.branches[0]["desc"]}"
+      exit
+    end
+
+    # Function for displaying a single branch in debug mode. We also always
+    # display the trunk, since otherwise it's displayed a single time then gone
+    # forever (until next time).
+    #
+    # @param branch_no [Integer] The number of the branch to be displayed.
+    def dig(branch_no)
+      branch = @plot.branches[branch_no]
+
+      Dialogue.display_trunk(@plot.trunk, true)
+      Dialogue.display_branch(branch, branch_no, true)
+
+      response = get_response(branch)
+      to_branch = parse_response(response, branch_no)
+
+      return to_branch
+    end
+
+    # Get a response for the displayed branch
+    #
+    # @param branch [Hash] A branch data set
+    # @return [Integer] the next branch
+    def get_response(branch)
+      total_branches = @plot.branches.count - 1
+      valid_options = ["1-#{total_branches}","t","a","b","x","l","s","q"]
+      print_options = valid_options.join(",")
+
+      print "\n[#{print_options}]> "
+      STDOUT.flush
+      response = STDIN.gets.chomp.to_s.downcase
+
+      until valid_options.include?(response) or response.to_i.between?(1,total_branches)
+        print "[## Invalid response. "
+        print "Valid options are #{print_options}"
+        print "\n[#{print_options}]> "
+        response = STDIN.gets.chomp.to_s.downcase
+      end
+
+      return response
+    end
+
+    # Parse the response from get_response
+    #
+    # @param response [String] The option selected
+    # @param branch_no [Integer] The currently-displayed branch
+    # @return [Integer] the branch to display
+    def parse_response(response, branch_no)
+      10.times { print "*" }
+      print "\n(Your choice: "
+
+      if response.to_i >= 1
+        print "Change to branch #{response.to_i})\n\n"
+        return response.to_i
+
+      end
+
+      case response.to_s.downcase
+      when "t"
+        print "Edit the trunk.)\n\n"
+        @plot.edit_trunk
+        return branch_no
+      when "a"
+        print "Add a new branch.)\n\n"
+        return branch_no
+      when "b"
+        print "Edit the current branch.)\n\n"
+        @plot.edit_branch(branch_no)
+        return branch_no
+      when "x"
+        print "Delete the current branch.)\n\n"
+        return branch_no
+      when "l"
+        print "Edit leaves of current branch.)\n\n"
+        return branch_no
+      when "s"
+        print "Save changes.)\n\n"
+        return branch_no
+      when "q"
+        print "Quit without saving.)\n\n"
+        print "Unsaved changes will be lost. Still quit? [y/n]> "
+        verify = STDIN.gets.chomp.to_s.downcase
+
+        return 0 if verify == "y" 
+        return branch_no
+      else
+        print "Unknown option. Returning to current branch.)\n\n"
+        return branch_no
+      end
+    end
+  end
+end
+
+=begin
+
+Process:
+- User selects to create/edit a tree
+  - If the user presented a file, use it as the tree file
+  - If the user failed to provide a file, create a new tree file in the current directory
+
+- Check if the file is empty.
+  - If so, assume a new tree
+  - If not, verify formatting
+
+- If new tree, prompt for trunk
+- If existing tree, display trunk and first branch
+
+- At this point, editing is the same
+  - Prompt provides options:
+    - #: Go to that branch number
+    - T: Modify the tree trunk
+    - A: Add a new branch (append to list of branches)
+    - B: Modify the current branch description
+    - X: Delete the current branch (does this renumber branches?)
+    - L: Modify the current leaves, respond with leaf prompt
+    - S: Save changes
+    - Q: Quit
+
+- Example prompt:
+  [ 0-5,T,A,B,X,L,S,Q ]>
+- Leaf prompt:
+
+Details:
+
+- Regardless of the file existing, the user will be editing a Hash, not the actual YAML file
+- Use Gardner to build and interact with the tree
+- Use Planter to modify the tree "in memory" (aka, the hash)
+- Use Dialog to interact with the tree "in memory", to test-run it
+- After each edit option, display the current branch with the new changes.
+
+=end

data/lib/sapling/utility.rb

@@ -0,0 +1,58 @@
+# Utility functionality for all of Sapling to reference
+
+# Constants
+
+# A series of constants for handing a brand new tree. The skeleton tree provides
+# a very basic introduction to Sapling. More details can be found in the
+# documentation.
+
+# The default trunk text of a new tree
+SKELE_TRUNK_TEXT = "Welcome to the Sapling Editor. For details, please see the
+documentation!"
+
+# The default first-branch text of a new tree
+SKELE_BRANCH_TEXT = "The first branch is always shown by default. It should act
+as the introduction to the story. From here, the user enters your world!"
+
+# The default first-leaf text of the first branch of a new tree. The leaf points
+# to it's own branch. The only way out of the program is to either force-quit or
+# reply with option 0.
+SKELE_LEAF_TEXT = "Each branch can have any number of leaves, which represent
+the options a user has on that branch. Each leaf points to another branch, or
+can point to branch 0 to immediately exit."
+
+# The final tree
+SKELETON_TREE = [
+  {"trunk" => "#{SKELE_TRUNK_TEXT}"},
+  {"branch" => {
+    "number" => 1,
+    "text" => "#{SKELE_BRANCH_TEXT}",
+    "leaf" => [{
+      "text" => "#{SKELE_LEAF_TEXT}",
+      "branch" => 1
+      }]
+    }
+  }
+]
+
+
+# Verify that a file is a dialogue tree file.
+#
+# @param file [File] The provided file
+# @return [Boolean] True if the file is a tree; false otherwise
+def verify_tree(file)
+  results = []
+  begin
+    tree = YAML.load_file(file)
+    results << tree[0].keys.include?("trunk")
+    results << tree[1]["branch"].keys.include?("number")
+    results << tree[1]["branch"].keys.include?("text")
+    results << tree[1]["branch"].keys.include?("leaf")
+  rescue
+    puts "Sorry chummer, I don't think this is a tree."
+    puts "Verify your YAML file is formatted properly."
+    results << false
+  end
+
+  results.include?(false) ? false : true
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: sapling-dialogue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bill Niblock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-14 00:00:00.000000000 Z
+dependencies: []
+description: Create, edit, and traverse Dialogue trees
+email: azulien@gmail.com
+executables:
+- sapling
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/sapling
+- lib/sapling.rb
+- lib/sapling/dialogue.rb
+- lib/sapling/gardner.rb
+- lib/sapling/planter.rb
+- lib/sapling/utility.rb
+homepage: http://www.theinternetvagabond.com/sapling/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A Dialogue Tree Utility
+test_files: []