mvcli 0.0.16 → 0.1.0

data/lib/mvcli/std/extensions/erb_extension.rb

@@ -0,0 +1,24 @@
+require "mvcli/erb"
+require "active_support/inflector"
+class MVCLI::ERBExtension
+  include ActiveSupport::Inflector
+
+  def to_path(name, extension_type)
+    check! extension_type
+    "#{pluralize extension_type}/#{name}.txt.erb"
+  end
+
+  def define(name, bytes, extension_type, namespace)
+    check! extension_type
+    erb = MVCLI::ERB.new
+    erb.compile bytes, to_path(name, extension_type)
+  end
+
+  private
+
+  def check!(extension_type)
+    if extension_type.to_s != "template"
+      fail ArgumentError, "invalid extension type '#{extension_type}' for ERB"
+    end
+  end
+end

data/lib/mvcli/std/providers/argv_provider.rb

@@ -0,0 +1,9 @@
+require "mvcli/argv"
+
+class MVCLI::ArgvProvider
+  requires :command
+
+  def value
+    MVCLI::Argv.new command.argv
+  end
+end

data/lib/mvcli/std/providers/config_provider.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+class MVCLI::ConfigProvider
+  requires :app
+
+  def self.value
+    new
+  end
+
+  attr_reader :home
+
+  def initialize
+    @home = find_or_create "#{ENV['HOME']}/.#{app.name}"
+  end
+
+  def directory(name)
+    pathname = find_or_create @home.join name
+    yield pathname if block_given?
+    return pathname
+  end
+
+  private
+
+  def find_or_create(path)
+    Pathname(path.to_s).tap do |path|
+      FileUtils.mkdir_p path.to_s unless path.exist?
+    end
+  end
+end

data/lib/mvcli/std/providers/middleware_provider.rb

@@ -0,0 +1,12 @@
+require "mvcli/middleware"
+require "mvcli/middleware/exit_status"
+require "mvcli/middleware/exception_logger"
+
+class MVCLI::MiddlewareProvider
+  def value
+    MVCLI::Middleware.new do |middleware|
+      middleware << MVCLI::Middleware::ExitStatus.new
+      middleware << MVCLI::Middleware::ExceptionLogger.new
+    end
+  end
+end

data/lib/mvcli/std/providers/router_provider.rb

@@ -0,0 +1,17 @@
+require "mvcli/router"
+
+module MVCLI
+  class RouterProvider
+    requires :cortex
+
+    def value
+      builder = Router::DSL.new
+      cortex.each do |core|
+        if core.path.exists? 'routes.rb'
+          builder.instance_eval core.path.read('routes.rb'), core.path.to_s('routes.rb'), 1
+        end
+      end
+      return builder.router
+    end
+  end
+end

data/lib/mvcli/std/routes.rb

@@ -0,0 +1,2 @@
+macro %r{^(-v|--version)} => "version"
+match 'version' => proc { |cmd| cmd.output.puts ::MVCLI::Provisioning::Scope[:app].version }

data/lib/mvcli/version.rb

@@ -1,3 +1,3 @@
 module MVCLI
-  VERSION = "0.0.16"
+  VERSION = "0.1.0"
 end

data/spec/features/managing_plugins_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe "installing a plugin" do
+  before { @timeout = 60 }
+  When { r "trivium install plugin trivium-timing --path #{fixture 'plugins/timing-plugin'}" }
+  Given(:fixtures) { Pathname(__FILE__).dirname.join('') }
+
+  Then { plugin_list == ['trivium-timing'] }
+  And { trivial_timing == '1s'}
+
+  describe "uninstalling the plugin" do
+    When { r "trivium uninstall plugin trivium-timing" }
+    Then { plugin_list == [] }
+    describe "trying to invoke the command" do
+      When(:result) { r "trivium time" }
+      Then { result.should have_failed }
+    end
+  end
+
+  def plugin_list
+    r "trivium show plugins"
+    all_stdout.split "\n"
+  end
+
+  def trivial_timing
+    r "trivium time"
+    all_stdout
+  end
+end

data/spec/fixtures/apps/trivium/app.rb

@@ -0,0 +1,10 @@
+require "mvcli/app"
+require "mvcli/plugins"
+require "trivium/version"
+
+module Trivium
+  class App < MVCLI::App
+    self.path = Pathname(__FILE__).dirname.join('app')
+    self.identifier = 'trivium'
+  end
+end

data/spec/fixtures/apps/trivium/bin/trivium

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+$:.unshift File.expand_path '../../lib', __FILE__
+require File.expand_path '../../app', __FILE__
+exit Trivium::App.main

data/spec/fixtures/apps/trivium/lib/trivium/version.rb

@@ -0,0 +1,3 @@
+module Trivium
+  VERSION = '1.0.0'
+end

data/spec/fixtures/apps/trivium/trivium.gemspec

@@ -0,0 +1,8 @@
+# -*- mode: ruby -*-
+# encoding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name = "trivium"
+  spec.version = "1.0.0"
+  spec.require_paths = ['lib']
+end

data/spec/fixtures/bin/trivium

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+load File.expand_path '../../apps/trivium/bin/trivium', __FILE__

data/spec/fixtures/plugins/timing-plugin/app/routes.rb

@@ -0,0 +1 @@
+match 'time' => proc { |cmd| cmd.output.puts '1s' }

data/spec/fixtures/plugins/timing-plugin/lib/trivium-timing.rb

@@ -0,0 +1,5 @@
+module Trivium
+  class Timing < MVCLI::Core
+    self.path = Pathname(__FILE__).join '../../app'
+  end
+end

data/spec/fixtures/plugins/timing-plugin/trivium-timing.gemspec

@@ -0,0 +1,9 @@
+# -*- mode: ruby -*-
+# encoding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name = "trivium-timing"
+  spec.version = "1.0.0"
+  spec.files = [__FILE__, 'app/routes.rb', 'lib/trivium-timing']
+  spec.require_paths = ['lib']
+end

data/spec/mvcli/action_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "mvcli/action"
+
+describe "MVCLI::Action" do
+  use_natural_assertions
+
+  Given(:command) { double :Command }
+  Given(:cortex) { double :Cortex }
+  Given(:action) { MVCLI::Action.new match, mapping }
+  Given(:match) { double :Match, :bindings => double(:Bindings) }
+  Given { action.stub(:cortex) { cortex } }
+  Given { action.stub(:middleware) { ->(cmd, &block) { block.call Map cmd: cmd } } }
+
+  context "when the mapping is callable" do
+    Given(:mapping) { ->(command) { command } }
+    When(:result) { action.call command }
+    Then { result.cmd == command }
+  end
+
+  context "when the mapping is a string" do
+    Given(:mapping) { 'servers#show' }
+    Given(:controller) { double(:Controller, call: Object.new) }
+    Given(:controller_class) { double :ControllerClass, new: controller }
+    Given { cortex.stub(:read) { controller_class } }
+
+    When(:result) { action.call command }
+    Then { result == controller.call }
+    Then { cortex.should have_received(:read).with(:controller, 'servers') }
+    Then { controller_class.should have_received(:new).with 'servers', 'show', match.bindings }
+  end
+end

data/spec/mvcli/controller_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "mvcli/controller"
+
+describe "A Controller" do
+  use_natural_assertions
+
+  Given(:controller) { MVCLI::Controller.new name, method, params }
+  Given(:cortex) { double(:Cortex) }
+  Given(:command) { double(:Command, output: StringIO.new ) }
+  Given { controller.stub(:cortex) { cortex } }
+  Given { cortex.stub(:read)  { proc { |context, output| @context, @output = context, output} } }
+
+  context "when called with the 'show' action" do
+    Given(:name) { 'servers' }
+    Given(:method) { 'show' }
+    Given(:params) { Map name: 'World' }
+    Given { controller.stub(:show) { params } }
+    When(:exit_status) { controller.call command }
+    Then { exit_status == 0 }
+    Then { @output == command.output }
+    And { cortex.should have_received(:read).with :template, "servers/show"}
+
+    context "when there's a corresponding form" do
+      Given { controller.stub(:argv) { double(:argv, options: {}) } }
+      Given { cortex.stub(:exists?).with(:form, "servers/show") { true } }
+      Given { cortex.stub(:read).with(:form, "servers/show") { double(:Form, new: form) } }
+      Given{ form.stub(:validate!) { true } }
+      Given(:form) { double :form }
+      Then{ controller.form == form }
+    end
+
+    context "when there's not a corresponding form" do
+    end
+  end
+end

data/spec/mvcli/core_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe "MVCLI Cores" do
+  use_natural_assertions
+
+  Given(:loader) { double(:Loader) }
+  Given { core.stub(:loader) { loader } }
+  Given { loader.stub(:exists?) { true } }
+
+
+  describe "with explicit values for path and namespace" do
+    Given(:core) { MVCLI::Core.new path: path, namespace: namespace}
+    Given(:path) { MVCLI::Path.new '/path/to/the/core' }
+    Given(:namespace) { Module.new }
+
+
+    describe "the query interface" do
+      Then { core.exists? :provider, 'naming' }
+      And { loader.should have_received(:exists?).with(path, :provider, 'naming') }
+    end
+
+    describe "reading the extension into memory" do
+      context "when it does not exist" do
+        Given { loader.stub(:exists?) { false } }
+        When(:result) { core.read :provider, 'naming' }
+        Then { result.should have_failed MVCLI::ExtensionNotFound  }
+      end
+      context "when it does exist" do
+        Given(:artifact) { Class.new }
+        Given { loader.stub(:read) { artifact } }
+        When(:result) { core.read :provider, 'naming' }
+        Then { loader.should have_received(:read).with(path, :provider, 'naming', namespace) }
+        And { result == artifact }
+        And { result.core == core }
+        And { result.new.core == core }
+      end
+    end
+  end
+
+  describe "with no explicit values for path and namespace" do
+    Given(:core) { MVCLI::Core.new  }
+    When(:result) { core.path }
+    Then { result.should have_failed MVCLI::InvalidPath }
+    Then { core.namespace == Object }
+  end
+
+  describe "resolving the namespace" do
+    When(:namespace) { core.namespace }
+    Invariant { MVCLI::Core.member? core.class }
+
+    describe "when the class is anonymous" do
+      Given(:core) { Class.new(MVCLI::Core).new }
+      Then { namespace == Object }
+      describe "but the namespace attribute is set" do
+        Given { core.class.namespace = MVCLI }
+        Then { namespace == MVCLI }
+      end
+    end
+    describe "when the class is named" do
+      Given(:core) do
+        module MVCLI
+          module Test
+            class MyCore < MVCLI::Core
+              new
+            end
+          end
+        end
+      end
+      Then { namespace == MVCLI::Test }
+      And { core.name == 'mvcli-test-mycore' }
+      describe "but the namespace class attribute is set" do
+        Given { core.class.namespace = MVCLI }
+        Then { namespace == MVCLI }
+      end
+    end
+  end
+end

data/spec/mvcli/cortex_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "mvcli/cortex"
+
+describe "A Cortex" do
+  use_natural_assertions
+  Given(:cortex) { MVCLI::Cortex.new }
+
+  describe "without any cores" do
+    When(:result) { cortex.read :extension, 'foo/bar/baz' }
+    Then { result.should have_failed MVCLI::ExtensionNotFound }
+  end
+
+  describe "with a few cores" do
+    Given(:core1) { add_core :Core1 }
+    Given(:core2) { add_core :Core2 }
+
+    context "when we access an object" do
+      When(:extension) { cortex.read :controller, "admin/users" }
+
+      context "and it is defined and exists" do
+        Given { core1.stub(:read) { double(:Extension, core: 1) } }
+        Given { core2.stub(:read) { double(:Extension, core: 2) } }
+
+        Invariant { cortex.exists? :controller, "admin/users"}
+
+        context "only in the first core" do
+          Given { core1.stub(:exists?) { true } }
+          Then { extension.core ==  1}
+        end
+        context "only in the second core" do
+          Given { core1.stub(:exists?) { false } }
+          Given { core2.stub(:exists?) { true } }
+          Then { extension.core == 2 }
+        end
+        context "in both cores" do
+          Given { core1.stub(:exists?) { true} }
+          Given { core2.stub(:exists?) { true } }
+          Then { core1.should have_received(:read) }
+          Then { core2.should_not have_received(:read) }
+        end
+      end
+    end
+  end
+
+  def add_core(name)
+    core = double name
+    cortex << core
+    return core
+  end
+end

data/spec/mvcli/erb_spec.rb

@@ -7,7 +7,7 @@ describe "MVCLI::ERB" do
     Given(:output) {""}
     Given(:template) {erb.compile "name: <%= this.name %>"}
     context "and call it with a context" do
-      When {template.call mock(:Context, :name => 'Charles'), output}
+      When {template.call double(:Context, :name => 'Charles'), output}
       Then {output.should eql "name: Charles"}
     end
   end

data/spec/mvcli/form_spec.rb

@@ -31,7 +31,7 @@ describe "A form for creating a load balancer" do
   Given(:form) do
     definition.new(params).tap do |f|
       f.stub(:decoders) {MVCLI::Decoding}
-      f.stub(:naming) {mock(:NameGenerator, generate: 'random-name')}
+      f.stub(:naming) {double(:NameGenerator, generate: 'random-name')}
     end
   end
   context "with invalid array properties" do

data/spec/mvcli/loader_spec.rb

@@ -2,22 +2,67 @@ require "spec_helper"
 require "mvcli/loader"
 
 describe "MVCLI::Loader" do
-  Given do
-    class ::TotallyAwesomeController
-      attr_reader :params
-      attr_reader :block
-      def initialize(params, &block)
-        @params = params
-        @block = block
+  use_natural_assertions
+  Given(:extensions) { Hash.new }
+  Given(:path) { double :Path }
+  Given(:loader) { MVCLI::Loader.new extensions }
+  Given { path.stub(:exists?) { true } }
+  Given { path.stub(:read) { content }}
+
+  describe "querying if an extension exists" do
+    context "when it does not exists in the path" do
+      Given { path.stub(:exists?) { false } }
+      Then { not loader.exists? path, :provider, 'bar' }
+      And { path.should have_received(:exists?).with 'providers/bar_provider.rb' }
+    end
+    context "when it does exist in the path" do
+      Given { path.stub(:exists?) { true } }
+      Then { loader.exists? path, :provider, 'bar' }
+
+      context "when the extension is read and it matches the naming conventions" do
+        Given { module ::ANamespace; end }
+        Given(:content) { "class ANamespace::BarProvider; def barf; end; end" }
+        When(:provider_class) { loader.read path, :provider, 'bar', ANamespace }
+        Then { path.should have_received(:read).with('providers/bar_provider.rb') }
+        Then { not provider_class.nil? }
+        Then { defined? ::ANamespace::BarProvider }
+        And { provider_class == ::ANamespace::BarProvider }
+        And { provider_class.method_defined? :barf }
+        after do
+          Object.send :remove_const, :ANamespace
+        end
+      end
+      context "when extension does not match naming conventions" do
+        Given(:content) { "class ArgleBargle; end" }
+        When(:result) { loader.read path, :provider, 'bar' }
+        Then { result.should have_failed LoadError }
+      end
+      context "when extension matches naming conventions but is not in the right namespace" do
+        Given { module ::OtherNamespace; end }
+        Given(:content) { "class Object::BarProvider; end" }
+        When(:result) { loader.read path, :provider, 'bar', OtherNamespace }
+        Then { result.should have_failed LoadError }
+        after do
+          Object.send :remove_const, :OtherNamespace
+        end
       end
     end
   end
-  Given(:loader) {MVCLI::Loader.new}
 
-  context "when a controller load is requested in the global  namespace" do
-    When(:controller){loader.load(:controller, 'totally_awesome', {:foo => :bar}) {'whee!'}}
-    Then {controller.should be_instance_of TotallyAwesomeController}
-    And {controller.params.should eql ({:foo => :bar})}
-    And {controller.block.call.should eql "whee!"}
+  describe "a custom extension type" do
+    Given(:handler) { double :TemplateHandler }
+    Given(:extensions) { ({:template => handler}) }
+    Given { handler.stub(:to_path) { |name| "templates/#{name}.txt.erb"} }
+
+    describe "querying" do
+      Then { loader.exists? path, :template, 'servers/show' }
+      And { path.should have_received(:exists?).with 'templates/servers/show.txt.erb' }
+    end
+    describe "loading" do
+      Given(:content) { "Hello Handler"}
+      Given { handler.stub(:define) { |name, bytes| [name, bytes].join ' -> ' } }
+      When(:ext) { loader.read path, :template, 'servers/show' }
+      Then { ext == "servers/show -> Hello Handler" }
+    end
   end
 end