mvcli 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1f731e4ba8f382b06704c3051bda33ded0ef7ce
-  data.tar.gz: 2ad3d53e76c0eb40e9980275c3dcb1fbbe33ea82
+  metadata.gz: 39bb6d037a235e80b610d16a1cff026dd0945134
+  data.tar.gz: 42a1e909308dea92677bf8e76abb6dcee1d8358f
 SHA512:
-  metadata.gz: 8b329020fa0bd200d8d85b177a905b434838a68748ad67fc344e438693e7e293bdc61b998495a73271e13aa0ab21d9150a520b8cea0bc7c057d9c53c865221c8
-  data.tar.gz: fdd24ba8968d733efae785848919313ba4e8cd77ca15063ae9dde273fc4b61bb95fdd712140ca826b417a7cdcb9a0dafd0b8ef12fbd7d023326ea283d0b8e7b8
+  metadata.gz: 2812db9dc93f3a3ec99d6cfa5b2af883e6ed04af8aea8538404b28b5969234c14c3b71615996011dbd348e7e4343de0ec923e48078487e3d3142a9da6b6b5a8f
+  data.tar.gz: e2913626bac2de10934365c49a80924365885aac67c7bf23f76764a1ed8ca53fd08792b38dd04dae92aa5c2619385b89b44309552d46216115203bf148b962ab

data/lib/mvcli/actions.rb

@@ -1,4 +1,6 @@
 require "map"
+require "mvcli/controller"
+require "mvcli/form"
 require_relative "loader"
 require_relative "renderer"
 

data/lib/mvcli/app.rb

@@ -12,8 +12,9 @@ module MVCLI
     def initialize
       @router = Router.new Actions.new root
       @router.instance_eval route_file.read, route_file.to_s, 1
-      ActiveSupport::Dependencies.autoload_paths << root.join('app/providers')
-      ActiveSupport::Dependencies.autoload_paths << root.join('app/controllers')
+      [:providers, :controllers, :forms, :models].each do |path|
+        ActiveSupport::Dependencies.autoload_paths << root.join('app', path.to_s)
+      end
       @middleware = Middleware.new
       @middleware << Provisioning::Middleware.new
       @middleware << @router

data/lib/mvcli/argv.rb

@@ -0,0 +1,48 @@
+require "map"
+
+class MVCLI::Argv
+  attr_reader :arguments, :options
+
+  def initialize(argv, switches = [])
+    @switches = switches.map(&:to_s)
+    @arguments, @options = scan argv
+  end
+
+  def scan(argv, arguments = [], options = Map.new)
+    current, *rest = argv
+    case current
+    when nil
+      [arguments, options]
+    when /^--(\w[[:graph:]]+)=([[:graph:]]+)$/
+      scan rest, arguments, merge(options, $1, $2)
+    when /^--no-(\w[[:graph:]]+)$/
+      scan rest, arguments, merge(options, $1, false)
+    when /^--(\w[[:graph:]]+)$/, /^-(\w)$/
+      key = underscore $1
+      if switch? key
+        scan rest, arguments, merge(options, key, true)
+      elsif rest.first =~ /^-/
+        scan rest, arguments, merge(options, key)
+      else
+        value, *rest = rest
+        scan rest, arguments, merge(options, key, value)
+      end
+    else
+      scan rest, arguments + [current], options
+    end
+  end
+
+  def switch?(key)
+    @switches.member? underscore key
+  end
+
+  def merge(options, key, value = nil)
+    key = underscore key
+    values = options[key] || []
+    options.merge(key => values + [value].compact)
+  end
+
+  def underscore(string)
+    string.gsub('-','_')
+  end
+end

data/lib/mvcli/decoding.rb

@@ -0,0 +1,25 @@
+require "map"
+
+class MVCLI::Decoding
+  def initialize
+    @enrichments = Map.new do |h,k|
+      h[k] = []
+    end
+  end
+
+  def call(name, value, target = Object)
+    if target.is_a?(Array)
+      [value].flatten.map {|element| call name, element, target.first}
+    else
+      @enrichments[name].reduce value do |value, enrichment|
+        enrichment.call value
+      end
+    end
+  end
+
+  def method_missing(name, &block)
+    fail "must supply a block to transform value named '#{name}'" unless block
+    @enrichments[name] << block
+    return self
+  end
+end

data/lib/mvcli/form/input.rb

@@ -0,0 +1,72 @@
+require "mvcli/form"
+require "active_support/inflector/methods"
+
+class MVCLI::Form::Input
+  def initialize(name, target, options = {}, &block)
+    @decoders = []
+    @handler = handler(target).new name, target, options, &block
+  end
+
+  def decode(&block)
+    @handler.decode &block
+    return self
+  end
+
+  def value(source, context = nil)
+    @handler.value source, context
+  end
+
+  def handler(target)
+    target.is_a?(Array) ? ListTarget : Target
+  end
+
+  class Target
+    def initialize(name, target, options = {}, &block)
+      @name, @options = name, Map(options)
+      @decoders = []
+      if block_given?
+        @decoders << block
+      end
+    end
+
+    def decode(&block)
+      @decoders << block
+    end
+
+    def value(source, context = nil)
+      if value = [source[@name]].flatten.first
+        @decoders.reduce(value) do |value, decoder|
+          decoder.call value
+        end
+      else
+        default context
+      end
+    end
+
+    def default(context)
+      value = @options[:default]
+      if value.respond_to?(:call)
+        if context
+          context.instance_exec(&value)
+        else
+          value.call
+        end
+      else
+        value
+      end
+    end
+  end
+
+  class ListTarget < Target
+    include ActiveSupport::Inflector
+
+    def value(source, context = nil)
+      source = Map(source)
+      list = [source[singularize @name]].compact.flatten.map do |value|
+        super({@name => value}, context)
+      end.compact
+      list.empty? ? [default(context)].compact.flatten : list
+    end
+  end
+
+end

data/lib/mvcli/form.rb

@@ -0,0 +1,87 @@
+require "mvcli/decoding"
+require "mvcli/validatable"
+
+module MVCLI
+  class Form
+    include MVCLI::Validatable
+
+    def initialize(params = {}, type = Map)
+      @source = params
+      @target = type
+    end
+
+    def value
+      self.class.output.call self
+    end
+
+    def attributes
+      self.class.inputs.reduce(Map.new) do |map, pair|
+        name, input = *pair
+        map.tap do
+          map[name] = input.value @source, self
+        end
+      end
+    end
+
+    class Decoder
+      def initialize(form, names)
+        @form, @names = form, names
+      end
+
+      def call(string)
+        @form.new Map Hash[@names.zip string.split ':']
+      end
+
+      def to_proc
+        proc {|*_| call(*_)}
+      end
+    end
+
+    class << self
+      attr_accessor :target
+      attr_reader :inputs, :output
+
+      def inherited(base)
+        base.class_eval do
+          @inputs = Map.new
+        end
+      end
+
+      def decoder
+        Decoder.new self, inputs.keys
+      end
+
+      def output(&block)
+        if block_given?
+          @output = block
+        else
+          @output
+        end
+      end
+
+      def input(name, target, options = {}, &block)
+        if block_given?
+          form = Class.new(MVCLI::Form, &block)
+          form.target = [target].flatten.first
+          validates_child name
+          input = Input.new(name, target, options, &form.decoder)
+        else
+          input = Input.new(name, target, options, &options[:decode])
+        end
+        @inputs[name] = input
+        if options[:required]
+          if target.is_a?(Array)
+            validates(name, "cannot be empty", nil: true) {|value| value && !value.empty?}
+          else
+            validates(name, "is required", nil: true) {|value| !value.nil?}
+          end
+        end
+        define_method(name) do
+          input.value @source, self
+        end
+      end
+    end
+  end
+end
+
+require "mvcli/form/input"

data/lib/mvcli/router.rb

@@ -1,5 +1,6 @@
 require "map"
-require_relative "router/pattern"
+require "mvcli/router/pattern"
+require "mvcli/argv"
 
 module MVCLI
   class Router
@@ -33,7 +34,8 @@ module MVCLI
       end
 
       def match(command)
-        match = @pattern.match(command.argv)
+        argv = MVCLI::Argv.new command.argv
+        match = @pattern.match(argv.arguments)
         if match.matches?
           proc do |command|
             action = @actions[@action] or fail "no action found for #{@action}"
@@ -42,9 +44,5 @@ module MVCLI
         end
       end
     end
-
-    class Match
-
-    end
   end
 end

data/lib/mvcli/validatable.rb

@@ -0,0 +1,188 @@
+require "map"
+
+module MVCLI::Validatable
+
+  def self.included(base)
+    base.extend ValidationDSL
+  end
+
+  def valid?
+    validation.valid?
+  end
+
+  def validate!
+    validation.validate!
+  end
+
+  def violations
+    validation.violations
+  end
+
+  def validation
+    validators.reduce(Validation.new(self)) do |validation, validator|
+      validation.tap do
+        validator.validate self, validation
+      end
+    end
+  end
+
+  def validators
+    self.class.validators
+  end
+
+  class ValidationError < StandardError
+    attr_reader :validation
+
+    def initialize(validation)
+      super validation.to_s
+      @validation = validation
+    end
+
+    def violations
+      validation.violations
+    end
+
+    def each(&block)
+      validation.each(&block)
+    end
+  end
+
+  class Validator
+    def initialize
+      @rules = []
+      @children = []
+    end
+
+    def validates(field, message, options = {}, &predicate)
+      @rules << Rule.new(field, message, Map(options), predicate)
+    end
+
+    def validates_child(name)
+      @children << name
+    end
+
+    def validate(object, validation = Validation.new(object))
+      @rules.reduce(validation) do |v, rule|
+        v.tap do
+          rule.call object, v.violations, v.errors
+        end
+      end
+      @children.each do |name|
+        validate_child object, name, validation
+      end
+      return validation
+    end
+
+    def validate_child(object, name, validation)
+      child = object.send(name) || []
+      validation.append name, [child].flatten.map(&:validation)
+    rescue StandardError => e
+      validation.errors[name] << e
+    end
+  end
+
+
+  class Validation
+    attr_reader :object, :violations, :errors
+
+    def initialize(object)
+      @object = object
+      @children = Map.new do |h,k|
+        h[k] = []
+      end
+      @violations = Map.new do |h,k|
+        h[k] = []
+      end
+      @errors = Map.new do |h,k|
+        h[k] = []
+      end
+    end
+
+    def valid?
+      violations.empty? && errors.empty? && children_valid?
+    end
+
+    def validate!
+      fail ValidationError, self unless valid?
+    end
+
+    def children_valid?
+      @children.values.each do |validations|
+        return false unless validations.all?(&:valid?)
+      end
+      return true
+    end
+
+    def [](key)
+      @children[key]
+    end
+
+    def each(&block)
+      @children.each &block
+    end
+
+    def append(name, validations)
+      @children[name] += validations
+    end
+
+    def to_s
+      elements = []
+      elements << "violations: #{@violations.inspect}" unless @violations.empty?
+      elements << "errors: #{@errors.inspect}" unless @errors.empty?
+      elements << "nested: #{children_to_s}" unless @children.empty?
+      [@object, elements.join(', ')].join ' '
+    end
+
+    def children_to_s
+      Hash[@children.keys.zip @children.values.map {|validations| validations.map(&:to_s)}].inspect
+    end
+  end
+
+  module ValidationDSL
+    def validator
+      @validator ||= Validator.new
+    end
+
+    def validators
+      ancestors.reduce [] do |validators, base|
+        validators.tap do
+          validators << base.validator if base.respond_to?(:validator)
+        end
+      end
+    end
+
+    def validates(field, message, options = {}, &predicate)
+      validator.validates field, message, options, &predicate
+    end
+
+    def validates_not(field, message, &predicate)
+      validates(field, message) {|*_| !predicate.call(*_)}
+    end
+
+    def validates_child(name)
+      validator.validates_child name
+    end
+  end
+
+  class Rule
+    def initialize(field, message, options, predicate)
+      @field, @message, @options, @predicate = field, message, options, predicate
+    end
+    def call(validatable, violations, errors)
+      value, error = read validatable
+      if error
+        errors[@field] << error
+      elsif value.nil?
+        return unless !!@options[:nil]
+      else
+        violations[@field] << @message unless @predicate.call value
+      end
+    end
+
+    def read(validatable)
+      return validatable.send(@field), nil
+    rescue StandardError => e
+      return nil, e
+    end
+  end
+end

data/lib/mvcli/version.rb

@@ -1,3 +1,3 @@
 module MVCLI
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/lib/mvcli.rb

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

data/spec/mvcli/argv_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "mvcli/argv"
+require "shellwords"
+
+describe "ARGV" do
+  use_natural_assertions
+  Given(:input) {Shellwords.shellsplit "before --one 1 --two=two stuff in the middle --three -f --four --no-five -p 6 --mo money --mo problems --two-word val --two-word-p after"}
+  Given(:argv) {MVCLI::Argv.new input, [:three, :f, :five, :two_word_p]}
+
+  context " options" do
+    Given(:options) {argv.options}
+    Then {options[:one] == ['1']}
+    Then {options[:two] == ['two']}
+    Then {options[:three] == [true]}
+    Then {options[:f] == [true]}
+    Then {options[:four] == []}
+    Then {options[:five] == [false]}
+    Then {options[:p] == ['6']}
+    Then {options[:mo] == ['money', 'problems']}
+    Then {options[:two_word] == ['val']}
+    Then {options[:two_word_p] == [true]}
+  end
+  context " aruments" do
+    Given(:arguments) {argv.arguments}
+    Then {arguments == %w(before stuff in the middle after)}
+  end
+end

data/spec/mvcli/form/input_spec.rb

@@ -0,0 +1,95 @@
+require "spec_helper"
+require "mvcli/form/input"
+
+describe "Form Inputs" do
+  use_natural_assertions
+  Given(:input) {MVCLI::Form::Input.new :field, type, options, &block}
+  Given(:type) {Object}
+  Given(:options) {{}}
+  Given(:block) {nil}
+  describe "with an integer type" do
+    Given(:type) {Integer}
+    context "when accessing a single value" do
+      When(:value) {input.value field: 5}
+      Then {value == 5}
+    end
+    context "when accessing an array of values" do
+      When(:value) {input.value field: [1,2,3]}
+      Then {value == 1}
+    end
+    context "when accessing a nil value" do
+      When(:value) {input.value field: nil}
+      Then {value.nil?}
+    end
+  end
+  describe "with a list of integers" do
+    Given(:type) {[Integer]}
+    context "when accessing an value represented as a single" do
+      When(:value) {input.value field: 5}
+      Then {value == [5]}
+    end
+    context "when accessing a value represented as an array" do
+      When(:value) {input.value field: [1,2,3]}
+      Then {value == [1,2,3]}
+    end
+    context "when accessing a nil value" do
+      When(:value) {input.value field: nil}
+      Then {value == []}
+    end
+    describe "with decoding" do
+      Given(:block) {->(s) { Integer s * 2 } }
+      context "with singular value" do
+        When(:value) {input.value field: '1'}
+        Then {value == [11]}
+      end
+      context "with array value" do
+        When(:value) {input.value field: ['1', '2']}
+        Then {value == [11,22]}
+      end
+      context "with a sparse array value" do
+        When(:value) {input.value field: ['1', nil, '2']}
+        Then {value == [11,22]}
+      end
+      context "with an empty list" do
+        When(:value) {input.value field: []}
+        Then {value == []}
+      end
+      context "with a nil value" do
+        When(:value) {input.value field: nil}
+        Then {value == []}
+      end
+    end
+  end
+  describe "with decoding" do
+    Given(:block) { ->(s) { Integer s * 2}}
+
+    context "when accessed" do
+      When(:value) {input.value field: ['1']}
+      Then {value == 11}
+    end
+    context "when accessing a nil value and no default" do
+      When(:value) {input.value field: nil}
+      Then {value.nil?}
+    end
+  end
+
+  describe "with a default" do
+    Given(:options) {{default: 5}}
+    context "when accesing nil" do
+      When(:value) {input.value field: nil}
+      Then {value == 5}
+    end
+    context "when accessing a value" do
+      When(:value) {input.value field: 10}
+      Then {value == 10}
+    end
+  end
+
+  describe "a plural list input" do
+    Given(:input) {MVCLI::Form::Input.new :fields, [Integer]}
+    context "passing a singular value" do
+      When(:value) { input.value field: 10 }
+      Then {value == [10]}
+    end
+  end
+end

data/spec/mvcli/form_spec.rb

@@ -0,0 +1,116 @@
+require "spec_helper"
+require "mvcli/form"
+require "mvcli/decoding"
+require "ipaddr"
+
+describe "A form for creating a load balancer" do
+  use_natural_assertions
+  Given(:definition) do
+    Class.new(MVCLI::Form) do
+      input :name, String, default: -> {naming.generate 'l', 'b'}
+
+      input :port, Integer, default: 80, decode: ->(s) {Integer s}
+
+      input :protocol, String, default: 'HTTP', decode: :upcase
+
+      input :virtual_ips, [String], default: ['PUBLIC']
+
+      input :nodes, [Node], required: true do
+        input :address, IPAddr, required: true, decode: ->(s) {IPAddr.new s}
+        input :port, Integer, default: 80, decode: ->(s) {Integer s}
+        input :type, String, default: 'PRIMARY', decode: :upcase
+        input :condition, String, default: 'ENABLED', decode: :upcase
+
+        validates(:port, "port must be between 0 and 65,535") {|port| port >= 0 && port <= 65535}
+        validates(:type, "invalid type") {|type| ['PRIMARY', 'SECONDARY'].member? type}
+        validates(:condition, "invalid condition") {|c| ['ENABLED', 'DISABLED'].member? c}
+      end
+    end
+  end
+  Given(:form) do
+    definition.new(params).tap do |f|
+      f.stub(:decoders) {MVCLI::Decoding}
+      f.stub(:naming) {mock(:NameGenerator, generate: 'random-name')}
+    end
+  end
+  context "with no nodes provided" do
+    Given(:params) {({node: []})}
+    Then {!form.valid?}
+    And {form.violations[:nodes] == ["cannot be empty"]}
+
+  end
+  context "with invalid node inputs" do
+    Given(:params) do
+      ({
+         node: ['10.0.0.1:-500', 'xxx:80']
+       })
+    end
+    Then {!form.valid?}
+    context "the first violation" do
+      Given(:violations) {form.validation[:nodes].first.violations}
+      Then {violations[:port] == ["port must be between 0 and 65,535"]}
+    end
+    context "the second error" do
+      Given(:errors) {form.validation[:nodes].last.errors}
+      Then {errors[:address].first.is_a?(IPAddr::InvalidAddressError)}
+    end
+  end
+  context "with partially specified, valid inputs" do
+    Given(:params) do
+      ({node: ['10.0.0.1:80']})
+    end
+    Then {form.name == 'random-name'}
+    And {form.port == 80}
+    And {form.protocol == 'HTTP'}
+    And {form.virtual_ips == ['PUBLIC']}
+    context "the default form node" do
+      Given(:node) {form.nodes.first}
+      Then {node.address == IPAddr.new('10.0.0.1')}
+      And {node.port == 80}
+    end
+  end
+  context "with fully specified, valid inputs" do
+    Given(:params) {
+      ({
+         name: 'foo',
+         port: '80',
+         protocol: 'http',
+         virtual_ip: ['public', 'servicenet'],
+         node: [
+                 '10.0.0.1:80:primary:enabled',
+                 '10.0.0.2:80:secondary:disabled'
+                ]
+       })
+    }
+    Then {form.valid?}
+    And {form.name == 'foo'}
+    And {form.port == 80}
+    And {form.protocol == 'HTTP'}
+    And {form.nodes.length == 2}
+    context ". On the first node" do
+      Given(:node) {form.nodes.first}
+      Then {node.address == IPAddr.new('10.0.0.1')}
+      And {node.port == 80}
+      And {node.condition == 'ENABLED'}
+      And {node.type == 'PRIMARY'}
+    end
+    context ". On the second node" do
+      Given(:node) {form.nodes.last}
+      Then {node.address == IPAddr.new('10.0.0.2')}
+      And {node.port == 80}
+      And {node.condition == 'DISABLED'}
+      And {node.type == 'SECONDARY'}
+    end
+  end
+end
+
+class Node
+  include MVCLI::Validatable
+  attr_accessor :address, :port, :protocol, :condition, :type
+  validates(:port, "port must be between 0 and 65,535") {|port| port >= 0 && port <= 65535}
+
+  def initialize(attrs)
+    @address, @port, @protocal, @condition, @type = *attrs.values_at(:address, :port, :protocol, :condition, :type)
+  end
+
+end

data/spec/mvcli/router_spec.rb

@@ -25,6 +25,12 @@ describe "MVCLI::Router" do
     Then {@command.argv.should eql ['login']}
   end
 
+  context "when there are command line options, it does not interfere" do
+    Given {router.match 'login' => 'logins#create'}
+    When {invoke 'login --then --go-away -f 6 -p'}
+    Then {@command.should_not be_nil}
+  end
+
   context "with a route matched to a block" do
     Given {router.match bam: ->(command) {@command = command}}
     When {invoke 'bam'}

data/spec/mvcli/validatable_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "mvcli/validatable"
+
+describe "a validator" do
+  Given(:validator) {MVCLI::Validatable::Validator.new}
+  context "when it validates a field that does not exist on the object" do
+    Given {validator.validates(:does_not_exist, "invalid") {}}
+    When(:validation) {validator.validate(Object.new)}
+    Then {validation.errors[:does_not_exist].class < NameError}
+    Then {not validation.valid?}
+  end
+  describe "validating a child" do
+    Given {validator.validates_child(:some_child)}
+    context "when it is nil" do
+      When(:validation) {validator.validate(mock(:Object, :some_child => nil))}
+      Then {validation.valid?}
+    end
+    context "when it does not exist" do
+      When(:validation) {validator.validate(Object.new)}
+      Then {not validation.errors[:some_child].nil?}
+      And {not validation.valid?}
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mvcli
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Charles Lowell
@@ -29,7 +29,7 @@ cert_chain:
   UgImJlChAzCoDP9zi9tdm6jAr7ttF25R9PPYr11ILb7dYe3qUzlNlM6zJx/nb31b
   IhdyRVup4qLcqYSTPsm6u7VA
   -----END CERTIFICATE-----
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: map
@@ -72,14 +72,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- example/controllers/loadbalancers_controller.rb
-- example/routes.rb
 - lib/mvcli.rb
 - lib/mvcli/actions.rb
 - lib/mvcli/app.rb
+- lib/mvcli/argv.rb
 - lib/mvcli/command.rb
 - lib/mvcli/controller.rb
+- lib/mvcli/decoding.rb
 - lib/mvcli/erb.rb
+- lib/mvcli/form.rb
+- lib/mvcli/form/input.rb
 - lib/mvcli/loader.rb
 - lib/mvcli/middleware.rb
 - lib/mvcli/middleware/exception_logger.rb
@@ -88,11 +90,15 @@ files:
 - lib/mvcli/renderer.rb
 - lib/mvcli/router.rb
 - lib/mvcli/router/pattern.rb
+- lib/mvcli/validatable.rb
 - lib/mvcli/version.rb
 - mvcli.gemspec
 - spec/mvcli/actions_spec.rb
+- spec/mvcli/argv_spec.rb
 - spec/mvcli/dummy/app/providers/test_provider.rb
 - spec/mvcli/erb_spec.rb
+- spec/mvcli/form/input_spec.rb
+- spec/mvcli/form_spec.rb
 - spec/mvcli/loader_spec.rb
 - spec/mvcli/middleware/exception_logger_spec.rb
 - spec/mvcli/middleware/exit_status_spec.rb
@@ -100,6 +106,7 @@ files:
 - spec/mvcli/provisioning_spec.rb
 - spec/mvcli/router/pattern_spec.rb
 - spec/mvcli/router_spec.rb
+- spec/mvcli/validatable_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/cowboyd/mvcli
 licenses:
@@ -127,8 +134,11 @@ specification_version: 4
 summary: Local Apps. Remote Apps. They're all at your fingertips
 test_files:
 - spec/mvcli/actions_spec.rb
+- spec/mvcli/argv_spec.rb
 - spec/mvcli/dummy/app/providers/test_provider.rb
 - spec/mvcli/erb_spec.rb
+- spec/mvcli/form/input_spec.rb
+- spec/mvcli/form_spec.rb
 - spec/mvcli/loader_spec.rb
 - spec/mvcli/middleware/exception_logger_spec.rb
 - spec/mvcli/middleware/exit_status_spec.rb
@@ -136,4 +146,6 @@ test_files:
 - spec/mvcli/provisioning_spec.rb
 - spec/mvcli/router/pattern_spec.rb
 - spec/mvcli/router_spec.rb
+- spec/mvcli/validatable_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/example/controllers/loadbalancers_controller.rb

@@ -1,10 +0,0 @@
-class LoadbalancersController < ApplicationController
-  include MVCLI::RemoteRestController
-
-  respond_to :txt, :json, :xml
-  performs :create, :show, :update, :destroy
-
-  param :name, :type => :string
-
-
-end

data/example/routes.rb

@@ -1,31 +0,0 @@
-collection :loadbalancers do
-  # match "create loadbalancer"
-  # match "show loadbalancers"
-  # match "loadbalancers"
-  # match "show loadbalancer :id" #=> 'loadbalancers#show'
-  # match "update loadbalancer :id #=> loadbalancers#update"
-  # match "destroy loadbalancer :id"
-  collection :nodes do
-    # match "create node on loadbalancer :loadbalancer_id"
-    # match "create loadbalancer :loadbalancer_id node"
-    # match "show nodes on loadbalancer :loadbalancer_id"
-    # match "loadbalancer nodes"
-    # match "show loadbalancer :loadbalancer_id  nodes"
-    # match "show loadbalancer :loadbalancer_id node :id"
-    # match "show node :id on loadbalancer :loadbalancer_id"
-    # match "update loadbalancer:node"
-    # match "destroy loadbalancer:node:$id"
-    # match "destroy loadbalancer node $id"
-    # match "destroy loadbalancer:node $id"
-    # match "help "
-  end
-
-  collection :virtual_ips, :only => :index
-  # match "show virtual_ips on loadbalancer :loadbalancer_id"
-  # match "show loadbalancer :loadbalancer_id virtual_ips"
-  # match "loadbalancers"
-end
-
-collection :servers do
-
-end