mvcli 0.0.16 → 0.1.0

data/lib/mvcli/path.rb

@@ -0,0 +1,41 @@
+require "pathname"
+
+module MVCLI
+  class Path
+    def initialize(base)
+      @base = Pathname(base.to_s)
+    end
+
+    def exists?(path)
+      @base.join(path).exist?
+    end
+
+    def read(path)
+      @base.join(path).read
+    end
+
+    def join(path)
+      self.class.new @base.join path
+    end
+
+    def nearest(pattern)
+      ancestors.each do |dir|
+        if entry = dir.entries.find { |e| e.to_s.match pattern }
+          return dir.join entry
+        end
+      end
+    end
+
+    def ancestors(dir = @base)
+      if dir == dir.parent
+        []
+      else
+        [dir] + ancestors(dir.parent)
+      end
+    end
+
+    def to_s(path = nil)
+      path.nil? ? @base.to_s : @base.join(path).to_s
+    end
+  end
+end

data/lib/mvcli/plugins.rb

@@ -0,0 +1,19 @@
+require "mvcli/core"
+
+module MVCLI
+  class Plugins < MVCLI::Core
+    requires :bundle, :cortex
+    self.path = File.expand_path '../plugins', __FILE__
+    self.namespace = ::MVCLI
+    self.identifier = 'mvcli-plugins'
+
+    def activate!
+      bundle.activate!
+      Core.drain do |cls|
+        core = cls.new if cls.path
+        core.activate!
+        cortex << core
+      end
+    end
+  end
+end

data/lib/mvcli/plugins/controllers/plugins_controller.rb

@@ -0,0 +1,23 @@
+class MVCLI::PluginsController < MVCLI::Controller
+  requires :cortex, :argv, :bundle
+
+  def install
+    @installation = bundle.replace params[:name], form.attributes
+    respond_with @installation
+  end
+
+  def uninstall
+    @installation = bundle.remove params[:name]
+    respond_with @installation
+  end
+
+  def index
+    @plugins = bundle.plugins
+    respond_with @plugins
+  end
+
+  def respond_with(response, options = {})
+    response
+  end
+
+end

data/lib/mvcli/plugins/forms/plugins/install_form.rb

@@ -0,0 +1,6 @@
+class MVCLI::Plugins::InstallForm < MVCLI::Form
+
+  input :path, Pathname, decode: ->(s) { Pathname s }
+
+  validates(:path, "no such directory") { |path| path.exist? }
+end

data/lib/mvcli/plugins/models/plugins/installation_model.rb

@@ -0,0 +1,33 @@
+class MVCLI::Plugins::InstallationModel
+  requires :config
+
+  def initialize(form)
+    @form = form
+  end
+
+  def name
+    gemspec.name
+  end
+
+  def version
+    gemspec.version
+  end
+
+  def location
+    @form.path
+  end
+
+  def gemspec
+    gemspec = Gem::Specification.load Dir[@form.path.join('*.gemspec')].first
+    config.directory "plugins" do |dir|
+      target = dir.join(gemspec.name)
+      FileUtils.rm_rf target
+      target.make_symlink location
+      Gem.paths.path.unshift dir.to_s
+      request = Gem::RequestSet.new *gemspec.dependencies
+      request.resolve
+      request.install_into dir
+    end
+    return gemspec
+  end
+end

data/lib/mvcli/plugins/providers/bundle_provider.rb

@@ -0,0 +1,116 @@
+class MVCLI::BundleProvider
+  requires :config
+
+  def value
+    self
+  end
+
+  def activate!
+    require activatefile if activatefile.exist?
+  end
+
+  def replace(name, options = {})
+    require 'bundler'
+    builder.dependencies.reject! { |dep| dep.name == name }
+    dep, *rest = builder.gem name, options
+    update! name
+    write!
+    return dep
+  end
+
+  def remove(gem_name)
+    require 'bundler'
+    dep = builder.dependencies.find { |d| d.name == gem_name }
+    fail "#{gem_name} is not an installed plugin" unless dep
+    builder.dependencies.reject! { |d| d == dep }
+    update! gem_name
+    write!
+    return dep
+  end
+
+  def plugins
+    lock.specs.select do |spec|
+      builder.dependencies.detect { |dep| dep.name == spec.name }
+    end
+  end
+
+  def gemfile
+    dir.join('Gemfile').tap do |path|
+      unless path.exist?
+        path.open "wb" do |file|
+          file.puts "source 'https://rubygems.org'"
+        end
+      end
+    end
+  end
+
+  def lockfile
+    dir.join 'Gemfile.lock'
+  end
+
+  def setupfile
+    dir.join 'bundle/bundler/setup.rb'
+  end
+
+  def activatefile
+    dir.join 'activate.rb'
+  end
+
+  def dir
+    config.directory('plugins')
+  end
+
+  def builder
+    @builder ||= Bundler::Dsl.new.tap do |builder|
+      builder.eval_gemfile gemfile
+    end
+  end
+
+  def lock
+    require 'bundler'
+    Bundler::LockfileParser.new lockfile.read
+  end
+
+  def write!
+    gemfile.open "w" do |file|
+      file.puts "source 'https://rubygems.org'"
+      builder.dependencies.each do |dep|
+        file << %|gem "#{dep.name}"|
+        if req = dep.requirements_list.first
+          file << %|, "#{req}"|
+        end
+        options = dep.source ? dep.source.options || {} : {}
+        options = Hash[options.map { |k, v| [k,v.to_s]}]
+        options.merge! "require" =>  dep.autorequire if dep.autorequire
+        file << %|, #{options.inspect}|
+        file << "\n"
+      end
+    end
+    activatefile.open "w" do |file|
+      file.puts "require #{setupfile.to_s.inspect}"
+      builder.dependencies.each do |dep|
+        require_names = dep.autorequire || [dep.name]
+        require_names.each do |name|
+          file.puts "require #{name.inspect}"
+        end
+      end
+    end
+  end
+
+  def update!(name)
+    path = Bundler.settings[:path]
+    original_definition_method = Bundler.method(:definition)
+    Bundler.with_clean_env do
+      ENV['BUNDLE_GEMFILE'] = gemfile.to_s
+      definition = builder.to_definition(lockfile, name => true)
+      Bundler.settings[:path] = dir.join('bundle').to_s
+      Dir.chdir dir do
+        Bundler.define_singleton_method(:definition) { definition }
+        Bundler::Installer.install dir, definition, standalone: [], "update" => true
+      end
+    end
+  ensure
+    Bundler.define_singleton_method(:definition, &original_definition_method)
+    Bundler.settings[:path] = path
+  end
+end

data/lib/mvcli/plugins/routes.rb

@@ -0,0 +1,3 @@
+match 'show plugins' => 'plugins#index'
+match 'install plugin :name' => 'plugins#install'
+match 'uninstall plugin :name' => 'plugins#uninstall'

data/lib/mvcli/plugins/templates/plugins/index.txt.erb

@@ -0,0 +1,3 @@
+<% for plugin in this %>
+<%= plugin.name %> <%= plugin.version %> 
+<% end %>

data/lib/mvcli/plugins/templates/plugins/install.txt.erb

@@ -0,0 +1 @@
+Installed plugin <%= this.name %> <%= this.requirement %>

data/lib/mvcli/plugins/templates/plugins/uninstall.txt.erb

@@ -0,0 +1 @@
+Uninstalled plugin <%= this.name %>

data/lib/mvcli/provisioning.rb

@@ -1,15 +1,14 @@
 require "map"
-require "active_support/concern"
-require "active_support/dependencies"
-require "mvcli/loader"
 
 module MVCLI
   module Provisioning
-    extend ActiveSupport::Concern
-    UnsatisfiedRequirement = Class.new StandardError
     MissingScope = Class.new StandardError
 
-    module ClassMethods
+    def self.included(base)
+      base.send :extend, Requires
+    end
+
+    module Requires
       def requires(*deps)
         deps.each do |dep|
           self.send(:define_method, dep) {Scope[dep]}
@@ -17,61 +16,72 @@ module MVCLI
       end
     end
 
+
+    ::Object.send :include, self
+
     class Scope
-      def initialize(command, provisioner)
-        @command = command
-        @provisioner = provisioner
+      requires :cortex
+
+      def initialize(options = {}, &block)
+        @providers = Map options
+        evaluate &block if block_given?
       end
 
       def [](name)
-        name.to_s == "command" ? @command : @provisioner[name]
+        unless provider = @providers[name]
+          provider = @providers[name] = cortex.read :provider, name
+        end
+        if provider.respond_to?(:value)
+          provider.value
+        elsif provider.respond_to?(:instance_methods) && provider.instance_methods.member?(:value)
+          provider.new.value
+        else
+          provider
+        end
       end
 
-      def evaluate
+      def evaluate(names = {})
         old = self.class.current
+        providers = @providers
+        @providers = Map @providers.to_hash.merge(names)
         self.class.current = self
         yield
       ensure
+        @providers = providers
         self.class.current = old
       end
 
-      def self.current
-        Thread.current[self.class.name]
-      end
+      private
 
-      def self.current!
-        current or fail MissingScope, "attempting to access scope, but none is active!"
+      def const(value)
+        Constant.new value
       end
 
-      def self.current=(scope)
-        Thread.current[self.class.name] = scope
-      end
+      class << self
+        def current
+          Thread.current[self.class.name]
+        end
 
-      def self.[](name)
-        current![name] or fail UnsatisfiedRequirement, "'#{name}' is required, but can't find it"
-      end
-    end
+        def current!
+          current or fail MissingScope, "attempting to access scope, but none is active!"
+        end
 
-    class Provisioner
-      def initialize
-        @loader = Loader.new
-        @providers = Map.new
-      end
-      def [](name)
-        unless provider = @providers[name]
-          provider = @providers[name] = @loader.load :provider, name
+        def current=(scope)
+          Thread.current[self.class.name] = scope
+        end
+
+        def [](name)
+          current![name]
         end
-        provider.value
       end
-    end
 
-    class Middleware
-      def call(command)
-        Scope.new(command, Provisioner.new).evaluate do
-          yield command
+      class Constant
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
         end
       end
     end
-    ::Object.send :include, self
   end
 end

data/lib/mvcli/router.rb

@@ -5,35 +5,52 @@ require "mvcli/argv"
 module MVCLI
   class Router
     class RoutingError < StandardError; end
+    requires :actions
 
-    def initialize(actions = nil)
-      @actions = actions || Map.new
+    attr_reader :routes
+    attr_reader :macros
+
+    def initialize
       @routes = []
       @macros = []
     end
 
-    def macro(options)
-      @macros.push Macro.new options
-    end
-
-    def match(options)
-      pattern, action = options.first
-      options.delete pattern
-      @routes << Route.new(pattern, @actions, action, options)
-    end
-
     def call(command)
       argv = @macros.reduce(command.argv) do |args, macro|
         macro.expand args
       end
       @routes.each do |route|
-        if match = route.match(argv)
-          return match.call command
+        if action = route.match(argv)
+          return action
         end
       end
       fail RoutingError, "no route matches '#{command.argv.join ' '}'"
     end
 
+    alias_method :[], :call
+
+    class DSL < BasicObject
+      attr_reader :router
+
+      def initialize
+        @router = Router.new
+      end
+
+      def macro(options)
+        @router.macros.push Macro.new options
+      end
+
+      def match(options)
+        pattern, action = options.first
+        options.delete pattern
+        @router.routes << Route.new(router, pattern, action, options)
+      end
+
+      def proc(&body)
+        ::Proc.new &body
+      end
+    end
+
     class Macro
       def initialize(options)
         @pattern, @expansion = options.first
@@ -45,19 +62,16 @@ module MVCLI
     end
 
     class Route
-      def initialize(pattern, actions, action, options = {})
+      def initialize(router, pattern, action, options = {})
         @pattern = Pattern.new pattern.to_s
-        @actions, @action, @options = actions, action, options
+        @router, @action, @options = router, action, options
       end
 
       def match(argv)
         argv = MVCLI::Argv.new argv
         match = @pattern.match(argv.arguments)
         if match.matches?
-          proc do |command|
-            action = @actions[@action] or fail "no action found for #{@action}"
-            action.call command, match.bindings
-          end
+          @router.actions.new match, @action
         end
       end
     end