mortar 0.7.8 → 0.7.9

data/lib/mortar/command/base.rb

@@ -107,6 +107,65 @@ class Mortar::Command::Base
     end
     return ""
   end
+
+  def validate_project_name(name)
+    project_names = api.get_projects().body["projects"].collect{|p| p['name']}
+    if project_names.include? name
+      error("Your account already contains a project named #{name}.\nPlease choose a different name for your new project, or clone the existing #{name} code using:\n\nmortar projects:clone #{name}")
+    end
+  end
+
+  def validate_project_structure()
+    present_dirs = Dir.glob("*").select { |path| File.directory? path }
+    required_dirs = ["controlscripts", "pigscripts", "macros", "udfs", "fixtures"]
+    missing_dirs = required_dirs - present_dirs
+
+    if missing_dirs.length > 0
+      error("Project missing required directories: #{missing_dirs.to_s}")
+    end
+  end
+
+  def register_project(name)
+    project_id = nil
+    action("Sending request to register project: #{name}") do
+      project_id = api.post_project(name).body["project_id"]
+    end
+    
+    project_result = nil
+    project_status = nil
+    display
+    ticking(polling_interval) do |ticks|
+      project_result = api.get_project(project_id).body
+      project_status = project_result.fetch("status_code", project_result["status"])
+      project_description = project_result.fetch("status_description", project_status)
+      is_finished = Mortar::API::Projects::STATUSES_COMPLETE.include?(project_status)
+
+      redisplay("Status: %s %s" % [
+        project_description + (is_finished ? "" : "..."),
+        is_finished ? " " : spinner(ticks)],
+        is_finished) # only display newline on last message
+      if is_finished
+        display
+        break
+      end
+    end
+    
+    case project_status
+    when Mortar::API::Projects::STATUS_FAILED
+      error("Project registration failed.\nError message: #{project_result['error_message']}")
+    when Mortar::API::Projects::STATUS_ACTIVE
+      yield project_result
+    else
+      raise RuntimeError, "Unknown project status: #{project_status} for project_id: #{project_id}"
+    end
+  end
+
+  def initialize_gitless_project(api_registration_result)
+    File.open(".mortar-project-remote", "w") do |f|
+      f.puts api_registration_result["git_url"]
+    end
+    git.sync_gitless_project(project)
+  end
   
 protected
 
@@ -244,6 +303,12 @@ protected
     end
   end
 
+  def validate_gitless_project!
+    unless project.root_path
+      error("#{current_command[:command]} must be run from the project root directory")
+    end
+  end
+
   def validate_script!(script_name)
     pigscript = project.pigscripts[script_name]
     controlscript = project.controlscripts[script_name]
@@ -330,6 +395,16 @@ protected
     (options[:no_browser])
   end
 
+  def sync_code_with_cloud
+    # returns git_ref
+    if project.gitless_project?
+      return git.sync_gitless_project(project)
+    else
+      validate_git_based_project!
+      return git.create_and_push_snapshot_branch(project)
+    end
+  end
+
 end
 
 module Mortar::Command

data/lib/mortar/command/describe.rb

@@ -47,8 +47,7 @@ class Mortar::Command::Describe < Mortar::Command::Base
       error "Currently Mortar does not support describing control scripts"
     end
     
-    validate_git_based_project!
-    git_ref = git.create_and_push_snapshot_branch(project)
+    git_ref = sync_code_with_cloud()
     
     describe_id = nil
     action("Starting describe") do

data/lib/mortar/command/illustrate.rb

@@ -51,8 +51,7 @@ class Mortar::Command::Illustrate < Mortar::Command::Base
       error "Currently Mortar does not support illustrating control scripts"
     end
     
-    validate_git_based_project!
-    git_ref = git.create_and_push_snapshot_branch(project)
+    git_ref = sync_code_with_cloud()
 
     illustrate_id = nil
     action("Starting illustrate") do

data/lib/mortar/command/jobs.rb

@@ -114,8 +114,8 @@ class Mortar::Command::Jobs < Mortar::Command::Base
       end
     end
  
-    validate_git_based_project!
-    git_ref = git.create_and_push_snapshot_branch(project)
+    git_ref = sync_code_with_cloud()
+    
     notify_on_job_finish = ! options[:donotnotify]
     
     # post job to API    

data/lib/mortar/command/projects.rb

@@ -59,6 +59,9 @@ class Mortar::Command::Projects < Mortar::Command::Base
   # projects:create PROJECTNAME
   #
   # Used when you want to start a new Mortar project using Mortar generated code.
+  #
+  # --withoutgit    # Create a Mortar project that is not its own git repo. Your code will still be synced with a git repo in the cloud.
+  #
   def create
     name = shift_argument
     unless name
@@ -66,82 +69,65 @@ class Mortar::Command::Projects < Mortar::Command::Base
     end
     
     Mortar::Command::run("generate:project", [name])
+
     FileUtils.cd(name)
-    git.git_init
-    git.git("add .")
-    git.git("commit -m \"Mortar project scaffolding\"")
-    Mortar::Command::run("projects:register", [name])
+    if options[:withoutgit]
+      Mortar::Command::run("projects:register", [name, "--withoutgit"])
+    else
+      git.git_init
+      git.git("add .")
+      git.git("commit -m \"Mortar project scaffolding\"")
+      Mortar::Command::run("projects:register", [name])
+    end
   end
   alias_command "new", "projects:create"
   
   # projects:register PROJECTNAME
   #
   # Used when you want to start a new Mortar project using your existing code in the current directory.
+  #
+  # --withoutgit    # Register code that is not its own git repo as a Mortar project. Your code will still be synced with a git repo in the cloud.
+  #
   def register
     name = shift_argument
     unless name
       error("Usage: mortar projects:register PROJECT\nMust specify PROJECT.")
     end
     validate_arguments!
-    
-    unless git.has_dot_git?
+
+    if options[:withoutgit]
+      validate_project_name(name)
+      validate_project_structure()
+
+      register_project(name) do |project_result|
+        initialize_gitless_project(project_result)
+      end
+    else
+      unless git.has_dot_git?
       # check if we're in the parent directory
-      if File.exists? name
-        error("mortar projects:register must be run from within the project directory.\nPlease \"cd #{name}\" and rerun this command.")
-      else
-        error("No git repository found in the current directory.\nPlease initialize a git repository for this project, and then rerun the register command.\nTo initialize your project in git, use:\n\ngit init\ngit add .\ngit commit -a -m \"first commit\"")
+        if File.exists? name
+          error("mortar projects:register must be run from within the project directory.\nPlease \"cd #{name}\" and rerun this command.")
+        else
+          error("No git repository found in the current directory.\nTo register a project that is not its own git repository, use the --withoutgit option.\nIf you do want this project to be its own git repository, please initialize git in this directory, and then rerun the register command.\nTo initialize your project in git, use:\n\ngit init\ngit add .\ngit commit -a -m \"first commit\"")
+        end
       end
-    end
-    
-    # ensure the project name does not already exist
-    project_names = api.get_projects().body["projects"].collect{|p| p['name']}
-    if project_names.include? name
-      error("Your account already contains a project named #{name}.\nPlease choose a different name for your new project, or clone the existing #{name} code using:\n\nmortar projects:clone #{name}")
-    end
-    
-    unless git.remotes(git_organization).empty?
-      begin
-        error("Currently in project: #{project.name}.  You can not register a new project inside of an existing mortar project.")
-      rescue Mortar::Command::CommandFailed => cf
-        error("Currently in an existing Mortar project.  You can not register a new project inside of an existing mortar project.")
+
+      validate_project_name(name)
+
+      unless git.remotes(git_organization).empty?
+        begin
+          error("Currently in project: #{project.name}.  You can not register a new project inside of an existing mortar project.")
+        rescue Mortar::Command::CommandFailed => cf
+          error("Currently in an existing Mortar project.  You can not register a new project inside of an existing mortar project.")
+        end
       end
-    end
-    
-    project_id = nil
-    action("Sending request to register project: #{name}") do
-      project_id = api.post_project(name).body["project_id"]
-    end
-    
-    project_result = nil
-    project_status = nil
-    display
-    ticking(polling_interval) do |ticks|
-      project_result = api.get_project(project_id).body
-      project_status = project_result.fetch("status_code", project_result["status"])
-      project_description = project_result.fetch("status_description", project_status)
-      is_finished = Mortar::API::Projects::STATUSES_COMPLETE.include?(project_status)
-
-      redisplay("Status: %s %s" % [
-        project_description + (is_finished ? "" : "..."),
-        is_finished ? " " : spinner(ticks)],
-        is_finished) # only display newline on last message
-      if is_finished
-        display
-        break
+
+      register_project(name) do |project_result|
+        git.remote_add("mortar", project_result['git_url'])
+        git.push_master
+        display "Your project is ready for use.  Type 'mortar help' to see the commands you can perform on the project.\n\n"
       end
     end
-    
-    case project_status
-    when Mortar::API::Projects::STATUS_FAILED
-      error("Project registration failed.\nError message: #{project_result['error_message']}")
-    when Mortar::API::Projects::STATUS_ACTIVE
-      git.remote_add("mortar", project_result['git_url'])
-      git.push_master
-      display "Your project is ready for use.  Type 'mortar help' to see the commands you can perform on the project.\n\n"
-    else
-      raise RuntimeError, "Unknown project status: #{project_status} for project_id: #{project_id}"
-    end
-    
   end
   alias_command "register", "projects:register"
 

data/lib/mortar/command/validate.rb

@@ -42,8 +42,7 @@ class Mortar::Command::Validate < Mortar::Command::Base
       error "Currently Mortar does not support validating control scripts"
     end
     
-    validate_git_based_project!
-    git_ref = git.create_and_push_snapshot_branch(project)
+    git_ref = sync_code_with_cloud()
     
     validate_id = nil
     action("Starting validate") do

data/lib/mortar/git.rb

@@ -87,7 +87,7 @@ module Mortar
           raise GitError, "No commits found in repository.  You must do an initial commit to initialize the repository."
         end
 
-        safe_copy(mortar_snapshot_pathlist) do
+        safe_copy(mortar_manifest_pathlist) do
           did_stash_changes = stash_working_dir("Stash for push to master")
           git('push mortar master')
         end
@@ -118,27 +118,29 @@ module Mortar
       # Only snapshot filesystem paths that are in a whitelist
       #
 
-      def mortar_snapshot_pathlist()
+      def mortar_manifest_pathlist(include_dot_git = true)
         ensure_valid_mortar_project_manifest()
 
-        snapshot_pathlist = File.read('.mortar-project-manifest').split("\n")
-        snapshot_pathlist << ".git"
+        manifest_pathlist = File.read(".mortar-project-manifest").split("\n")
+        if include_dot_git
+          manifest_pathlist << ".git"
+        end
 
-        snapshot_pathlist.each do |path|
+        manifest_pathlist.each do |path|
           unless File.exists? path
             Helpers.error(".mortar-project-manifest includes file/dir \"#{path}\" that is not in the mortar project directory.")
           end
         end
         
-        snapshot_pathlist
+        manifest_pathlist
       end
 
       #
       # Create a snapshot whitelist file if it doesn't already exist
       #
       def ensure_valid_mortar_project_manifest()
-        if File.exists? '.mortar-project-manifest'
-          File.open('.mortar-project-manifest', 'r+') do |manifest|
+        if File.exists? ".mortar-project-manifest"
+          File.open(".mortar-project-manifest", "r+") do |manifest|
             contents = manifest.read()
             manifest.seek(0, IO::SEEK_END)
 
@@ -187,7 +189,7 @@ module Mortar
 
         # Copy code into a temp directory so we don't confuse editors while snapshotting
         curdir = Dir.pwd
-        tmpdir = safe_copy(mortar_snapshot_pathlist)
+        tmpdir = safe_copy(mortar_manifest_pathlist)
       
         starting_branch = current_branch
         snapshot_branch = "mortar-snapshot-#{Mortar::UUID.create_random.to_s}"
@@ -195,11 +197,13 @@ module Mortar
         # checkout a new branch
         git("checkout -b #{snapshot_branch}")
       
-        add_untracked_files()
+        # stage all changes (including deletes)
+        git("add .")
+        git("add -u .")
 
         # commit the changes if there are any
         if ! is_clean_working_directory?
-          git("commit -a -m \"mortar development snapshot commit\"")
+          git("commit -m \"mortar development snapshot commit\"")
         end
       
         Dir.chdir(curdir)
@@ -215,21 +219,7 @@ module Mortar
         end
 
         Dir.chdir(snapshot_dir)
-
-        git_ref = Helpers.action("Sending code snapshot to Mortar") do
-          # push the code
-          begin
-            push(project.remote, snapshot_branch)
-          rescue
-            retry if retry_snapshot_push?
-            Helpers.error("Could not connect to github remote. Tried #{@snapshot_push_attempts.to_s} times.")
-          end
-
-          # grab the commit hash
-          ref = git_ref(snapshot_branch)
-          ref
-        end
-
+        git_ref = push_with_retry(project.remote, snapshot_branch, "Sending code snapshot to Mortar")
         FileUtils.remove_entry_secure(snapshot_dir)
         Dir.chdir(curdir)
         return git_ref
@@ -246,7 +236,82 @@ module Mortar
         @snapshot_push_attempts ||= 0
         @snapshot_push_attempts += 1
         @snapshot_push_attempts < 10
-      end 
+      end
+
+      def mortar_mirrors_dir()
+        "/tmp/mortar-git-mirrors"
+      end
+
+      def sync_gitless_project(project)
+        # the project is not a git repo, so we manage a mirror directory that is a git repo
+
+        project_dir = project.root_path
+        mirror_dir = "#{mortar_mirrors_dir}/#{project.name}"
+
+        ensure_gitless_project_mirror_exists(project_dir, mirror_dir)
+        sync_gitless_project_with_mirror(project_dir, mirror_dir)
+        git_ref = sync_gitless_project_mirror_with_cloud(project_dir, mirror_dir)
+
+        Dir.chdir(project_dir)
+        return git_ref
+      end
+
+      def ensure_gitless_project_mirror_exists(project_dir, mirror_dir)
+        # create and initialize mirror git repo if it doesn't already exist
+        unless File.directory? mirror_dir
+          unless File.directory? mortar_mirrors_dir
+            FileUtils.mkdir_p mortar_mirrors_dir
+          end
+
+          # clone mortar-code repo
+          remote_path = File.open(".mortar-project-remote").read.strip
+          clone(remote_path, mirror_dir)
+
+          # make an initial commit to master
+          Dir.chdir(mirror_dir)
+          File.open(".gitkeep", "w").close()
+          git("add .")
+          git("commit -m \"mortar development initial commit\"")
+          git("remote add mortar #{remote_path}")
+          push_with_retry("mortar", "master", "Setting up gitless Mortar project")
+        end
+      end
+
+      def sync_gitless_project_with_mirror(project_dir, mirror_dir)
+        # pull from master and overwrite everything
+        Dir.chdir(mirror_dir)
+        git("fetch --all")
+        git("reset --hard mortar/master")
+
+        # wipe mirror dir and copy project files into it
+        # since we fetched mortar/master earlier, the git diff will now be b/tw master and the current state
+        # mortar_manifest_pathlist(false) means don't copy .git
+        FileUtils.rm_rf(Dir.glob("#{mirror_dir}/*"))
+        Dir.chdir(project_dir)
+        FileUtils.cp_r(mortar_manifest_pathlist(false), mirror_dir)
+
+        # update master
+        Dir.chdir(mirror_dir)
+        unless is_clean_working_directory?
+          git("add .")
+          git("add -u .") # this gets deletes
+          git("commit -m \"mortar development snapshot commit\"")
+        end
+      end
+
+      def sync_gitless_project_mirror_with_cloud(project_dir, mirror_dir)
+        # checkout snapshot branch.
+        # it will permenantly keep the code in this state (as opposed to master, which will be updated)
+        Dir.chdir(mirror_dir)
+        snapshot_branch = "mortar-snapshot-#{Mortar::UUID.create_random.to_s}"
+        git("checkout -b #{snapshot_branch}")
+
+        # push everything (master updates and snapshot branch)
+        git_ref = push_with_retry("mortar", snapshot_branch, "Sending code snapshot to Mortar", true)
+
+        git("checkout master")
+        return git_ref
+      end
 
       #    
       # add
@@ -255,12 +320,6 @@ module Mortar
       def add(path)
         git("add #{path}")
       end
-      
-      def add_untracked_files
-        untracked_files.each do |untracked_file|
-          add untracked_file
-        end
-      end
 
       #
       # branch
@@ -295,6 +354,40 @@ module Mortar
         git("push #{remote_name} #{ref}")
       end
 
+      def push_all(remote_name)
+        git("push #{remote_name} --all")
+      end
+
+      def push_with_retry(remote_name, branch_name, action_msg, push_all_branches = false)
+        git_ref = Helpers.action(action_msg) do
+          # push the code
+          begin
+              if push_all_branches
+                push_all(remote_name)
+              else
+                push(remote_name, branch_name)
+              end
+          rescue
+            retry if retry_snapshot_push?
+            Helpers.error("Could not connect to github remote. Tried #{@snapshot_push_attempts.to_s} times.")
+          end
+
+          # grab the commit hash
+          ref = git_ref(branch_name)
+          ref
+        end
+
+        return git_ref
+      end
+
+      #
+      # pull
+      #
+
+      def pull(remote_name, ref)
+        git("pull #{remote_name} #{ref}")
+      end
+
 
       #
       # remotes

data/lib/mortar/project.rb

@@ -82,6 +82,10 @@ module Mortar
       def fixtures_path
         path = File.join(@root_path, "fixtures")
       end
+
+      def gitless_project?()
+        File.exists?(File.join(@root_path, ".mortar-project-remote"))
+      end
     end
     
     class ProjectEntity

data/lib/mortar/version.rb

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

data/spec/mortar/command/describe_spec.rb

@@ -144,5 +144,28 @@ STDERR
         end
       end
     end
+
+    it "requests and reports a describe for a gitless project" do
+      with_gitless_project do |p|
+          # stub api requests
+          describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          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), :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
+          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(@git).sync_gitless_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
+
+          # stub launchy
+          mock(Launchy).open(describe_url) {Thread.new {}}
+                    
+          write_file(File.join(p.pigscripts_path, "my_script.pig"))
+          stderr, stdout = execute("describe my_script my_alias --polling_interval 0.05 -p key=value", p, @git)
+        end
+    end
   end
 end

data/spec/mortar/command/illustrate_spec.rb

@@ -223,6 +223,32 @@ STDOUT
 STDERR
         end
       end
+
+      it "requests and reports an illustrate for a gitless project" do
+        with_gitless_project do |p|
+          # stub api requests
+          illustrate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          illustrate_url = "https://api.mortardata.com/illustrates/#{illustrate_id}"
+          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), :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
+          mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_READING_DATA,     "status_description" => "Reading data"})).ordered
+          mock(Mortar::Auth.api).get_illustrate(illustrate_id, :exclude_result => true).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Illustrate::STATUS_PRUNING_DATA,     "status_description" => "Pruning data"})).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
+          
+          mock(@git).sync_gitless_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
+
+          # stub launchy
+          mock(Launchy).open(illustrate_url) {Thread.new {}}
+                    
+          write_file(File.join(p.pigscripts_path, "my_script.pig"))
+          stderr, stdout = execute("illustrate my_script --polling_interval 0.05 -p key=value", p, @git)
+        end
+      end
     end
   end
 end

data/spec/mortar/command/jobs_spec.rb

@@ -388,6 +388,26 @@ PARAMS
 STDERR
         end
       end
+
+      it "runs a job for a gitless project" do
+        with_gitless_project do |p|
+          # stub api requests
+          job_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+          job_url = "http://127.0.0.1:5000/jobs/job_detail?job_id=c571a8c7f76a4fd4a67c103d753e2dd5"
+          cluster_size = 5
+
+          mock(@git).sync_gitless_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
+
+          mock(Mortar::Auth.api).post_job_new_cluster("myproject", "my_script", is_a(String), cluster_size, 
+            :parameters => match_array([{"name" => "FIRST_PARAM", "value" => "FOO"}, {"name" => "SECOND_PARAM", "value" => "BAR"}]), 
+            :cluster_type => Jobs::CLUSTER_TYPE__PERSISTENT,
+            :notify_on_job_finish => true,
+            :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 my_script --clustersize 5 -p FIRST_PARAM=FOO -p SECOND_PARAM=BAR", p, @git)
+        end
+      end
     end
     
     context("status") do

data/spec/mortar/command/projects_spec.rb

@@ -140,6 +140,35 @@ Sending request to register project: some_new_project... done\n\n\r\e[0KStatus:
 STDOUT
       end
 
+      it "generates and registers a gitless project" do
+        mock(Mortar::Auth.api).get_projects().returns(Excon::Response.new(:body => {"projects" => [project1, project2]}))
+        project_id = "1234abcd1234abcd1234"
+        project_name = "some_new_project"
+        project_git_url = "git@github.com:mortarcode-dev/#{project_name}"
+        mock(Mortar::Auth.api).post_project("some_new_project") {Excon::Response.new(:body => {"project_id" => project_id})}
+        mock(Mortar::Auth.api).get_project(project_id).returns(Excon::Response.new(:body => {"status" => Mortar::API::Projects::STATUS_ACTIVE,
+                                                                                             "git_url" => project_git_url})).ordered
+
+        # test that sync_gitless_project is called. the method itself is tested in git_spec.
+        mock(@git).sync_gitless_project.with_any_args.times(1) { true }
+
+        stderr, stdout = execute("projects:create #{project_name} --withoutgit", nil, @git)
+        Dir.pwd.end_with?("some_new_project").should be_true
+        File.exists?(".mortar-project-remote").should be_true
+        File.exists?("macros").should be_true
+        File.exists?("fixtures").should be_true
+        File.exists?("pigscripts").should be_true
+        File.exists?("udfs").should be_true
+        File.exists?("README.md").should be_true
+        File.exists?("Gemfile").should be_false
+        File.exists?("macros/.gitkeep").should be_true
+        File.exists?("fixtures/.gitkeep").should be_true
+        File.exists?("pigscripts/some_new_project.pig").should be_true
+        File.exists?("udfs/python/some_new_project.py").should be_true
+
+        File.read("pigscripts/some_new_project.pig").each_line { |line| line.match(/<%.*%>/).should be_nil }
+      end
+
     end
     
     context("register") do
@@ -170,7 +199,8 @@ STDERR
           stderr, stdout = execute("projects:register some_new_project")
           stderr.should == <<-STDERR
  !    No git repository found in the current directory.
- !    Please initialize a git repository for this project, and then rerun the register command.
+ !    To register a project that is not its own git repository, use the --withoutgit option.
+ !    If you do want this project to be its own git repository, please initialize git in this directory, and then rerun the register command.
  !    To initialize your project in git, use:
  !    
  !    git init
@@ -246,6 +276,28 @@ STDOUT
 Sending request to register project: some_new_project... done\n\n\r\e[0KStatus: Pending... /\r\e[0KStatus: Creating... -\r\e[0KStatus: Active  \n\nYour project is ready for use.  Type 'mortar help' to see the commands you can perform on the project.\n
 STDOUT
       end
+
+      it "registers a gitless project" do
+        mock(Mortar::Auth.api).get_projects().returns(Excon::Response.new(:body => {"projects" => [project1, project2]}))
+        project_id = "1234abcd1234abcd1234"
+        project_name = "some_new_project"
+        project_git_url = "git@github.com:mortarcode-dev/#{project_name}"
+        mock(Mortar::Auth.api).post_project("some_new_project") {Excon::Response.new(:body => {"project_id" => project_id})}
+        mock(Mortar::Auth.api).get_project(project_id).returns(Excon::Response.new(:body => {"status_description" => "Pending", "status_code" => Mortar::API::Projects::STATUS_PENDING})).ordered
+        mock(Mortar::Auth.api).get_project(project_id).returns(Excon::Response.new(:body => {"status_description" => "Creating", "status_code" => Mortar::API::Projects::STATUS_CREATING})).ordered
+        mock(Mortar::Auth.api).get_project(project_id).returns(Excon::Response.new(:body => {"status_description" => "Active", "status_code" => Mortar::API::Projects::STATUS_ACTIVE,
+                                                                                             "git_url" => project_git_url})).ordered
+
+        any_instance_of(Mortar::Command::Projects) do |obj|
+          mock(obj).project.returns(nil)
+          mock(obj).validate_project_structure.returns(true)
+        end
+
+        # test that sync_gitless_project is called. the method itself is tested in git_spec.
+        mock(@git).sync_gitless_project.with_any_args.times(1) { true }
+
+        stderr, stdout = execute("projects:register some_new_project --withoutgit --polling_interval 0.05", nil, @git)
+      end
       
     end
 

data/spec/mortar/command/validate_spec.rb

@@ -128,5 +128,24 @@ STDERR
         end
       end
     end
+
+    it "requests and reports a validate for a gitless project" do
+      with_gitless_project do |p|
+        # stub api requests
+        validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
+        parameters = ["name"=>"key", "value"=>"value" ]
+        
+        mock(Mortar::Auth.api).post_validate("myproject", "my_script", is_a(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
+        mock(Mortar::Auth.api).get_validate(validate_id).returns(Excon::Response.new(:body => {"status_code" => Mortar::API::Validate::STATUS_SUCCESS, "status_description" => "Success"})).ordered
+        
+        mock(@git).sync_gitless_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
+
+        write_file(File.join(p.pigscripts_path, "my_script.pig"))
+        stderr, stdout = execute("validate my_script --polling_interval 0.05 -p key=value", p, @git)
+      end
+    end
   end
 end

data/spec/mortar/git_spec.rb

@@ -25,7 +25,7 @@ module Mortar
     before do
       @git = Mortar::Git::Git.new
     end
-    
+
     context "has_git?" do
       it "returns false with no git installed" do
         mock(@git).run_cmd("git --version").returns(["-bash: git: command not found",-1])
@@ -248,7 +248,7 @@ STASH
       end
     end
     
-    context "snapshot" do
+    context "snapshot with git project" do
       it "raises when no commits are found in the repo" do
         with_blank_project do |p|
           lambda { @git.create_snapshot_branch }.should raise_error(Mortar::Git::GitError)
@@ -301,6 +301,71 @@ STASH
         end
       end
     end
+
+    # we manually create and destroy "mirror_dir" instead of using FakeFS
+    # because FakeFS doesn't clean up properly when you use Dir.chdir inside of it
+    context "snapshot with gitless project" do
+
+      it "creates a mirror directory for the project when one does not already exist" do
+        with_gitless_project do |p|
+          mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
+          mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
+
+          mock(@git).git.with_any_args.any_times { true }
+          mock(@git).clone.with_any_args.times(1) { FileUtils.mkdir("#{mirror_dir}/#{p.name}") }
+          mock(@git).push_with_retry.with_any_args.times(2) { true }
+          mock(@git).is_clean_working_directory? { false }
+
+          @git.sync_gitless_project(p)
+
+          File.directory?(mirror_dir).should be_true
+          FileUtils.rm_rf(mirror_dir)
+        end
+      end
+
+      it "syncs files to the project mirror" do
+        with_gitless_project do |p|
+          mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
+          mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
+
+          project_mirror_dir = File.join(mirror_dir, p.name)
+          FileUtils.mkdir_p(project_mirror_dir)
+          FileUtils.touch("#{p.root_path}/pigscripts/calydonian_boar.pig")
+
+          mock(@git).git.with_any_args.any_times { true }
+          mock(@git).clone.with_any_args.never
+          mock(@git).push_with_retry.with_any_args.times(1) { true }
+          mock(@git).is_clean_working_directory? { false }
+
+          @git.sync_gitless_project(p)
+
+          File.exists?("#{project_mirror_dir}/pigscripts/calydonian_boar.pig").should be_true
+          FileUtils.rm_rf(mirror_dir)
+        end
+      end
+
+      it "syncs deleted files to the project mirror" do
+        with_gitless_project do |p|
+          mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
+          mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
+
+          project_mirror_dir = File.join(mirror_dir, p.name)
+          FileUtils.mkdir_p(project_mirror_dir)
+          FileUtils.cp_r(Dir.glob("#{p.root_path}/*"), project_mirror_dir)
+          FileUtils.touch("#{project_mirror_dir}/pigscripts/calydonian_boar.pig")
+
+          mock(@git).git.with_any_args.any_times { true }
+          mock(@git).clone.with_any_args.never
+          mock(@git).push_with_retry.with_any_args.times(1) { true }
+          mock(@git).is_clean_working_directory? { false }
+
+          @git.sync_gitless_project(p)
+
+          File.exists?("#{project_mirror_dir}/pigscripts/calydonian_boar.pig").should be_false
+          FileUtils.rm_rf(mirror_dir)
+        end
+      end
+    end
     
 =begin
     #TODO: Fix this.

data/spec/spec_helper.rb

@@ -168,6 +168,7 @@ def with_blank_project(&block)
   FileUtils.mkdir_p(File.join(project_path, "udfs"))
   FileUtils.mkdir_p(File.join(project_path, "udfs/python"))
   FileUtils.mkdir_p(File.join(project_path, "udfs/jython"))
+  FileUtils.mkdir_p(File.join(project_path, "fixtures"))
 
   Dir.chdir(project_path)
   
@@ -207,6 +208,15 @@ def with_git_initialized_project(&block)
   with_blank_project(&commit_proc)
 end
 
+def with_gitless_project(&block)
+  with_blank_project do |project|
+    File.open(File.join(project.root_path, ".mortar-project-remote"), "w") do |f|
+      f.puts "git@github.com:mortarcode-dev/4dbbd83cae8d5bf8a4000000_#{project.name}.git"
+    end
+    block.call(project)
+  end
+end
+
 def write_file(path, contents="")
   FileUtils.mkdir_p File.dirname(path)
   File.open(path, 'w') {|f| f.write(contents)}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mortar
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000 Z
+date: 2013-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mortar-api-ruby