mortar 0.8.3 → 0.8.4

data/lib/mortar/auth.rb

@@ -117,7 +117,10 @@ class Mortar::Auth
     def netrc_path
       default = Netrc.default_path
       encrypted = default + ".gpg"
-      if File.exists?(encrypted)
+      from_env = ENV['MORTAR_LOGIN_FILE']
+      if from_env
+        from_env
+      elsif File.exists?(encrypted)
         encrypted
       else
         default

data/lib/mortar/command/base.rb

@@ -160,11 +160,11 @@ class Mortar::Command::Base
     end
   end
 
-  def initialize_gitless_project(api_registration_result)
+  def initialize_embedded_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, "master")
+    git.sync_embedded_project(project, "master")
   end
   
 protected
@@ -303,7 +303,7 @@ protected
     end
   end
 
-  def validate_gitless_project!
+  def validate_embedded_project!
     unless project.root_path
       error("#{current_command[:command]} must be run from the project root directory")
     end
@@ -399,8 +399,8 @@ protected
 
   def sync_code_with_cloud
     # returns git_ref
-    if project.gitless_project?
-      return git.sync_gitless_project(project, embedded_project_user_branch)
+    if project.embedded_project?
+      return git.sync_embedded_project(project, embedded_project_user_branch)
     else
       validate_git_based_project!
       return git.create_and_push_snapshot_branch(project)

data/lib/mortar/command/projects.rb

@@ -60,7 +60,7 @@ class Mortar::Command::Projects < Mortar::Command::Base
   #
   # 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.
+  # --embedded    # 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
@@ -71,8 +71,8 @@ class Mortar::Command::Projects < Mortar::Command::Base
     Mortar::Command::run("generate:project", [name])
 
     FileUtils.cd(name)
-    if options[:withoutgit]
-      Mortar::Command::run("projects:register", [name, "--withoutgit"])
+    if options[:embedded]
+      Mortar::Command::run("projects:register", [name, "--embedded"])
     else
       git.git_init
       git.git("add .")
@@ -87,7 +87,7 @@ class Mortar::Command::Projects < Mortar::Command::Base
   #
   # 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.
+  # --embedded    # 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
@@ -96,12 +96,12 @@ class Mortar::Command::Projects < Mortar::Command::Base
     end
     validate_arguments!
 
-    if options[:withoutgit]
+    if options[:embedded]
       validate_project_name(name)
       validate_project_structure()
 
       register_project(name) do |project_result|
-        initialize_gitless_project(project_result)
+        initialize_embedded_project(project_result)
       end
     else
       unless git.has_dot_git?
@@ -109,7 +109,7 @@ class Mortar::Command::Projects < Mortar::Command::Base
         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\"")
+          error("No git repository found in the current directory.\nTo register a project that is not its own git repository, use the --embedded 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
 
@@ -139,7 +139,7 @@ class Mortar::Command::Projects < Mortar::Command::Base
   # co-worker creates a Mortar project from an internal repository you would clone the internal
   # repository and then after cloning call mortar projects:set_remote.
   #
-  # --withoutgit    # make this a gitless project tied to the specified remote
+  # --embedded    # make this a embedded project tied to the specified remote
   #
   def set_remote
     project_name = shift_argument
@@ -148,7 +148,7 @@ class Mortar::Command::Projects < Mortar::Command::Base
       error("Usage: mortar projects:set_remote PROJECT\nMust specify PROJECT.")
     end
 
-    unless options[:withoutgit]
+    unless options[:embedded]
       unless git.has_dot_git?
         error("Can only set the remote for an existing git project.  Please run:\n\ngit init\ngit add .\ngit commit -a -m \"first commit\"\n\nto initialize your project in git.")
       end
@@ -165,11 +165,11 @@ class Mortar::Command::Projects < Mortar::Command::Base
       error("No project named: #{project_name} exists. You can create this project using:\n\n mortar projects:create")
     end
 
-    if options[:withoutgit]
+    if options[:embedded]
       File.open(".mortar-project-remote", "w") do |f|
         f.puts project["git_url"]
       end
-      git.sync_gitless_project(project, embedded_project_user_branch)
+      git.sync_embedded_project(project, embedded_project_user_branch)
     else
       git.remote_add("mortar", project["git_url"])
     end

data/lib/mortar/git.rb

@@ -242,7 +242,7 @@ module Mortar
         "/tmp/mortar-git-mirrors"
       end
 
-      def sync_gitless_project(project, branch)
+      def sync_embedded_project(project, branch)
         # the project is not a git repo, so we manage a mirror directory that is a git repo
         # branch is which branch to sync to. this will be master if the cloud repo
         # is being initialized, or a branch based on the user's name in any other circumstance
@@ -250,15 +250,15 @@ module Mortar
         project_dir = project.root_path
         mirror_dir = "#{mortar_mirrors_dir}/#{project.name}"
 
-        ensure_gitless_project_mirror_exists(mirror_dir)
-        sync_gitless_project_with_mirror(mirror_dir, project_dir, branch)
-        git_ref = sync_gitless_project_mirror_with_cloud(mirror_dir, branch)
+        ensure_embedded_project_mirror_exists(mirror_dir)
+        sync_embedded_project_with_mirror(mirror_dir, project_dir, branch)
+        git_ref = sync_embedded_project_mirror_with_cloud(mirror_dir, branch)
 
         Dir.chdir(project_dir)
         return git_ref
       end
 
-      def ensure_gitless_project_mirror_exists(mirror_dir)
+      def ensure_embedded_project_mirror_exists(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
@@ -275,14 +275,14 @@ module Mortar
                                          # initialization is not necessary if this is not the first user to use it 
             File.open(".gitkeep", "w").close()
             git("add .")
-            git("commit -m \"Setting up gitless Mortar project\"")
+            git("commit -m \"Setting up embedded Mortar project\"")
             git("remote add mortar #{remote_path}")
-            push_with_retry("mortar", "master", "Setting up gitless Mortar project")
+            push_with_retry("mortar", "master", "Setting up embedded Mortar project")
           end
         end
       end
 
-      def sync_gitless_project_with_mirror(mirror_dir, project_dir, branch)
+      def sync_embedded_project_with_mirror(mirror_dir, project_dir, branch)
         # pull from remote branch and overwrite everything, if it exists.
         # if it doesn't exist, create it.
         Dir.chdir(mirror_dir)
@@ -315,7 +315,7 @@ module Mortar
         end
       end
 
-      def sync_gitless_project_mirror_with_cloud(mirror_dir, branch)
+      def sync_embedded_project_mirror_with_cloud(mirror_dir, branch)
         # checkout snapshot branch.
         # it will permenantly keep the code in this state (as opposed to the user's base branch, which will be updated)
         Dir.chdir(mirror_dir)

data/lib/mortar/project.rb

@@ -83,7 +83,7 @@ module Mortar
         path = File.join(@root_path, "fixtures")
       end
 
-      def gitless_project?()
+      def embedded_project?()
         File.exists?(File.join(@root_path, ".mortar-project-remote"))
       end
     end

data/lib/mortar/version.rb

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

data/spec/mortar/auth_spec.rb

@@ -170,5 +170,18 @@ module Mortar
       expect(@cli.has_credentials).to be_false
     end
 
+    it "uses path from env when specified" do
+      netrc_path = '/foo/bar/baz'
+      ENV['MORTAR_LOGIN_FILE'] = netrc_path
+      expect(@cli.netrc_path).to eq(netrc_path)
+      ENV.delete('MORTAR_LOGIN_FILE')
+    end
+
+    it "uses the default path when no environment setting" do
+      FakeFS do
+        expect(@cli.netrc_path).to eq(Netrc.default_path)
+      end
+    end
+
   end
 end

data/spec/mortar/command/describe_spec.rb

@@ -189,8 +189,8 @@ STDERR
       end
     end
 
-    it "requests and reports a describe for a gitless project" do
-      with_gitless_project do |p|
+    it "requests and reports a describe for an embedded project" do
+      with_embedded_project do |p|
           # stub api requests
           describe_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           describe_url = "https://api.mortardata.com/describe/#{describe_id}"
@@ -202,7 +202,7 @@ STDERR
           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" }
+          mock(@git).sync_embedded_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
 
           # stub launchy
           mock(Launchy).open(describe_url) {Thread.new {}}

data/spec/mortar/command/illustrate_spec.rb

@@ -258,8 +258,8 @@ STDERR
         end
       end
 
-      it "requests and reports an illustrate for a gitless project" do
-        with_gitless_project do |p|
+      it "requests and reports an illustrate for an embedded project" do
+        with_embedded_project do |p|
           # stub api requests
           illustrate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
           illustrate_url = "https://api.mortardata.com/illustrates/#{illustrate_id}"
@@ -274,7 +274,7 @@ STDERR
           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" }
+          mock(@git).sync_embedded_project.with_any_args.times(1) { "somewhere_over_the_rainbow" }
 
           # stub launchy
           mock(Launchy).open(illustrate_url) {Thread.new {}}

data/spec/mortar/command/jobs_spec.rb

@@ -456,14 +456,14 @@ STDERR
         end
       end
 
-      it "runs a job for a gitless project" do
-        with_gitless_project do |p|
+      it "runs a job for an embedded project" do
+        with_embedded_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(@git).sync_embedded_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"}]), 

data/spec/mortar/command/projects_spec.rb

@@ -143,7 +143,7 @@ NOTE: You'll need to change to the new directory to use your project:
 STDOUT
       end
 
-      it "generates and registers a gitless project" do
+      it "generates and registers an embedded project" do
         mock(Mortar::Auth.api).get_projects().returns(Excon::Response.new(:body => {"projects" => [project1, project2]}))
         project_id = "1234abcd1234abcd1234"
         project_name = "some_new_project"
@@ -152,10 +152,10 @@ STDOUT
         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 }
+        # test that sync_embedded_project is called. the method itself is tested in git_spec.
+        mock(@git).sync_embedded_project.with_any_args.times(1) { true }
 
-        stderr, stdout = execute("projects:create #{project_name} --withoutgit", nil, @git)
+        stderr, stdout = execute("projects:create #{project_name} --embedded", 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
@@ -202,7 +202,7 @@ STDERR
           stderr, stdout = execute("projects:register some_new_project")
           stderr.should == <<-STDERR
  !    No git repository found in the current directory.
- !    To register a project that is not its own git repository, use the --withoutgit option.
+ !    To register a project that is not its own git repository, use the --embedded 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:
  !    
@@ -280,7 +280,7 @@ Sending request to register project: some_new_project... done\n\n\r\e[0KStatus:
 STDOUT
       end
 
-      it "registers a gitless project" do
+      it "registers an embedded project" do
         mock(Mortar::Auth.api).get_projects().returns(Excon::Response.new(:body => {"projects" => [project1, project2]}))
         project_id = "1234abcd1234abcd1234"
         project_name = "some_new_project"
@@ -296,10 +296,10 @@ STDOUT
           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 }
+        # test that sync_embedded_project is called. the method itself is tested in git_spec.
+        mock(@git).sync_embedded_project.with_any_args.times(1) { true }
 
-        stderr, stdout = execute("projects:register some_new_project --withoutgit --polling_interval 0.05", nil, @git)
+        stderr, stdout = execute("projects:register some_new_project --embedded --polling_interval 0.05", nil, @git)
       end
       
     end

data/spec/mortar/command/validate_spec.rb

@@ -129,8 +129,8 @@ STDERR
       end
     end
 
-    it "requests and reports a validate for a gitless project" do
-      with_gitless_project do |p|
+    it "requests and reports a validate for an embedded project" do
+      with_embedded_project do |p|
         # stub api requests
         validate_id = "c571a8c7f76a4fd4a67c103d753e2dd5"
         parameters = ["name"=>"key", "value"=>"value" ]
@@ -141,7 +141,7 @@ STDERR
         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" }
+        mock(@git).sync_embedded_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)

data/spec/mortar/git_spec.rb

@@ -304,10 +304,10 @@ STASH
 
     # 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
+    context "snapshot with embedded project" do
 
       it "creates a mirror directory for the project when one does not already exist" do
-        with_gitless_project do |p|
+        with_embedded_project do |p|
           mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
           mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
 
@@ -316,7 +316,7 @@ STASH
           mock(@git).push_with_retry.with_any_args.times(2) { true }
           mock(@git).is_clean_working_directory? { false }
 
-          @git.sync_gitless_project(p, "master")
+          @git.sync_embedded_project(p, "master")
 
           File.directory?(mirror_dir).should be_true
           FileUtils.rm_rf(mirror_dir)
@@ -324,7 +324,7 @@ STASH
       end
 
       it "syncs files to the project mirror" do
-        with_gitless_project do |p|
+        with_embedded_project do |p|
           mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
           mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
 
@@ -337,7 +337,7 @@ STASH
           mock(@git).push_with_retry.with_any_args.times(1) { true }
           mock(@git).is_clean_working_directory? { false }
 
-          @git.sync_gitless_project(p, "bob-the-builder-base")
+          @git.sync_embedded_project(p, "bob-the-builder-base")
 
           File.exists?("#{project_mirror_dir}/pigscripts/calydonian_boar.pig").should be_true
           FileUtils.rm_rf(mirror_dir)
@@ -345,7 +345,7 @@ STASH
       end
 
       it "syncs deleted files to the project mirror" do
-        with_gitless_project do |p|
+        with_embedded_project do |p|
           mirror_dir = File.join(Dir.tmpdir, "mortar", "test-git-mirror")
           mock(@git).mortar_mirrors_dir.any_times { mirror_dir }
 
@@ -359,7 +359,7 @@ STASH
           mock(@git).push_with_retry.with_any_args.times(1) { true }
           mock(@git).is_clean_working_directory? { false }
 
-          @git.sync_gitless_project(p, "bob-the-builder-base")
+          @git.sync_embedded_project(p, "bob-the-builder-base")
 
           File.exists?("#{project_mirror_dir}/pigscripts/calydonian_boar.pig").should be_false
           FileUtils.rm_rf(mirror_dir)

data/spec/spec_helper.rb

@@ -208,7 +208,7 @@ def with_git_initialized_project(&block)
   with_blank_project(&commit_proc)
 end
 
-def with_gitless_project(&block)
+def with_embedded_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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mortar
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-05 00:00:00.000000000 Z
+date: 2013-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mortar-api-ruby
@@ -270,7 +270,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Client library and CLI to interact with the Mortar service.