mortar 0.15.6 → 0.15.7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2NhOTIwODIyNDBiY2NmOGVkN2FmMmNiNDc5NDhiYmM3NWY5MGUyZA==
+    YjQyM2RmYTBiYjJjNjI3NzA2NDkyMWM0ZmNjZmFkZTgwMGQxNDRkZQ==
   data.tar.gz: !binary |-
-    MDI1MDk2YzQyZWQwYjQwMTJjODcxNWQ3ZjY3MGUwNGUwOTVlM2ExMw==
+    YjY1ZDAzMjlmZjEzNTQyZDcwNjQ3ZjAyYmI0MDNlY2ZjNmQxMmY5MQ==
 SHA512:
   metadata.gz: !binary |-
-    YjZjYzk4MTk4Y2M2OTJlMWIwYmIzNTAwY2I1YjI5NDFhZGY4OWNlNjQ2Nzdj
-    NjhmZTI2NTM5MDVjOWRmNTlhMjc5NTJmNmZmOTZlOTQyYTYxNjY4YzFjNDM1
-    ZTJmMDhlYzIyZjEzZTRhZDRhYjFkZWUwMzI5OWM4MzkwOWM4OTM=
+    ODc3YWI0NDkwOGUyOTRlYjI0MzQ3MzgyYmY1MjA4MzBkNjEyZTM1YmUwZmM0
+    MTFjOTNlMmJhOGYxNTllMDhmODQ5MmE4N2ZjM2RjNDY2ZDY4ZTU5MGYxNjYz
+    ZWNjNzYyMTQ5NDc2ODRkM2QyMDE3MjAwOGNjYjg3MzhkYzQyYzA=
   data.tar.gz: !binary |-
-    NDkyMDQxMTYyMmNhY2U1ZWRkNzg1MTc3MDg5NTEzMjRjNzNhZWM1ZGU3OWQz
-    YWQ0ZjZiYzQyNzY4MjE0NGU4ZWE2N2MxNDIzZTcwNzZiZGJjYzIzNTBiY2Jj
-    OWE5NzEzZDkyNWE0ZDEwZDRkMmJlM2U3Y2M2Nzk4MjNiYmZkMjE=
+    ODU5MzE3YTRhYmZmMzEzNWVlMjdlZGViNmY3Mzk4MTJiMjE1MTBhNjNiYjUy
+    ZDUwNjM0NTM1OGY1MzgzM2QwODRlYWRhMmFhMWE4NjQxYTQ0Y2RiMTJjN2Fi
+    Zjg0MjQzNjNkZmE5Mjk1ODdjZDE3ZjJjNzYzMDMyOWUxNWY4YzY=

data/lib/mortar/command/describe.rb

@@ -52,7 +52,10 @@ class Mortar::Command::Describe < Mortar::Command::Base
     
     describe_id = nil
     action("Starting describe") do
-      describe_id = api.post_describe(project.name, pigscript.name, alias_name, git_ref, :pig_version => pig_version.version, :parameters => pig_parameters).body["describe_id"]
+      describe_id = api.post_describe(project.name, pigscript.name, alias_name, git_ref, 
+        :pig_version => pig_version.version, 
+        :project_script_path => pigscript.rel_path,
+        :parameters => pig_parameters).body["describe_id"]
     end
         
     describe_result = nil

data/lib/mortar/command/illustrate.rb

@@ -57,7 +57,10 @@ class Mortar::Command::Illustrate < Mortar::Command::Base
 
     illustrate_id = nil
     action("Starting illustrate") do
-      illustrate_id = api.post_illustrate(project.name, pigscript.name, alias_name, skip_pruning, git_ref, :pig_version => pig_version.version, :parameters => pig_parameters).body["illustrate_id"]
+      illustrate_id = api.post_illustrate(project.name, pigscript.name, alias_name, skip_pruning, git_ref, 
+        :pig_version => pig_version.version, 
+        :project_script_path => pigscript.rel_path,
+        :parameters => pig_parameters).body["illustrate_id"]
     end
         
     illustrate_result = nil

data/lib/mortar/command/jobs.rb

@@ -166,6 +166,7 @@ class Mortar::Command::Jobs < Mortar::Command::Base
         use_spot_instances = options[:spot] || false
         api.post_job_new_cluster(project_name, script_name, git_ref, cluster_size, 
           :pig_version => pig_version.version, 
+          :project_script_path => script.rel_path,
           :parameters => pig_parameters,
           :cluster_type => cluster_type,
           :notify_on_job_finish => notify_on_job_finish,
@@ -175,6 +176,7 @@ class Mortar::Command::Jobs < Mortar::Command::Base
         cluster_id = options[:clusterid]
         api.post_job_existing_cluster(project_name, script_name, git_ref, cluster_id,
           :pig_version => pig_version.version, 
+          :project_script_path => script.rel_path,
           :parameters => pig_parameters,
           :notify_on_job_finish => notify_on_job_finish,
           :is_control_script => is_control_script).body

data/lib/mortar/command/validate.rb

@@ -47,7 +47,10 @@ class Mortar::Command::Validate < Mortar::Command::Base
     
     validate_id = nil
     action("Starting validate") do
-      validate_id = api.post_validate(project.name, pigscript.name, git_ref, :pig_version => pig_version, :pig_version => pig_version.version, :parameters => pig_parameters).body["validate_id"]
+      validate_id = api.post_validate(project.name, pigscript.name, git_ref, 
+        :pig_version => pig_version.version, 
+        :project_script_path => pigscript.rel_path,
+        :parameters => pig_parameters).body["validate_id"]
     end
         
     validate_result = nil

data/lib/mortar/project.rb

@@ -15,6 +15,7 @@
 #
 
 require 'fileutils'
+require 'pathname'
 
 module Mortar
   module Project
@@ -194,6 +195,11 @@ module Mortar
         script_file.close
         script_contents
       end
+
+      def rel_path
+        p = Pathname.new(@path).dirname
+        rel_path = p.relative_path_from(Pathname.pwd).to_s
+      end
       
       def to_s
         code

data/lib/mortar/version.rb

@@ -16,5 +16,5 @@
 
 module Mortar
   # see http://semver.org/
-  VERSION = "0.15.6"
+  VERSION = "0.15.7"
 end

data/spec/mortar/command/base_spec.rb

@@ -176,7 +176,7 @@ no_browser=true
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           mock(Launchy).open(describe_url) {Thread.new {}}
 
@@ -204,7 +204,7 @@ no_browser=true
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 
@@ -232,7 +232,7 @@ polling_interval=10
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
 
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters=>[]) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_SUCCESS, "status_description" => "Success", "web_result_url" => describe_url})).ordered
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
 

data/spec/mortar/command/describe_spec.rb

@@ -98,7 +98,7 @@ STDERR
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -129,7 +129,7 @@ STDOUT
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered
@@ -163,7 +163,7 @@ STDOUT
           column_number = 32
           error_type = 'PigError'
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_FAILURE, "status_description" => "Failed",
             "error_message" => error_message,
@@ -198,7 +198,7 @@ STDERR
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
           parameters = ["name"=>"key", "value"=>"value" ]
           
-          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
+          mock(Mortar::Auth.api).post_describe("myproject", "my_script", "my_alias", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"describe_id" => describe_id})}
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_GATEWAY_STARTING, "status_description" => "Gateway starting"})).ordered
           mock(Mortar::Auth.api).get_describe(describe_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Describe::STATUS_PROGRESS, "status_description" => "Starting pig"})).ordered

data/spec/mortar/command/illustrate_spec.rb

@@ -74,7 +74,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -108,7 +108,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -142,7 +142,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -169,7 +169,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", true, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_SUCCESS,          "status_description" => "Succeeded", "web_result_url" => illustrate_url})).ordered
                     
@@ -195,7 +195,7 @@ STDOUT
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered
@@ -232,7 +232,7 @@ STDOUT
           error_type = 'PigError'
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", "my_alias", false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,  "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_FAILURE, 
             "error_message" => error_message,
@@ -268,7 +268,7 @@ STDERR
           parameters = ["name"=>"key", "value"=>"value" ]
           
           # These don't test the validity of the error message, it only tests that the CLI can handle a message returned from the server
-          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
+          mock(Mortar::Auth.api).post_illustrate("myproject", "my_script", nil, false, is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"illustrate_id" => illustrate_id})}
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_QUEUED,           "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PROGRESS,         "status_description" => "In progress"})).ordered

data/spec/mortar/command/jobs_spec.rb

@@ -47,7 +47,8 @@ module Mortar::Command
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.9", 
+            :pig_version => "0.9",
+            :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__SINGLE_JOB,
             :notify_on_job_finish => true,
@@ -83,6 +84,7 @@ STDOUT
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String),cluster_size,
                                                       :pig_version => "0.9", 
+                                                      :project_script_path => be_a_kind_of(String),
                                                       :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]),
                                                       :cluster_type => Jobs::CLUSTER_TYPE__PERMANENT,
                                                       :notify_on_job_finish => true,
@@ -142,6 +144,7 @@ STDERR
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String),cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -177,6 +180,7 @@ STDOUT
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String),cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -212,6 +216,7 @@ STDOUT
 
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
               :pig_version => "0.9", 
+              :project_script_path => be_a_kind_of(String),
               :parameters => [],
               :notify_on_job_finish => false,
               :is_control_script=>true) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -245,6 +250,7 @@ STDOUT
 
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id,
               :pig_version => "0.9", 
+              :project_script_path => be_a_kind_of(String),
               :parameters => [],
               :notify_on_job_finish => false,
               :is_control_script=>true) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -278,6 +284,7 @@ STDOUT
           mock(Mortar::Auth.api).get_clusters() {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -315,6 +322,7 @@ STDOUT
           mock(Mortar::Auth.api).get_clusters() {Excon::Response.new(:body => {'clusters' => []})}
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -350,7 +358,7 @@ STDOUT
           job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
           cluster_id = "e2790e7e8c7d48e39157238d58191346"
 
-          mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.9", :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
+          mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), cluster_id, :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => [], :notify_on_job_finish => false, :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
 
           write_file(File.join(p.pigscripts_path, "my_script.pig"))
           stderr, stdout = execute("jobs:run pigscripts/my_script.pig --clusterid e2790e7e8c7d48e39157238d58191346 -d", p, @git)
@@ -404,6 +412,7 @@ STDOUT
           }
           mock(Mortar::Auth.api).post_job_existing_cluster("myproject", "my_script", is_a(String), large_cluster_id, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => [], 
             :notify_on_job_finish => true,
             :is_control_script=>false) {Excon::Response.new(:body => {"job_id" => job_id, "web_job_url" => job_url})}
@@ -436,7 +445,8 @@ STDOUT
           cluster_size = 5
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
-            :pig_version => "0.9", 
+            :pig_version => "0.9",
+            :project_script_path => be_a_kind_of(String), 
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -464,6 +474,7 @@ PARAMS
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST", "value" => "FOO"}, {"name" => "SECOND", "value" => "BAR"}, {"name" => "THIRD", "value" => "BEAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,
@@ -519,6 +530,7 @@ STDERR
 
           mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
             :pig_version => "0.9", 
+            :project_script_path => be_a_kind_of(String),
             :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
             :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
             :notify_on_job_finish => true,

data/spec/mortar/command/validate_spec.rb

@@ -72,8 +72,8 @@ STDERR
           # stub api requests
           validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           parameters = ["name"=>"key", "value"=>"value" ]
-          
-          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.9", :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+
+          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_PROGRESS, "status_description" => "Starting"})).ordered
@@ -103,7 +103,7 @@ STDOUT
           column_number = 32
           error_type = 'PigError'
           
-          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.9", :parameters => []) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+          mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.9", :project_script_path => be_a_kind_of(String), :parameters => []) {Excon::Response.new(:body => {"validate_id" => validate_id})}
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
           mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_FAILURE, "status_description" => "Failed",
             "error_message" => error_message,
@@ -137,7 +137,7 @@ STDERR
         validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
         parameters = ["name"=>"key", "value"=>"value" ]
         
-        mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12", :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
+        mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(String), :pig_version => "0.12", :project_script_path => be_a_kind_of(String), :parameters => parameters) {Excon::Response.new(:body => {"validate_id" => validate_id})}
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_QUEUED, "status_description" => "Pending"})).ordered
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_GATEWAY_STARTING, "status_description" => "GATEWAY_STARTING"})).ordered
         mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_PROGRESS, "status_description" => "Starting"})).ordered

data/spec/mortar/project_spec.rb

@@ -65,6 +65,7 @@ module Mortar
           p.pigscripts.my_script.name.should == "my_script"
           p.pigscripts.my_script.path.should == pigscript_path
           p.pigscripts.my_script.executable_path.should == "pigscripts/my_script.pig"
+          p.pigscripts.my_script.rel_path.end_with?('pigscripts').should be_true 
         end
       end
 
@@ -74,6 +75,7 @@ module Mortar
           write_file pigscript_path
           p.pigscripts.my_script.name.should == "my_script"
           p.pigscripts.my_script.path.should == pigscript_path
+          p.pigscripts.my_script.rel_path.end_with?("pigscripts/subdir").should be_true
         end
       end
       

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mortar
 version: !ruby/object:Gem::Version
-  version: 0.15.6
+  version: 0.15.7
 platform: ruby
 authors:
 - Mortar Data
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-10 00:00:00.000000000 Z
+date: 2014-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.1
 - !ruby/object:Gem::Dependency
   name: netrc
   requirement: !ruby/object:Gem::Requirement