houdini 0.2.4 → 0.3.0

data/lib/houdini/postback_processor.rb

@@ -0,0 +1,21 @@
+module Houdini
+  module PostbackProcessor
+    EnvironmentMismatchError = Class.new RuntimeError
+    APIKeyMistmatchError     = Class.new RuntimeError
+
+    def self.process(class_name, model_id, params)
+      task_manager = params.delete(:task_manager) || TaskManager
+
+      if params[:environment] != Houdini.environment
+        raise EnvironmentMismatchError, "Environment received does not match Houdini.environment"
+      end
+
+			# # Houdini doesn't send the API key back
+      # if params[:api_key] != Houdini.api_key and params[:environment] == "production"
+      #   raise APIKeyMistmatchError, "API key received doesn't match our API key."
+      # end
+
+      task_manager.process class_name, model_id, params[:blueprint], params[:output], params[:verbose_output]
+    end
+  end
+end

data/lib/houdini/task.rb

@@ -1,15 +1,51 @@
 module Houdini
   class Task
-    attr_accessor :short_name, :version, :task_info, :on, :if, :after_submit, :on_task_completion
-
-    def initialize(short_name, options)
-      @short_name = short_name.to_s
-      @version = options[:version]
-      @task_info = options[:task_info]
-      @on = options[:on] || :after_create
-      @if = options[:if] || true
-      @after_submit = options[:after_submit]
-      @on_task_completion = options[:on_task_completion] || :update_attributes
+    attr :options
+    protected :options
+
+    def initialize(klass, blueprint, options={})
+      @class_name         = klass.name
+      @blueprint          = blueprint.to_s
+      @input              = options[:input]
+      @after_submit       = options[:after_submit]
+      @on_task_completion = options[:on_task_completion]
+      @finder             = options[:finder] || :find
+      @id_method          = options[:id_method] || :id
+    end
+
+    def process(object_id, results, verbose_results)
+      # we have to re-constantize the class name because Rails reloads the classes in development
+      obj = self.class.callable @class_name.constantize, @finder, object_id
+      self.class.callable obj, @on_task_completion, results, verbose_results  if @on_task_completion
+    end
+
+    def submit!(object, options={})
+      get_input   = options[:input_transformer] || self.class.method(:get_input)
+      submit_task = options[:submit_task]       || Houdini.method(:submit!)
+
+      id = self.class.callable object, @id_method
+
+      submit_task.call @blueprint, object.class.name, id, get_input.call(object, @input)
+
+      self.class.callable(object, @after_submit) if @after_submit
+    end
+
+    def self.get_input(object, input)
+      input.inject({}) do |hash, (info_name, model_attribute)|
+        hash.merge info_name => callable(object, model_attribute){ model_attribute }
+      end
+    end
+
+    def self.callable(object, callable, *args)
+      if callable.is_a? Symbol
+        object.send callable, *args
+      elsif callable.respond_to? :call
+        object.instance_exec *args, &callable
+      elsif block_given?
+        yield callable, *args
+      else
+        raise "#{callable.inspect} is not a Symbol and does not respond to #call"
+      end
     end
   end
 end

data/lib/houdini/task_manager.rb

@@ -0,0 +1,20 @@
+module Houdini
+  module TaskManager
+    def self.register(klass, blueprint, options, task_builder=Task)
+      @tasks ||= {}
+      @tasks[ [klass.name, blueprint.to_sym] ] = task_builder.new(klass, blueprint, options)
+    end
+
+    def self.submit!(object, blueprint)
+      if @tasks
+        task = @tasks[ [object.class.name, blueprint.to_sym] ]
+        task.submit! object
+      end
+    end
+
+    def self.process(class_name, id, blueprint, output, verbose_output)
+      task = @tasks[ [class_name, blueprint.to_sym] ]
+      task.process id, output, verbose_output
+    end
+  end
+end

data/lib/houdini/version.rb

@@ -1,3 +1,3 @@
 module Houdini
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/spec/dummy/app/models/article.rb

@@ -2,24 +2,22 @@ class Article < ActiveRecord::Base
   include Houdini::Model
 
   houdini :edit_for_grammar,
-    :version => 1,
-    :task_info => {
-      'original_text' => :original_text,
+    :input => {
+      'input1' => :original_text,
+      'input2' => proc{ original_text },
+      'input3' => "some text"
     },
-    :after_submit => :update_houdini_attributes,
-    :on_task_completion => :process_houdini_edited_text
-
-  after_create :moderate_image, :if => :original_text
-
-  def moderate_image
-    Houdini.perform!(:edit_for_grammar, self)
-  end
+    :on                 => :after_create,
+    :after_submit       => :update_houdini_attributes,
+    :on_task_completion => :process_houdini_edited_text,
+    :finder             => lambda{|id| last },
+    :id_method          => lambda{ 'model-slug' }
 
   def update_houdini_attributes
-    update_attribute(:houdini_request_sent_at, Time.now)
+    update_attribute(:houdini_request_sent_at, Date.today.to_time)
   end
 
-  def process_houdini_edited_text(params)
-    update_attribute(:edited_text, params[:edited_text])
+  def process_houdini_edited_text(output, verbose_output)
+    update_attribute(:edited_text, output[:edited_text])
   end
 end

data/spec/houdini/model_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Houdini::Model do
+  let :test_model do
+    Class.new do
+      include Houdini::Model
+    end
+  end
+
+  describe ".houdini" do
+    it "should define a method that submits the task" do
+      task_manager = double :task_manager
+      task_manager.should_receive(:register).with(test_model, :blueprint_name, :other_options => {})
+      test_model.houdini :blueprint_name, :task_manager => task_manager, :other_options => {}
+
+      test_model_instance = test_model.new
+
+      task_manager.should_receive(:submit!).with(test_model_instance, :blueprint_name)
+      test_model_instance.houdini_submit_blueprint_name!
+    end
+
+    it "should attach callback methods" do
+      test_model.should_receive(:after_create).with(:houdini_submit_blueprint_name!)
+      test_model.houdini :blueprint_name, :on => :after_create
+    end
+  end
+end

data/spec/houdini/postback_processor_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Houdini::PostbackProcessor, ".process!" do
+  let(:houdini_settings) do
+    { :environment => "production", :api_key => "MY_KEY", :app_url => "http://localhost:3000" }
+  end
+  context "when the environments dont match" do
+    before do
+      Houdini.setup "production", houdini_settings
+    end
+
+    it "should raise an EnvironmentMismatchError" do
+      lambda{
+        Houdini::PostbackProcessor.process 'Class', 42, :environment => "sandbox"
+      }.should raise_error(Houdini::PostbackProcessor::EnvironmentMismatchError)
+    end
+  end
+
+  context "when in production and given API key doesn't match" do
+    it "should raise an APIKeyMistmatchError" do
+			pending "Houdini doesn't send the API key back."
+      lambda{
+        Houdini::PostbackProcessor.process 'Class', 42, :environment => "production", :api_key => "ANOTHER_KEY"
+      }.should raise_error(Houdini::PostbackProcessor::APIKeyMistmatchError)
+    end
+  end
+
+  context "given a classname and id" do
+    it "should load the object, and have it process the postback, and return the result" do
+      task_manager   = double :task_manager
+      output         = double :output
+      verbose_output = double :verbose_output
+
+      task_manager.should_receive(:process).with('MyClass', 42, 'blueprint_name', output, verbose_output)
+
+      Houdini::PostbackProcessor.process 'MyClass', 42, houdini_settings.merge(
+        :blueprint      => 'blueprint_name',
+        :output         => output,
+        :verbose_output => verbose_output,
+        :task_manager   => task_manager
+      )
+    end
+  end
+end

data/spec/houdini/task_manager_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Houdini::TaskManager do
+  describe ".register, .submit!, and .process" do
+    class MyClass; end
+
+    it "should save it and let us call it again, when we give the right blueprint and class" do
+      options                = double :options
+      task_builder           = double :task_builder
+      task                   = double :task
+      obj                    = MyClass.new
+      houdini_output         = double :houdini_output
+      verbose_houdini_output = double :verbose_houdini_output
+      processing_result      = double :processing_result
+
+      task_builder.should_receive(:new).with(MyClass, :blueprint_name, options).and_return(task)
+      Houdini::TaskManager.register(MyClass, :blueprint_name, options, task_builder)
+
+      task.should_receive(:submit!).with(obj)
+      Houdini::TaskManager.submit!(obj, :blueprint_name)
+
+      task.should_receive(:process).with(42, houdini_output, verbose_houdini_output).and_return(processing_result)
+      Houdini::TaskManager.process('MyClass', 42, 'blueprint_name', houdini_output, verbose_houdini_output).should == processing_result
+    end
+  end
+end

data/spec/houdini/task_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Houdini::Task do
+  describe "submit!(obj)" do
+    class TestModel
+      def id; 42; end
+    end
+
+    let(:model_object){ TestModel.new }
+    let(:input){ double :input }
+    it "should use the input transformer and submit it to houdini" do
+      task = Houdini::Task.new TestModel, :blueprint
+      submit_task = double(:callable)
+      submit_task.should_receive(:call).with('blueprint', "TestModel", 42, input)
+      task.submit! model_object, :input_transformer => proc{ input }, :submit_task => submit_task
+    end
+
+    it "should call the after_submit callback, when given a symbol" do
+      task = Houdini::Task.new TestModel, :blueprint, :after_submit => :after_submit
+      model_object.should_receive :after_submit
+      task.submit! model_object, :input_transformer => proc{}, :submit_task => proc{}
+    end
+
+    it "should call the after_submit callback, when given a block" do
+      task = Houdini::Task.new TestModel, :blueprint, :after_submit => proc{ after_submit }
+      model_object.should_receive :after_submit
+      task.submit! model_object, :input_transformer => proc{}, :submit_task => proc{}
+    end
+
+    it "should call the :id you provided to get the id" do
+      task = Houdini::Task.new TestModel, :blueprint, :id_method => lambda{ 'model-id' }
+      submit_task = double(:callable)
+      submit_task.should_receive(:call).with('blueprint', "TestModel", 'model-id', nil)
+      task.submit! model_object, :input_transformer => proc{}, :submit_task => submit_task
+    end
+  end
+
+  describe ".callable" do
+    let(:obj){ double :obj, :some_method => result }
+    subject{ Houdini::Task.callable(obj, callable, *args) }
+    let(:result){ double :result }
+    let(:args){ [double(:arg1), double(:arg2)] }
+
+    context "given a symbol" do
+      let(:callable){ :some_method }
+      before{ obj.should_receive(:some_method).with(*args) }
+      it{ should == result }
+    end
+
+    context "given a proc" do
+      let(:callable){ lambda{|*args| some_method(*args) } }
+      before{ obj.should_receive(:some_method).with(*args) }
+      it{ should == result }
+    end
+
+    context "given something else" do
+      let(:callable){ 42 }
+      it "should raise an error" do
+        lambda{
+          Houdini::Task.callable(obj, callable)
+        }.should raise_error
+      end
+
+      context "and also given a block" do
+        it "should call the block with the callable and return the result" do
+          Houdini::Task.callable(double, 42){|c| c * 2 }.should == 84
+        end
+      end
+    end
+  end
+
+  describe ".get_input" do
+    subject{ Houdini::Task.get_input(input_object, input_hash) }
+    let(:input_object){ double :obj, :some_method => "some input", :some_method2 => "some more input" }
+
+    context "given an object and an instance hash" do
+      let(:input_hash){  { :input1 => :some_method, :input2 => :some_method2 }  }
+      it "should build a hash based on the one given, and the values in the object" do
+        should == { :input1 => "some input", :input2 => "some more input" }
+      end
+    end
+    context "given symbols" do
+      let(:input_hash){ { :input1=>:some_method } }
+      it "should get call the corresponding methods" do
+        should == { :input1 => "some input" }
+      end
+    end
+    context "given lambdas" do
+      let(:input_hash){ { :input1=>lambda{some_method} }  }
+      it "should use evaluate procs in the context of the given object" do
+        should == { :input1 => "some input" }
+      end
+    end
+    context "given procs" do
+      let(:input_hash){ { :input1=>proc{some_method} }  }
+      it "should use evaluate procs in the context of the given object" do
+        should == { :input1 => "some input" }
+      end
+    end
+    context "given other values" do
+      let(:input_hash){ { :input1=>"some input", :input2=>42 } }
+      it "should return the value, if it's not callable" do
+        should == input_hash
+      end
+    end
+  end
+
+  describe "#process" do
+		class TestClass
+		end
+
+    it "should call the callback on the object, giving it the houdini output, and verbose output, and return the result" do
+      obj = double :obj
+      houdini_output         = double :houdini_output
+      verbose_houdini_output = double :verbose_houdini_output
+      process_result         = double :process_result
+
+      task = Houdini::Task.new TestClass, :blueprint_name, :on_task_completion => :after_houdini_completion, :finder => :custom_finder
+
+      TestClass.should_receive(:custom_finder).with(42).and_return(obj)
+      obj.should_receive(:after_houdini_completion).with(houdini_output, verbose_houdini_output).and_return(process_result)
+
+      task.process 42, houdini_output, verbose_houdini_output
+    end
+
+    it "should reload the class from it's name, so that this can work in Rails dev mode" do
+			klass = double :klass, :name => 'TestClass'
+
+      task = Houdini::Task.new klass, :blueprint_name
+
+      TestClass.should_receive(:find)
+
+      task.process 42, double, double
+    end
+  end
+end

data/spec/houdini_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Houdini, ".submit!" do
+  it "should call .request with the right paramers" do
+    Houdini.setup "some_environment", :api_key =>"SOME-API-KEY", :app_url => "http://localhost:3000"
+
+    expected_params = {
+      :environment  => "some_environment",
+      :api_key      => "SOME-API-KEY",
+      :blueprint    => :blueprint_name,
+      :postback_url => "http://localhost:3000/houdini/ClassName/42/postbacks",
+      :input        => { :input1 => 1, :input2 => 'two' }
+    }
+
+    Houdini.should_receive(:request).with(expected_params)
+
+    Houdini.submit! :blueprint_name, "ClassName", 42, :input1 => 1, :input2 => 'two'
+  end
+
+	it "should not send requests if environment is 'test'" do
+    Houdini.setup "test", :api_key => "SOME-API-KEY", :app_url => "http://localhost:3000"
+    Houdini.should_receive(:request).never
+    Houdini.submit! :blueprint_name, "ClassName", 42, :input1 => 1, :input2 => 'two'
+	end
+end

data/spec/requests/integration_spec.rb

@@ -1,35 +1,37 @@
 require 'spec_helper'
 
-describe "Text Classification" do
+describe "End-to-end" do
   before do
+    Houdini.setup 'production', :app_url => "http://my-app:3333/"
     Article.delete_all
-    Houdini::Base.stub!(:request).and_return(["200", "{response:success}"]) # TODO: VCR
   end
 
   it "should send task to Houdini and properly receive the postback" do
-    p = Article.new(:original_text => 'This is incorect.')
-    p.stub!(:id).and_return(1)
+    article = Article.new :original_text => 'This is incorect.'
 
     params = {
-      "api_key" => Houdini.api_key,
-      "environment" => Houdini.environment,
-      "postback_url" => "http://example.com:80/houdini/Article/1/edit_for_grammar/postbacks",
-      "task_design" => "edit_for_grammar",
-      "task_design_version" => 1,
-      "task_info" => {
-        "original_text" => "This is incorect."
+      "api_key"      => Houdini.api_key,
+      "environment"  => Houdini.environment,
+      "postback_url" => "http://my-app:3333/houdini/Article/model-slug/postbacks",
+      "blueprint"    => "edit_for_grammar",
+      "input"    => {
+        "input1" => "This is incorect.",
+        "input2" => "This is incorect.",
+        "input3" => "some text"
       }
     }.symbolize_keys
 
-    Houdini::Base.should_receive(:request).with(params)
+    Houdini.should_receive(:request).with(params)
 
-    p.save
-    p.reload
-    p.houdini_request_sent_at.to_date.should == Time.now.to_date
+    article.save!
+    article.reload
+    article.houdini_request_sent_at.should == Date.today.to_time
 
-    post "houdini/article/#{p.id}/edit_for_grammar/postbacks", {:edited_text => "This is incorrect."}.to_json
+    output_params = {"edited_text"=>"This is incorrect."}
 
-    p.reload
-    p.edited_text.should == "This is incorrect."
+    post "houdini/Article/model-slug/postbacks", params.merge("id" => "000000000000", "status"=>"complete", "output" => output_params, "verbose_output"=> output_params).to_json
+
+    article.reload
+    article.edited_text.should == "This is incorrect."
   end
-end
+end