vop 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b5225000e9764e0e3a47151ecfbbd7cd02d58e58
+  data.tar.gz: 26bd6366f5abff2a055feb239d6f85e4aa1ddefd
+SHA512:
+  metadata.gz: 40e2acbd8735da52baafb4c01a6df32b514573d8c8cb4490401132c199554a370c687e69a041f167363b25f7865f44e9f4e58bc2d1717243a8d0d3153165d60e
+  data.tar.gz: dfde831a155f30531cec4396eff46870ba9ba22fc622c3f9a9087732276187993c99a1dea045c3b0a42d0d15a1435ad5dff0dcbc0f1812ecb034e48beeb8066d

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    vop (0.3.0)
+      activesupport
+      docopt
+      net-scp
+      net-ssh
+      pry
+      terminal-table
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (5.0.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    coderay (1.1.1)
+    concurrent-ruby (1.0.2)
+    diff-lcs (1.2.5)
+    docopt (0.5.0)
+    i18n (0.7.0)
+    method_source (0.8.2)
+    minitest (5.10.1)
+    net-scp (1.2.1)
+      net-ssh (>= 2.6.5)
+    net-ssh (3.2.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (11.3.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    slop (3.6.0)
+    terminal-table (1.7.3)
+      unicode-display_width (~> 1.1.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  rake
+  rspec
+  vop!
+
+BUNDLED WITH
+   1.10.6

data/README.md

@@ -0,0 +1,2 @@
+# vop
+new and improved, now with twice the vitamins!

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/vop.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+$: << File.join(Pathname.new(File.join(File.dirname(__FILE__), '..')).realpath, 'lib')
+
+require 'vop/shell'
+require 'docopt'
+require 'pp'
+
+begin
+  shell = Vop::Shell::setup()
+  if shell.options["--execute"]
+    last_response = shell.execute(shell.options["--execute"])
+  else
+    last_response = shell.run_cli
+  end
+
+  # TODO exit_status = last_response && last_response.status == Vop.Status::OK ? 0 : 1
+  exit 0
+rescue => detail
+  if detail.is_a? Docopt::Exit
+    puts detail.message
+  else
+    $stderr.puts "error : #{detail.message}\n#{detail.backtrace[0..9].join("\n")}"
+    exit 42
+  end
+end

data/bin/vop.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+ruby $DIR/vop.rb $*

data/exe/vop

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+
+$: << File.join(Pathname.new(File.join(File.dirname(__FILE__), '..')).realpath, 'lib')
+
+require 'vop/shell'
+require 'docopt'
+require 'pp'
+
+begin
+  shell = Vop::Shell::setup()
+  if shell.options["--execute"]
+    last_response = shell.execute(shell.options["--execute"])
+  else
+    last_response = shell.run_cli
+  end
+
+  # TODO exit_status = last_response && last_response.status == Vop.Status::OK ? 0 : 1
+  exit 0
+rescue => detail
+  if detail.is_a? Docopt::Exit
+    puts detail.message
+  else
+    $stderr.puts "error : #{detail.message}\n#{detail.backtrace[0..9].join("\n")}"
+    exit 42
+  end
+end

data/lib/vop.rb

@@ -0,0 +1,242 @@
+require 'pp'
+require 'logger'
+require 'pathname'
+
+require 'vop/version'
+require 'vop/plugin_loader'
+require 'active_support/inflector'
+
+module Vop
+
+  VOP_ROOT = Pathname.new(File.join(File.dirname(__FILE__), '..')).realpath
+  CORE_PLUGIN_PATH = Pathname.new(File.join(File.dirname(__FILE__), 'vop', 'plugins')).realpath
+  #CONFIG_PATH = '/etc/vop'
+  #PLUGIN_CONFIG_PATH = File.join(CONFIG_PATH, 'plugins.d')
+
+  class Vop
+
+    DEFAULTS = {
+      :search_path => [
+        File.join(VOP_ROOT, '..', 'plugins/standard'),
+        File.join(VOP_ROOT, '..', 'plugins/extended')
+      ],
+      :command_dir_name => 'commands',
+      :plugin_config => {
+
+      }
+    }
+
+    attr_reader :config
+
+    attr_reader :plugins
+    attr_reader :commands
+
+    def initialize(options = {})
+      at_exit {
+        self.shutdown
+      }
+
+      @version = ::Vop::VERSION
+
+      @config = DEFAULTS
+      @config.merge! options
+
+      $logger = Logger.new(STDOUT)
+      $logger.level = options['--verbose'] ? Logger::DEBUG : Logger::INFO
+
+      _reset
+
+      $logger.info "virtualop (#{@version}) init complete."
+      $logger.info "hello."
+    end
+
+    def _pry
+      binding.pry
+    end
+
+    def _reset
+      $logger.debug "loading..."
+
+      load_plugins
+
+      $logger.info "loaded #{@commands.size} commands from #{@plugins.size} plugins"
+    end
+
+    def _search_path
+      [ CORE_PLUGIN_PATH ] + config[:search_path]
+    end
+
+    def inspect
+      chunk_size = 25
+      plugin_string = @plugins.keys.sort[0..chunk_size-1].join(' ')
+      if @plugins.length > chunk_size
+        plugin_string += " + #{@plugins.length - chunk_size} more"
+      end
+      "vop #{@version} (#{plugin_string})"
+    end
+
+    def eat(command)
+      @commands[command.short_name] = command
+
+      self.class.send(:define_method, command.short_name) do |*args|
+        ruby_args = args.length > 0 ? args[0] : {}
+        self.execute(command.short_name, ruby_args)
+      end
+    end
+
+    def load_plugins
+      @plugins = {}
+      @commands = {}
+      @hooks = Hash.new { |h,k| h[k] = [] }
+
+      # step 1 : read plugins from all existing source dirs
+      candidates = _search_path
+      search_path = candidates.select { |path| File.exists? path }
+      search_path.each do |path|
+        PluginLoader.read(self, path)
+      end
+
+      # step 2 : activate plugins (in the right order)
+      ordered_plugins.each do |plugin|
+        plugin.init
+      end
+
+      # step 3 : expand entities
+      @plugins['core'].state[:entities].each do |entity|
+        entity_name = entity[:name]
+        entity_command = @commands[entity_name]
+        list_command_name = "list_#{entity_name.pluralize(42)}"
+        $logger.debug "generating #{list_command_name}"
+        list_command = Command.new(entity_command.plugin, list_command_name)
+
+        if entity[:options][:on]
+          list_command.params << {
+            :name => entity[:options][:on],
+            :multi => false,
+            :mandatory => true,
+            :default_param => true
+          }
+        end
+        list_command.block = entity_command.param(entity[:key])[:lookup]
+        eat(list_command)
+        # TODO add pseudo source code so that `source <list_command_name>` works
+      end
+
+      # TODO add pre-flight hook so that plugins can attach logic to execute here
+    end
+
+    def resolve(plugin, resolved, unresolved, level = 0)
+      unresolved << plugin.name
+
+      plugin.dependencies.each do |dep|
+        unless resolved.include? dep
+          if unresolved.include? dep
+            raise "running in circles #{plugin.name} -> #{dep}"
+          else
+            unless @plugins.has_key? dep
+              raise "missing dependency: #{plugin.name} depends on #{dep}"
+            end
+            dependency = @plugins[dep]
+            resolve(dependency, resolved, unresolved, level + 1)
+          end
+        end
+      end
+      resolved << plugin.name
+    end
+
+    def ordered_plugins
+      root_plugin = Plugin.new(self, '__root__', nil)
+      @plugins.values.each do |plugin|
+        root_plugin.dependencies << plugin.name
+      end
+      resolved = []
+      unresolved = []
+
+      resolve(root_plugin, resolved, unresolved)
+      resolved.delete_if { |x| x == root_plugin.name }
+
+      resolved.map { |x| @plugins[x] }
+    end
+
+    def command(name)
+      unless commands.has_key?(name)
+        raise "no such command : #{name}"
+      end
+
+      commands[name]
+    end
+
+    def core
+      @plugins['core']
+    end
+
+    def hook(name, plugin_name)
+      @hooks[name] << plugin_name
+    end
+
+    def call_hook(name, *payload)
+      @hooks[name].each do |plugin_name, block|
+        @plugins[plugin_name].call_hook(name, payload)
+      end
+    end
+
+    def before_execute(request)
+      #puts ">> #{request.command_name} #{request.param_values.keys}"
+      call_hook :before_execute, request
+    end
+
+    def after_execute(request, response)
+      #puts "<< #{request.command_name} #{response.result}"
+      call_hook :after_execute, request, response
+    end
+
+    def execute(command_name, param_values, extra = {})
+      request = Request.new(command_name, param_values, extra)
+      before_execute(request)
+
+      (result, context) = execute_command(command_name, param_values, extra)
+
+      response = Response.new(result, context)
+      after_execute(request, response)
+
+      result
+    end
+
+    def execute_command(command_name, param_values, extra = {})
+      $logger.debug "+++ #{command_name} +++"
+      command = @commands[command_name]
+
+      command.execute(param_values, extra)
+    end
+
+    def shutdown()
+      $logger.debug "shutting down..."
+    end
+
+  end
+
+  class Request
+
+    attr_reader :command_name, :param_values
+
+    def initialize(command_name, param_values, extra = {})
+      @command_name = command_name
+      @param_values = param_values
+      # fuck extra
+    end
+
+  end
+
+  class Response
+
+    attr_reader :result
+
+    def initialize(result, context)
+      @result = result
+      @context = context
+    end
+
+  end
+
+
+end