hem 1.0.1.beta1

data/lib/hem/lib/vm/command.rb

@@ -0,0 +1,131 @@
+module Hem
+  module Lib
+    module Vm
+      class Command
+        class << self
+          attr_accessor :vm_inspector
+          @@vm_inspector = Inspector.new
+        end
+
+        attr_accessor :opts, :command
+
+        def initialize command, opts = {}
+          @command = command
+          @opts = {
+              :auto_echo => false,
+              :psuedo_tty => false,
+              :pwd => opts[:pwd] || @@vm_inspector.project_mount_path,
+              :append => ''
+          }.merge(opts)
+        end
+
+        def pipe cmd, pipe_opts = {}
+          pipe_opts = pipe_opts.merge({ :on => :vm })
+          cmd = "echo #{cmd.shellescape.gsub(/(\\+)/, '\\\\\1')}" if @opts[:auto_echo]
+
+          case pipe_opts[:on]
+            when :vm
+              @pipe_in_vm = cmd
+            when :host
+              @pipe = cmd
+            else
+              raise "Unknown pipe source: #{pipe_opts[:on]}"
+          end
+          @opts[:psuedo_tty] = false
+          return self
+        end
+
+        def << cmd
+          pipe cmd, :on => :host
+        end
+
+        def < cmd
+          pipe cmd, :on => :vm
+        end
+
+        # TODO Refactor in to ssh helper with similar opts to shell helper
+        # TODO Migrate all vm_shell functionality this direction
+        def run
+          return if @command.nil?
+          require 'net/ssh/simple'
+          opts = @@vm_inspector.ssh_config.merge(@opts)
+
+          Net::SSH::Simple.sync do
+            ssh_opts = {
+                :user => opts[:ssh_user],
+                :port => opts[:ssh_port],
+                :forward_agent => true,
+                :global_known_hosts_file => "/dev/null",
+                :paranoid => false,
+                :user_known_hosts_file => "/dev/null"
+            }
+
+            ssh_opts[:keys] = [opts[:ssh_identity]] if opts[:ssh_identity]
+
+            tmp = Tempfile.new "vm_command_exec"
+
+            begin
+              filename = File.basename(tmp.path)
+              remote_file = "/tmp/#{filename}"
+              tmp.write "#{@command}#{opts[:append]}"
+              tmp.close
+
+              scp_put opts[:ssh_host], tmp.path, remote_file, ssh_opts
+              result = ssh opts[:ssh_host], "cd #{opts[:pwd]}; exec /bin/bash #{remote_file}", ssh_opts
+              ssh opts[:ssh_host], "rm #{remote_file}", ssh_opts
+
+              # Throw exception if exit code not 0
+
+              return opts[:capture] ? result.stdout : result.success
+            ensure
+              tmp.unlink
+            end
+          end
+        end
+
+        # TODO Speed up Vagrant SSH connections
+        # May need to be disabled for windows (mm_send_fd: UsePrivilegeSeparation=yes not supported)
+        # https://gist.github.com/jedi4ever/5657094
+
+        def to_s
+          opts = @@vm_inspector.ssh_config.merge(@opts)
+
+          psuedo_tty = opts[:psuedo_tty] ? "-t" : ""
+
+          ssh_command = [
+              "ssh",
+              "-o 'UserKnownHostsFile /dev/null'",
+              "-o 'StrictHostKeyChecking no'",
+              "-o 'ForwardAgent yes'",
+              "-o 'LogLevel FATAL'",
+              "-p #{opts[:ssh_port]}",
+              "-i #{opts[:ssh_identity].shellescape}",
+              psuedo_tty,
+              "#{opts[:ssh_user].shellescape}@#{opts[:ssh_host].shellescape}"
+          ].join(" ")
+
+          pwd_set_command = " -- \"cd #{@opts[:pwd].shellescape}; exec /bin/bash"
+
+          vm_command = [
+              @pipe_in_vm,
+              @command
+          ].compact.join(" | ")
+
+          command = [
+              ssh_command + pwd_set_command,
+              vm_command.empty? ? nil : vm_command.shellescape
+          ].compact.join(" -c ") + "#{opts[:append].shellescape}\""
+
+          [
+              @pipe,
+              command
+          ].compact.join(" | ")
+        end
+
+        def to_str
+          to_s
+        end
+      end
+    end
+  end
+end

data/lib/hem/lib/vm/inspector.rb

@@ -0,0 +1,73 @@
+module Hem
+  module Lib
+    module Vm
+      class Inspector
+        attr_accessor :ssh_config, :project_mount_path, :project_config
+
+        def project_mount_path
+          configured_path = maybe(Hem.project_config.vm.project_mount_path)
+          return configured_path if configured_path
+          return @project_mount_path if @project_mount_path
+
+          tmp = Tempfile.new('vm_command_locator', Hem.project_path)
+
+          begin
+            tmp.write(Hem.project_path)
+
+            locator_file = File.basename(tmp.path)
+
+            pattern = Hem.windows? ? 'vboxsf' : Hem.project_path.shellescape
+
+            sed = 's/.* on \(.*\) type.*/\1\/%%/g'.gsub('%%', locator_file)
+            locator_results = Command.new(
+                "mount | grep #{pattern} | sed -e\"#{sed}\" | xargs md5sum",
+                :capture => true,
+                :pwd => '/'
+            ).run
+          ensure
+            tmp.unlink
+          end
+
+          match = locator_results.match(/^([a-z0-9]{32})\s+(.*)$/)
+
+          raise Exception.new("Unable to locate project mount point in VM") if !match
+
+          @vm_project_mount_path = File.dirname(match[2])
+
+          # Stash it in config
+          Hem.project_config[:vm] ||= {}
+          Hem.project_config[:vm][:project_mount_path] = @vm_project_mount_path
+          Hem::Config::File.save(Hem.project_config_file, Hem.project_config)
+
+          return @vm_project_mount_path
+        end
+
+        def ssh_config
+          return @ssh_config if @ssh_config
+          config = nil
+          locate "*Vagrantfile" do
+            config = shell "vagrant ssh-config", :capture => true
+          end
+
+          raise Exception.new "Could not retrieve VM ssh configuration" unless config
+
+          patterns = {
+              :ssh_user => /^\s*User (.*)$/,
+              :ssh_identity => /^\s*IdentityFile (.*)$/,
+              :ssh_host => /^\s*HostName (.*)$/,
+              :ssh_port => /^\s*Port (\d+)/
+          }
+
+          output = {}
+
+          patterns.each do |k, pattern|
+            match = config.match(pattern)
+            output[k] = match[1] if match
+          end
+
+          return @ssh_config = output
+        end
+      end
+    end
+  end
+end

data/lib/hem/logging.rb

@@ -0,0 +1,20 @@
+module Hem
+  class << self
+    attr_accessor :logger
+  end
+
+  module Logging
+    def logger
+      Hem::Logging.logger
+    end
+
+    def self.logger
+      unless Hem.logger
+        Hem.logger = Logger.new(STDOUT)
+        Hem.logger.level = Logger::WARN
+      end
+
+      return Hem.logger
+    end
+  end
+end

data/lib/hem/metadata.rb

@@ -0,0 +1,42 @@
+module Hem
+    class Metadata
+    class << self
+      attr_accessor :metadata, :store, :defaults
+
+      def store
+        @store ||= {}
+      end
+
+      def metadata
+        @metadata ||= {}
+      end
+
+      def default type, value
+        @defaults ||= {}
+        @defaults[type] = value
+        store[type] = value if store[type].nil?
+      end
+
+      def add task, type, data = nil
+        data = store[type] if data.nil?
+        metadata[task] ||= {}
+        metadata[task][type] = data
+      end
+
+      def to_store task
+        reset_store
+        return unless metadata[task]
+        metadata[task].each do |k,v|
+          store[k] = v
+        end
+      end
+
+      def reset_store
+        @store = {}
+        @defaults.each do |k, v|
+          @store[k] = v.nil? ? nil : v.dup
+        end
+      end
+    end
+  end
+end

data/lib/hem/null.rb

@@ -0,0 +1,31 @@
+module Hem
+  class Null
+    def method_missing(method, *args, &block)
+      self
+    end
+
+    def nil?
+      true
+    end
+
+    def to_a
+      []
+    end
+
+    def to_s
+      ""
+    end
+
+    def to_f
+      0.0
+    end
+
+    def to_i
+      0
+    end
+  end
+end
+
+def maybe val
+  val.nil? ? nil : val
+end

data/lib/hem/patches/deepstruct.rb

@@ -0,0 +1,21 @@
+# Copied from the DeepStruct gem
+# Modified to return Null on unknown key
+module DeepStruct
+  class HashWrapper < DeepWrapper
+    def method_missing(method, *args, &block)
+      return @value.send(method, *args, &block) if @value.respond_to?(method)
+      method = method.to_s
+      if method.chomp!('?')
+        key = method.to_sym
+        self.has_key?(key) && !!self[key]
+      elsif method.chomp!('=')
+        raise ArgumentError, "wrong number of arguments (#{arg_count} for 1)", caller(1) if args.length != 1
+        self[method] = args[0]
+      elsif args.length == 0 && self.has_key?(method)
+        self[method]
+      else
+        Hem::Null.new
+      end
+    end
+  end
+end

data/lib/hem/patches/rake.rb

@@ -0,0 +1,101 @@
+module Rake
+  class Task
+    attr_accessor :opts
+    def opts
+      @opts = @opts || {}
+    end
+  end
+
+  module DSL
+    def before(task_name, new_tasks = nil, &new_task)
+      task_name = task_name.to_s
+      new_tasks = [new_tasks].flatten.compact
+      old_task = Rake.application.instance_variable_get('@tasks').delete(task_name)
+
+      Hem::Metadata.to_store task_name
+      task task_name => old_task.prerequisites do
+        new_task.call unless new_task.nil?
+        new_tasks.each do |t|
+          Rake::Task[t].invoke
+        end
+        old_task.invoke
+      end
+    end
+
+    def after(task_name, new_tasks = nil, &new_task)
+      task_name = task_name.to_s
+      new_tasks = [new_tasks].flatten.compact
+      old_task = Rake.application.instance_variable_get('@tasks').delete(task_name)
+
+      Hem::Metadata.to_store task_name
+      task task_name => old_task.prerequisites do
+        old_task.invoke
+        new_tasks.each do |t|
+          Rake::Task[t].invoke
+        end
+        new_task.call unless new_task.nil?
+      end
+    end
+
+    def replace *args, &block
+      old = (args[0].is_a? Hash) ? args[0].keys[0] : args[0]
+      Hem::Logging.logger.debug("rake.dsl: Replacing #{old} with block")
+      Rake::Task[old].clear
+      task(*args, &block)
+    end
+
+    def invoke task, *args, &block
+      Rake::Task[task].invoke(*args, &block)
+    end
+
+    def hidden value = true
+      Hem::Metadata.store[:hidden] = value
+    end
+
+    def project_only
+      Hem::Metadata.store[:project_only] = true
+    end
+
+    def task *args, &block
+      name = args[0].is_a?(Hash) ? args[0].keys.first.to_s : args[0]
+      scoped_name = Rake.application.current_scope.path_with_task_name(name).to_s
+
+      [:opts, :desc, :long_desc, :hidden, :project_only].each do |meta|
+        Hem::Metadata.add scoped_name, meta
+      end
+
+      Hem::Metadata.reset_store
+
+      Hem::Logging.logger.debug("Added metadata to #{scoped_name} -- #{Hem::Metadata.metadata[scoped_name]}")
+
+      task = Rake::Task.define_task(*args, &block)
+    end
+
+    def option *args
+      Hem::Metadata.store[:opts].push args
+    end
+
+    def desc description
+      Hem::Metadata.store[:desc] = description
+    end
+
+    def long_desc description
+      Hem::Metadata.store[:long_desc] = description
+    end
+
+    alias :_old_namespace :namespace
+    def namespace name, opts = {}, &block
+      scoped_name = Rake.application.current_scope.path_with_task_name(name).to_s
+      [:desc, :long_desc, :hidden, :project_only].each do |meta|
+        Hem::Metadata.add scoped_name, meta
+      end
+
+      Hem::Metadata.reset_store
+
+      _old_namespace(name, &block)
+    end
+  end
+end
+
+Hem::Metadata.default :opts, []
+Hem::Metadata.default :desc, nil

data/lib/hem/patches/rubygems.rb

@@ -0,0 +1,6 @@
+# No sensible way to silence gem warnings
+class Gem::Specification
+  def self.warn m
+    #NOP
+  end
+end

data/lib/hem/patches/slop.rb

@@ -0,0 +1,69 @@
+class Slop
+  attr_accessor :long_desc, :arg_list, :hidden, :desc, :unparsed
+
+  # Slop has a description method but it uses @config which is inherited
+  # This is not desired behaviour
+  def description desc = nil
+    @desc = desc if desc
+    @desc
+  end
+
+  def long_description desc = nil
+    @long_desc = desc if desc
+    @long_desc
+  end
+
+  def arg_list list = nil
+    @arg_list = list if list
+    @arg_list
+  end
+
+  def hidden value = nil
+    @hidden = value if value
+    @hidden
+  end
+
+  def project_only value = nil
+    @config[:project_only] = value unless value.nil?
+    @config[:project_only]
+  end
+
+  alias :old_parse! :parse!
+  def parse!(items = ARGV, &block)
+    if @unparsed.nil?
+      split_index = items.index('--')
+
+      unparsed = []
+      unless split_index.nil?
+        unparsed = items.slice(split_index + 1, items.length)
+        items = items.slice(0, split_index)
+      end
+
+      @unparsed = unparsed.map do |c|
+        "\'#{c.gsub("'", '\\\'').gsub('(', '\\(').gsub(')', '\\)')}\'"
+      end.join(' ')
+    end
+
+    old_parse!(items, &block)
+  end
+
+  class Option
+    DEFAULT_OPTIONS[:key_delimiter] = '='
+
+    alias :old_value= :value=
+    def value=(new_value)
+      if config[:as].to_s.downcase == 'hash'
+        @value ||= {}
+
+        if new_value.respond_to?(:split)
+          new_array_hash = new_value.split(config[:delimiter], config[:limit]).map do |v|
+            v.split(config[:key_delimiter], 2)
+          end
+          @value.merge!(Hash[new_array_hash])
+        end
+      else
+        self.old_value = new_value
+      end
+    end
+  end
+end

data/lib/hem/paths.rb

@@ -0,0 +1,96 @@
+module Hem
+  class << self
+    attr_accessor :project_path
+
+    def config_path
+      [ File.join(ENV['HOME'], '.hem'), File.join(ENV['HOME'], '.hobo') ].each do |path|
+        return path if File.exists? File.join(path, 'config.yaml')
+      end
+    end
+
+    def seed_cache_path
+      File.join(config_path, 'seeds')
+    end
+
+    def detect_project_type
+      return unless @project_type.nil?
+
+      searches = [
+        { type: "Hem", indicators: [ "Hemfile", "tools/hem"] },
+        { type: "Hobo", indicators: [ "Hobofile", "tools/hobo"] },
+        { type: "Hem", indicators: ["tools/vagrant/Vagrantfile"] }
+      ]
+
+      searches.each do |search|
+        next if @project_path
+        path = project_path_compat search
+        if path
+          @project_type = search[:type]
+          @project_path = path
+          break
+        end
+      end
+
+      @project_type ||= 'Hem'
+    end
+
+    def project_dsl_type
+      detect_project_type
+      @project_type
+    end
+
+    def project_dsl_file
+      "#{project_dsl_type}file"
+    end
+
+    def project_path
+      detect_project_type
+      @project_path
+    end
+
+    def project_path_compat search
+      dir = Dir.pwd.split('/').reverse
+      min_length = Gem.win_platform? ? 1 : 0
+      Hem::Logging.logger.debug("paths.project: Searching backwards from #{Dir.pwd}")
+
+      while dir.length > min_length
+        test_dir = dir.reverse.join('/')
+        Hem::Logging.logger.debug("paths.project: Testing #{test_dir}")
+
+        results = search[:indicators].map do |s|
+          File.exists?(File.join(test_dir, s))
+        end
+
+        match = results - [false]
+
+        return test_dir if match.length > 0
+
+        dir.shift
+      end
+      return nil
+    end
+
+    def project_bin_path
+      return nil if !project_path
+      File.join(project_path, 'bin')
+    end
+
+    def hemfile_path
+      return nil if !project_path
+      File.join(project_path, project_dsl_file)
+    end
+
+    def project_config_file
+      return nil if !project_path
+      File.join(project_path, 'tools', project_dsl_type.downcase, 'config.yaml')
+    end
+
+    def user_config_file
+      File.join(config_path, 'config.yaml')
+    end
+
+    def user_hemfile_path
+      File.join(config_path, project_dsl_file)
+    end
+  end
+end

data/lib/hem/tasks/assets.rb

@@ -0,0 +1,92 @@
+desc "Project asset commands"
+project_only
+namespace :assets do
+  def render_delta delta, type
+    if delta[:add] and delta[:add].length > 0
+      x = type == 'download' ? 'download from S3' : 'upload to S3'
+      Hem.ui.section "  Files to #{x}:" do
+        delta[:add].each do |f|
+          Hem.ui.success "    #{f}"
+        end
+      end
+    end
+
+    if delta[:remove] and delta[:remove].length > 0
+      x = type == 'download' ? 'locally' : 'from S3'
+      puts Hem.ui.color "  Files to delete #{x}:", :error
+      delta[:remove].each do |f|
+        puts Hem.ui.color "    #{f}", :error
+      end
+      Hem.ui.separator
+    end
+  end
+
+  def do_sync src, dst, env, type
+    unless Hem.project_config.asset_bucket.nil?
+      sync = Hem::Lib::S3::Sync.new(Hem.aws_credentials)
+      changes = sync.sync(src, dst, :dry => true)
+
+      if (changes[:add] + changes[:remove]).length > 0
+        answer = if type == 'download' && changes[:remove].length == 0
+          'y'
+        else
+          render_delta changes, type
+          Hem.ui.ask "Proceed? (Y/N)", :default => 'Y'
+        end
+
+        if answer.downcase == 'y'
+          sync.sync(src, dst)
+        else
+          raise Hem::Error.new "Asset sync aborted"
+        end
+      else
+        Hem.ui.warning "  No changes required"
+      end
+    else
+      Hem.ui.warning "  No asset bucket configured. Skipping..."
+    end
+  end
+
+  desc "Download project assets"
+  option "-e=", "--env=", "Environment"
+  task :download do |task, args|
+    Hem.ui.section "Synchronizing assets (download)" do
+      env = task.opts[:env] || args[:env] || 'development'
+      src = "s3://#{Hem.project_config.asset_bucket}/#{env}/"
+      dst = "#{Hem.project_path}/tools/assets/#{env}"
+      do_sync src, dst, env, "download"
+    end
+  end
+
+  desc "Upload project assets"
+  option "-e=", "--env=", "Environment"
+  task :upload do |task, args|
+    Hem.ui.section "Synchronizing assets (upload)" do
+      env = task.opts[:env] || args[:env] || 'development'
+      dst = "s3://#{Hem.project_config.asset_bucket}/#{env}/"
+      src = "#{Hem.project_path}/tools/assets/#{env}"
+      Hem.ui.warning "Please note that asset uploads can be destructive and will affect the whole team!"
+      Hem.ui.warning "Only upload if you're sure your assets are free from errors and will not impact other team members"
+      do_sync src, dst, env, "upload"
+    end
+  end
+
+  desc "Apply project assets"
+  option "-e=", "--env=", "Environment"
+  project_only
+  task :apply do |task, args|
+    env = task.opts[:env] || args[:env] || 'development'
+    path = "tools/assets/#{env}"
+
+    next unless File.exists? path
+
+    Dir.new(path).each do |file|
+      file = File.join(path, file)
+      next unless File.file? file
+      Hem.asset_applicators.each do |matcher, proc|
+        proc.call(file) if matcher.match(file)
+      end
+    end
+
+  end
+end

data/lib/hem/tasks/config.rb

@@ -0,0 +1,15 @@
+desc "Configure hem"
+task :config do
+  config = Hem.user_config
+
+  # Not required at present
+  # config.full_name = Hem.ui.ask("Full name", :default => config.full_name).to_s
+  # config.email = Hem.ui.ask("Email", :default => config.email).to_s
+
+  config[:aws] ||= {}
+  config.aws.access_key_id = Hem.ui.ask("AWS access key ID", :default => config.aws.access_key_id).to_s
+  config.aws.secret_access_key = Hem.ui.ask("AWS secret access key", :default => config.aws.secret_access_key).to_s
+
+  Hem::Config::File.save(Hem.user_config_file, config)
+  File.chmod(0600, Hem.user_config_file)
+end