anvil 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Lancelot Carlson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,17 @@
+== Welcome to Anvil
+
+Anvil is a ruby framework that utilizes GUI toolkits to create GUI based applications. The instructions for getting started are below:
+
+== Installation
+
+sudo gem install anvil
+
+Note: This will pull down the widget wrapper gem as well.
+
+== Getting Started
+
+Go to your projects directory (where ever that might be) and run the following command:
+
+anvil my_app
+
+Replace my_app with the name of the application you are creating. This will generate the files necessary for creating an Anvil application.

data/Rakefile

@@ -0,0 +1,85 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+require 'lib/version'
+
+NAME = "anvil"
+
+windows = (PLATFORM =~ /win32|cygwin/)
+
+SUDO = windows ? "" : "sudo"
+
+dist_dirs = [ "lib", "spec", "app_generators" ]
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = Anvil::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A GUI framework for Ruby"
+  s.description = "A collection of DSL's and frameworks that take full advantage of Ruby's powerful syntax"
+  s.author = "Lance Carlson"
+  s.email = "lancecarlson@gmail.com"
+  s.homepage = "http://anvil.rubyforge.org"
+  s.has_rdoc = true
+  s.executables = ['anvil']
+
+  s.add_dependency('widget_wrapper')
+  s.add_dependency('rubigen')
+  s.add_dependency('rake')
+
+  s.files = [ "MIT-LICENSE", "Rakefile", "README", "spec_helper.rb" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob("#{dir}/**/*")
+  end
+  
+  s.rubyforge_project = 'anvil'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'Anvil'
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.rdoc_files.include('README', 'CHANGELOG', 'MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Run :package and install the resulting .gem'
+task :install => :package do
+  sh %{#{SUDO} gem install pkg/#{NAME}-#{Anvil::VERSION} --no-rdoc --no-ri}
+end
+
+desc 'Run :clean and uninstall the .gem'
+task :uninstall => [:clean] do
+  sh %{#{SUDO} gem uninstall #{NAME}}
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec.opts']
+end
+
+desc "Run all specs and generate an rcov report"
+Spec::Rake::SpecTask.new('spec:rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec.opts']
+  t.rcov = true
+  t.rcov_dir = 'coverage'
+  t.rcov_opts = ['--exclude', 'gems', '--exclude', 'spec']
+end
+
+task :release => :package do
+  if ENV['RELEASE']
+    sh %{rubyforge add_release #{NAME} #{NAME} "#{ENV['RELEASE']}" pkg/#{NAME}-#{Anvil::VERSION}.gem}
+  else
+    puts 'Must specify release!'
+  end
+end

data/app_generators/anvil/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/app_generators/anvil/anvil_generator.rb

@@ -0,0 +1,95 @@
+class AnvilGenerator < RubiGen::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name']) unless defined? DEFAULT_SHEBANG
+  
+  default_options   :shebang => DEFAULT_SHEBANG
+  
+  attr_reader :name
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    @destination_root = File.expand_path(@name)
+    extract_options
+  end
+
+  def manifest
+    script_options     = { :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang] }
+
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+      
+      # copy skeleton
+      m.file_copy_each %w( Rakefile )
+      m.file_copy_each %w( application.rb exceptions.rb ), "app/controllers"
+      #m.file_copy_each %w( global_helper.rb ), "app/helpers"
+      m.file_copy_each %w( application.rb ), "app/views"      
+      #m.file_copy_each %w( boot.rb merb_init.rb router.rb upload.conf dependencies.rb), "config"
+      #m.file_copy_each %w( development.rb production.rb test.rb ), "config/environments"
+      m.file_copy_each %w( spec_helper.rb ), "spec"
+      #m.file_copy_each %w( test_helper.rb), "test"
+
+      # build default config
+      #m.template "config/merb.yml", "config/merb.yml", :assigns => {:key => "#{@name.upcase}#{rand(9999)}"}
+      
+      # build scripts
+      #%w( stop_merb generate destroy ).each do |file|
+        #m.file     "script/#{file}",        "script/#{file}", script_options
+        #m.template "script/win_script.cmd", "script/#{file}.cmd", :assigns => { :filename => file } if windows
+      #end
+    end
+  end
+  
+  def windows
+    (RUBY_PLATFORM =~ /dos|win32|cygwin/i) || (RUBY_PLATFORM =~ /(:?mswin|mingw)/)
+  end
+  
+  protected
+    def banner
+      <<-EOS
+Creates an Anvil application stub.
+
+USAGE: #{spec.name} -g path"
+EOS
+    end
+
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # # For each option below, place the default
+      # # at the top of the file next to "default_options"
+      # opts.on("-r", "--ruby=path", String,
+      #        "Path to the Ruby binary of your choice (otherwise scripts use env, dispatchers current path).",
+      #        "Default: #{DEFAULT_SHEBANG}") { |options[:shebang]| }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      app/controllers
+      app/models
+      app/helpers
+      app/views/layout
+      app/views/exceptions
+      config/environments
+      lib
+      log
+      script
+      spec/models
+      spec/controllers
+      test/unit
+      gems
+    )
+    
+end

data/app_generators/anvil/templates/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+require 'rdoctask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+require 'rubygems'

data/app_generators/anvil/templates/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class Application < WidgetWrapper::Controller
+end

data/app_generators/anvil/templates/app/controllers/exceptions.rb

@@ -0,0 +1,3 @@
+class Exceptions < Application
+
+end

data/app_generators/anvil/templates/app/views/application.rb

@@ -0,0 +1,3 @@
+anvil "Anvil App" do
+  frame "New Anvil App!", :center => true
+end

data/app_generators/anvil/templates/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format

data/app_generators/anvil/templates/spec/spec_helper.rb

@@ -0,0 +1 @@
+# Coming Soon

data/bin/anvil

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'console'
+
+ANVIL_ROOT = Dir.pwd
+
+Anvil::Console.run

data/lib/console.rb

@@ -0,0 +1,67 @@
+require 'optparse'
+require File.join(File.dirname(__FILE__), 'initializer')
+require File.join(File.dirname(__FILE__), 'core_ext')
+require File.join(File.dirname(__FILE__), 'generators')
+
+module Anvil
+  class Console
+    @@anvil_opts = {}
+    cattr_accessor :anvil_opts
+    
+    class << self
+      
+      def run
+        parse_opts
+        
+        # Start Anvil when option is set
+        Anvil::Initializer.run if @@anvil_opts[:start_anvil]
+        
+        # Generate fresh Anvil Application if option is set
+        if @@anvil_opts[:generate]
+          Anvil::AppGenerator.run @@anvil_opts[:generate]
+          exit!
+        end
+      end
+      
+      def parse_opts(argv = ARGV)
+        options = {}
+        
+        options[:start_anvil] = true
+        
+        opts = OptionParser.new do |opts|
+          opts.banner = "Usage: anvil [gih] [argument]"
+          opts.define_head "Anvil GUI framework."
+          opts.separator '*'*80
+          opts.separator 'If no flags are given, Anvil starts in the foreground'
+          opts.separator '*'*80
+          
+          opts.on("-i", "--irb-console", "This flag will start Anvil in irb console. Your application models and classes will be loaded and available through console.") do |console|
+            options[:console] = true
+            options[:start_anvil] = false
+            puts "Coming Soon!"
+          end
+          
+          opts.on("-g", "--generate-app PATH", "Generate a fresh Anvil application at PATH") do |path|
+            options[:generate] = path || Dir.pwd
+            options[:start_anvil] = false
+          end
+          
+          opts.on("-?", "-h", "--help", "Show this help message") do
+            puts opts
+            exit
+          end
+        end
+        
+        opts.parse!(argv)
+        
+        # anvil <argument> is the same as anvil -g <argument>
+        if argv.size == 1
+          options[:generate] = File.expand_path(argv.last)
+          options[:start_anvil] = false
+        end
+        
+        @@anvil_opts = options
+      end
+    end
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each{|file| require(file)}

data/lib/core_ext/class.rb

@@ -0,0 +1,180 @@
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+  end
+  
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+  
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+  
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+  end
+
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => (value.dup rescue value))
+        end
+      end
+      
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end

data/lib/generators.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/generators/*.rb"].sort.each{|file| require(file)}

data/lib/generators/anvil_app.rb

@@ -0,0 +1,19 @@
+#require 'fileutils'
+#require 'find'
+
+module Anvil
+  class AppGenerator
+    def self.run(path)
+      require 'rubygems'
+      require 'rubigen'
+
+      require 'rubigen/scripts/generate'
+      source = RubiGen::PathSource.new(:application, 
+        File.join(File.dirname(__FILE__), "../../app_generators"))
+      RubiGen::Base.reset_sources
+      RubiGen::Base.append_sources source
+      #RubiGem::Base.use_application_sources!
+      RubiGen::Scripts::Generate.new.run([path], :generator => 'anvil', :backtrace => true)
+    end
+  end
+end

data/lib/initializer.rb

@@ -0,0 +1,116 @@
+require 'rubygems'
+
+module Anvil
+  class Initializer
+    attr_reader :configuration
+ 
+    def self.run(command = :process, configuration = Configuration.new)
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.send(command)
+      initializer
+    end
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def process
+      set_load_paths
+      require_frameworks
+      require_controllers
+      require_models
+      load_application_view
+    end
+
+    def set_load_paths
+      load_paths = configuration.load_paths + configuration.framework_load_paths
+      load_paths.reverse_each{|dir| $LOAD_PATH.unshift(dir) if File.directory?(dir)}
+      $LOAD_PATH.uniq!
+    end
+
+    def require_frameworks
+      configuration.frameworks.each{|framework| require(framework.to_s)}
+    end
+
+    def require_controllers
+    end
+
+    def require_models
+    end
+
+    def load_application_view
+      application_file = File.join(configuration.view_path, 'application.rb')
+      
+      if File.exists?(application_file)
+        eval(File.read(application_file))
+      else
+        raise "Cannot find application view in: #{File.expand_path(application_file)}"
+      end
+    end
+  end
+
+  class Configuration
+    attr_reader :root_path
+    attr_accessor :load_paths
+    attr_accessor :framework_root_path
+    attr_accessor :controller_path
+    attr_accessor :model_path
+    attr_accessor :view_path
+    attr_accessor :frameworks
+    
+    def initialize
+      self.load_paths = default_application_load_paths
+      self.frameworks = default_frameworks
+      self.controller_path = default_controller_path
+      self.model_path = default_model_path
+      self.view_path = default_view_path
+    end
+
+    # Default frameworks loaded into anvil applications. Default is widget_wrapper.
+    def default_frameworks
+      [ :widget_wrapper ]
+    end
+
+    # Framework load paths
+    def framework_load_paths
+      %w(
+        anvilties
+        widget_wrapper 
+      ).map{|dir| "#{framework_root_path}/#{dir}"}.select{|dir| File.directory?(dir)}
+    end
+
+    # Default application load paths. This can be added onto in configuration.
+    def default_application_load_paths
+      %w(
+        app
+        config
+        ).map{|dir| "#{root_path}/#{dir}"}.select{|dir| File.directory?(dir)} 
+    end
+
+    # Default controller files load path. This can be changed in configuration.
+    def default_controller_path
+      @controller_path ||= File.join(root_path, 'app', 'controllers')
+    end
+    
+    # Default model files load path. This can be changed in configuration.
+    def default_model_path
+      @model_path ||= File.join(root_path, 'app', 'models')
+    end
+   
+    # Default view files load path. This can be changed in configuration. 
+    def default_view_path
+      @view_path ||= File.join(root_path, 'app', 'views')
+    end
+     
+    # Default framework root path. This can be changed in configuration.
+    def framework_root_path
+      @framework_root_path ||= File.join(File.dirname(__FILE__), '..')
+    end
+    
+    # Root path of the application.
+    def root_path
+      ANVIL_ROOT
+    end
+  end
+end 

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Anvil
+  VERSION = '0.0.1' unless defined?(::Anvil::VERSION)
+end

data/spec/console_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../lib/console'
+
+describe Anvil::Console do
+  describe "run sequence" do    
+    it "should run the argument parser" do
+      Anvil::Initializer.stub!(:run)
+      Anvil::AppGenerator.stub!(:run)
+      Anvil::Console.stub!(:exit!)
+      
+      Anvil::Console.should_receive(:parse_opts)
+      Anvil::Console.run
+    end
+    
+    it "should run anvil when the option is supplied" do
+      Anvil::Console.stub!(:parse_opts)
+      Anvil::Console.anvil_opts[:start_anvil] = true
+      Anvil::Console.stub!(:exit!)
+      
+      Anvil::Initializer.should_receive(:run)
+      Anvil::Console.run
+    end
+    
+    it "should generate a fresh anvil application skeleton when options is supplied" do
+      Anvil::Console.stub!(:parse_opts)
+      Anvil::Console.anvil_opts[:start_anvil] = false
+      Anvil::Console.anvil_opts[:generate] = '/some/path'
+      
+      Anvil::Initializer.should_not_receive(:run)
+      Anvil::AppGenerator.should_receive(:run).with('/some/path')
+      Anvil::Console.should_receive(:exit!)
+      Anvil::Console.run
+    end
+  end
+  
+  describe "argument parser" do
+    it "should start anvil when no arguments are given" do
+      Anvil::Console.parse_opts([])
+      Anvil::Console.anvil_opts[:start_anvil].should be_true
+    end
+    
+    it "should run the interactive console when the -i or --irb-console option is specified" do
+      Anvil::Console.should_receive(:puts).twice.with("Coming Soon!")
+      Anvil::Console.parse_opts(["-i"])
+      Anvil::Console.parse_opts(["--irb-console"])
+      pending("Need to get figure how to use irb console")
+    end
+    
+    it "should generate a fresh anvil application skeleton when -g PATH, --generate-app PATH" do
+      Anvil::Console.parse_opts(["-g", "/some/path"])
+      Anvil::Console.parse_opts(["--generate-app", "/some/path"])
+      Anvil::Console.anvil_opts[:generate].should == '/some/path'
+      Anvil::Console.anvil_opts[:start_anvil].should be_false
+    end
+    
+    it "should generate a fresh anvil application skeleton when the application name is given and no options are provided" do
+      File.should_receive(:expand_path).with("cool_app").and_return("/some/path/cool_app")
+      Anvil::Console.parse_opts(["cool_app"])
+      Anvil::Console.anvil_opts[:generate].should == "/some/path/cool_app"
+    end
+    
+    it "should print the help message when -?, -h or --help option is specified" do
+      Anvil::Console.should_receive(:puts).exactly(3).times
+      Anvil::Console.should_receive(:exit).exactly(3).times
+      Anvil::Console.parse_opts(["-?"])
+      Anvil::Console.parse_opts(["-h"])
+      Anvil::Console.parse_opts(["--help"])
+    end
+  end
+end

data/spec/generators/anvil_app_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../lib/generators/anvil_app'
+require 'rubigen'
+require 'rubigen/scripts/generate'
+
+describe Anvil::AppGenerator do
+  it "should run the fresh application generator" do
+    @path_source = mock(RubiGen::PathSource)
+    @generator = mock(RubiGen::Scripts::Generate)
+    
+    RubiGen::PathSource.should_receive(:new).with(:application, './spec/generators/../../lib/generators/../../app_generators').and_return(@path_source)
+    RubiGen::Base.should_receive(:reset_sources)
+    RubiGen::Base.should_receive(:append_sources).with(@path_source)
+    RubiGen::Scripts::Generate.should_receive(:new).and_return(@generator)
+    @generator.should_receive(:run).with(['/some/path'], {:generator=>"anvil", :backtrace=>true})
+    Anvil::AppGenerator.run('/some/path')
+  end
+end

data/spec/initializer_spec.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../lib/initializer'
+
+include Anvil
+
+describe Anvil::Initializer do
+  before(:each) do
+    @config = mock(Configuration)
+    @init = mock(Initializer)
+    Initializer.stub!(:new).and_return(@init)
+    @init.stub!(:process)
+  end
+
+  it "should run and return a new instance" do
+    Initializer.run(:process, @config).should == @init
+  end
+
+  it "should run and yield a configuration block" do
+    @config.should_receive(:root_path).and_return('test')
+    Initializer.run(:process, @config) {|config| config.root_path}
+  end
+end
+
+describe Anvil::Initializer, "process" do
+  before(:each) do
+    @config = mock(Configuration)
+    @init = Initializer.new @config
+  end
+  
+  it "should have a process method that will step through the entire initialization" do
+    @init.should_receive(:set_load_paths)
+    @init.should_receive(:require_frameworks)
+    @init.should_receive(:require_controllers)
+    @init.should_receive(:require_models)
+    @init.should_receive(:load_application_view)
+    @init.process 
+  end
+
+  it "should have a configuration instance" do
+    @init.configuration.should == @config
+  end
+
+  it "should set the load paths" do
+    File.should_receive(:directory?).any_number_of_times.and_return(true)
+    @config.should_receive(:load_paths).and_return(['crap', '1', '2', '3', 'stuff'])
+    @config.should_receive(:framework_load_paths).and_return(['api', 'stuff'])
+    @init.set_load_paths.slice(0..5).should == ['crap', '1', '2', '3', 'stuff', 'api']
+  end
+
+  it "should require the frameworks" do
+    @config.should_receive(:frameworks).and_return([:framework1, :framework2])
+    @init.should_receive(:require).with('framework1').and_return(true)  
+    @init.should_receive(:require).with('framework2').and_return(true)  
+    @init.require_frameworks 
+  end
+
+  it "should require the controllers" do
+  end
+
+  it "should require the models" do
+  end
+
+  it "should load the application view" do
+    @config.should_receive(:view_path).and_return('/view/path')
+    File.should_receive(:exists?).with('/view/path/application.rb').and_return(true)
+    File.should_receive(:read).with('/view/path/application.rb').and_return('')
+    @init.should_receive(:eval).with('') 
+    @init.load_application_view
+  end
+
+  it "should raise an error if it can't find the view path" do
+    @config.stub!(:view_path).and_return('')
+    File.should_receive(:exists?).and_return(false)
+    lambda { @init.load_application_view }.should raise_error
+  end
+end
+
+describe Anvil::Configuration do
+  before(:each) do
+    ANVIL_ROOT = '/some/root/path'
+    @config = Configuration.new
+  end
+
+  it "should assign default_application_load_paths to load_paths" do
+    @config.load_paths.should == @config.default_application_load_paths
+  end
+  
+  it "should assign default_frameworks to frameworks" do
+    @config.frameworks.should == @config.default_frameworks
+  end
+
+  it "should assign default_controller_path to controller_path" do
+    @config.controller_path.should == @config.default_controller_path
+  end
+
+  it "should assign default_model_path to model_path" do
+    @config.model_path.should == @config.default_model_path
+  end
+ 
+  it "should assign default_view_path to view_path" do
+    @config.view_path.should == @config.default_view_path
+  end 
+
+  it "should have frameworks defaulted to widget_wraper" do
+    @config.default_frameworks.should == [ :widget_wrapper ]
+  end
+  
+  it "should have default application load paths" do
+    @config.stub!(:framework_root_path).and_return('/root')
+    File.should_receive(:directory?).with('/root/anvilties').and_return(true)
+    File.should_receive(:directory?).with('/root/widget_wrapper').and_return(true)
+    @config.framework_load_paths.should == %w(/root/anvilties /root/widget_wrapper)
+  end
+ 
+  it "should have default application load paths" do
+    @config.stub!(:root_path).and_return('/root')
+    File.should_receive(:directory?).with('/root/app').and_return(true)
+    File.should_receive(:directory?).with('/root/config').and_return(true)
+    @config.default_application_load_paths.should == %w(/root/app /root/config)
+  end
+
+  it "should have a default controller path" do
+    @config.controller_path.should == '/some/root/path/app/controllers'
+  end
+
+  it "should allow you to override the default controller path" do
+    @config.controller_path = '/overriding/controller/path'
+    @config.controller_path.should == '/overriding/controller/path'
+  end
+
+  it "should have a default model path" do
+    @config.model_path.should == '/some/root/path/app/models'
+  end
+
+  it "should allow you to override the default model path" do
+    @config.model_path = '/overriding/model/path'
+    @config.model_path.should == '/overriding/model/path'
+  end
+
+  it "should have a default view path" do
+    @config.view_path.should == '/some/root/path/app/views'
+  end
+
+  it "should allow you to override the default view path" do
+    @config.view_path = '/overriding/view/path'
+    @config.view_path.should == '/overriding/view/path'
+  end
+  
+  it "should allow you to set the default framework path" do
+    @config.framework_root_path = '/new/path'
+    @config.framework_root_path.should == '/new/path'
+  end
+   
+  it "should have a default framework load path" do
+    @config.framework_root_path.should == './spec/../lib/..'
+  end
+
+  it "should have a root path" do
+    @config.root_path.should == '/some/root/path'
+  end
+end

data/spec_helper.rb

@@ -0,0 +1,2 @@
+Spec::Runner.configure do |config|
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: anvil
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lance Carlson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2007-12-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: widget_wrapper
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rubigen
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A collection of DSL's and frameworks that take full advantage of Ruby's powerful syntax
+email: lancecarlson@gmail.com
+executables: 
+- anvil
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- Rakefile
+- README
+- spec_helper.rb
+- bin/anvil
+- lib/console.rb
+- lib/core_ext
+- lib/core_ext/class.rb
+- lib/core_ext.rb
+- lib/generators
+- lib/generators/anvil_app.rb
+- lib/generators.rb
+- lib/initializer.rb
+- lib/version.rb
+- spec/console_spec.rb
+- spec/generators
+- spec/generators/anvil_app_spec.rb
+- spec/initializer_spec.rb
+- app_generators/anvil
+- app_generators/anvil/anvil_generator.rb
+- app_generators/anvil/templates
+- app_generators/anvil/templates/app
+- app_generators/anvil/templates/app/controllers
+- app_generators/anvil/templates/app/controllers/application.rb
+- app_generators/anvil/templates/app/controllers/exceptions.rb
+- app_generators/anvil/templates/app/helpers
+- app_generators/anvil/templates/app/models
+- app_generators/anvil/templates/app/views
+- app_generators/anvil/templates/app/views/application.rb
+- app_generators/anvil/templates/config
+- app_generators/anvil/templates/Rakefile
+- app_generators/anvil/templates/spec
+- app_generators/anvil/templates/spec/spec.opts
+- app_generators/anvil/templates/spec/spec_helper.rb
+- app_generators/anvil/templates/test
+- app_generators/anvil/USAGE
+has_rdoc: true
+homepage: http://anvil.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: anvil
+rubygems_version: 1.0.0
+signing_key: 
+specification_version: 2
+summary: A GUI framework for Ruby
+test_files: []
+