minvee 0.0.1

data/lib/minvee.rb

@@ -0,0 +1,885 @@
+#!/usr/bin/ruby -w
+require 'json'
+require 'uri'
+
+# requires
+require 'fileutils'
+
+
+#===============================================================================
+# Minvee
+# This module is just to initialize the namespace. It doesn't do anything.
+#
+module Minvee
+	# Version
+	VERSION = '0.0.1'
+end
+#
+# Minvee
+#===============================================================================
+
+
+
+#===============================================================================
+# Minvee::Client
+#
+module Minvee::Client
+	#---------------------------------------------------------------------------
+	# tmp dir
+	#
+	@@tmp_dir = '/tmp'
+	
+	def self.tmp_dir
+		return @@tmp_dir
+	end
+	
+	def self.tmp_dir=(p_dir)
+		@@tmp_dir = p_dir
+	end
+	#
+	# tmp dir
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# process_command_line
+	#
+	def self.process_command_line(params)
+		# $tm.hrm
+		
+		# action
+		command = params.shift
+		
+		# must have action
+		if not command
+			puts 'syntax: ' + script_name() + ' command [command options]'
+			exit 1
+		end
+		
+		# normalize command
+		command = command.downcase
+		command = command.gsub(/\s+/mu, '')
+		
+		# run command
+		if cmd = @@COMMANDS[command]
+			puts cmd
+		else
+			puts 'unknown command: ' + command
+		end
+	end
+	#
+	# process_command_line
+	#---------------------------------------------------------------------------
+	
+	
+	# commands
+	@@COMMANDS = {}
+	
+	#---------------------------------------------------------------------------
+	# prep
+	#
+	@@COMMANDS['prep'] = {}
+	
+	@@COMMANDS['prep']['sub'] = Proc.new do
+		puts 'hello world'
+	end
+	#
+	# prep
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# help
+	#
+	def self.help
+		
+		
+		puts 'syntax: ' + script_name() + ' command [command options]'
+		
+	end
+	#
+	# help
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# script_name
+	#
+	def self.script_name
+		return File.basename(__FILE__)
+	end
+	#
+	# script_name
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# zip
+	#
+	def self.zip(root, opts={})
+		# $tm.hrm
+		
+		# default options
+		opts = {'auto_delete'=>true}.merge(opts)
+		
+		# get temp path to zip file
+		tgt_path = Minvee::Utils::TempPath.new(self.tmp_dir, 'ext'=>'tgz')
+		
+		# build command
+		cmd = [
+			'tar',
+			'-czf',
+			tgt_path.to_s,
+			'./',
+		]
+		
+		# go to working copy and zip there
+		Dir.chdir(root) do
+			system(*cmd)
+		end
+		
+		# return path
+		return tgt_path
+	end
+	#
+	# zip
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# find_working_copy_dir
+	# TODO: Allow for possibility that effective user does not own the
+	# working copy.
+	#
+	def self.find_working_copy_dir(opts={})
+		# $tm.hrm
+		
+		# use explicit or current directory
+		if current_dir = opts['dir']
+			current_dir = File.expand_path(current_dir, Dir::pwd)
+		else
+			current_dir = Dir::pwd
+		end
+		
+		# loop while the current dir is owned by the effective user
+		while File.stat(current_dir).writable?
+			# check for minvee.json
+			if File.exist?(current_dir + '/minvee.json')
+				return current_dir
+			end
+			
+			# go to parent directory
+			current_dir = File.expand_path('..', current_dir)
+		end
+		
+		# didn't find working copy
+		return nil
+	end
+	#
+	# find_working_copy_dir
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# find_working_copy
+	#
+	def self.find_working_copy(opts={})
+		# $tm.hrm
+		
+		# get working copy directory
+		root = find_working_copy_dir(opts)
+		root or return nil
+		
+		# instantiate working copy object
+		wc = Minvee::Client::WorkingCopy.new(root, opts)
+		
+		# return
+		return wc
+	end
+	#
+	# find_working_copy
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Client
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Utils
+#
+module Minvee::Utils
+	#---------------------------------------------------------------------------
+	# rand_pk
+	#
+	@@rnd_chars = 'a'.upto('z').to_a + '0'.upto('9').to_a
+	@@rnd_chars_max = @@rnd_chars.length - 1
+	
+	def self.rand_pk()
+		# intialize rv
+		rv = ''
+		
+		# build return string
+		10.times do
+			rv += @@rnd_chars[rand 0 .. @@rnd_chars_max]
+		end
+		
+		# freeze return value
+		rv.freeze
+		
+		# return
+		return rv
+	end
+	#
+	# rand_pk
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# atomic_write
+	#
+	def self.atomic_write(tgt_path)
+		# $tm.hrm
+		
+		# get temp path
+		tmp_path = Minvee::Utils::TempPath.new(Minvee::Client.tmp_dir)
+		
+		# ensure the tmp path gets deleted
+		begin
+			# provide write handle
+			File.open(tmp_path, 'w') do |tmp_file|
+				yield(tmp_file)
+			end
+			
+			# move the temp file to the permanent location
+			FileUtils.mv(tmp_path, tgt_path)
+		ensure
+			# delete the tmp path
+			tmp_path.close
+		end
+	end
+	#
+	# atomic_write
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Utils
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Client::Message
+#
+class Minvee::Client::Message
+	attr_reader :languages
+	attr_reader :params
+	attr_reader :path
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_path)
+		# initialize params
+		@params = {}
+		
+		# initialize languages
+		@languages = ['general']
+		
+		# clone path
+		@path = p_path.clone
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# src
+	#
+	def src
+		# intialize search
+		search = @path.clone
+		
+		# initialize rv
+		rv = Minvee::Client::Message::Sources.srcs['general']
+		
+		# get message source
+		while search.length > 0
+			rv = rv[search.shift()]
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# src
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# expand
+	#
+	def expand
+		# $tm.hrm
+		
+		# initialize return value
+		rv = []
+		
+		# split src
+		tokens = src.split(/(\[\[[a-z0-9\-\_]+?\]\])/imu)
+		tokens = tokens.grep(/\S/imu)
+		
+		# build return value
+		tokens.each do |token|
+			if token.match(/\A\[\[[a-z0-9\-\_]+?\]\]\z/imu)
+				token.sub!(/\A\[\[\s*/imu, '')
+				token.sub!(/\s*\]\]\z/imu, '')
+				
+				if @params.has_key?(token)
+					rv.push @params[token].to_s
+				end
+			else
+				rv.push token
+			end
+		end
+		
+		# return
+		return rv.join('')
+	end
+	#
+	# expand
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Client::Message
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Client::Message::Sources
+#
+module Minvee::Client::Message::Sources
+	@@srcs = {}
+	def self.srcs; return @@srcs; end;
+	
+	# general
+	@@srcs['general'] = {
+		'test' => {
+			'a' => 'test message a',
+			'b' => 'test [[[[my-param]] b',
+		},
+		
+		'questions' => {
+			'yes' => {
+				'letter' => 'y',
+				'word' => 'yes',
+			},
+			'no' => {
+				'letter' => 'n',
+				'word' => 'no',
+			},
+		}
+	}
+end
+#
+# Minvee::Client::Message::Sources
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Client::WorkingCopy
+#
+class Minvee::Client::WorkingCopy
+	attr_accessor :root
+	attr_reader :settings
+	
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(p_root, opts={})
+		# $tm.hrm
+		
+		# p_root must be defined
+		if p_root.nil?
+			raise 'root-not-defined: did not get a defined root for working copy'
+		end
+		
+		# hold on to root
+		@root = p_root.to_s.dup
+		
+		# normalize and freeze root
+		@root.sub!(/\/+\z/imu, '')
+		@root.freeze
+		
+		# if directory doesn't exist
+		if not File.exist?(@root)
+			raise 'root-not-exists: do not find a directory at ' + @root
+		end
+		
+		# if settings file doesn't exist
+		if not File.exist?(self.settings_path)
+			raise 'no-settings-file: do not find minvee.json at ' + settings_path
+		end
+		
+		# slurp in file
+		# KLUDGE: File or JSON will throw errors at this point if there are any.
+		# We'll just let those bubble up to the script that is calling this
+		# method instead of catching the exceptions here.
+		@settings = JSON.parse(File.read(self.settings_path))
+		
+		# check settings
+		check_settings(opts)
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# zip
+	#
+	def zip(opts={})
+		return Minvee::Client.zip(@root, opts)
+	end
+	#
+	# zip
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# settings_path
+	#
+	def settings_path
+		return @root + '/minvee.json'
+	end
+	#
+	# settings_path
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# save_settings
+	#
+	def save_settings
+		Minvee::Utils.atomic_write(self.settings_path) do |file|
+			file.print JSON.pretty_generate(@settings)
+		end
+	end
+	#
+	# save_settings
+	#---------------------------------------------------------------------------
+	
+	
+	# private from here on
+	private
+	
+	
+	#---------------------------------------------------------------------------
+	# check_settings
+	# settings must have a project element, which is a hash, and that hash
+	# must have a url.
+	#
+	def check_settings(opts={})
+		# $tm.hrm
+		
+		# default options
+		opts = {'check_url'=>true}.merge(opts)
+		
+		# must be hash
+		if not @settings.is_a?(Hash)
+			raise "settings-not-hash: the settings for #{@root} are not a hash"
+		end
+		
+		# convenience
+		project = @settings['project']
+		
+		# must have project element
+		if not project
+			raise "settings-no-project: there are no project settings for #{@root}"
+		end
+		
+		# project element must be a hash
+		if not project.is_a?(Hash)
+			raise "settings-project-not-hash: the project element for #{@root} is not a hash"
+		end
+		
+		# must have project url
+		if not project['url']
+			raise "settings-project-no-url: the settings for #{@root} do not have a project url"
+		end
+		
+		# must be an HTTPS url
+		# TODO: We'll probably need to expand what types of URLs are allowed.
+		# For example, we should probably allow http on localhost.
+		if opts['check_url']
+			if not URI(project['url']).is_a?(URI::HTTPS)
+				raise "settings-project-invalid-url: the project url for #{@root} is not an HTTPS url: " + project['url']
+			end
+		end
+	end
+	#
+	# check_settings
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Client::WorkingCopy
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Utils::TempPath
+#
+class Minvee::Utils::TempPath
+	attr_reader :path
+	attr_accessor :auto_delete
+	
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(base, opts={})
+		# default options
+		opts = {'auto_delete'=>true}.merge(opts)
+		
+		# if explicit path sent
+		if opts['explicit']
+			@path = base
+		
+		# else build random path
+		else
+			# if path is a directory, add /
+			if File.directory?(base)
+				base = base.sub(/\/*\z/imu, '/')
+			end
+			
+			# initialize path
+			@path = base + Minvee::Utils.rand_pk
+			
+			# add suffix
+			if opts['suffix']
+				@path +=  '.' + opts['suffix']
+			end
+			
+			# add ext if sent
+			if opts['ext']
+				ext = opts['ext'].dup
+				ext.sub!(/\A\.*/imu, '.')
+				@path += ext
+			end
+		end
+		
+		# set finalizer for this object
+		ObjectSpace.define_finalizer(self, proc { self.class.finalize(self.object_id) })
+		
+		# set auto delete
+		@auto_delete = opts['auto_delete']
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# to_s. and to_str
+	#
+	def to_str
+		return @path
+	end
+	
+	def to_s
+		return @path
+	end
+	
+	def +(str)
+		return @path.to_s + str
+	end
+	#
+	# to_s. and to_str
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# close
+	#
+	def close
+		# if file exists, delete it
+		if self.auto_delete
+			if File.directory?(self.path)
+				FileUtils.rm_rf(self.path)
+			elsif File.exist?(self.path)
+				File.delete(self.path)
+			end
+		end
+	end
+	#
+	# close
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# finalize method
+	#
+	def self.finalize(id)
+		# $tm.hrm
+		
+		# get object from id
+		myself = ObjectSpace._id2ref(id)
+		
+		# close
+		myself.close()
+	end
+	#
+	# finalize method
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Utils::TempPath
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Utils::TempDir
+#
+class Minvee::Utils::TempDir < Minvee::Utils::TempPath
+	#---------------------------------------------------------------------------
+	# initialize
+	#
+	def initialize(base, opts={})
+		# call super method
+		super(base, opts)
+		
+		# create directory
+		FileUtils::mkdir_p(@path)
+	end
+	#
+	# initialize
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Utils::TempDir
+#===============================================================================
+
+
+#===============================================================================
+# Minvee::Client::Questions
+#
+module Minvee::Client::Questions
+	#---------------------------------------------------------------------------
+	# ask
+	#
+	def self.ask(type, opts)
+		# $tm.hrm
+		
+		# select
+		if type == 'select'
+			return self.select(opts)
+			
+		# short
+		elsif type == 'short'
+			return self.short(opts)
+				
+		# boolean
+		elsif type == 'boolean'
+			return self.boolean(opts)
+			
+		# else unknown
+		else
+			raise 'unknown question type: ' + type
+		end
+	end
+	#
+	# ask
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# select
+	#
+	def self.select(opts)
+		# $tm.hrm
+		
+		# initialize choice
+		choice = ''
+		
+		# initialize choices hash
+		choices = {}
+		
+		# initialize return hash
+		rv = {}
+		
+		# normalized choices
+		opts['choices'].each do |k, v|
+			choices[k.downcase] = v
+		end
+		
+		# prompt user until they make a choice
+		while not choices[choice]
+			# empty line
+			puts
+			
+			# output question
+			puts opts['question']
+			
+			# output choices
+			choices.each do |k, v|
+				puts k + ': ' + v['text']
+			end
+			
+			# empty line
+			puts
+			
+			# prompt
+			print opts['prompt'] + ': '
+			
+			# get input from user
+			choice = gets
+			choice.sub!(/\s+\z/imu, '')
+			choice.sub!(/\A\s+/imu, '')
+			choice.downcase!
+		end
+		
+		# store choice
+		rv['choice'] = choice
+		
+		# if "other"
+		if choices[choice]['other']
+			while not rv['other']
+				# get other choice
+				print choices[choice]['other'] + ': '
+				response = gets
+				
+				# normalize response
+				response.sub!(/\s+\z/imu, '')
+				response.sub!(/\A\s+/imu, '')
+				
+				# if response has content, we're done with this loop
+				if response.length > 0
+					rv['other'] = response
+				end
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# select
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# short
+	#
+	def self.short(opts)
+		# $tm.hrm
+		
+		# initialize return hash
+		rv = {}
+		
+		# loop until we get an answer
+		while not rv['response']
+			# get other choice
+			print opts['prompt'] + ': '
+			response = gets
+			
+			# normalize response
+			response.sub!(/\s+\z/imu, '')
+			response.sub!(/\A\s+/imu, '')
+			
+			# if response has content, or response is not required, we're done
+			if (response.length > 0) or (not opts['required'])
+				rv['response'] = response
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# short
+	#---------------------------------------------------------------------------
+	
+	
+	#---------------------------------------------------------------------------
+	# boolean
+	#
+	def self.boolean(opts)
+		# $tm.hrm
+		
+		# initialize return hash
+		rv = {}
+		
+		# output prompt
+		puts opts['prompt']
+		
+		# boolean options
+		bools = {
+			Minvee::Client::Message.new(%w{questions yes letter}).expand => true,
+			Minvee::Client::Message.new(%w{questions no letter}).expand => false,
+		}
+		
+		# initialize choices
+		choices = []
+		
+		# yes
+		choices.push 'y'
+		choices.push 'n'
+		
+		# default
+		if opts.has_key?('default')
+			has_default = true
+			
+			if opts['default']
+				choices[0].upcase!
+			else
+				choices[1].upcase!
+			end
+		end
+		
+		# ask until we get an answer
+		while rv['response'].nil?
+			# prompt
+			print choices.join('/'), ': '
+			
+			# get response
+			response = gets
+			
+			# normalize response
+			response.sub!(/\s+\z/imu, '')
+			response.sub!(/\A\s+/imu, '')
+			response.downcase!()
+			
+			# if anything left in the string, get the first character
+			if response.length > 0
+				response = response[0]
+			end
+			
+			# if we got an acceptable answer
+			if bools.has_key?(response)
+				rv['response'] = bools[response]
+			elsif has_default and (response == '')
+				rv['response'] = opts['default']
+			end
+		end
+		
+		# return
+		return rv
+	end
+	#
+	# boolean
+	#---------------------------------------------------------------------------
+end
+#
+# Minvee::Client::Questions
+#===============================================================================
+
+
+#===============================================================================
+# run if the script was not loaded by another script
+#
+if caller().length <= 0
+	Minvee::Client.process_command_line ARGV
+end
+#
+# run if the script was not loaded by another script
+#===============================================================================