akiva 0.1.0 → 0.1.1

data/lib/akiva/core_brain/actions/preparators/compare_two_subjects_properties_from_comparison_adjective.rb

@@ -0,0 +1,19 @@
+Akiva::Brain.update do
+
+  add_action :compare_two_subjects_properties_from_comparison_adjective do |response|
+    answers_values = response[:answers].map{|hash| hash.last.first.last }
+
+    begin
+      units = Akiva::Brain::Helpers::Units.new(answers_values)
+      units.compare # in the future, you may want to pass a multiplicator here
+    rescue
+      # we fail silently for now, as the error probably comes from the data in TheBigDB anyway,
+      # which could well be invalid (= not convertible units)
+    else
+      property_comparator = Akiva::Brain::Helpers::ComparisonAdjectivesToProperties[response[:filter_captures]["comparison_adjective"]][:comparator]
+      response[:comparison_boolean_result] = (units.result == property_comparator)
+    end # begin
+
+  end
+
+end

data/lib/akiva/core_brain/actions/preparators/extract_property_from_comparison_adjective.rb

@@ -0,0 +1,10 @@
+Akiva::Brain.update do
+
+  add_action :extract_property_from_comparison_adjective do |response|
+
+    # Note: for now, we're only working with the first property listed for the adjective
+    response[:defined_properties] = [Akiva::Brain::Helpers::ComparisonAdjectivesToProperties[response[:filter_captures]["comparison_adjective"]][:properties].first]
+
+  end
+
+end

data/lib/akiva/core_brain/actions/preparators/regroup_separated_subjects.rb

@@ -0,0 +1,10 @@
+Akiva::Brain.update do
+
+  add_action :regroup_separated_subjects do |response|
+    response[:defined_subjects] ||= []
+    response[:filter_captures].each_pair do |name, capture|
+      response[:defined_subjects] << Akiva::Brain::Helpers.cleanup_articles(capture) if name =~ /\Asubject\d+/
+    end
+  end
+
+end

data/lib/akiva/core_brain/actions/preparators/sort_answers_by_units.rb

@@ -0,0 +1,35 @@
+Akiva::Brain.update do
+
+  add_action :sort_answers_by_units do |response|
+    # This is supposed to sort one answer for one property for multiple subjects,
+    # you may want to create another action to do something more.
+
+    answers_values = response[:answers].map{|hash| hash.last.first.last }
+
+    begin
+      units = Akiva::Brain::Helpers::Units.new(answers_values)
+      units.sort
+    rescue
+      # we fail silently for now, as the error probably comes from the data in TheBigDB anyway,
+      # which could well be invalid (= not convertible units)
+    else
+      response[:sorted_answers_by_units] = []
+      units.result.each do |instantiated_value|
+        response[:answers].each do |hash|
+          if instantiated_value == hash.last.first.last
+            response[:sorted_answers_by_units] <<
+              {
+                hash.first => {
+                  hash.last.first.first => {
+                    value: instantiated_value.to_s
+                  }
+                }
+              }
+          end
+        end
+      end
+    end # begin
+
+  end
+
+end

data/lib/akiva/core_brain/actions/template.rb

@@ -0,0 +1,23 @@
+# Akiva::Brain.update do
+#
+#   add_action :name_of_action do |response|
+#     # 'response' is the same hash passed to all before_actions and to the action itself
+#     # The following keys are set from the start:
+#     response[:filter_matched] => {regex: /[original regex capturing the following (?<stuff_captured>.+)/, action: :name_of_action, [other options]}
+#     response[:filter_captures] => Hash of the captures made in the regex e.g. {"stuff_captured" => "words captured from the question"}
+#   end
+#   
+#   # If you're going to work with a huge action, you may want to pass a class instance instead of a block,
+#   # the method #process will be called with the current response as an argument.
+#   # The important difference is that you must return the new response when exiting #process, instead of modifying "response" as you do in blocks
+#   
+#    class MyCustomAction
+#      def process(response)
+#        # do stuff
+#        return new_response
+#      end
+#    end
+#
+#    add_action :name_of_action, MyCustomAction.new
+#
+# end

data/lib/akiva/core_brain/filters/get_answers_from_subjects_and_properties.rb

@@ -0,0 +1,15 @@
+Akiva::Brain.update do
+  # The priority is based upon order of creation: last created -> highest priority.
+
+  add_filter :get_answers_from_subjects_and_properties,
+    /\A(?:What (?:is|are)|What's) the (?<properties>.+?) of (?:a |an |the )?(?<subjects>.+?)(?: \?)?\z/i,
+    formatter: :list_all_answers
+
+  add_filter :get_answers_from_subjects_and_properties,
+    /\AIs (?<subject1>.+?) (?<comparison_adjective>(#{Akiva::Brain::Helpers::ComparisonAdjectivesToProperties.keys.join("|")})?) than (?<subject2>.+?)(?: \?)?\z/i,
+    before_action: [:regroup_separated_subjects, :extract_property_from_comparison_adjective],
+    after_action: [:compare_two_subjects_properties_from_comparison_adjective],
+    formatter: :boolean_from_comparison
+
+
+end

data/lib/akiva/core_brain/filters/template.rb

@@ -0,0 +1,9 @@
+# Akiva::Brain.update do
+#
+#   add_filter :name_of_the_action_that_will_be_called,
+#     /regex matching that will trigger this action/i,
+#     before_action: [:pre_action_one, :pre_action_two, [...]], # will be executed in this order
+#     after_action: [:post_action_one, :post_action_two, [...]], # will be executed in this order
+#     formatter: :name_of_formatter
+#
+# end

data/lib/akiva/core_brain/formatters/boolean_from_comparison.rb

@@ -0,0 +1,17 @@
+Akiva::Brain.update do
+  
+  add_formatter :boolean_from_comparison do |response|
+    if response.has_key?(:comparison_boolean_result)
+      if response[:comparison_boolean_result]
+        response[:formatted] = "Yes"
+      else
+        response[:formatted] = "No"
+      end
+
+      if response.has_key?(:actions_chain) and response[:actions_chain].include?(:compare_two_subjects_properties_from_comparison_adjective)
+        response[:formatted] += " (#{Akiva::Brain.formatters[:list_all_answers].call(response)})"
+      end
+    end
+  end
+
+end

data/lib/akiva/core_brain/formatters/list_all_answers.rb

@@ -0,0 +1,28 @@
+Akiva::Brain.update do
+
+  add_formatter :list_all_answers do |response|
+    
+    describe_properties = lambda do |subject|
+      if (properties = response[:properties][subject]).size == 1 # if there is only one property
+        response[:answers][subject][properties.first]
+      else # if there are multiple properties
+        answers = response[:answers][subject].values
+        properties.map.with_index do |property, i|
+          property.capitalize + ": " + answers[i]
+        end.join(", ")
+      end
+    end
+
+    if response[:subjects]
+      if response[:subjects].size == 1 # if there's only one subject
+        response[:formatted] = describe_properties.call(response[:subjects].first)
+      else # if there are multiple subjects
+        response[:formatted] = response[:subjects].map do |subject|
+          subject + " => " + describe_properties.call(subject)
+        end.join("; ")
+      end
+    end
+    
+  end
+
+end

data/lib/akiva/core_brain/formatters/template.rb

@@ -0,0 +1,19 @@
+# Akiva::Brain.update do
+#
+#   add_formatter :formatter_name do |response|
+#     # you must set response[:formatted] as a textual answer to the question
+#   end
+#
+#   # If you're going to work with a huge formatter, you may want to pass a class instance instead of a block,
+#   # the method #process will be called with the current response as an argument.
+#   # The important difference is that you must return the new response when exiting #process, instead of modifying "response" as you do in blocks
+#   
+#    class MyCustomFormatter
+#      def process(response)
+#        # do stuff
+#        return new_response
+#      end
+#    end
+#
+#    add_formatter :name_of_action, MyCustomFormatter.new
+# end

data/lib/akiva/core_brain/helpers/comparison_adjectives_to_properties.rb

@@ -0,0 +1,151 @@
+module Akiva
+  module Brain
+    module Helpers
+      ComparisonAdjectivesToProperties = {
+        "bigger" => {properties: %w(size), comparator: "superior"},
+        "blacker" => {properties: %w(blackness), comparator: "superior"},
+        "bolder" => {properties: %w(boldness), comparator: "superior"},
+        "braver" => {properties: %w(courage), comparator: "superior"},
+        "brighter" => {properties: %w(brightness), comparator: "superior"},
+        "busier" => {properties: %w(business), comparator: "superior"},
+        # "cleaner" => {properties: %w(cleanliness)},
+        "clearer" => {properties: %w(clearness), comparator: "superior"},
+        # "cleverer" => {properties: %w(cleverness)},
+        "colder" => {properties: %w(temperature), comparator: "inferior"},
+        "cooler" => {properties: %w(temperature), comparator: "inferior"},
+        "darker" => {properties: %w(luminosity), comparator: "inferior"},
+        # "dearer" => {properties: %w(dearness)},
+        "deeper" => {properties: %w(depth), comparator: "superior"},
+        # "dirtier" => {properties: %w(dirtiness)},
+        "drier" => {properties: %w(humidity), comparator: "inferior"},
+        # "easier" => {properties: %w(easiness)},
+        # "fairer" => {properties: %w(fairness)},
+        "faster" => {properties: %w(speed), comparator: "superior"},
+        "fatter" => {properties: %w(fatness), comparator: "superior"},
+        # "finer" => {properties: %w()},
+        "funnier" => {properties: %w(funniness), comparator: "superior"},
+        "greater" => {properties: %w(greatness), comparator: "superior"},
+        "greener" => {properties: %w(greeness), comparator: "superior"},
+        # "happier" => {properties: %w(happiness)},
+        # "harder" => {properties: %w(hardness)},
+        "healthier" => {properties: %w(healthiness)},
+        "heavier" => {properties: ["weight", "average weight"], comparator: "superior"},
+        # "higher" => {properties: %w(highness)},
+        "hotter" => {properties: %w(temperature), comparator: "superior"},
+        # "kinder" => {properties: %w(kindness)},
+        "larger" => {properties: %w(size), comparator: "superior"},
+        # "later" => {properties: %w(timing)},
+        # "lazier" => {properties: %w(laziness)},
+        "lighter" => {properties: ["weight", "average weight"], comparator: "inferior"},
+        "longer" => {properties: %w(size duration), comparator: "superior"},
+        # "lower" => {properties: %w(lowerness)},
+        # "luckier" => {properties: %w(luck)},
+        # "madder" => {properties: %w(madness)},
+        # "merrier" => {properties: %w(merriness)},
+        # "narrower" => {properties: %w(narrowness)},
+        # "naughtier" => {properties: %w(naughtiness)},
+        # "nearer" => {properties: %w(nearness)},
+        "newer" => {properties: ["age", "creation date", "release date"], comparator: "inferior"},
+        # "noiser" => {properties: %w(noisiness)},
+        "older" => {properties: ["age", "creation date", "release date"], comparator: "superior"},
+        # "paler" => {properties: %w(paleness)},
+        "poorer" => {properties: ["net worth"], comparator: "inferior"},
+        # "prettier" => {properties: %w(prettiness)},
+        # "prouder" => {properties: %w(proudness)},
+        "quicker" => {properties: %w(speed), comparator: "superior"},
+        # "redder" => {properties: %w(redness)},
+        "richer" => {properties: ["net worth"], comparator: "superior"},
+        # "sadder" => {properties: %w(sadness)},
+        # "saffer" => {properties: %w(safeness)},
+        # "shallower" => {properties: %w(shallowness)},
+        # "sharper" => {properties: %w(sharpness)},
+        "shorter" => {properties: %w(size duration), comparator: "inferior"},
+        # "shallower" => {properties: %w(shallowness)},
+        "slower" => {properties: %w(speed), comparator: "inferior"},
+        "smaller" => {properties: %w(size duration), comparator: "inferior"},
+        # "smoother" => {properties: %w(smoothness)},
+        "stronger" => {properties: %w(power), comparator: "superior"},
+        # "sweeter" => {properties: %w(sweetness)},
+        "taller" => {properties: %w(height size), comparator: "superior"},
+        # "thicker" => {properties: %w(thickness)},
+        "thinner" => {properties: %w(size), comparator: "inferior"},
+        "tinier" => {properties: %w(size), comparator: "inferior"},
+        # "uglier" => {properties: %w(ugliness)},
+        "warmer" => {properties: %w(temperature), comparator: "superior"},
+        "weakness" => {properties: %w(power), comparator: "inferior"},
+        "wealthier" => {properties: ["net worth"], comparator: "superior"},
+        "wetter" => {properties: %w(humidity), comparator: "superior"},
+        # "whither" => {properties: %w()},
+        "wider" => {properties: %w(wideness size), comparator: "superior"},
+        # "wilder" => {properties: %w(wildness)},
+        # "wiser" => {properties: %w(wiseness)},
+        "younger" => {properties: %w(age), comparator: "inferior"},
+
+
+        "more ancient" => {properties: ["age", "creation date", "release date"], comparator: "inferior"},
+        # "more beautiful" => {properties: %w(looks)},
+        # "more brilliant" => {properties: %w(brilliantness)},
+        # "more careful" => {properties: %w(carefulness)},
+        # "more careless" => {properties: %w(carefulness)},
+        # "more cheerful" => {properties: %w(cheerfulness)},
+        # "more comfortable" => {properties: %w(comfortableness)},
+        # "more dangerous" => {properties: %w(dangerousness)},
+        # "more delightful" => {properties: %w(delightfulness)},
+        # "more difficult" => {properties: %w(difficultness)},
+        # "more enjoyable" => {properties: %w(enjoyability)},
+        # "more foolish" => {properties: %w(foolishness)},
+        # "more forgetful" => {properties: %w(forgetfulness)},
+        # "more frightening" => {properties: %w(frighteningness)},
+        # "more generous" => {properties: %w(generousness)},
+        # "more handsome" => {properties: %w(handsomeness)},
+        # "more helpful" => {properties: %w(helpfulness)},
+        # "more ignorant" => {properties: %w(ignorantness)},
+        # "more important" => {properties: %w(importantness)},
+        # "more intelligent" => {properties: %w(intelligentness)},
+        # "more interesting" => {properties: %w(interestingness)},
+        # "more pleasant" => {properties: %w(pleasantness)},
+        "more powerful" => {properties: %w(power), comparator: "superior"},
+        "more prosperous" => {properties: ["gross domestic product"], comparator: "superior"},
+        # "more sensible" => {properties: %w(sensibleness)},
+        # "more terrible" => {properties: %w(terribleness)},
+        # "more thoughtful" => {properties: %w(thoughtfulness)},
+        # "more unusual" => {properties: %w(unusualness)},
+        # "more useful" => {properties: %w(usefulness)},
+        "more valuable" => {properties: ["worth", "price"], comparator: "superior"},
+        # "more wonderful" => {properties: %w(wonderfulness)},
+
+        "less ancient" => {properties: ["age", "creation date", "release date"], comparator: "inferior"},
+        # "less beautiful" => {properties: %w(looks)},
+        # "less brilliant" => {properties: %w(brilliantness)},
+        # "less careful" => {properties: %w(carefulness)},
+        # "less careless" => {properties: %w(carefulness)},
+        # "less cheerful" => {properties: %w(cheerfulness)},
+        # "less comfortable" => {properties: %w(comfortableness)},
+        # "less dangerous" => {properties: %w(dangerousness)},
+        # "less delightful" => {properties: %w(delightfulness)},
+        # "less difficult" => {properties: %w(difficultness)},
+        # "less enjoyable" => {properties: %w(enjoyability)},
+        # "less foolish" => {properties: %w(foolishness)},
+        # "less forgetful" => {properties: %w(forgetfulness)},
+        # "less frightening" => {properties: %w(frighteningness)},
+        # "less generous" => {properties: %w(generousness)},
+        # "less handsome" => {properties: %w(handsomeness)},
+        # "less helpful" => {properties: %w(helpfulness)},
+        # "less ignorant" => {properties: %w(ignorantness)},
+        # "less important" => {properties: %w(importantness)},
+        # "less intelligent" => {properties: %w(intelligentness)},
+        # "less interesting" => {properties: %w(interestingness)},
+        # "less pleasant" => {properties: %w(pleasantness)},
+        "less powerful" => {properties: %w(power), comparator: "superior"},
+        "less prosperous" => {properties: ["gross domestic product"], comparator: "superior"},
+        # "less sensible" => {properties: %w(sensibleness)},
+        # "less terrible" => {properties: %w(terribleness)},
+        # "less thoughtful" => {properties: %w(thoughtfulness)},
+        # "less unusual" => {properties: %w(unusualness)},
+        # "less useful" => {properties: %w(usefulness)},
+        "less valuable" => {properties: ["worth", "price"], comparator: "superior"},
+        # "less wonderful" => {properties: %w(wonderfulness)},
+      }
+    end
+  end
+end

data/lib/akiva/core_brain/helpers/misc.rb

@@ -0,0 +1,28 @@
+module Akiva
+  module Brain
+    module Helpers
+
+      def self.degroup_multiple_values(string)
+        # NOTE: we probably should check the dictionary here to improve the values detections,
+        # and limit the number of requests made.
+        values = []
+
+        string.split(" && ").each do |sub0|
+          sub0.split(",").each do |sub1|
+            sub1.split(" and ").each do |sub2|
+              val = sub2.strip
+              val.gsub!(/\A(a|an|the) /i, "")
+              values << val
+            end
+          end
+        end
+
+        values.uniq
+      end
+
+      def self.cleanup_articles(string)
+        string.gsub(/\A(a|an|the) /i, "")
+      end
+    end
+  end
+end

data/lib/akiva/core_brain/helpers/units.rb

@@ -0,0 +1,167 @@
+module Akiva
+  module Brain
+    module Helpers
+      class Units
+        class UnitNotRecognizedError < StandardError; end
+        class IncompatibleUnitsError < StandardError; end
+        class TooLongToInstantiateError < StandardError; end
+        class NeedTwoValuesToCompareError < StandardError; end
+        class CantCompareMoreThanTwoValuesError < StandardError; end
+        class InputMustBeAnArray < StandardError; end
+
+        attr_reader :input, :result, :instantiated_values, :first_value, :last_value
+
+        def initialize(input)
+          @input = input
+        end
+
+        def compare(options = {})
+          check_presence_of_values
+          check_type_of_values
+          check_length_of_values_for_comparison
+          instantiate_values
+          check_compatibility_of_units
+
+          @first_value = @instantiated_values.first
+          @last_value = @instantiated_values.last
+
+          if multiplicators = options[:multiplicators]
+            @first_value = (@first_value * multiplicators[0]) if multiplicators[0]
+            @last_value = (@last_value * multiplicators[1]) if multiplicators[1]
+          end
+
+          @first_value, @last_value = self.class.adjust_units(@first_value, @last_value)
+
+          if @first_value > @last_value
+            @result = "superior"
+          elsif @first_value < @last_value
+            @result = "inferior"
+          else
+            @result = "equal"
+          end
+        end
+
+        def sort
+          check_presence_of_values
+          check_type_of_values
+          check_maximum_length_of_values
+          instantiate_values
+          check_compatibility_of_units
+
+          @result = @instantiated_values.sort
+        end
+
+        def convert(new_unit = "")
+          instantiate_values
+
+          begin
+            new_instantiated_value = @instantiated_value.convert_to(new_unit)
+            @result = new_instantiated_value.scalar.to_f.to_s
+            @result = @result[0..@result.size-3] if @result.match(/\.0$/) # 135.0 => 135
+          rescue ArgumentError => error_string
+            if error_string.to_s.include?("Unit not recognized") or error_string.to_s.include?("No Unit Specified")
+              raise UnitNotRecognizedError
+            elsif error_string.to_s.include?("Incompatible Units")
+              raise IncompatibleUnitsError
+            else
+              raise
+            end
+          end
+        end
+
+
+        def self.adjust_units(value_1, value_2)
+          if ((value_1.to_s.include?("e+") or value_1.to_s.include?("e-")) and (!value_2.to_s.include?("e+") and !value_2.to_s.include?("e-"))) or value_1.scalar.to_s.size > value_2.scalar.to_s.size
+            value_1 = value_1.convert_to(value_2)
+          elsif ((!value_1.to_s.include?("e+") and !value_1.to_s.include?("e-")) and (value_2.to_s.include?("e+") or value_2.to_s.include?("e-"))) or value_1.scalar.to_s.size < value_2.scalar.to_s.size
+            value_2 = value_2.convert_to(value_1)
+          end
+
+          [value_1, value_2]
+        end
+
+        private
+        def check_presence_of_value
+          if @input.nil?
+            raise NeedTwoValuesToCompareError
+          end
+        end
+
+        def check_presence_of_values
+          if @input.nil?
+            raise NeedTwoValuesToCompareError
+          end
+        end
+
+        def check_type_of_values
+          unless @input.is_a?(Array) or @input.is_a?(Hash)
+            raise InputMustBeAnArray
+          end
+        end
+
+        def check_length_of_values_for_comparison
+          if @input.size < 2
+            raise NeedTwoValuesToCompareError
+          elsif @input.size > 2
+            raise CantCompareMoreThanTwoValuesError
+          end
+        end
+
+        def check_maximum_length_of_values
+          if @input.size > 100
+            raise CantCompareMoreThanTwoValuesError
+          end
+        end
+
+        def instantiate_values
+          # we accept strings here specially for the "convert" action
+          # everywhere else it is filtered with check_type_of_values
+
+          if @input.is_a?(String)
+            values_strings = [@input]
+          elsif @input.is_a?(Hash)
+            values_strings = @input.values
+          else
+            values_strings = @input
+          end
+
+          begin
+            # we check how much time it takes because it can be REALLY slow be big textual values
+            # e.g. "900000000000000000000000000000000000 meters" took 5secs to instantiate (!)
+            Timeout::timeout(0.1) do
+              if @input.is_a?(String)
+                @instantiated_value = Unit(@input)
+              elsif values_strings.is_a?(Array)
+                @instantiated_values = values_strings.map{|_| Unit(_) }
+              end
+            end
+          rescue Timeout::Error
+            raise CantCompareMoreThanTwoValuesError
+            return false
+          rescue ArgumentError => error_string
+            if error_string.to_s.include?("Unit not recognized")
+              raise UnitNotRecognizedError
+              return false
+            else
+              raise # error unknown
+            end
+          end
+        end
+
+        def check_compatibility_of_units
+          # we simply check if it can be sorted
+          begin
+            @instantiated_values.sort
+          rescue ArgumentError => error_string
+            if error_string.to_s.include?("Incompatible Units")
+              raise IncompatibleUnitsError.new(error_string)
+            else
+              raise
+            end
+          end
+        end
+
+      end
+    end
+  end
+end