mvcli 0.0.16 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5e10792fd29ac8531f3fad187e62aa0faf29289
-  data.tar.gz: 4fcf5e6a896261dd9a269e648c5bbba049b37ff3
+  metadata.gz: 6e1696b11a3f57cab397bf56d5d6f92256cc2d87
+  data.tar.gz: 22ed45da46826cf30cbdbc8872180095c0044c38
 SHA512:
-  metadata.gz: 4787013d0c68f4eadb8665f0852f8bad35cf1242073bc39693c5eeb3b9a24102ea502e2f5283f346fc67f350bd44c886f3b1085ebfe8619d289aafb93f26f326
-  data.tar.gz: a27d207aa5395d024e1ff71c2dc27e692758172b0e3776719ed35f671d987e734560005b13f338245a921d5c8cef74533b55343f911e46e39c0b6714d6fa13f4
+  metadata.gz: ca533f2e0da7d76bae735d3e8c7f68e49d53054218c330d3307181f678db4b3269b18d6ab3e8682a51b9581ad4402d9a7efaf61873deabb70e76c00744c637d7
+  data.tar.gz: 7d07c41506ab82e1cc4a673dc156cd0db4168c933246e39e6de6c43f67cf67fe8a2cdb363322d67a30318e9a7f24bcc1f34bb82f546e1819c1b5cb77f2695715

data/Changelog.md

@@ -0,0 +1,4 @@
+## 0.1.0 2014/05/21
+
+* make form object implicit to all controllers
+

data/Gemfile

@@ -4,7 +4,7 @@ source 'https://rubygems.org'
 gemspec
 
 gem "rake"
-gem "rspec", "~> 2.13.0"
+gem "rspec", "~> 2.14.0"
 gem "rspec-given"
-gem "rspec-spies"
+gem "aruba"
 gem "pry"

data/README.md

@@ -1,9 +1,13 @@
-## Mvcli
+## MVCLI
 [![Gem Version](https://badge.fury.io/rb/mvcli.png)](http://badge.fury.io/rb/mvcli)
 [![Build Status](https://travis-ci.org/cowboyd/mvcli.png?branch=master)](https://travis-ci.org/cowboyd/mvcli)
 [![Dependency Status](https://gemnasium.com/cowboyd/mvcli.png)](https://gemnasium.com/cowboyd/mvcli)
 
-This is still an experiment, but I am beginning to suspect it will be nice.
+MVCLI is an first-class application framework for building command
+line applications.
+
+If you are familiar with other request-based MVC frameworks like Ruby
+on Rails, then you will feel right at home with mvcli.
 
 For an example of an application that uses this, see [rumm][1]
 

data/app.rb

@@ -0,0 +1,7 @@
+require "mvcli/app"
+
+module MVCLI
+  class CLI < ::MVCLI::App
+    self.path = File.expand_path '../app', __FILE__
+  end
+end

data/bin/mvcli

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require File.expand_path '../../app', __FILE__
+exit MVCLI::CLI.main

data/lib/mvcli.rb

@@ -1,3 +1,4 @@
 module MVCLI
   require "mvcli/version"
+  require "mvcli/core"
 end

data/lib/mvcli/action.rb

@@ -0,0 +1,31 @@
+require "map"
+
+module MVCLI
+  class Action
+    requires :cortex, :middleware
+
+    attr_reader :match, :mapping, :endpoint
+
+    def initialize(match, mapping)
+      @match, @mapping  = match, mapping
+    end
+
+    def call(command)
+      middleware.call(command) do |command|
+        endpoint.call command
+      end
+    end
+
+    def endpoint
+      return @endpoint if @endpoint
+      if mapping.respond_to? :call
+        @endpoint = mapping
+      else
+        require "mvcli/controller"
+        controller_name, method = mapping.to_s.split('#')
+        controller = cortex.read :controller, controller_name
+        @enpoint = controller.new controller_name, method, match.bindings
+      end
+    end
+  end
+end

data/lib/mvcli/app.rb

@@ -1,41 +1,36 @@
-require "mvcli"
-require "mvcli/middleware/exit_status"
-require "mvcli/middleware/exception_logger"
-require_relative "middleware"
-require_relative "command"
-require_relative "actions"
-require_relative "router"
-require_relative "provisioning"
+require "mvcli/cortex"
+require "mvcli/loader"
+require "mvcli/action"
+require "mvcli/command"
 
 module MVCLI
-  class App
-    def initialize
-      @router = Router.new Actions.new root
-      @router.instance_eval route_file.read, route_file.to_s, 1
-      [:providers, :controllers, :forms, :models].each do |path|
-        ActiveSupport::Dependencies.autoload_paths << root.join('app', path.to_s)
-      end
-      @middleware = Middleware.new
-      @middleware << MVCLI::Middleware::ExitStatus.new
-      @middleware << MVCLI::Middleware::ExceptionLogger.new
-      @middleware << Provisioning::Middleware.new
-      @middleware << @router
-    end
+  class App < MVCLI::Core
+    requires :router
 
     def call(command)
-      @middleware.call command
+      Scope.new(bootstrap command) do
+        cortex.activate!
+        action = router[command]
+        return action.call command
+      end
     end
 
-    def root
-      self.class.root or fail "Invalid App: undefined application root directory"
+    def bootstrap(command)
+      Map command: command, app: self, cortex: cortex, loader: loader, actions: Action
     end
 
-    def route_file
-      root.join 'app/routes.rb'
+    def cortex
+      @cortex ||= Cortex.new do |cortex|
+        Core.drain do |cls|
+          cortex << cls.new if cls.path
+        end
+      end
     end
 
-    class << self
-      attr_accessor :root
+    def loader
+      #TODO: use generic extension mechanism
+      require "mvcli/std/extensions/erb_extension"
+      MVCLI::Loader.new :template => MVCLI::ERBExtension.new
     end
 
     def main(argv = ARGV.dup, input = $stdin, output = $stdout, log = $stderr, env = ENV.dup)

data/lib/mvcli/controller.rb

@@ -1,7 +1,25 @@
+require "mvcli/erb"
+require "mvcli/form"
+
 class MVCLI::Controller
+  requires :command, :cortex, :argv
   attr_reader :params
 
-  def initialize(params = {})
-    @params = params
+  def initialize(name, method, params)
+    @name, @method, @params = name, method, params
+  end
+
+  def call(command)
+    response = send @method
+    template = cortex.read :template, "#{@name}/#{@method}"
+    template.call response, command.output
+    return 0
+  end
+
+  def form
+    template = cortex.read :form, "#{@name}/#{@method}"
+    form = template.new argv.options
+    form.validate!
+    form
   end
 end

data/lib/mvcli/core.rb

@@ -0,0 +1,101 @@
+require "map"
+require "mvcli/path"
+require "mvcli/provisioning"
+
+module MVCLI
+  class ExtensionNotFound < StandardError; end
+  class InvalidPath < StandardError; end
+
+  class Core
+
+    requires :loader
+    attr_accessor :path, :name, :namespace
+
+    def initialize(options = {})
+      options = Map options
+      @path = options[:path]
+      @name = options[:name]
+      @namespace = options[:namespace]
+    end
+
+    def activate!
+    end
+
+    def path
+      path = @path || self.class.path
+      fail InvalidPath, "core `#{name}` cannot have a nil path" unless path
+      path.is_a?(MVCLI::Path) ? path : MVCLI::Path.new(path.to_s)
+    end
+
+    def namespace
+      @namespace || self.class.namespace || enclosing_namespace || Object
+    end
+
+    def name
+      @name || self.class.identifier || self.class.name.gsub('::', '-').downcase unless namespace == Object
+    end
+
+    def version
+      spec = Gem::Specification.load path.nearest('.gemspec$').to_s
+      spec.version
+    end
+
+    def exists?(extension_type, name)
+      loader.exists? path, extension_type, name
+    end
+
+    def read(extension_type, name, options = {})
+      unless exists? extension_type, name
+        fail ExtensionNotFound, "unable to locate #{extension_type} '#{name}'"
+      end
+      this = self
+      loader.read(path, extension_type, name, namespace).tap do |ext|
+        [ext, ext.singleton_class].each do |cls|
+          cls.send(:define_method, :core) { this } if cls.respond_to?(:define_method, true)
+        end
+      end
+    end
+
+    private
+
+    def enclosing_namespace
+      if self.class != MVCLI::Core && name = self.class.name
+        components = name.split('::')[0..-2]
+        unless components.empty?
+          eval components.join('::')
+        end
+      end
+    end
+
+    class << self
+      include Enumerable
+      attr_accessor :path, :identifier, :namespace, :version
+
+      def inherited(base)
+        ::MVCLI::Core << base
+      end
+
+      def all
+        @all ||= []
+      end
+
+      def <<(base)
+        all << base
+      end
+
+      def each(&visitor)
+        all.each &visitor
+      end
+
+      def drain(&visitor)
+        each &visitor
+        all.clear
+      end
+    end
+
+    class Std < self
+      self.path = Pathname(__FILE__).dirname.join 'std'
+      self.namespace = MVCLI
+    end
+  end
+end

data/lib/mvcli/cortex.rb

@@ -0,0 +1,38 @@
+require "mvcli/core"
+
+module MVCLI
+  class Cortex
+    include Enumerable
+
+    def initialize
+      @cores = []
+      yield self if block_given?
+    end
+
+    def activate!
+      each(&:activate!)
+    end
+
+    def <<(core)
+      tap do
+        @cores << core
+      end
+    end
+
+    def each(&block)
+      @cores.each &block
+    end
+
+    def exists?(extension_point, extension_name)
+      @cores.detect {|core| core.exists? extension_point, extension_name }
+    end
+
+    def read(extension_point, extension_name)
+      if core = exists?(extension_point, extension_name)
+        core.read extension_point, extension_name
+      else
+        fail MVCLI::ExtensionNotFound, "unable to find #{extension_point} '#{extension_name}'"
+      end
+    end
+  end
+end

data/lib/mvcli/form.rb

@@ -1,6 +1,19 @@
 require "mvcli/decoding"
 require "mvcli/validatable"
 
+#TODO: need a way to leverage actual input inside error messages
+#   validates(:path, 'no such directory #{path}' ) { path.exist? }
+
+#TODO: need a way to nest validation in order to specify dependencies. e.g.
+#   validates(:path) { path.exist? }.then do
+#     validates(:path) { path.read_first_line == 'BEGIN' }
+#   end
+
+
+#TODO: need a way to validate multiple values. e.g.
+#  validates(:address, :port) { |a, p| address_valid_for_port a, p }
+
+
 module MVCLI
   class Form
     include MVCLI::Validatable

data/lib/mvcli/loader.rb

@@ -2,10 +2,54 @@ require "active_support/inflector/methods"
 
 module MVCLI
   class Loader
-    include ActiveSupport::Inflector
+
+    def initialize(extensions = {})
+      @extensions = Map extensions
+      @default_handler = RubyClassLoader.new
+    end
 
     def load(type, name, *args, &block)
       constantize(camelize("#{name}_#{type}")).new(*args, &block)
     end
+
+    def exists?(path, extension_type, name)
+      pathname = handler(extension_type).to_path name, extension_type
+      path.exists? pathname
+    end
+
+    def read(path, extension_type, name, namespace = Object)
+      pathname = handler(extension_type).to_path name, extension_type
+      bytes = path.read pathname
+      handler(extension_type).define name, bytes, extension_type, namespace
+    end
+
+    private
+
+    def handler(extension_type)
+      @extensions[extension_type] || @default_handler
+    end
+
+    class RubyClassLoader
+      include ActiveSupport::Inflector
+
+      def to_path(name, extension_type)
+        "#{pluralize extension_type}/#{name}_#{extension_type}.rb"
+      end
+
+      def define(name, bytes, extension_type, namespace)
+        eval bytes, TOPLEVEL_BINDING, to_path(name, extension_type), 1
+        components = [namespace.name, classify("#{name}_#{extension_type}")]
+        components.shift if namespace == Object
+        lookup components.join('::'), to_path(name, extension_type)
+      end
+
+      private
+
+      def lookup(class_name, filename)
+        constantize class_name
+      rescue NameError
+        fail LoadError, "expected #{filename} to define #{class_name}"
+      end
+    end
   end
 end

data/lib/mvcli/middleware.rb

@@ -2,10 +2,19 @@ module MVCLI
   class Middleware
     def initialize
       @apps = []
+      yield self if block_given?
     end
 
-    def call(command)
-      invoke command, 0
+    def call(command, apps = @apps, &block)
+      app, *rest = apps + [block].compact
+      if app
+        app.call(command) do |yielded|
+          yielded ||= command
+          call yielded, rest
+        end
+      else
+        return 0
+      end
     end
 
     def [](idx)
@@ -20,19 +29,8 @@ module MVCLI
       @apps << app
     end
 
-    private
-
-    def invoke(command, index)
-      if app = @apps[index]
-        app.call(command) do |c|
-          if @apps[index + 1]
-            c ||= command
-            invoke c, index + 1
-          end
-        end
-      else
-        return 0
-      end
+    def length
+      @apps.length
     end
   end
 end