merb-core 0.9.2

data/LICENSE

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

@@ -0,0 +1,21 @@
+merb-core is a new branch of Merb (also referred to as merb-next or the 0.9 series) which aims to provide a stable, stripped down API for a future Merb 1.0 release.
+
+This branch is based off the 0.5 release series but with significant rewrites.
+
+Goals of this release:
+
+  * Stabilize the @public interface methods to provide for a more consistent application development experience.
+  * Remove features until nothing except a central application API is left
+  * Improve comments on methods using a standard documentation methodology as described in DOCUMENTATION_STANDARDS
+  * Separate the tests into two sections... "private" and "public"
+    * Public methods are methods tagged with @public that will be part of the standard, stable Merb API
+    * Private methods are implementation methods that might 
+  * Implement a new render API
+  * Build more extensions to regain selected features when needed
+  
+To familiarize yourself with how a merb-core application might look,
+use merb-gen (from merb-more) to generate a few apps:
+$ merb-gen myapp                   # a "normal" merb app
+$ merb-gen myapp --flat            # a flattened app
+$ merb-gen myapp --very-flat       # a single-file app
+

data/Rakefile

@@ -0,0 +1,285 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "rake/testtask"
+require "spec/rake/spectask"
+require "fileutils"
+
+def __DIR__
+  File.dirname(__FILE__)
+end
+
+require __DIR__ + "/tools/rakehelp"
+require __DIR__ + "/tools/annotation_extract"
+
+include FileUtils
+
+NAME = "merb-core"
+
+require "lib/merb-core/version"
+require "lib/merb-core/test/run_specs"
+
+##############################################################################
+# Packaging & Installation
+##############################################################################
+CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"]
+
+windows = (PLATFORM =~ /win32|cygwin/) rescue nil
+
+SUDO = windows ? "" : "sudo"
+
+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
+  s.platform     = Gem::Platform::RUBY
+  s.author       = "Ezra Zygmuntowicz"
+  s.email        = "ez@engineyard.com"
+  s.homepage     = "http://merb.devjavu.com"
+  s.summary      = "Merb. Pocket rocket web framework."
+  s.bindir       = "bin"
+  s.description  = s.summary
+  s.executables  = %w( merb )
+  s.require_path = "lib"
+  s.files        = %w( LICENSE README Rakefile TODO ) + Dir["{docs,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 "erubis"
+  s.add_dependency "rake"
+  s.add_dependency "json_pure"
+  s.add_dependency "rspec"
+  s.add_dependency "rack"
+  s.add_dependency "hpricot"
+  s.add_dependency "mime-types"
+  # 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.gem_spec = spec
+end
+
+desc "Run :package and install the resulting .gem"
+task :install => :package do
+  sh %{#{SUDO} gem install --local pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+end
+
+desc "Run :package and install the resulting .gem with jruby"
+task :jinstall => :package do
+  sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+end
+
+desc "Run :clean and uninstall the .gem"
+task :uninstall => :clean do
+  sh %{#{SUDO} gem uninstall #{NAME}}
+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
+
+  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
+
+##############################################################################
+# rSpec & rcov
+##############################################################################
+desc "Run :specs, :rcov"
+task :aok => [:specs, :rcov]
+
+# 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
+
+def setup_specs(name, spec_cmd='spec')
+  desc "Run all specs (#{name})"
+  task "specs:#{name}" do
+    run_specs("spec/**/*_spec.rb", spec_cmd)
+  end
+
+  desc "Run private specs (#{name})"
+  task "specs:#{name}:private" do
+    run_specs("spec/private/**/*_spec.rb", spec_cmd)
+  end
+
+  desc "Run public specs (#{name})"
+  task "specs:#{name}:public" do
+    run_specs("spec/public/**/*_spec.rb", spec_cmd)
+  end
+end
+
+setup_specs("mri", "spec")
+setup_specs("jruby", "jruby -S spec")
+
+task "specs" => ["specs:mri"]
+task "specs:private" => ["specs:mri:private"]
+task "specs:public" => ["specs:mri:public"]
+
+desc "Run coverage suite"
+task :rcov do
+  require 'fileutils'
+  FileUtils.rm_rf("coverage") if File.directory?("coverage")
+  FileUtils.mkdir("coverage")
+  path = File.expand_path(Dir.pwd)
+  files = Dir["spec/**/*_spec.rb"]
+  files.each do |spec|
+    puts "Getting coverage for #{File.expand_path(spec)}"
+    command = %{rcov #{File.expand_path(spec)} --aggregate #{path}/coverage/data.data --exclude ".*" --include-file "lib/merb-core(?!\/vendor)"}
+    command += " --no-html" unless spec == files.last
+    `#{command} 2>&1`
+  end
+end
+
+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/**/#{task}_spec.rb"
+  end
+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
+end
+
+# desc "RCov"
+# Spec::Rake::SpecTask.new("rcov") do |t|
+#   t.rcov_opts = ["--exclude", "gems", "--exclude", "spec"]
+#   t.spec_opts = ["--format", "specdoc", "--colour"]
+#   t.spec_files = Dir["spec/**/*_spec.rb"].sort
+#   t.libs = ["lib", "server/lib"]
+#   t.rcov = true
+# end
+
+STATS_DIRECTORIES = [
+  ['Code', 'lib/'],
+  ['Unit tests', 'spec']
+].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
+end
+
+task :release => :package do
+  if ENV["RELEASE"]
+    sh %{rubyforge add_release merb merb "#{ENV["RELEASE"]}" pkg/#{NAME}-#{Merb::VERSION}.gem}
+  else
+    puts "Usage: rake release RELEASE='Clever tag line goes here'"
+  end
+end
+
+##############################################################################
+# SYNTAX CHECKING
+##############################################################################
+
+task :check_syntax do
+  `find . -name "*.rb" |xargs -n1 ruby -c |grep -v "Syntax OK"`
+  puts "* Done"
+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
+  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"
+    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/**/#{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
+    end
+
+    example = " -e '#{spec_name}'" unless spec_name.empty?
+    
+    sh "#{spec_cmd} #{run_file_name} --format specdoc --colour #{example}"
+  end
+end

data/bin/merb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require "merb-core"
+
+unless %w[-a --adapter -i --irb-console -r --script-runner].any? { |o| ARGV.index(o) }
+  ARGV.push *%w[-a mongrel]
+end
+  
+Merb.start

data/bin/merb-specs

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"..","lib","merb-core","test","run_specs")
+
+run_specs ARGV

data/docs/bootloading.dox

@@ -0,0 +1,57 @@
+The Merb boot process starts when you run the Merb binary, which calls `Merb.start`. Merb.start performs the
+following tasks:
+
+list.
+* Loads merb.yml from the root directory or config directory and puts them in the Merb::Config hash
+* Parses config arguments from the command-line and adds them to the Merb::Config hash
+* Runs the BootLoaders (see below)
+* Starts the Merb Rack adapter
+
+The BootLoader is a configurable process, which, by default, runs the following processes:
+
+deflist.
+Environment: Sets the Merb environment based on any -e flag passed the merb binary
+BuildFramework: Set the framework paths, which can either be set in the Merb::Config[:framework]
+  variable or defaults to the paths described below.
+Dependencies: Load dependencies.rb, which should include any plugins that will be loaded, as well
+  as an after_app_loaded hook.
+Logger: Set up the logger in the `Merb.dir_for(:log)` directory. In test mode, it will be called
+  `test_logger`. In other modes, it will be set to `merb.#{pid}.log`. The log level will default
+  to `info` but can be specified via the Merb::Config[:log_level] option.
+LoadRouter: The router is loaded from `Merb.dir_for(:config)/router.rb`.
+LoadClasses: Files in all of the load paths are `require`d, and classes added during the load of
+  each files are tracked so they can be removed later during the reloading process.
+Templates: All templates under the `_template_root` of any loaded controllers, as well as all 
+  templates under `Merb.dir_for(:view)` are registered as inlined templates.
+MimeTypes: Register all MimeTypes (see below for defaults).
+AfterAppLoads: Call any `after_app_loads` hooks that were registered in dependencies.rb
+MixinSessionContainer: Register the session types and set the app to use one if 
+  `Merb::Config[:session_type]` is set.
+ChooseAdapter: Set `Merb.adapter` to be the adapter chosen via Merb::Config[:adapter] (which
+  can be specified via the `-a foo` command-line parameter).
+RackUpApplication: Set up a default rack application. Alternatively, allow for additional configuration 
+  in `Merb.dir_for(:config)/rack.rb`, which will be evaluated in the context of a Rack::Builder.new
+  block.
+ReloadClasses: If Merb::Config[:reload_classes] is set, begin the process of reloading classes
+  every time a class is modified.
+  
+deflist: Default Framework Paths.
+application: Merb.root/app/controller/application.rb
+config: Merb.root/config
+lib: Merb.root/lib
+log: Merb.root/log
+view: Merb.root/app/views
+model: Merb.root/app/models
+controller: Merb.root/app/controllers
+helper: Merb.root/app/helpers
+mailer: Merb.root/app/mailers
+part: Merb.root/app/parts
+
+deflist: MimeTypes.
+\:all: no transform, */*
+\:yaml: to_yaml, application/x-yaml or text/yaml
+\:text: to_text, text/plain
+\:html: to_html, text/html or application/xhtml+xml or application/html
+\:xml: to_xml, application/xml or text/xml or application/x-xml, adds "Encoding: UTF-8" response header
+\:js: to_json, text/javascript ot application/javascript or application/x-javascript
+\:json: to_json, application/json or text/x-json

data/docs/documentation_standards

@@ -0,0 +1,40 @@
+Every method should have documentation above the method definition that fits this basic model...
+
+# Render the specified item, with the specified options.
+#
+# ==== Parameters
+# thing<String, Symbol, nil>::
+#   The thing to render. This will default to the current action
+# opts<Hash>:: An options hash (see below)
+#
+# ==== Options (opts)
+# :format<Symbol>:: A registered mime-type format
+# :template<String>::
+#   The path to the template relative to the template root
+# :status<~to_i>::
+#   The status to send to the client. Typically, this would
+#   be an integer (200), or a Merb status code (Accepted)
+# :layout<~to_s>::
+#   A layout to use instead of the default. This should be
+#   relative to the layout root. By default, the layout will
+#   be either the controller_name or application. If you
+#   want to use an alternative content-type than the one
+#   that the base template was rendered as, you will need
+#   to do :layout => “foo.#{content_type}” (i.e. “foo.json”)
+#
+# ==== Returns
+# String:: The rendered template, including layout, if appropriate.
+#
+# ==== Raises
+# TemplateNotFound::
+#   There is no template for the specified location.
+#
+# ==== Alternatives
+# If you pass a Hash as the first parameter, it will be moved to
+# opts and “thing” will be the current action
+#
+#—
+# @public
+def render(thing = nil, opts = {})
+  <snip>
+end

data/docs/new_render_api

@@ -0,0 +1,51 @@
+## TEMPLATES
+
+# Render an action
+render :symbol
+
+# Render a string
+render "string"
+
+# Render an object; will call to_#{content-type} on this if the default template is not found
+display @obj
+
+# Provide an alternative default thing to render; note that we can use strings here for template paths
+# because strings would never fail and fallback to the @obj
+display @obj, :symbol
+display @obj, "full/path/to/template"
+
+# Render a template
+render_template "full/path/to/template"
+
+# Render with a mime-type (same as render, but with added mime-type set)
+render_json :symbol
+render_json "string"
+
+# Render nothing at all
+render_nothing
+
+# TEMPLATE OPTIONS (all functions above can use these options)
+
+# :format can be used to override the mime-type arrived at via content-negotiation
+render :symbol, :format => :xml
+
+# :status can set the status that will be returned to the browser
+render :symbol, :status => Successful::Accepted
+# or
+render :symbol, :status => 202
+
+# :layout sets the layout to use; default: controller.to_path || :application; :none means no layout
+render :symbol, :layout => :none
+
+## PARTIALS
+
+# Render a partial
+partial :symbol
+
+# Render a partial with an object (it will default to the local var "symbol" in the partial)
+partial :symbol, :with => @object
+partial :symbol, :with => @object, :as => "something"
+
+# Render a partial with a collection of objects (same :as semantics)
+partial :symbol, :with => [col, lec, tion]
+partial :symbol, :with => [col, lec, tion], :as => "name"