merb 0.5.3 → 0.9.2

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2006 Ezra Zygmuntowicz
-
-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

@@ -1,277 +0,0 @@
-= Merb
-
-Like Ruby on Rails, Merb (Mongrel + ERB) is an MVC framework. Unlike Rails, Merb is ORM-agnostic, JavaScript library agnostic, and template language agnostic, preferring plugins that add in support for a particular feature rather than trying to produce a monolithic library with everything in the core. In fact, this is a guiding principle of the project, which has led to third-party support for the ActiveRecord, DataMapper, and Sequel ORMs.
-
-In addition, it means that the core code in Merb is kept simple and well organised. This has multiple benefits. It means it's faster for one thing. It's also easier to understand, maintain and extend.
-
-=== Get Merb
-
-The simplest way to get Merb is to install the gem:
-
-  $ sudo gem install merb --include-dependencies
-  
-If you want to contribute (or just use the latest code), you can build the gem from the svn trunk:
-
-  $ sudo gem install mongrel json json_pure erubis mime-types rspec hpricot mocha rubigen haml markaby mailfactory Ruby2Ruby -y
-  $ svn co http://svn.devjavu.com/merb/trunk merb
-  $ cd merb
-  $ rake install
-
-To generate a new merb app after the gem is installed:
-  
-  $ merb myapp
-
-==== Dependencies
-
-Currently, Merb itself depends on the following gems:
-
-* mongrel
-* json_pure
-* erubis
-* mime-types
-* rspec
-* rubigen 
-* ruby2ruby 
-* rake 
- 
-** If you are on windows see this blog post oj how to get up and running:
-http://www.ghostonthird.com/2007/11/17/merb-on-windows-it-works/
- 
-You must also have either the json or json_pure gem installed. Note that the json gem 
-provides a faster library but will not work with jRuby. 
- 
-Optionally, merb can take advantage of the following gems: 
- 
-* mailfactory (if you wish to use merb's mailers)
-* haml 1.8 or greater (if you wish to use HAML templates, i.e. .haml files)
-* markaby (if you wish to use Markaby template, i.e. .mab files) 
-* builder (if you wish to use Builder templates, i.e. .rxml, .rerb or .builder files) 
-* memcache-client (for use with Danga Interactive's memcached) 
-* swiftiply 
-* eventmachine 
-* rcov
-* ruby-debug (if you want to use debugging functionality)
-
-You will also probably need to install your ORM of choice as well as any gem plugins you want to use (see below).
-
-=== The +merb+ server
-
-right now you add your routes in
-the appdir/config/router.rb file. So by default it runs on port 4000
-
-	$ cd /path/to/your/merb/app
-	$ merb  
-
-Or to start merb on a different port:
-
-	$ merb -p 3500
-
-To start a cluster of merb servers you specify the first port and then how many 
-servers you want spawned. SO this command will start a merb instance on ports
-3000, 3001, 3002
-
-	$ merb -p 3000 -c 3
-
-To start a Merb IRB console where all your models and other classes are pre loaded
-use the -i flag
-
-	$ merb -i
-
-To enable ruby-debug support, start Merb with
-
-  $ merb -D
-
-Now you can use the +debugger+ method everywhere in your code to open an rdebug session.
-	
-To see all the available command line flags use:
-
-	$ merb -h
-		
-	
-== Using Merb
-
-Merb uses the Model-View-Controller (MVC) pattern.  Incoming requests are matched in the Router and
-directed to an appropriate controller action.
-
-=== Model
-
-Merb does not come with its own model layer.  While you are free to use whatever data system you like,
-the merb core team does maintain plugins for the following Object Relational Mappers (ORM's):
-
-ActiveRecord:: The same ORM that Rails uses. (<tt>sudo gem install merb_activerecord</tt>)
-DataMapper:: Fairly new ORM. (<tt>sudo gem install merb_datamapper</tt>)
-Sequel:: Fairly new ORM. (<tt>sudo gem install merb_sequel</tt>)
-
-To use your choice ORM, install the appropriate gem and uncomment the appropriate +use_orm+ line in
-Merb.root/config/dependencies.rb
-
-=== Controllers
-
-(Merb.root/app/controllers/*)
-
-Merb controllers inherit from Merb::Controller and contain built in view/template rendering.
-Incoming requests are usually mapped to a specific method in a controller.  For example, using
-the default routes, a request to http://www.yourapp.com/posts/show/1 would call the the #show
-method of your PostsController (and params[:id] would = 1.)
-
-The return value of your action function gets sent back to the client as the view.  In most cases,
-you are going to want to end your functions with a call to +render+.  By default, +render+ will
-render the view template associated with your action (in default merb that would be 
-Merb.root/app/views/<controller>/<action>.html.erb - see the View section for more info.)
-
-Controllers can be generated by calling Merb.root/script/generate controller ControllerName.
-By default, generated controllers inherit from the Application class (Merb.root/app/controllers/application.rb)
-which itself inherits from Merb:Controller.  Application is a good place to put code pertinent to all controllers.
-An example would be setting a filter to check if a user is logged in or to preload user data for each controller.
-
-==== +before+ and +after+ filters
-
-Use the +before+ method in your controllers. +before+ accepts either a symbol, string or a Proc/lambda object. If you give it a symbol it will call a method with the same name as the symbol. If you give it a proc that takes one argument it will call the proc with the current controller as that argument. You can use :only and :exclude as options to your filters to exclude or include actions from certain filters. :only and :exclude take :symbols or [:sym, :sam] array of symbols.
-
-	class Foo < Merb::Controller
- 
-	  before :setup_user, :only => :foo
-	  before lambda {|c| c.headers['X-Foo] = 'bar' }, :exclude => [:foo, :baz]
-
-	  def setup_user
-	    # blah blah
-	  end
-
-	  def foo
-	    # blah
-	  end
-
-	  def regular_action
-	    # blah
-	  end
-
-	end
-
-To stop the before filter chain you use throw :halt with a few options:
-
-	# halts the filter chain and calls filters_halted which you can override 
-	# in your controller to specialize it.
-
-	throw :halt
-
-	# halts the filters and calls the method named after the symbol:
-
-	throw :halt, :other_action
-
-	# halts the filter chain and returns the result of the Proc being called
-
-	throw :halt, Proc.new{ |c| c.redirect "/foo" }
-
-	# halts the chain and returns whatever is in the string
-
-	throw :halt, "<h1>You don't have permissions dude!</h1>"
-
-	or even render templates:
-
-	throw :halt, render 'foo'
-	throw :halt, partial 'foo'
-
-After filters accept a symbol, string or Proc and call that proc with the controller:
-
-	after Proc.new {|c| Tidy.new(c.body) }, :only => :index
-
-
-=== Views
-
-(Merb.root/app/views/*)
-
-A view can be loosely defined as any data sent back to the client (a "view" of your data.)
-By default, Merb controllers send the return value of your controller action as the view.
-The Controller#render method simply renders the specified view and returns it as a string.
-By default, a call to +render+ without any options renders the view template associated
-with that controller action.  Using the default ERB templating system, this means that a
-call to +render+ in Posts#index would render the file Merb.root/app/views/posts/index.html.erb
-
-==== Layouts
-
-(Merb.root/app/views/layout/*)
-
-Layouts are generic templates in which your specific view templates are rendered.  A sample
-layout could look like:
-
-  <html>
-    <head><title>My Application Layout</title></head>
-    <body>
-      <img src="header" />
-      <div id="content">
-        <%= catch_content :layout %>
-      </div>
-    </body>
-  </html>
-
-By default, +render+ will look for a corresponding layout for your controller in the form
-of Merb.root/app/views/layout/<controller>.html.erb .  If no specific layout is present,
-+render+ will attempt to use Merb.root/app/view/layout/application.html.erb
-
-<i>See #render for more details/options, as well as how to use different templating systems
-in your app.</i>
-
-You can return several different types of values from your controller actions:
-
-* String: Any string will get sent to the browser as standard text/html
-* File/IO: Any file descriptor will get handed over to mongrel to be streamed to the client.
-* Proc Object: The object will be called and the return value sent to the client.
-
-That last point has some cool connotations if you think about it. Merb does 
-have a mutex lock around the call to your controller’s action anywhere that
-you can call AR objects. Merb’s lock is way smaller then rails giant lock 
-though and allows for many more concurrent requests to be handled by one 
-process. By returning a Proc object from your action, you allow merb to 
-release the lock and the proc is called in multi threaded way. This allows 
-for all kinds of cool streaming and ‘futures’ where you return the proc and 
-release the mutex. It’s basically like handing over the proc to mongrel and 
-mongrel handles calling it in a thread safe manner.
-
-=== Helpers
-
-(Merb.root/app/helpers/*)
-
-app/helpers/global_helper.rb will be available to all of your views.
- Helpers named after your controller plus _helper.rb will be included in the views
- for that controller only.
-
-=== File uploads
-When a file is uploaded with Merb, it gets put in a Tempfile. So 
-you just want to copy it to the right place on the filesystem.
-
-	def upload
-	  puts params[:file].inspect
-	  FileUtils.mv params[:file][:tempfile].path, Merb.root+"/uploads/#{params[:file][:filename]}"
-	  render
-	end
-
-A file upload will have a hash of params like this:
-
-	{ 
-	:filename => File.basename(filename),  
-	:content_type => content_type,  
-	:tempfile => <Tempfile>, 
-	:size => File.size(body) 
-	}
-
-== Merb app layout
-
-	merb_app:
-
-	  app
-	    controllers
-	    helpers
-	    mailers	    
-	    models
-	    parts
-	    views
-	  config
-	  gems
-	  lib
-	  log
-	  public
-	  Rakefile
-	  script
-	  spec
-	  test
-	    unit

data/Rakefile

@@ -1,237 +1,118 @@
-require "rake"
-require "rake/clean"
-require "rake/gempackagetask"
-require "rake/rdoctask"
-require "rake/testtask"
-require "spec/rake/spectask"
-require "fileutils"
+## THESE ARE CRUCIAL
+module Merb
+  # Set this to the version of merb-core that you are building against/for
+  VERSION = "0.9.2"
 
-def __DIR__
-  File.dirname(__FILE__)
+  # Set this to the version of merb-more you plan to release
+  MORE_VERSION = "0.9.2"
 end
 
-require __DIR__ + "/tools/rakehelp"
-require __DIR__ + "/tools/annotation_extract"
-
+require "rake/clean"
+require "rake/gempackagetask"
+require 'fileutils'
 include FileUtils
 
-NAME = "merb"
-
-require "lib/merb/version"
-
-##############################################################################
-# Packaging & Installation
-##############################################################################
-CLEAN.include ["**/.*.sw?", "*.gem", ".config"]
-
-windows = (PLATFORM =~ /win32|cygwin/)
-
-SUDO = windows ? "" : "sudo"
+gems = %w[
+  merb-action-args merb-assets merb-gen merb-haml
+  merb-builder merb-mailer merb-parts merb-cache
+]
 
-setup_clean ["pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"]
-
-desc "Packages up Merb."
-task :default => :package
-
-task :merb => [:clean, :rdoc, :package]
-
-spec = Gem::Specification.new do |s|
-  s.name         = NAME
-  s.version      = Merb::VERSION
+merb_more_spec = Gem::Specification.new do |s|
+  s.name         = "merb-more"
+  s.version      = Merb::MORE_VERSION
   s.platform     = Gem::Platform::RUBY
   s.author       = "Ezra Zygmuntowicz"
   s.email        = "ez@engineyard.com"
-  s.homepage     = "http://merb.devjavu.com"
-  s.summary      = "Merb == Mongrel + Erb. Pocket rocket web framework."
-  s.bindir       = "bin"
+  s.homepage     = "http://www.merbivore.com"
+  s.summary      = "(merb - merb-core) == merb-more.  The Full Stack. Take what you need; leave what you don't."
   s.description  = s.summary
-  s.executables  = %w( merb )
-  s.require_path = "lib"
-  s.files        = %w( LICENSE README Rakefile TODO ) + [Merb.svn_revision_filename] + Dir["{bin,spec,lib,examples,app_generators,merb_generators,merb_default_generators,rspec_generators,test_unit_generators,script}/**/*"]
-
-  # rdoc
-  s.has_rdoc         = true
-  s.extra_rdoc_files = %w( README LICENSE TODO )
-  #s.rdoc_options     += RDOC_OPTS + ["--exclude", "^(app|uploads)"]
-
-  # Dependencies
-  s.add_dependency "mongrel"
-  s.add_dependency "erubis"
-  #s.add_dependency "haml", ">= 1.8"
-  s.add_dependency "mime-types"
-  s.add_dependency "rubigen"
-  s.add_dependency "rake"
-  s.add_dependency "ruby2ruby"
-  s.add_dependency "json_pure"
-  
-  # Requirements
-  s.requirements << "install the json gem to get faster json parsing"
-  s.required_ruby_version = ">= 1.8.4"
-end
-
-Rake::GemPackageTask.new(spec) do |package|
-  # package.need_tar = true
-  package.gem_spec = spec
-end
-
-desc "Run :package and install the resulting .gem"
-task :install => :package do
-  sh %{#{SUDO} gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+  s.files        = %w( LICENSE README Rakefile TODO lib/merb-more.rb )
+  s.add_dependency "merb-core", ">= #{Merb::VERSION}"
+  gems.each do |gem|
+    s.add_dependency gem, [">= #{Merb::VERSION}", "<= 1.0"]
+  end
 end
 
-desc "Run :clean and uninstall the .gem"
-task :uninstall => :clean do
-  sh %{#{SUDO} gem uninstall #{NAME}}
+merb_spec = Gem::Specification.new do |s|
+  s.name         = "merb"
+  s.version      = Merb::MORE_VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.author       = "Ezra Zygmuntowicz"
+  s.email        = "ez@engineyard.com"
+  s.homepage     = "http://www.merbivore.com"
+  s.summary      = "(merb-core + merb-more) == all of Merb"
+  s.description  = s.summary
+  s.files        = %w( LICENSE README Rakefile TODO )
+  s.add_dependency "merb-core", "= #{Merb::VERSION}"
+  s.add_dependency "merb-more", "= #{Merb::MORE_VERSION}"
 end
 
-##############################################################################
-# Documentation
-##############################################################################
-task :doc => [:rdoc]
-namespace :doc do
-
-  Rake::RDocTask.new do |rdoc|
-    files = ["README", "LICENSE", "CHANGELOG", "lib/**/*.rb"]
-    rdoc.rdoc_files.add(files)
-    rdoc.main = "README"
-    rdoc.title = "Merb Docs"
-    rdoc.template = __DIR__ + "/tools/allison-2.0.2/lib/allison.rb"
-    rdoc.rdoc_dir = "doc/rdoc"
-    rdoc.options << "--line-numbers" << "--inline-source"
-  end
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache", "lib/merb-more.rb"]
 
-  desc "run webgen"
-  task :webgen do
-    sh %{cd doc/site; webgen}
-  end
-
-  desc "rdoc to rubyforge"
-  task :rubyforge do
-    # sh %{rake doc}
-    sh %{#{SUDO} chmod -R 755 doc} unless windows
-    sh %{/usr/bin/scp -r -p doc/rdoc/* ezmobius@rubyforge.org:/var/www/gforge-projects/merb}
-  end
-
-end
+windows = (PLATFORM =~ /win32|cygwin/) rescue nil
 
-##############################################################################
-# rSpec & rcov
-##############################################################################
-desc "Run :specs, :rcov"
-task :aok => [:specs, :rcov]
+SUDO = windows ? "" : "sudo"
 
-desc "Run all specs"
-Spec::Rake::SpecTask.new("specs") do |t|
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.spec_files = Dir["spec/**/*_spec.rb"].sort
-end
+# desc "Installs Merb More."
+# task :default => :install
 
-desc "Run a specific spec with TASK=xxxx"
-Spec::Rake::SpecTask.new("spec") do |t|
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.libs = ["lib", "server/lib" ]
-  t.spec_files = (ENV["TASK"] || '').split(',').map do |task|
-    "spec/merb/#{task}_spec.rb"
-  end
+Rake::GemPackageTask.new(merb_more_spec) do |package|
+  package.gem_spec = merb_more_spec
 end
 
-desc "Run all specs output html"
-Spec::Rake::SpecTask.new("specs_html") do |t|
-  t.spec_opts = ["--format", "html"]
-  t.libs = ["lib", "server/lib" ]
-  t.spec_files = Dir["spec/**/*_spec.rb"].sort
+Rake::GemPackageTask.new(merb_spec) do |package|
+  package.gem_spec = merb_spec
 end
 
-desc "RCov"
-Spec::Rake::SpecTask.new("rcov") do |t|
-  t.rcov_opts = ["--exclude", "gems", "--exclude", "spec"]
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.rcov_opts = ["--exclude","gems"]
-  t.spec_files = Dir["spec/**/*_spec.rb"].sort
-  t.libs = ["lib", "server/lib" ]
-  t.rcov = true
+desc "Install it all"
+task :install => [:install_gems, :package] do
+  sh %{#{SUDO} gem install --local pkg/merb-more-#{Merb::MORE_VERSION}.gem  --no-update-sources}
+  sh %{#{SUDO} gem install --local pkg/merb-#{Merb::MORE_VERSION}.gem --no-update-sources}
 end
 
-STATS_DIRECTORIES = [
-  ['Code', 'lib/'],
-  ['Unit tests', 'specs']
-].collect { |name, dir| [ name, "./#{dir}" ] }.
-  select  { |name, dir| File.directory?(dir) }
-
-desc "Report code statistics (KLOCs, etc) from the application"
-task :stats do
-  require __DIR__ + "/tools/code_statistics"
-  # require "extra/stats"
-  verbose = true
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+desc "Build the merb-more gems"
+task :build_gems do
+  gems.each do |dir|
+    Dir.chdir(dir){ sh "rake package" }
+  end
 end
 
-task :release => :package do
-  if ENV["RELEASE"]
-    puts %{rubyforge add_release merb merb "#{ENV["RELEASE"]}" pkg/#{NAME}-#{Merb::VERSION}.gem}
-  else
-    puts "Usage: rake release RELEASE='Clever tag line goes here'"
+desc "Install the merb-more sub-gems"
+task :install_gems do
+  gems.each do |dir|
+    Dir.chdir(dir){ sh "#{SUDO} rake install" }
   end
 end
 
-##############################################################################
-# SVN
-##############################################################################
-namespace :repo do
-
-  desc "Add new files to repository"
-  task :add do
-    if File.directory?(".git")
-      system "git add *"
-    elsif File.directory?(".svn")
-      system "svn status | grep '^\?' | sed -e 's/? *//' | sed -e 's/ /\ /g' | xargs svn add"
-    end
+desc "Uninstall the merb-more sub-gems"
+task :uninstall_gems do
+  gems.each do |sub_gem|
+    sh %{#{SUDO} gem uninstall #{sub_gem}}
   end
+end
 
-  desc "Fetch changes from master repository"
-  task :rebase do
-    if File.directory?(".git")
-      system "git stash ; git svn rebase ; git stash apply"
-    elsif File.directory?(".svn")
-      system "svn update"
-    end
-  end
-  
-  desc "commit modified changes to the repository"
-  task :commit do
-    if File.directory?(".git")
-      system "git commit"
-    elsif File.directory?(".svn")
-      system "svn commit"
+task :package => ["lib/merb-more.rb"]
+desc "Create merb-more.rb"
+task "lib/merb-more.rb" do
+  mkdir_p "lib"
+  File.open("lib/merb-more.rb","w+") do |file|
+    file.puts "### AUTOMATICALLY GENERATED.  DO NOT EDIT."
+    gems.each do |gem|
+      next if gem == "merb-gen"
+      file.puts "require '#{gem}'"
     end
   end
-  
 end
 
-# Run specific tests or test files. Searches nested spec directories as well.
-# 
-# Based on a technique popularized by Geoffrey Grosenbach
-rule "" do |t|
-  spec_cmd = (RUBY_PLATFORM =~ /java/) ? "jruby -S spec" : "spec"
-  # spec:spec_file:spec_name
-  if /spec:(.*)$/.match(t.name)
-    arguments = t.name.split(':')
-    
-    file_name = arguments[1]
-    spec_name = arguments[2..-1]
-
-    spec_filename = "#{file_name}_spec.rb"
-    specs = Dir["spec/merb/**/#{spec_filename}"]
-    
-    if path = specs.detect { |f| spec_filename == File.basename(f) }
-      run_file_name = path
-    else
-      puts "No specs found for #{t.name.inspect}"
-      exit
+desc "Bundle up all the merb-more gems"
+task :bundle => [:package, :build_gems] do
+  mkdir_p "bundle"
+  cp "pkg/merb-#{Merb::MORE_VERSION}.gem", "bundle"
+  cp "pkg/merb-more-#{Merb::MORE_VERSION}.gem", "bundle"
+  gems.each do |gem|
+    File.open("#{gem}/Rakefile") do |rakefile|
+      rakefile.read.detect {|l| l =~ /^VERSION\s*=\s*"(.*)"$/ }
+      sh %{cp #{gem}/pkg/#{gem}-#{$1}.gem bundle/}
     end
-
-    example = " -e '#{spec_name}'" unless spec_name.empty?
-    
-    sh "#{spec_cmd} #{run_file_name} --format specdoc --colour #{example}"
   end
 end