safedb 0.5.1005 → 0.7.1001

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 637a4011eceb0a65ec0139c499d2494576ff9cfbdbd90c84907e9ed734753438
-  data.tar.gz: 48ac523f4c4f0d457bdd6a9ddfa1ca87e5c19ee1deb62c49bd14a7129cda9aae
+  metadata.gz: 32727ae3d52f041e5049daf92f2bb09aa5783b7d78e8f837f77025dae5a711d7
+  data.tar.gz: 8d26aad01a827d65f85d2445154e8ee38fbbbbce04570cbc51bd38c198c73c1d
 SHA512:
-  metadata.gz: c4064ea7b9b61840733de27aec02d99e2cd2fd9d60ad9b8b41b130a77cf0606a04c25229580b25c3bc5af472eab08727fbef4d33f0b13a970246091e64bc19ef
-  data.tar.gz: 30c16510557f03cdcfdf4f78cf3c64f7701cfd8ca0418a6af2a11ff517071c5e2bbfced54cd401a31aa058bb1b50ae214f5894d4978a0d34d5daa1061bc601ea
+  metadata.gz: a552f7d3b9b958cfad7910f777d1f3d1bd3c91b6bca0b0625c19ddee0699683650d3109fe82934860474035dd51b4333ff3e212442cf56b317f567813ea60dfc
+  data.tar.gz: 25cec4ed1f64dcd2d0faa8b6423601d867eebb4527202266d31bff7d77df57d77687284d51fefb4fb6ea6befb4aa7398ead2e9632fe2a0c0fcc265efc2546ceb

data/CONTRIBUTING.md

@@ -111,7 +111,7 @@ safe open <<chapter>> <<verse>>
 cd ~/.ssh
 safe eject github.ssh.config
 safe eject safedb.code.private.key
-chmod 600 safedb.code.private.key
+chmod 600 safedb.code.private.key.pem
 cd <<repositories-folder>>
 ssh -i ~/.ssh/safedb.code.private.key.pem -vT git@safedb.code
 git clone https://github.com/devops4me/safedb.net safedb.net

data/genius-decision.txt

@@ -0,0 +1,25 @@
+
+###########################################################################
+Put the JSOn files together with the crypts in the same git repository
+###########################################################################
+
+
+The bottom line to simplify is that everything goes up - the file
+
+safe pull does not need any authentication
+safe push requires you to be authenticated
+
+
+Maybe safe pull will create a subdirectory in .safedb.net and then writes into a config (say json) file in ~/.safedb.net the directory name.
+Maybe safe switch changes the safe database folder by writing that config file
+
+
+
+
+Simplify the Safe
+
+ - safe pull https://github.com..../repo-name?branch-or-commit-name
+ - pull backs up the current directory into ~/.safe-backups
+
+ - safe push (will send wherever the pull came from)
+ - or safe push (from a verse uses the config in the verse to do the push

data/lib/cli.rb

@@ -128,6 +128,17 @@ class CLI < Thor
 
 
 
+  # Description of the tell use case command line call.
+  desc "tell", "detail the secret key/value pairs that start with the @ symbol"
+
+  # Detail the secret key/value pairs that start with the @ symbol.
+  def tell
+    log.info(x) { "tell the secret key/value pairs that begin with the @ symbol." }
+    SafeDb::Tell.new().flow()
+  end
+
+
+
   # Description of the print use case command line call.
   desc "print <key_name>", "print the key value at the opened chapter and verse"
 
@@ -144,14 +155,48 @@ class CLI < Thor
 
 
 
-  # Description of the verse use case command line call.
-  desc "verse", "print the verse name at the opened chapter and verse"
+  # Description of the copy use case command line call.
+  desc "copy <line>", "copy a line value (at the current chapter/verse) into the clipboard."
+
+  # Copy into the clipboard the value held by the named line at the
+  # current book's open chapter and verse.
+  #
+  # This is more accurate and more secure than echoing the password and
+  # then performing a SELECT then COPY and then PASTE.
+  # 
+  # Use <b>safe clear</b> to wipe (overwrite) the sensitive value in
+  # the clipboard.
+  #
+  # @param line [String] the name of the line whose data will be copied.
+  #        If no line is given the default @password is assumed.
+  def copy( line = nil )
+    log.info(x) { "copy the line value at the current chpater/verse into the clipboard." }
+    copy_uc = SafeDb::Copy.new
+    copy_uc.line = line
+    copy_uc.flow()
+  end
+
+
+
+  # Description of the paste use case command line call.
+  desc "paste <line>", "paste a value into the line key which defaults to @password if not provided."
 
-  # Print the name of the verse at the opened chapter and verse location.
-  def verse
-    log.info(x) { "print the verse name at the opened chapter and verse." }
-    verse_uc = SafeDb::Verse.new
-    verse_uc.flow()
+  # Paste the current clipboard or selection text into the specified line
+  # at the current book's open chapter and verse.
+  #
+  # Sensitive values now neither need to be put on the commnad line (safe put)
+  # or inputted perhaps with a typo when using (safe input).
+  # 
+  # Use <b>safe wipe</b> to wipe (overwrite) any sensitive values that has
+  # been placed on the clipboard.
+  #
+  # @param line [String] the name of the line that the copied data will be
+  #        placed alongside. The line either may or may not exist.
+  def paste( line = nil )
+    log.info(x) { "paste the line value within the clipboard into the current chpater/verse." }
+    paste_uc = SafeDb::Paste.new
+    paste_uc.line = line
+    paste_uc.flow()
   end
 
 
@@ -168,6 +213,17 @@ class CLI < Thor
 
 
 
+  # Description of the safe wipe use case.
+  desc "wipe", "Wipe both clipboards of any sensitive data that may exist there."
+
+  # The<b>wipe</b> use case clears out any sensitive information from the clipboard.
+  def wipe
+    log.info(x) { "wipe out any sensitive information from the clipboard." }
+    SafeDb::Wipe.new.flow()
+  end
+
+
+
   # Description of the open use case command.
   desc "open <chapter> <verse>", "open a chapter and verse to read from or write to"
 
@@ -293,6 +349,80 @@ class CLI < Thor
 
 
 
+  # Description of the remote command.
+  desc "remote --provision", "Create (provision) remote storage for the safe database (backend) crypt files."
+
+  # The <tt>--provision</tt> option conveys that we want to carve out
+  # some remote storage so that our database can be accessed by multiple
+  # machines in different corners of the globe.
+  method_option :provision, :type => :boolean, :aliases => "-p"
+
+  # Creates remote storage for the safe database crypt files.
+  def remote
+    log.info(x) { "performing a remote storage use case. The provision flag is set to #{options[ :provision ]}." }
+    remote_uc = SafeDb::Remote.new()
+    remote_uc.provision = true if options[ :provision ]
+    remote_uc.provision = false unless options[ :provision ]
+    remote_uc.flow()
+  end
+
+
+
+  # Description of the safe git command.
+  desc "git --clone", "Clone the remote repository whose properties are in the current chapter and verse."
+
+    # If the --clone switch is included this class will expect to be at a verse
+    # that contains either a github token, username, reponame combination or a
+    # publicly publicly clonable url, or ssh url with the private keys and SSH host
+    # configuration already setup.
+
+    # If the --push switch is included this class will expect to be at a verse
+    # that has a path to a git url within it. If this is missing the present working
+    # directory is assumed to be the git repository in question.
+    #
+    # If the verse contains a branch name which is not the current branch then
+    # we raise a query to the user instead of pushing to the wrong place. This is
+    # a good double (sanity) check.
+
+
+    # If the --push switch is included this class will expect to be at a verse
+    # that has a path to a git url within it. If this is missing the present working
+    # directory is assumed to be the git repository in question.
+
+    # If the --no-ssl-verify switch is passed into this class it will urge git not
+    # to worry when a site does not have a (presently) trusted SSL certificate.
+
+    # If the --to switch has a value which is a path to a local (possibly non-existing)
+    # folder to clone to - this will override the verse line git.clone.path
+
+#####  method_option :provision, :type => :boolean, :aliases => "-p"
+
+
+  def git
+    log.info(x) { "performing a git repository interaction." }
+####    git_uc = SafeDb::Git.new()
+#####    remote_uc.provision = true if options[ :provision ]
+#####    remote_uc.provision = false unless options[ :provision ]
+####    git_uc.flow()
+    SafeDb::Git.new().flow()
+  end
+
+
+
+  # Description of the safe database push command.
+  desc "push", "push crypts to github and put index keys on removable drive"
+
+  # After backing up local assets the <b>push use case</b> creates a remoe github
+  # repository if necessary and initializes the master crypts as a git repository
+  # if necessary and then adds, commits and pushes the crypts up to the github
+  # remote for safe keeping.
+  def push
+    log.info(x) { "push crypt assets to github and refresh the index keys on removable drive." }
+    SafeDb::Push.new().flow()
+  end
+
+
+
   # Description of the set configuration directives command.
   desc "set <directive_name> <directive_value>", "set book-scoped configuration directive"
 
@@ -362,6 +492,21 @@ class CLI < Thor
   end
 
 
+  # Description of the safe keys command.
+  desc "keys <name>", "create a public/private keypair against the given name."
+
+  # The default action of the <b>keys use case</b> is to create a private and
+  # public keypair and store them within the open chapter and verse.
+  # @param keypair_name [String] optional name of the keypair (for example gitlab)
+  def keys( keypair_name = nil )
+    log.info(x) { "Generate an elliptic curve private and public cryptographic keys." }
+    log.info(x) { "The keypair name [ #{keypair_name} ] was given." } if keypair_name
+    keys_uc = SafeDb::Keys.new
+    keys_uc.keypair_name = keypair_name if keypair_name
+    keys_uc.flow()
+  end
+
+
 
   # Description of the read command.
   desc "read <file_url>", "read file into the open chapter and verse for safe keeping."
@@ -381,7 +526,7 @@ class CLI < Thor
 
 
   # Description of the write command.
-  desc "write <file_key>", "write out file to current folder or use --to_dir=</path/to/dir."
+  desc "write <file_key>", "write out file to current folder or use --to_dir=/path/to/dir."
 
   # The <b>write use case</b> writes out a file that was previously ingested
   # and coccooned inside the safe.
@@ -464,6 +609,8 @@ class CLI < Thor
     log.info(x) { "will export IAM credentials then invoke $ terraform #{command}" }
     terraform_uc = SafeDb::Terraform.new
     terraform_uc.command = command if command
+    terraform_uc.debug = true if options[ :debug ]
+    terraform_uc.debug = false unless options[ :debug ]
     terraform_uc.flow()
   end
 

data/lib/controller/{admin/auth.rb → abstract/authenticate.rb}

@@ -4,7 +4,7 @@ module SafeDb
 
   # Parent to use cases like Init and Login that perform early
   # initialize workflows.
-  class Auth < Controller
+  class Authenticate < Controller
 
     # This authorization use case should always have a book name
     # provided and sometimes may have a password parameter.
@@ -21,7 +21,6 @@ module SafeDb
     # at the <b>next login</b>.
     def is_book_initialized?()
 
-      KeyError.not_new( @book_name, self )
       return false unless File.exists?( Indices::MASTER_INDICES_FILEPATH )
       data_map = DataMap.new( Indices::MASTER_INDICES_FILEPATH )
       return false unless data_map.has_section?( @book_id )

data/lib/controller/{controller.rb → abstract/controller.rb}

@@ -39,7 +39,7 @@ module SafeDb
       return if is_no_token_uc
       exit(100) unless ops_key_exists?
 
-      is_login_uc = class_name.eql?( "login" )
+      is_login_uc = [ "login", "push", "pull" ].include? class_name
       return if is_login_uc
 
       not_logged_in = StateInspect.not_logged_in?()
@@ -65,6 +65,49 @@ module SafeDb
     end
 
 
+    # Login to the book and open the chapter and verse location that holds
+    # information about the remote backend that we push and pull to.
+    #
+    # To do this we must discover which book, chapter and verse holds
+    # the backend storage properties. This information should be available
+    # in the master keys file set by <tt>safe remote --provision</tt>
+    #
+    # After this call the @verse key/value map will contain properties
+    # pertaining to the safe#s backend remote store.
+    def open_remote_backend_location
+
+      verse_coordinates = Master.new().get_backend_coordinates()
+      the_book_id = verse_coordinates.split("/")[0]
+      the_chapter = verse_coordinates.split("/")[1]
+      the_verse = verse_coordinates.split("/")[2]
+
+      puts "" 
+      puts "Will login to book with id #{the_book_id}"
+
+      login_uc = Login.new()
+      login_uc.login_book_id = the_book_id
+      login_uc.suppress_output = true
+      login_uc.flow()
+      
+      puts "Login successful. Opening #{the_chapter}/#{the_verse}"
+
+      @book = Book.new()
+      @book.set_open_chapter_name( the_chapter )
+      @book.set_open_verse_name( the_verse )
+      @verse = @book.get_open_verse_data()
+      @book.write_open_chapter()
+
+    end
+
+
+
+    # Set the verse data structure for this controller. Usually called
+    # from another controller that wants to pass in a predefined map.
+    # @param incoming_verse [Hash] the incoming verse map to set
+    def set_verse( incoming_verse )
+      @verse = incoming_verse
+    end
+
     # This parental behaviour decrypts and reads the ubiquitous chapter and verse
     # data structures and indices.
     def read_verse()
@@ -198,14 +241,12 @@ module SafeDb
 
     def ops_key_exists?
 
-      log_env()
-
       if ( ENV.has_key? ENV_VAR_KEY_NAME )
         return true
       end
 
       puts ""
-      puts "safe needs you to create a branch key."
+      puts "safe needs you to create a shell token."
       puts "To automate this step see the documentation."
       puts "To create the key run the below command."
       puts ""
@@ -220,26 +261,6 @@ module SafeDb
     end
 
 
-    def log_env()
-
-      log.debug(x) { "Gem Root Folder    => #{Gem.dir()}" }
-      log.debug(x) { "Gem Config File    => #{Gem.config_file()}" }
-      log.debug(x) { "Gem Binary Path    => #{Gem.default_bindir()}" }
-      log.debug(x) { "Gem Host Path      => #{Gem.host()}" }
-      log.debug(x) { "Gem Caller Folder  => #{Gem.location_of_caller()}" }
-      log.debug(x) { "Gem Paths List     => #{Gem.path()}" }
-      log.debug(x) { "Gem Platforms      => #{Gem.platforms()}" }
-      log.debug(x) { "Gem Ruby Version X => #{Gem.ruby()}" }
-      log.debug(x) { "Gem Ruby Version Y => #{Gem::VERSION}" }
-      log.debug(x) { "Gem Ruby Version Z => #{Gem.latest_rubygems_version()}" }
-      log.debug(x) { "Gem User Folder    => #{Gem.user_dir()}" }
-      log.debug(x) { "Gem User Home      => #{Gem.user_home()}" }
-
-      return
-
-    end
-
-
   end
 
 

data/lib/controller/access/banner.txt

@@ -0,0 +1,6 @@
+
+
+   __|  __|  __|
+   _|  (   \__ \   The World's First Personal Database
+ ____|\___|____/
+

data/lib/controller/{admin → access}/init.rb

@@ -28,12 +28,12 @@ module SafeDb
   # - the book name ( maybe from SAFE_BOOK_NAME ) follows convention
   # - the shell must have a SAFE_TTY_TOKEN environment variable
   #
-  class Init < Auth
+  class Init < Authenticate
 
 
     def execute
 
-# @todo => in parent class Auth validate the book name
+# @todo => in parent class Authenticate validate the book name
 
 
       @book_id = Identifier.derive_ergonomic_identifier( @book_name, Indices::SAFE_BOOK_ID_LENGTH )
@@ -43,7 +43,7 @@ module SafeDb
         return
       end
 
-      StateMigrate.create_book( @book_id )
+      EvolveState.create_book( @book_id )
 
 # @todo => search for password in environment variable
 
@@ -53,7 +53,7 @@ module SafeDb
       master_keys = DataMap.new( Indices::MASTER_INDICES_FILEPATH )
       master_keys.use( @book_id )
 
-      StateMigrate.recycle_both_keys(
+      EvolveState.recycle_both_keys(
         @book_id,
         book_secret,
         master_keys,

data/lib/controller/{admin → access}/login.rb

@@ -23,18 +23,29 @@ module SafeDb
   # - a file in the present directory (with a pre-agreed name)
   # - a URL from a parameter or pre-agreed
   # - the shell's secure password reader
-  class Login < Auth
+  class Login < Authenticate
+
+# DELETE ME #######################    attr_writer :clip, :login_book_id, :suppress_output
 
     # If the clip switch is present it signifies that the password should
     # be read in from the clipboard. Any text selection puts text into the
     # the clipboard - no need specifically to use Ctrl-c (copy).
     attr_writer :clip
 
-    def execute
+    # Either the @book_name or the @login_book_id may be provided. The
+    # @login_book_id takes precedence if both are provided.
+    attr_writer :login_book_id
 
-# @todo => in parent class Auth validate the book name
+    # The view of chapter and verse names within the book is not printed out
+    # after a successful login if this suppress_output flag is set to true.
+    attr_writer :suppress_output
+
+    def execute
 
-      @book_id = Identifier.derive_ergonomic_identifier( @book_name, Indices::SAFE_BOOK_ID_LENGTH )
+      @book_id = @login_book_id if @login_book_id
+      @book_id = Identifier.derive_ergonomic_identifier( @book_name, Indices::SAFE_BOOK_ID_LENGTH ) unless @login_book_id
+      @book_reference = @login_book_id if @login_book_id
+      @book_reference = @book_name unless @login_book_id
 
       unless ( is_book_initialized?() )
         print_not_initialized
@@ -42,24 +53,22 @@ module SafeDb
       end
 
       if( StateInspect.is_logged_in?( @book_id ) )
-        StateMigrate.use_book( @book_id )
-        View.new().flow()
+        EvolveState.use_book( @book_id )
+        View.new().flow() unless @suppress_output
         return
       end
 
-# @todo => search for password in environment variable
-
       book_password = Clipboard.read_password() if @clip
       book_password = KeyPass.password_from_shell( false ) if( @password.nil?() && !@clip )
       book_password = @password unless @password.nil?()
 
-# @todo => if password is correct - if not print out an error.
-
       book_keys = DataMap.new( Indices::MASTER_INDICES_FILEPATH )
       book_keys.use( @book_id )
+      is_login_successful = EvolveState.login( book_keys, book_password )
+      print_login_failure() unless is_login_successful
+      return unless is_login_successful
 
-      StateMigrate.login( book_keys, book_password )
-      View.new().flow()
+      View.new().flow() unless @suppress_output
 
     end
 
@@ -67,28 +76,24 @@ module SafeDb
     private
 
 
-    def print_already_logged_in
+    def print_login_failure()
 
       puts ""
-      puts "We are already logged in. Open a secret envelope, put, then seal."
-      puts ""
-      puts "    #{COMMANDMENT} open aws.credentials:s3reader"
-      puts "    #{COMMANDMENT} put access_key ABCD1234"
-      puts "    #{COMMANDMENT} put secret_key FGHIJ56789"
-      puts "    #{COMMANDMENT} put region_key eu-central-1"
-      puts "    #{COMMANDMENT} seal"
+      puts "The login into book [ #{@book_reference} ] has failed."
+      puts "Please check the book name and password combination."
+      puts "Also visit login docs on how to present passwords."
       puts ""
 
     end
 
 
-    def print_not_initialized
+    def print_not_initialized()
 
       puts ""
-      puts "This book [ #{@book_name} ] has not yet been initialized."
+      puts "This book [ #{@book_reference} ] has not yet been initialized."
       puts "Please initialize it with this command."
       puts ""
-      puts "    #{COMMANDMENT} init #{@book_name}"
+      puts "    #{COMMANDMENT} init #{@book_reference}"
       puts ""
 
     end

data/lib/controller/api/docker/docker.rb

@@ -7,34 +7,16 @@ module SafeDb
     #     safe docker login
     #     safe docker logout
 
-    class Docker < Controller
+    class Docker < QueryVerse
 
         # The command which currently must be login, logout or
         # an empty string.
         attr_writer :command
 
-        def execute
+        def query_verse()
 
-            return unless ops_key_exists?
-            master_db = get_master_database()
-            return if unopened_envelope?( master_db )
-
-            # Get the open chapter identifier (id).
-            # Decide whether chapter already exists.
-            # Then get (or instantiate) the chapter's hash data structure
-            chapter_id = ENVELOPE_KEY_PREFIX + master_db[ ENV_PATH ]
-            verse_id = master_db[ KEY_PATH ]
-            chapter_exists = KeyApi.db_envelope_exists?( master_db[ chapter_id ] )
-
-            # Unlock the chapter data structure by supplying
-            # key/value mini-dictionary breadcrumbs sitting
-            # within the master database at the section labelled
-            # envelope@<<actual_chapter_id>>.
-            chapter_data = DataStore.from_json( Lock.content_unlock( master_db[ chapter_id ] ) )
-
-            key_value_dictionary = chapter_data[ verse_id ]
-            docker_username = key_value_dictionary[ "docker.username" ]
-            docker_password = key_value_dictionary[ "@docker.password" ]
+            docker_username = @verse[ "docker.username" ]
+            docker_password = @verse[ "@docker.password" ]
             docker_login_cmd = "docker login --username #{docker_username} --password #{docker_password} 2>/dev/null"
             docker_logout_cmd = "docker logout"
             docker_cmd = @command.eql?( "logout" ) ? docker_logout_cmd : docker_login_cmd

data/lib/controller/api/git/git.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/ruby
+	
+module SafeDb
+
+  class Git < QueryVerse
+
+    # If the --clone switch is included this class will expect to be at a verse
+    # that contains either a github token, username, reponame combination or a
+    # publicly publicly clonable url, or ssh url with the private keys and SSH host
+    # configuration already setup.
+    attr_writer :clone
+
+    # If the --push switch is included this class will expect to be at a verse
+    # that has a path to a git url within it. If this is missing the present working
+    # directory is assumed to be the git repository in question.
+    #
+    # If the verse contains a branch name which is not the current branch then
+    # we raise a query to the user instead of pushing to the wrong place. This is
+    # a good double (sanity) check.
+    attr_writer :push
+
+    # If the --push switch is included this class will expect to be at a verse
+    # that has a path to a git url within it. If this is missing the present working
+    # directory is assumed to be the git repository in question.
+    attr_writer :pull
+
+    # If the --no-ssl-verify switch is passed into this class it will urge git not
+    # to worry when a site does not have a (presently) trusted SSL certificate.
+    attr_writer :no_ssl_verify
+
+    # If the --to switch has a value which is a path to a local (possibly non-existing)
+    # folder to clone to - this will override the verse line git.clone.path
+    attr_writer :to
+
+
+    def query_verse()
+
+      puts ""
+
+      require "octokit"
+
+      git_repository_name = @verse[ Indices::GIT_REPOSITORY_NAME_KEYNAME ]
+      git_repository_user = @verse[ Indices::GIT_REPOSITORY_USER_KEYNAME ]
+      git_repository_host = @verse[ Indices::GIT_REPOSITORY_HOST_KEYNAME ]
+      git_repository_id = "#{git_repository_user}/#{git_repository_name}"
+
+=begin
+      # Clone repo using the github token
+      github_access_token = @verse[ Indices::GITHUB_ACCESS_TOKEN ]
+      git_repository_url = "https://#{github_access_token}@github.com/#{git_repository_id}"
+=end
+
+      # Clone repo using a SSH public/private keypair
+      git_repository_url = "git@#{git_repository_host}:#{git_repository_id}"
+      non_existent_path = File.join( get_clone_directory(), git_repository_name )
+
+      log.info(x) { "[gitflow] cloning remote repository called #{git_repository_name}" }
+      log.info(x) { "[gitflow] git repository user : #{git_repository_user}" }
+      log.info(x) { "[gitflow] git repository host : #{git_repository_host}" }
+      log.info(x) { "[gitflow] git repository clone path : #{non_existent_path}" }
+
+      git_clone_cmd = "git clone #{git_repository_url} #{non_existent_path}"
+      git_clone_output = %x[ #{ git_clone_cmd } ]
+      log.info(x) { "[gitflow] git clone output   : #{git_clone_output}" }
+
+      puts ""
+
+    end
+
+
+    # The git clone directory destination can be deemed from one of 3 places with
+    # the precedence order shown below.
+    #
+    # - the --to switch passed on the command line
+    # - the GIT_CLONE_BASE_PATH keyname within indices
+    # - the present working directory
+    #
+    # This method returns a File object which it could possibly create if the
+    # first two options denote a path that does not exist (but could).
+    #
+    # Failure is not yet handled but should be.
+    def get_clone_directory()
+
+      if @to
+        folder_exists = File.directory?( @to )
+        FileUtils.mkdir_p( @to ) unless folder_exists
+        return @to
+      end
+
+      if @verse.has_key?( Indices::GIT_CLONE_BASE_PATH )
+        folder_exists = File.directory?( @verse[ Indices::GIT_CLONE_BASE_PATH ] )
+        FileUtils.mkdir_p( @verse[ Indices::GIT_CLONE_BASE_PATH ] ) unless folder_exists
+        return @verse[ Indices::GIT_CLONE_BASE_PATH ]
+     end
+
+      return Dir.pwd()
+
+   end
+
+
+  end
+
+
+end