colloquy 1.0.0

data/lib/colloquy/input.rb

@@ -0,0 +1,14 @@
+
+class Colloquy::Input < String
+  attr_accessor :direct
+  
+  def initialize(input)
+    @direct = input.respond_to?(:direct) ? input.direct : false
+    
+    super(input.to_s)
+  end
+  
+  def direct?
+    @direct
+  end
+end

data/lib/colloquy/logger.rb

@@ -0,0 +1,11 @@
+require 'active_support/logger'
+require 'active_support/core_ext/date_time'
+
+class Colloquy::Logger < ActiveSupport::Logger
+
+  class ActiveSupport::Logger::SimpleFormatter
+    def call(severity, time, progname, msg)
+      msg = "#{Time.now.to_formatted_s(:db)}, #{severity} #{msg.strip}\n"
+    end
+  end
+end

data/lib/colloquy/menu.rb

@@ -0,0 +1,128 @@
+
+class Colloquy::Menu
+  include Colloquy::Paginator
+  
+  attr_accessor :keys, :flow
+  
+  def initialize(options = {})
+    @flow = options[:flow] || nil
+    @page = options[:page] || 1
+    @prefix = options[:prefix]
+    @suffix = options[:suffix]
+    @keys = []
+  end
+  
+  def render(page = @page)    
+    paginate unless @pages
+    
+    assemble_prefix
+    assemble_suffix
+    
+    execute_before_page_hook
+    "#{render_prefix}#{render_body(page)}#{render_suffix}"
+  end
+  
+  def key(input, page = @page)
+    state = @flow.send(:state)
+    
+    return false unless input.to_i.to_s == input
+    return false if input.to_i > @pages[page - 1].size
+    
+    key = if @pages
+      @pages[page - 1][input.to_i - 1]
+    end
+    
+    if key.respond_to? :push
+      key.first
+    else
+      key
+    end
+  end
+  
+  def push(*args)
+    @keys.push(*args)
+  end
+  
+  def <<(symbol)
+    @keys << symbol
+    
+    self
+  end
+  
+  def empty?
+    @keys.empty?
+  end
+  
+  def [](symbol)
+    @keys[symbol]
+  end
+  
+  def freeze
+    @keys.freeze
+  end
+  
+  def prefix(&block)
+    @prefix_block = block
+  end
+  
+  def suffix(&block)
+    @suffix_block = block
+  end
+  
+  def prefix=(string)
+    @prefix = string
+  end
+  
+  def suffix=(string)
+    @suffix = string
+  end
+  
+  def reset!
+    @keys = []
+    @pages = nil
+    @page = 1
+    @prefix = nil
+    @suffix = nil
+  end
+  
+  private  
+  def assemble_prefix(options = {})
+    @flow.tap do |f|
+      current_page_for_menu = f.headers[:page]
+      f.headers[:page] = options[:page] if options[:page]
+      
+      @prefix = f.instance_eval &@prefix_block if @prefix_block
+      
+      f.headers[:page] = current_page_for_menu
+    end
+  end
+  
+  def assemble_suffix(options = {})
+    @flow.tap do |f|
+      current_page_for_menu = f.headers[:page]
+      f.headers[:page] = options[:page] if options[:page]
+      
+      @suffix = @flow.instance_eval &@suffix_block if @suffix_block
+      
+      f.headers[:page] = current_page_for_menu
+    end
+  end
+  
+  def assemble
+    @assembled_strings = @keys.collect do |item|
+      render_each(item)
+    end
+  end
+  
+  def render_each(item)
+    "#{Colloquy::MessageBuilder.to_message(item, :flow => @flow)}"
+  end
+  
+  def render_prefix
+    @prefix ? "#{@prefix}\n" : ""
+  end
+  
+  def render_suffix
+    @suffix ? "\n#{@suffix}" : ""  
+  end
+end

data/lib/colloquy/message_builder.rb

@@ -0,0 +1,54 @@
+
+class Colloquy::MessageBuilder
+  class << self
+    def to_message(message_emergent, options = {})
+      message_emergent, parameters = extract_parameters(message_emergent)
+      message = replace_from_options(message_emergent, options)
+      message = substitute_parameters(message, parameters)
+      message.to_s
+    end
+    
+    private
+    def extract_parameters(message_emergent)
+      parameters = nil
+      
+      if message_emergent.respond_to? :push
+        parameters = message_emergent.last
+        message_emergent = message_emergent.first
+      end
+      
+      [message_emergent, parameters]
+    end
+    
+    def replace_from_options(message_emergent, options)
+      messages = if options[:flow]
+        options[:flow].messages
+      else
+        options[:messages]
+      end
+      
+      # try a direct match
+      message = messages["#{message_emergent}".to_sym] if messages
+      
+      # try a match converting underscores to hash indices
+      unless message
+        message =
+          begin
+            message_emergent_as_keys = message_emergent.to_s.split('_').map(&:to_sym)
+          
+            message_emergent_as_keys.inject(messages) { |message_substituted, key| message_substituted[key] }
+          rescue TypeError
+            nil
+          rescue NoMethodError
+            nil
+          end
+      end
+      
+      message || "#{message_emergent}"
+    end
+    
+    def substitute_parameters(message, parameters)      
+      message % parameters
+    end
+  end
+end

data/lib/colloquy/node.rb

@@ -0,0 +1,67 @@
+class Colloquy::Node
+  attr_reader :identifier, :options
+  attr_writer :flow
+  
+  def initialize(identifier = :index, options = {}, &block)
+    @identifier = identifier.to_sym
+    @flow = options[:flow] || nil
+    @options = options.delete(:flow)
+    
+    instance_eval &block if block
+  end
+  
+  def prompt(message)
+    @prompt = Colloquy::Prompt.new(:message => message, :flow => @flow)
+  end
+  
+  def prompt?
+    @prompt && !@prompt.blank?
+  end
+  
+  def menu?
+    @menu && !@menu.empty?
+  end
+
+  def menu
+    @menu ||= Colloquy::Menu.new(:flow => @flow)
+  end
+  
+  def render
+    if @prompt
+      @prompt.render
+    elsif !menu.empty?
+      menu.render
+    else
+      ""
+    end.strip
+  end
+  
+  def method_missing(method, *arguments, &block)
+    if @flow and @flow.respond_to? method
+      @flow.send(method, *arguments, &block) 
+    else
+      raise NoMethodError, "#{method} is missing in the flow"
+    end
+  end
+  
+  def request(&block)
+    @request_block = block 
+  end
+  
+  def request!(input = nil)
+    @request_block.call(input) if @request_block
+  end
+  
+  def process(&block)
+    @process_block = block 
+  end
+  
+  def process!(input = nil)
+    @process_block.call(input) if @process_block
+  end
+
+  def reset!
+    @prompt = nil
+    menu.reset!
+  end
+end

data/lib/colloquy/paginator.rb

@@ -0,0 +1,59 @@
+
+module Colloquy::Paginator
+  def self.included(klass)
+    if defined? Colloquy::Menu and klass == Colloquy::Menu
+      require_relative 'paginator/menu'
+      
+      klass.class_eval do
+        include Colloquy::Paginator::Menu
+      end
+    elsif defined? Colloquy::Prompt and klass == Colloquy::Prompt
+       require_relative 'paginator/prompt'
+       
+       klass.class_eval do
+         include Colloquy::Paginator::Prompt
+       end
+    end
+    
+    klass.class_eval do
+      attr_accessor :page, :pages
+      
+      include Colloquy::Paginator::Common
+    end
+  end
+  
+  module Common
+    def total_pages
+      paginate unless @pages
+      
+      @pages.length
+    end
+    
+    def page_available?(page)
+      paginate unless @pages
+      
+      page <= @pages.length && page > 0
+    end
+    
+    def paginate!
+      paginate
+    end
+    
+    def before_page(&block)
+      @before_page_block = block
+    end
+    
+    def maximum_response_length(message)
+      if message.to_s.ascii_only?
+        Colloquy.maximum_message_length
+     else
+        Colloquy.maximum_unicode_length
+     end
+    end
+    
+    private
+    def execute_before_page_hook(&block)
+      @flow.instance_eval &@before_page_block if @before_page_block
+    end
+  end
+end

data/lib/colloquy/paginator/menu.rb

@@ -0,0 +1,79 @@
+
+module Colloquy::Paginator::Menu
+  private
+  def paginate
+    assemble unless @assembled_strings
+
+    @pages = []
+    
+    if @assembled_strings.join("\n").length + (3 * @assembled_strings.length) < allowed_menu_length(:without_more => true)
+      @pages << @keys.compact
+    else
+      accumulator = []
+      accumulator_keys = []
+      
+      @assembled_strings.zip(@keys).each do |string, key|        
+        accumulator << string
+        accumulator_keys << key
+        
+        if accumulator.join("\n").length + (3 * accumulator.length) > allowed_menu_length(:page => @pages.length + 1)
+          if @pages.empty? or render_previous.empty?
+            @pages << accumulator_keys[0..-2].compact.push(:more)
+          else
+            @pages << accumulator_keys[0..-2].compact.push(:previous).push(:more)
+          end
+          accumulator = [accumulator[-1]]
+          accumulator_keys = [accumulator_keys[-1]]
+        end
+      end
+
+      total_options_in_menu = @pages.flatten.length - (@pages.length * 2) + 1
+
+      if total_options_in_menu < @assembled_strings.length
+          @pages << @keys[total_options_in_menu..-1]
+          @pages.last << :previous unless render_previous.empty?
+      end
+    end
+
+    @assembled_strings = nil
+    
+    @pages
+  end
+  
+  def allowed_menu_length(options = {})
+    # This comes last, and is of the form:
+    # "\nX. <More Text>"
+    more_length = 1 + 3 + "#{render_more}".length 
+    previous_length = 1 + 3 + "#{render_previous}".length 
+    
+    more_length = 0 if options[:without_more]
+    previous_length = 0 if options[:without_more]
+    previous_length = 0 if options[:page] == 1
+    
+      
+    # Assemble the prefix and suffix again because they can change based on the page
+    assemble_prefix(:page => options[:page] || 1)
+    assemble_suffix(:page => options[:page] || 1)
+    
+    # maximum_message_length is from the renderer!
+    maximum_response_length(@assembled_strings) - (render_prefix.length + render_suffix.length + more_length + previous_length)
+  end
+  
+  def render_body(page = 1)
+    menu = @pages[page - 1].dup
+
+    menu = menu.each_with_index.map do |option, index| 
+      "#{index + 1}. #{render_each(option)}"
+    end
+
+    menu.join("\n")
+  end
+  
+  def render_more
+    @rendered_more ||= Colloquy::MessageBuilder.to_message(:more, :flow => @flow)
+  end
+
+  def render_previous
+    @rendered_previous ||= Colloquy::MessageBuilder.to_message(:previous, :flow => @flow)
+  end
+end

data/lib/colloquy/paginator/prompt.rb

@@ -0,0 +1,32 @@
+
+module Colloquy::Paginator::Prompt
+  private
+  def paginate
+    
+    message_body = Colloquy::MessageBuilder.to_message(@message, flow: @flow)
+
+    allowed_length = maximum_response_length(message_body)
+
+    @pages = []
+    
+    if message_body.length < allowed_length
+      @pages << message_body
+    else
+      # allowed message length is from renderer; depends on character encoding
+      length = allowed_length - (render_more.length + 3 + 1)
+      @pages = message_body.squeeze(' ').scan(/\b.{1,#{length}}(?:$|\b)/m)
+      
+      @pages[0..-2].map! { |page| page << "\n1. " << render_more }
+      
+      @pages
+    end
+  end
+  
+  def render_body(page)
+    @pages[page - 1]
+  end
+  
+  def render_more
+    @rendered_more ||= Colloquy::MessageBuilder.to_message(:more, flow: @flow)
+  end
+end