akiva 0.1.0 → 0.1.1

data/lib/akiva/core_brain/loader.rb

@@ -0,0 +1,3 @@
+["helpers", "filters", "actions", "formatters"].each do |folder|
+  Dir[File.join(File.dirname(__FILE__), folder, "**/*.rb")].each {|file| require file }
+end

data/lib/akiva/question.rb

@@ -0,0 +1,88 @@
+module Akiva
+  class Question
+    attr_reader :content, :filter_matched, :filter_captures, :response
+
+    def initialize(content, meta = {})
+      @content = content
+      @ran_filters = @executed_action = @executed_formatter = false
+      @anonymous_action = AnonymousAction.new
+      @response = {}
+    end
+
+    def run_filters
+      return self if @ran_filters
+
+      Akiva::Brain.filters.each do |filter|
+        if match_data = filter[:regex].match(@content)
+          @filter_matched = filter
+          @filter_captures = Hash[match_data.names.zip(match_data.captures)]
+          break
+        end
+      end
+
+      @ran_filters = true
+      self
+    end
+
+    def execute_action
+      return self if @executed_action or @filter_matched.nil?
+
+      actions_chain = (@filter_matched[:before_action] || []) + [@filter_matched[:action]] + (@filter_matched[:after_action] || []) 
+
+      @response.merge!(filter_matched: @filter_matched, filter_captures: @filter_captures, formatter: @filter_matched[:formatter], actions_chain: actions_chain)
+
+      actions_chain.each do |action_name|
+        if action = Akiva::Brain.actions[action_name]
+          if action.is_a?(Proc)
+            @anonymous_action.instance_exec(@response, &action)
+          else
+            @response = action.process(@response)
+          end
+        else
+          raise "The action #{action_name} isn't registered"
+        end
+      end
+
+      @executed_action = true
+      self
+    end
+
+    def execute_formatter
+      return self if @executed_formatter
+
+      if @response[:formatter]
+        if formatter = Akiva::Brain.formatters[@response[:formatter]]
+          if formatter.is_a?(Proc)
+            @anonymous_action.instance_exec(@response, &formatter)
+          else
+            @response = formatter.process(@response)
+          end
+        else
+          raise "The formatter #{@response[:formatter]} isn't registered"
+        end
+      end
+
+      @executed_formatter = true
+      self
+    end
+
+    def process
+      # shortcut method
+      run_filters
+      execute_action
+      execute_formatter
+
+      self
+    end
+
+    def formatted_response
+      # shortcut method
+      process
+      @response[:formatted]
+    end
+
+
+    class AnonymousAction; end
+
+  end
+end

data/lib/akiva/version.rb

@@ -0,0 +1,9 @@
+module Akiva
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].compact.join('.')
+  end
+end

data/spec/lib/akiva/brain_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe "Akiva Brain" do
+  before { reload_core_brain }
+  after { reload_core_brain }
+
+  describe "adding filters" do
+    it "is correctly reflected in the filters list" do
+      Akiva::Brain.update do
+        add_filter :action_name, /first filter/
+      end
+
+      Akiva::Brain::filters.first.should == {
+        regex: /first filter/,
+        action: :action_name
+      }
+
+      Akiva::Brain.update do
+        add_filter :action_name, /second filter/, other_options: [:a, :b, :c]
+      end
+
+      Akiva::Brain::filters.first.should == {
+        regex: /second filter/,
+        action: :action_name,
+        other_options: [:a, :b, :c]
+      }
+    end
+  end
+
+
+  describe "adding action" do
+    it "as a block is correctly reflected in the actions list" do
+      action = ->(response){ }
+
+      Akiva::Brain.update do
+        add_action :foobar, &action
+      end
+
+      Akiva::Brain::actions[:foobar].should == action
+    end
+
+    it "as an instance is correctly reflected in the actions list" do
+      class MyCustomAction
+        def process(response)
+          response.merge(processed: true)
+        end
+      end
+
+      action = MyCustomAction.new
+
+      Akiva::Brain.update do
+        add_action :foobar, action
+      end
+
+      Akiva::Brain::actions[:foobar].should == action
+    end
+  end
+
+  describe "adding formatters" do
+    it "as a block is correctly reflected in the formatters list" do
+      formatter = ->(response){ }
+
+      Akiva::Brain.update do
+        add_formatter :foobar, &formatter
+      end
+
+      Akiva::Brain::formatters[:foobar].should == formatter
+    end
+
+    it "as an instance is correctly reflected in the formatters list" do
+      class MyCustomFormatter
+        def process(response)
+          response.merge(processed: true)
+        end
+      end
+
+      formatter = MyCustomFormatter.new
+
+      Akiva::Brain.update do
+        add_formatter :foobar, formatter
+      end
+
+      Akiva::Brain::formatters[:foobar].should == formatter
+    end
+
+  end
+
+
+end

data/spec/lib/akiva/core_brain/actions/get_answers_from_subjects_and_properties_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+# TODO rebuild specs like the preparators
+
+describe "Akiva CoreBrain Actions" do
+  it "executes on « What's the weight of an iPhone 5s »" do
+    stub_statements(:a0)
+
+    question = Akiva::Question.new("What's the weight of an iPhone 5s").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["iPhone 5s"])
+    question.response.should include(properties: {"iPhone 5s" => ["weight"]})
+    question.response.should include(answers: {"iPhone 5s" => {"weight" => "112 grams"}})
+  end
+
+  it "executes on « What are the weight and height of an iPhone 5s »" do
+    stub_statements(:a0, :a1, :a2)
+
+    question = Akiva::Question.new("What are the weight and height of an iPhone 5s").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["iPhone 5s"])
+    question.response.should include(properties: {"iPhone 5s" => ["weight", "height"]})
+    question.response.should include(answers: {"iPhone 5s" => {"weight" => "112 grams", "height" => "123.8 mm"}})
+  end
+
+  it "executes on « What are the weight of an iPhone 5s and a Galaxy S4 »" do
+    stub_statements(:a0, :a3, :a4)
+
+    question = Akiva::Question.new("What are the weight of an iPhone 5s and a Galaxy S4").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["iPhone 5s", "Galaxy S4"])
+    question.response.should include(properties: {"iPhone 5s" => ["weight"], "Galaxy S4" => ["weight"]})
+    question.response.should include(answers: {"iPhone 5s" => {"weight" => "112 grams"}, "Galaxy S4" => {"weight" => "130 grams"}})
+  end
+
+  it "executes on « What are the weight and height of an iPhone 5s and a Galaxy S4 »" do
+    stub_statements(:a0, :a1, :a2, :a3, :a4, :a5, :a6)
+
+    question = Akiva::Question.new("What are the weight and height of an iPhone 5s and a Galaxy S4").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["iPhone 5s", "Galaxy S4"])
+    question.response.should include(properties: {"iPhone 5s" => ["weight", "height"], "Galaxy S4" => ["weight", "height"]})
+    question.response.should include(answers: {"iPhone 5s" => {"weight" => "112 grams", "height" => "123.8 mm"}, "Galaxy S4" => {"weight" => "130 grams", "height" => "136.6 mm"}})
+  end
+
+  it "executes on « What is the salary of the Director of Public Affairs and Communication »" do
+    stub_statements(:b0)
+
+    question = Akiva::Question.new("What is the salary of the Director of Public Affairs and Communication").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["Director of Public Affairs and Communication"])
+    question.response.should include(properties: {"Director of Public Affairs and Communication" => ["salary"]})
+    question.response.should include(answers: {"Director of Public Affairs and Communication" => {"salary" => "$10,000"}})
+  end
+
+  it "executes on « What is the salary and benefits of the Director of Public Affairs and Communication »" do
+    stub_statements(:b0, :b1, :b2)
+
+    question = Akiva::Question.new("What is the salary and benefits of the Director of Public Affairs and Communication").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["Director of Public Affairs and Communication"])
+    question.response.should include(properties: {"Director of Public Affairs and Communication" => ["salary", "benefits"]})
+    question.response.should include(answers: {"Director of Public Affairs and Communication" => {"salary" => "$10,000", "benefits" => "Dental"}})
+  end
+
+  it "executes on « Is the iPhone 5s heavier than the Galaxy S4 »" do
+    stub_statements(:a0, :a3, :a4)
+
+    question = Akiva::Question.new("Is the iPhone 5s heavier than the Galaxy S4").run_filters.execute_action
+    question.response.should be_instance_of(Hash)
+    question.response.should include(subjects: ["iPhone 5s", "Galaxy S4"])
+    question.response.should include(properties: {"iPhone 5s" => ["weight"], "Galaxy S4" => ["weight"]})
+    question.response.should include(answers: {"iPhone 5s" => {"weight" => "112 grams"}, "Galaxy S4" => {"weight" => "130 grams"}})
+    question.response.should include(comparison_boolean_result: false)
+  end
+
+end

data/spec/lib/akiva/core_brain/actions/preparators/compare_two_subjects_properties_from_comparison_adjective_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Actions Preparator compare_two_subjects_properties_from_comparison_adjective" do
+  it "updates the response correctly" do
+    proc = Akiva::Brain.actions[:compare_two_subjects_properties_from_comparison_adjective]
+    response = {
+      filter_captures: {"comparison_adjective" => "heavier"},
+      answers: {"subject1" => {"property" => "112 grams"}, "subject2" => {"property" => "2 kg"}}
+    }
+    proc.call(response)
+
+    response.should include(comparison_boolean_result: false)
+
+    response = {
+      filter_captures: {"comparison_adjective" => "heavier"},
+      answers: {"subject1" => {"property" => "112 grams"}, "subject2" => {"property" => "111 g"}}
+    }
+    proc.call(response)
+
+    response.should include(comparison_boolean_result: true)
+  end
+end

data/spec/lib/akiva/core_brain/actions/preparators/extract_property_from_comparison_adjective_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Actions Preparator extract_property_from_comparison_adjective" do
+  it "updates the response correctly" do
+    proc = Akiva::Brain.actions[:extract_property_from_comparison_adjective]
+    response = {filter_captures: {"comparison_adjective" => "heavier"}}
+    proc.call(response)
+
+    response.should include(defined_properties: ["weight"])
+  end
+end

data/spec/lib/akiva/core_brain/actions/preparators/regroup_separated_subjects_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Actions Preparator regroup_separated_subjects" do
+  it "updates the response correctly" do
+    proc = Akiva::Brain.actions[:regroup_separated_subjects]
+    response = {filter_captures: {"subject1" => "the iPhone 5s", "subject2" => "a Galaxy S4", "something_else" => "foobar"}}
+    proc.call(response)
+
+    response.should include(defined_subjects: ["iPhone 5s", "Galaxy S4"])
+  end
+end

data/spec/lib/akiva/core_brain/actions/preparators/sort_answers_by_units_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Actions Preparator sort_answers_by_units" do
+  it "updates the response correctly" do
+    proc = Akiva::Brain.actions[:sort_answers_by_units]
+    response = {answers: {"subject1" => {"property" => "112 grams"}, "subject2" => {"property" => "2 kg"}, "subject3" => {"property" => "10 g"}}}
+    proc.call(response)
+
+    response.should include(sorted_answers_by_units: [
+      {
+        "subject3" => {
+          "property" => {
+            value: "10 g",
+            # value_with_adjusted_unit: nil
+          }
+        }
+      },
+      {
+        "subject1" => {
+          "property" => {
+            value: "112 g",
+            # value_with_adjusted_unit: nil
+          }
+        }
+      },
+      {
+        "subject2" => {
+          "property" => {
+            value: "2 kg",
+            # value_with_adjusted_unit: nil
+          }
+        }
+      }
+    ])
+  end
+end

data/spec/lib/akiva/core_brain/filters/get_answers_from_subjects_and_properties_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Filters" do
+  it "matches « What's the weight of an iPhone 5s »" do
+    question = Akiva::Question.new("What's the weight of an iPhone 5s").run_filters
+    question.filter_matched.should be_instance_of(Hash)
+    question.filter_matched.should include(action: :get_answers_from_subjects_and_properties)
+    question.filter_captures["subjects"].should == "iPhone 5s"
+    question.filter_captures["properties"].should == "weight"
+  end
+
+  it "matches « What are the weight and height of an iPhone 5s »" do
+    question = Akiva::Question.new("What are the weight and height of an iPhone 5s").run_filters
+    question.filter_matched.should be_instance_of(Hash)
+    question.filter_matched.should include(action: :get_answers_from_subjects_and_properties)
+    question.filter_captures["subjects"].should == "iPhone 5s"
+    question.filter_captures["properties"].should == "weight and height"
+  end
+
+  it "matches « What are the weight, height and width of an iPhone 5s »" do
+    question = Akiva::Question.new("What are the weight, height and width of an iPhone 5s").run_filters
+    question.filter_matched.should be_instance_of(Hash)
+    question.filter_matched.should include(action: :get_answers_from_subjects_and_properties)
+    question.filter_captures["subjects"].should == "iPhone 5s"
+    question.filter_captures["properties"].should == "weight, height and width"
+  end
+
+  it "matches « What are the weight, height and width of the iPhone 5s and the Galaxy S4 »" do
+    question = Akiva::Question.new("What are the weight, height and width of the iPhone 5s and the Galaxy S4").run_filters
+    question.filter_matched.should be_instance_of(Hash)
+    question.filter_matched.should include(action: :get_answers_from_subjects_and_properties)
+    question.filter_captures["subjects"].should == "iPhone 5s and the Galaxy S4"
+    question.filter_captures["properties"].should == "weight, height and width"
+  end
+
+  it "matches « Is the iPhone 5s heavier than the Galaxy S4 »" do
+    question = Akiva::Question.new("Is the iPhone 5s heavier than the Galaxy S4").run_filters
+    question.filter_matched.should be_instance_of(Hash)
+    question.filter_matched.should include(action: :get_answers_from_subjects_and_properties)
+    question.filter_captures["subject1"].should == "the iPhone 5s"
+    question.filter_captures["subject2"].should == "the Galaxy S4"
+    question.filter_captures["comparison_adjective"].should == "heavier"
+  end
+end

data/spec/lib/akiva/core_brain/formatters/boolean_from_comparison_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Formatter boolean_from_comparison" do
+  it "updates the response correctly" do
+    proc = Akiva::Brain.formatters[:boolean_from_comparison]
+    response = {
+      comparison_boolean_result: true
+    }
+    proc.call(response)
+
+    response[:formatted].should == "Yes"
+
+    response = {
+      comparison_boolean_result: false
+    }
+    proc.call(response)
+
+    response[:formatted].should == "No"
+  end
+
+
+  describe "with the action compare_two_subjects_properties_from_comparison_adjective among the list called" do
+    it "updates the response correctly" do
+      proc = Akiva::Brain.formatters[:boolean_from_comparison]
+      response = {
+        actions_chain: [:compare_two_subjects_properties_from_comparison_adjective],
+        comparison_boolean_result: false,
+        subjects: ["iPhone 5s", "Galaxy S4"],
+        properties: {"iPhone 5s" => ["weight"], "Galaxy S4" => ["weight"]},
+        answers: {"iPhone 5s" => {"weight" => "112 grams"}, "Galaxy S4" => {"weight" => "130 grams"}}
+      }
+      proc.call(response)
+
+      response[:formatted].should == "No (iPhone 5s => 112 grams; Galaxy S4 => 130 grams)"
+    end
+  end
+
+end

data/spec/lib/akiva/core_brain/formatters/list_all_answers_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe "Akiva CoreBrain Formatter list_all_answers" do
+  describe "with one subject and one property" do
+    it "updates the response correctly" do
+      proc = Akiva::Brain.formatters[:list_all_answers]
+      response = {
+        subjects: ["iPhone 5s"],
+        properties: {"iPhone 5s" => ["weight"]},
+        answers: {"iPhone 5s" => {"weight" => "112 grams"}}
+      }
+      proc.call(response)
+
+      response[:formatted].should == "112 grams"
+    end
+  end
+
+  describe "with one subject and multiple properties" do
+    it "updates the response correctly" do
+      proc = Akiva::Brain.formatters[:list_all_answers]
+      response = {
+        subjects: ["iPhone 5s"],
+        properties: {"iPhone 5s" => ["weight", "height"]},
+        answers: {"iPhone 5s" => {"weight" => "112 grams", "height" => "123.8 mm"}}
+      }
+      proc.call(response)
+
+      response[:formatted].should == "Weight: 112 grams, Height: 123.8 mm"
+    end
+  end
+
+  describe "with multiple subjects and one property" do
+    it "updates the response correctly" do
+      proc = Akiva::Brain.formatters[:list_all_answers]
+      response = {
+        subjects: ["iPhone 5s", "Galaxy S4"],
+        properties: {"iPhone 5s" => ["weight"], "Galaxy S4" => ["weight"]},
+        answers: {"iPhone 5s" => {"weight" => "112 grams"}, "Galaxy S4" => {"weight" => "130 grams"}}
+      }
+      proc.call(response)
+
+      response[:formatted].should == "iPhone 5s => 112 grams; Galaxy S4 => 130 grams"
+    end
+  end
+
+  describe "with multiple subjects and multiple properties" do
+    it "updates the response correctly" do
+      proc = Akiva::Brain.formatters[:list_all_answers]
+      response = {
+        subjects: ["iPhone 5s", "Galaxy S4"],
+        properties: {"iPhone 5s" => ["weight", "height"], "Galaxy S4" => ["weight", "height"]},
+        answers: {"iPhone 5s" => {"weight" => "112 grams", "height" => "123.8 mm"}, "Galaxy S4" => {"weight" => "130 grams", "height" => "136.6 mm"}}
+      }
+      proc.call(response)
+
+      response[:formatted].should == "iPhone 5s => Weight: 112 grams, Height: 123.8 mm; Galaxy S4 => Weight: 130 grams, Height: 136.6 mm"
+    end
+  end
+
+end