Remove predicate functionality

doc/smart-answer-flows.md

@@ -107,19 +107,6 @@ next_node(permitted: permitted_next_nodes) do |response|
 end
 ```
 
-#### DEPRECATED: Using predicates
-
-This is the same example from above expressed using predicates:
-
-```ruby
-next_node_if(:green, responded_with('green')) )
-next_node(:red)
-```
-
-The `responded_with` function actually returns a [predicate](http://en.wikipedia.org/wiki/Predicate_%28mathematical_logic%29) which will be invoked during processing. If the predicate returns `true` then the `:green` node will be next, otherwise the next rule will be evaluated. In this case the next rule says `:red` is the next node with no condition.
-
-See [Smart Answer predicates](smart-answers-predicates.md) for more detailed information about this style.
-
 ### Storing data for later use
 
 You can use the `precalculate`, `next_node_calculation`, `save_input_as` and `calculate` methods to store data for later use.

lib/graph_presenter.rb

@@ -13,9 +13,6 @@ def adjacency_list
       adjacency_list = {}
       @flow.questions.each do |node|
         adjacency_list[node.name] = []
-        node.next_node_function_chain.each do |(nextnode, predicates)|
-          adjacency_list[node.name] << [nextnode, predicates.map(&:label).compact.join(" AND\n")]
-        end
         node.permitted_next_nodes.each do |permitted_next_node|
           existing_next_nodes = adjacency_list[node.name].map(&:first)
           unless existing_next_nodes.include?(permitted_next_node)

lib/smart_answer/calculators/registrations_data_query.rb

@@ -60,10 +60,6 @@ def commonwealth_country?(country_slug)
       COMMONWEALTH_COUNTRIES.include?(country_slug)
     end
 
-    def responded_with_commonwealth_country?
-      SmartAnswer::Predicate::RespondedWith.new(COMMONWEALTH_COUNTRIES, "commonwealth country")
-    end
-
     def has_consulate?(country_slug)
       COUNTRIES_WITH_CONSULATES.include?(country_slug)
     end

lib/smart_answer/question/base.rb

@@ -1,17 +1,13 @@
 module SmartAnswer
   module Question
     class Base < Node
-      attr_reader :next_node_function_chain
       class NextNodeUndefined < StandardError; end
 
       def initialize(flow, name, options = {}, &block)
         @save_input_as = nil
         @validations ||= []
-        @next_node_function_chain ||= []
         @default_next_node_function ||= lambda {|_|}
         @permitted_next_nodes = []
-        @predicate_stack = []
-        @predicates = {}
         @uses_erb_template = options[:use_erb_template]
         super
       end
@@ -24,18 +20,13 @@ def next_node(next_node = nil, permitted: [], &block)
           @permitted_next_nodes += permitted
           @default_next_node_function = block
         elsif next_node
-          next_node_if(next_node)
+          @permitted_next_nodes = [next_node]
+          @default_next_node_function = proc { next_node }
         else
           raise ArgumentError
         end
       end
 
-      def next_node_if(next_node, *predicates, &block)
-        predicates << block if block_given?
-        @next_node_function_chain << [next_node, normalize_predicates(@predicate_stack + predicates)]
-        @permitted_next_nodes << next_node
-      end
-
       def validate(message = nil, &block)
         @validations << [message, block]
       end
@@ -46,7 +37,7 @@ def permitted_next_nodes(*args)
 
       def next_node_for(current_state, input)
         validate!(current_state, input)
-        next_node = next_node_from_function_chain(current_state, input) || next_node_from_default_function(current_state, input)
+        next_node = next_node_from_default_function(current_state, input)
         responses_and_input = current_state.responses + [input]
         raise NextNodeUndefined.new("Next node undefined. Node: #{current_state.current_node}. Responses: #{responses_and_input}") unless next_node
         unless @permitted_next_nodes.include?(next_node)
@@ -74,47 +65,6 @@ def transition(current_state, raw_input)
         new_state
       end
 
-      # Within an #on_condition block, all #next_node and #next_node_if
-      # clauses must additionally satisfy the given predicate. Nesting of
-      # #on_condition blocks is permitted.
-      #
-      # Example:
-      #
-      # on_condition(->(r) {r == 'tourism'}) do
-      #   next_node_if(:outcome_visit_waiver) { %w(oman qatar united-arab-emirates).include?(passport_country) }
-      #   next_node_if(:outcome_taiwan_exception) { %w(taiwan).include?(passport_country) }
-      #   next_node_if(:outcome_school_n) do
-      #     country_group_non_visa_national.include?(passport_country) or country_group_ukot.include?(passport_country))
-      #   end
-      #   next_node(:outcome_general_y)
-      # end
-      def on_condition(predicate, &block)
-        @predicate_stack << predicate
-        instance_eval(&block)
-        @predicate_stack.pop
-      end
-
-      def responded_with(acceptable_responses)
-        SmartAnswer::Predicate::RespondedWith.new(acceptable_responses)
-      end
-
-      def variable_matches(variable_name, acceptable_responses)
-        SmartAnswer::Predicate::VariableMatches.new(variable_name, acceptable_responses)
-      end
-
-      def define_predicate(identifier, label = nil, &block)
-        raise "method #{identifier} already defined" if self.class.method_defined?(identifier)
-        @predicates[identifier] = SmartAnswer::Predicate::Callable.new(label || identifier.to_s, &block)
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        @predicates.has_key?(method)
-      end
-
-      def method_missing(method, *args, &block)
-        @predicates.fetch(method)
-      end
-
       def parse_input(raw_input)
         raw_input
       end
@@ -148,25 +98,6 @@ def validate!(current_state, input)
         end
       end
 
-      def normalize_predicates(predicates)
-        predicates.map do |predicate|
-          if predicate.is_a?(SmartAnswer::Predicate::Base)
-            predicate
-          else
-            SmartAnswer::Predicate::Callable.new(nil, predicate)
-          end
-        end
-      end
-
-      def next_node_from_function_chain(current_state, input)
-        found = @next_node_function_chain.find do |(_, predicates)|
-          predicates.all? do |predicate|
-            predicate.call(current_state, input)
-          end
-        end
-        found && found.first
-      end
-
       def next_node_from_default_function(current_state, input)
         current_state.instance_exec(input, &@default_next_node_function)
       end