cora 0.0.4

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+
+notifications:
+  irc: "irc.freenode.org#siriproxy"

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cora.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => "--color" do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/.+\.rb}) { "spec" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/cora.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cora/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cora"
+  s.version     = Cora::VERSION
+  s.authors     = ["Jack Chen (chendo)"]
+  s.email       = ["@chendo"]
+  s.homepage    = ""
+  s.summary     = "Example summary"
+  s.description = "Example description"
+
+  s.rubyforge_project = "cora"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "rake"
+
+  s.add_runtime_dependency "geocoder"
+
+  s.files         = `git ls-files 2> /dev/null`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/* 2> /dev/null`.split("\n")
+  s.executables   = `git ls-files -- bin/* 2> /dev/null`.split("\n").map{ |f| File.basename(f) }
+
+  s.require_paths = ["lib"]
+end

data/lib/cora.rb

@@ -0,0 +1,62 @@
+require "cora/version"
+require "cora/plugin"
+require "cora/location"
+
+class Cora
+
+  attr_reader :location
+
+  def plugins
+    @plugins ||= []
+  end
+
+  def process(text)
+    log "Processing '#{text}'"
+
+    if @callback
+      log "Active callback found, resuming"
+
+      # We must set the active callback to nil first, otherwise
+      # multiple callbacks within one listen block won't work
+      callback = @callback
+      @callback = nil
+      callback.call(text)
+      return true
+    end
+
+    plugins.each do |plugin|
+      log "Processing plugin #{plugin}"
+      return true if plugin.process(text)
+    end
+
+    log "No matches for '#{text}'"
+    no_matches
+  end
+
+  def respond(text, options = {})
+  end
+
+  def no_matches
+  end
+
+  def set_priority_plugin(plugin)
+    plugins.delete(plugin)
+    plugins.unshift(plugin)
+  end
+
+  def set_callback(&block)
+    @callback = block
+  end
+
+  def set_active_fiber(fiber)
+    @fiber = fiber
+  end
+
+  def set_location(latitude, longitude, extra = {})
+    @location = Location.new(latitude, longitude, extra)
+  end
+
+  def log(text)
+    $stderr.puts(text) if defined?(LOG)
+  end
+end

data/lib/cora/location.rb

@@ -0,0 +1,34 @@
+require 'geocoder'
+
+class Cora::Location
+
+  extend Forwardable
+
+  def_delegators :result, :address, :city, :state, :state_code, :country, :country_code, :postal_code
+
+  attr_reader :latitude, :longitude, :extra
+
+  def initialize(latitude, longitude, extra = {})
+    @latitude = latitude
+    @longitude = longitude
+    @extra = extra
+  end
+
+  # Returns nil if geolocation failed, or an instance of Geocoder::Result::Google
+  # See: http://rubydoc.info/github/alexreisner/geocoder/master/Geocoder/Result/Google
+  def result
+    results.first
+  end
+
+  # Returns an array of objects of class Geocoder::Result::Google (probably)
+  def results
+    @results ||= perform_reverse_geocode
+  end
+
+  private
+
+  def perform_reverse_geocode
+    Geocoder.search([latitude, longitude].join(','))
+  end
+
+end

data/lib/cora/plugin.rb

@@ -0,0 +1,97 @@
+require 'fiber'
+require 'forwardable'
+
+class Cora::Plugin
+
+  # These could use some more work
+  CONFIRM_REGEX = /yes|yeah|yep|ok|confirm|affirmative|indeed|engage/i
+  DENY_REGEX = /no|nope|nah|cancel|negative/i
+
+  extend Forwardable
+
+  def_delegators :manager, :log, :location
+
+  attr_accessor :manager, :match_data
+  attr_reader :current_state
+
+  class << self
+
+    def listen_for(regex, options = {}, &block)
+      listeners[regex] = {
+        block: block,
+        within_state: ([options[:within_state]].flatten)
+      }
+    end
+
+    def listeners
+      @listeners ||= {}
+    end
+
+  end
+
+  def process(text)
+    listeners.each do |regex, entry|
+      if match = text.match(regex)
+        captures = match.captures
+        log "Matches #{regex}"
+
+        if entry[:within_state]
+          log "Applicable states: #{entry[:within_state].join(', ')}"
+          log "Current state: #{current_state}"
+
+          if entry[:within_state].include?(current_state)
+            log "Matches, executing block"
+
+            self.match_data = match
+            Fiber.new {
+              instance_exec(*captures, &entry[:block])
+            }.resume
+            return true
+          end
+        end
+      end
+
+    end
+    false
+  end
+
+  def listeners
+    self.class.listeners
+  end
+
+  def say(text, options={})
+    log "Say: #{text}"
+    manager.respond(text, options)
+  end
+
+  def ask(question, options={})
+    log "Ask: #{question}"
+
+    f = Fiber.current
+    options[:prompt_for_response] = true
+    manager.respond(question, options)
+    manager.set_callback do |text|
+      f.resume(text)
+    end
+
+    Fiber.yield
+  end
+
+  def confirm(question, options = {unmatched_message: "I'm sorry, I didn't understand that."}, &block)
+    while (response = ask(question))
+      if response.match(CONFIRM_REGEX)
+        return true
+      elsif response.match(DENY_REGEX)
+        return false
+      else
+        say options[:unmatched_message]
+      end
+    end
+  end
+
+  def set_state(state)
+    @current_state = state
+    manager.set_priority_plugin(self)
+  end
+
+end

data/lib/cora/version.rb

@@ -0,0 +1,3 @@
+class Cora
+  VERSION = "0.0.4"
+end

data/spec/cora_spec.rb

@@ -0,0 +1,223 @@
+require 'spec_helper'
+require 'support/test_plugin'
+
+describe Cora do
+  context "integration test" do
+    let(:plugin) do
+      TestPlugin.new.tap { |plugin| plugin.manager = subject }
+    end
+
+    before do
+      subject.plugins << plugin
+    end
+
+    context "single state" do
+      it "responds to a simple test hook" do
+
+        subject.should_receive(:respond).with("test!", {})
+        subject.process("this is a test")
+
+      end
+    end
+
+    context "say" do
+      it "responds to a say with options" do
+        subject.should_receive(:respond).with("test options", {option: "option"})
+        subject.process("options")
+      end
+    end
+
+    context "multiple state" do
+      it "doesn't respond to listeners that don't have the required state" do
+        subject.should_receive(:no_matches)
+
+        subject.process("bar")
+      end
+
+      it "responds when in the correct state" do
+        subject.process("foo")
+
+        subject.should_receive(:respond).with("bar get", {})
+        subject.process("bar")
+      end
+    end
+
+    context "multiple plugins" do
+      class TestPlugin2 < Cora::Plugin
+
+        listen_for /test/ do
+          say "test2"
+        end
+
+        listen_for /bar/ do
+          say "bad bar"
+        end
+
+      end
+
+      before do
+        subject.plugins << TestPlugin2.new.tap { |plugin| plugin.manager = subject}
+      end
+
+      it "processes the plugins in order" do
+        subject.should_receive(:respond).with("test!", {})
+        subject.process("test")
+
+        subject.plugins.reverse!
+        subject.should_receive(:respond).with("test2", {})
+        subject.process("test")
+      end
+
+      it "when state is set, cora should ignore other plugins" do
+        subject.plugins.reverse! # So TestPlugin2's bar is checked first
+        subject.process("foo")
+        subject.should_receive(:respond).with("bar get", {})
+        subject.process("bar")
+      end
+    end
+
+    context "asking" do
+      # Now this is interesting. On further thought, we can't do
+      # answer = ask("What is your name?")
+      # since we need to relinquish the CPU somehow. Either we use blocks,
+      # but since we're on 1.9, we can use Fibers. I think?
+
+      it "gets input from the user and uses it intelligently" do
+        subject.should_receive(:respond).with("Who should I send it to?", prompt_for_response: true)
+        subject.process("send message")
+        subject.should_receive(:respond).with("Sending message to chendo", {})
+        subject.process("chendo")
+      end
+
+      it "can ask multiple questions" do
+        subject.should_receive(:respond).with("Question 1", prompt_for_response: true)
+        subject.process("ask multiple")
+
+        subject.should_receive(:respond).with("You said: Answer 1", {})
+        subject.should_receive(:respond).with("Question 2", prompt_for_response: true)
+        subject.process("Answer 1")
+
+        subject.should_receive(:respond).with("You said: Answer 2", {})
+        subject.should_receive(:respond).with("Question 3", prompt_for_response: true)
+        subject.process("Answer 2")
+
+        subject.should_receive(:respond).with("You said: Answer 3", {})
+        subject.process("Answer 3")
+      end
+      
+      it "can ask questions with options" do
+      	subject.should_receive(:respond).with("Question with option", {prompt_for_response: true, option: "option"})
+      	subject.process("ask option")
+      	subject.process("plamoni")
+      	
+      	random_num = rand(1000000)
+      	subject.should_receive(:respond).with("Question with option", {prompt_for_response: true, option: random_num})
+      	subject.process("ask option #{random_num}")
+      	subject.process("plamoni")
+      end
+    end
+
+    context "confirming" do
+      it "can confirm with affirmative responses" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Confirmed", {})
+        subject.process("Yes")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Confirmed", {})
+        subject.process("Yeah")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Confirmed", {})
+        subject.process("Yep")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Confirmed", {})
+        subject.process("Yes please")
+      end
+
+      it "can deny with deny responses" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Cancelled", {})
+        subject.process("No")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Cancelled", {})
+        subject.process("Nah")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Cancelled", {})
+        subject.process("Nope")
+
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("Cancelled", {})
+        subject.process("No thanks")
+      end
+
+      it "can call confirm recursively" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("nested confirm")
+        subject.should_receive(:respond).with("Confirmed", {})
+        subject.should_receive(:respond).with("What about inside itself?", prompt_for_response: true)
+        subject.process("Yes")
+        subject.should_receive(:respond).with("Confirmed2", {})
+        subject.process("Yes")
+      end
+
+      it "can call confirm sequentially" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true).ordered
+        subject.process("sequential confirm")
+        subject.should_receive(:respond).with("Confirmed", {}).ordered
+        subject.should_receive(:respond).with("And a second time?", prompt_for_response: true).ordered
+        subject.process("Yes")
+        subject.should_receive(:respond).with("Cancelled2", {}).ordered
+        subject.should_receive(:respond).with("And a third time?", prompt_for_response: true).ordered
+        subject.process("No")
+        subject.should_receive(:respond).with("Confirmed3", {}).ordered
+        subject.process("Yes")
+      end
+
+      it "can reprompt if given invalid answer to confirmation" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm something")
+        subject.should_receive(:respond).with("I'm sorry, I didn't understand that.", {}).ordered
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true).ordered
+        subject.should_receive(:respond).with("Confirmed", {}).ordered
+        # subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("Lamp")
+        subject.process("Yes")
+      end
+
+      it "can reprompt with custom message if given invalid answer to confirmation" do
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("confirm custom reprompt")
+        subject.should_receive(:respond).with("What you say!?", {}).ordered
+        subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true).ordered
+        subject.should_receive(:respond).with("Confirmed", {}).ordered
+        # subject.should_receive(:respond).with("Does confirm work?", prompt_for_response: true)
+        subject.process("Lamp")
+        subject.process("Yes")
+      end
+    end
+
+    context "captures" do
+      it "passes the captures to the block" do
+        subject.should_receive(:respond).with("Nice to meet you, Jackie Chan", {})
+        subject.process("my name is Jackie Chan")
+      end
+
+      it "lets you access the match_data for dynamic capture count" do
+        subject.should_receive(:respond).with("only repeat this", {})
+        subject.process("only repeat this, not this")
+      end
+      end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+require 'cora'

data/spec/support/test_plugin.rb

@@ -0,0 +1,96 @@
+
+class TestPlugin < Cora::Plugin
+
+  listen_for /test/ do
+    say "test!"
+  end
+  
+  listen_for /^options$/ do
+    say "test options", {option: "option"}
+  end
+
+  listen_for /^foo$/ do
+    say "foo"
+    set_state :waiting_for_bar
+  end
+
+  listen_for /send message/ do
+    receipent = ask "Who should I send it to?"
+    say "Sending message to #{receipent}"
+  end
+
+  listen_for /ask multiple/ do
+    answer = ask "Question 1"
+    say "You said: #{answer}"
+    answer = ask "Question 2"
+    say "You said: #{answer}"
+    answer = ask "Question 3"
+    say "You said: #{answer}"
+  end
+  
+  listen_for /ask option[ ]?([0-9]*)/ do |numeric_option|
+    opt = "option"
+    opt = numeric_option.to_i if not numeric_option.empty?
+    answer = ask "Question with option", {option: opt}
+  end
+
+  listen_for /confirm something/ do
+    if confirm "Does confirm work?"
+      say "Confirmed"
+    else
+      say "Cancelled"
+    end
+  end
+
+  listen_for /confirm custom reprompt/ do
+    if confirm "Does confirm work?", unmatched_message: "What you say!?"
+      say "Confirmed"
+    else
+      say "Cancelled"
+    end
+  end
+
+
+  listen_for /nested confirm/ do
+    if confirm "Does confirm work?"
+      say "Confirmed"
+      if confirm "What about inside itself?"
+        say "Confirmed2"
+      else
+        say "Cancelled2"
+      end
+    else
+      say "Cancelled"
+    end
+  end
+
+  listen_for /sequential confirm/ do
+    if confirm "Does confirm work?"
+      say "Confirmed"
+    else
+      say "Cancelled"
+    end
+    if confirm "And a second time?"
+      say "Confirmed2"
+    else
+      say "Cancelled2"
+    end
+    if confirm "And a third time?"
+      say "Confirmed3"
+    else
+      say "Cancelled3"
+    end
+  end
+
+  listen_for /bar/, within_state: :waiting_for_bar do
+    say "bar get"
+  end
+
+  listen_for /my name is (\w+) (\w+)/i do |first_name, last_name|
+    say "Nice to meet you, #{first_name} #{last_name}"
+  end
+
+  listen_for /only repeat this/i do
+    say "#{match_data}"
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: cora
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Jack Chen (chendo)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70356401591140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70356401591140
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70356401590140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70356401590140
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70356401588880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70356401588880
+- !ruby/object:Gem::Dependency
+  name: geocoder
+  requirement: &70356401588060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70356401588060
+description: Example description
+email:
+- ! '@chendo'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- Rakefile
+- cora.gemspec
+- lib/cora.rb
+- lib/cora/location.rb
+- lib/cora/plugin.rb
+- lib/cora/version.rb
+- spec/cora_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_plugin.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cora
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Example summary
+test_files:
+- spec/cora_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_plugin.rb