innate-2013.02.21/ 0000755 0000041 0000041 00000000000 12166103251 013405 5 ustar www-data www-data innate-2013.02.21/.travis.yml 0000644 0000041 0000041 00000000551 12166103251 015517 0 ustar www-data www-data script: 'RUBYOPT=-rubygems rake bacon'
before_script:
- test -s "$HOME/.rvm/scripts/rvm" && source "$HOME/.rvm/scripts/rvm"
- test -s .gems && rvm gemset import .gems
rvm:
- 1.8.7
- 1.9.2
- 1.9.3
- jruby-18mode
- jruby-19mode
- rbx-18mode
- rbx-19mode
- ruby-head
notifications:
email:
- mf@rubyists.com
branches:
only:
- master
innate-2013.02.21/tasks/ 0000755 0000041 0000041 00000000000 12166103251 014532 5 ustar www-data www-data innate-2013.02.21/tasks/authors.rake 0000644 0000041 0000041 00000002012 12166103251 017056 0 ustar www-data www-data # Once git has a fix for the glibc in handling .mailmap and another fix for
# allowing empty mail address to be mapped in .mailmap we won't have to handle
# them manually.
desc 'Update AUTHORS'
task :authors do
authors = Hash.new(0)
`git shortlog -nse`.scan(/(\d+)\s(.+)\s<(.*)>$/) do |count, name, email|
case name
when "ahoward"
name, email = "Ara T. Howard", "ara.t.howard@gmail.com"
when "Martin Hilbig blueonyx@dev-area.net"
name, email = "Martin Hilbig", "blueonyx@dev-area.net"
when "Michael Fellinger m.fellinger@gmail.com"
name, email = "Michael Fellinger", "m.fellinger@gmail.com"
end
authors[[name, email]] += count.to_i
end
File.open('AUTHORS', 'w+') do |io|
io.puts "Following persons have contributed to #{GEMSPEC.name}."
io.puts '(Sorted by number of submitted patches, then alphabetically)'
io.puts ''
authors.sort_by{|(n,e),c| [-c, n.downcase] }.each do |(name, email), count|
io.puts("%6d %s <%s>" % [count, name, email])
end
end
end
innate-2013.02.21/tasks/changelog.rake 0000644 0000041 0000041 00000001135 12166103251 017325 0 ustar www-data www-data desc 'update changelog'
task :changelog do
File.open('CHANGELOG', 'w+') do |changelog|
`git log -z --abbrev-commit`.split("\0").each do |commit|
next if commit =~ /^Merge: \d*/
ref, author, time, _, title, _, message = commit.split("\n", 7)
ref = ref[/commit ([0-9a-f]+)/, 1]
author = author[/Author: (.*)/, 1].strip
time = Time.parse(time[/Date: (.*)/, 1]).utc
title.strip!
changelog.puts "[#{ref} | #{time}] #{author}"
changelog.puts '', " * #{title}"
changelog.puts '', message.rstrip if message
changelog.puts
end
end
end
innate-2013.02.21/tasks/setup.rake 0000644 0000041 0000041 00000000427 12166103251 016541 0 ustar www-data www-data desc 'install dependencies from gemspec'
task :setup => [:gem_setup] do
GemSetup.new :verbose => false do
DEPENDENCIES.each do |name, options|
gem(name, options)
end
DEVELOPMENT_DEPENDENCIES.each do |name, options|
gem(name, options)
end
end
end
innate-2013.02.21/tasks/manifest.rake 0000644 0000041 0000041 00000000152 12166103251 017202 0 ustar www-data www-data desc 'update manifest'
task :manifest do
File.open('MANIFEST', 'w+'){|io| io.puts(*GEMSPEC.files) }
end
innate-2013.02.21/tasks/rcov.rake 0000644 0000041 0000041 00000001067 12166103251 016353 0 ustar www-data www-data desc 'code coverage'
task :rcov => :clean do
specs = Dir['spec/innate/**/*.rb']
specs -= Dir['spec/innate/cache/common.rb']
# we ignore adapter as this has extensive specs in rack already.
ignore = %w[ gem rack bacon innate/adapter\.rb ]
ignore << 'fiber\.rb' if RUBY_VERSION < '1.9'
ignored = ignore.join(',')
cmd = "rcov --aggregate coverage.data --sort coverage -t --%s -x '#{ignored}' %s"
while spec = specs.shift
puts '', "Gather coverage for #{spec} ..."
html = specs.empty? ? 'html' : 'no-html'
sh(cmd % [html, spec])
end
end
innate-2013.02.21/tasks/reversion.rake 0000644 0000041 0000041 00000000352 12166103251 017412 0 ustar www-data www-data desc "update version.rb"
task :reversion do
File.open("lib/#{GEMSPEC.name}/version.rb", 'w+') do |file|
file.puts("module #{PROJECT_MODULE}")
file.puts(' VERSION = %p' % GEMSPEC.version.to_s)
file.puts('end')
end
end
innate-2013.02.21/tasks/gem_setup.rake 0000644 0000041 0000041 00000005001 12166103251 017362 0 ustar www-data www-data task :gem_setup do
class GemSetup
def initialize(options = {}, &block)
@gems = []
@options = options.dup
@verbose = @options.delete(:verbose)
run(&block)
end
def run(&block)
return unless block_given?
instance_eval(&block)
setup
end
def gem(name, version = nil, options = {})
if version.respond_to?(:merge!)
options = version
else
options[:version] = version
end
@gems << [name, options]
end
# all gems defined, let's try to load/install them
def setup
require 'rubygems'
require 'rubygems/dependency_installer'
@gems.each do |name, options|
setup_gem(name, options)
end
end
def setup_gemspec(gemspec)
gemspec.dependencies.each do |dependency|
dependency.version_requirements.as_list.each do |version|
gem(dependency.name, version)
end
end
setup
end
# First try to activate.
# If activation fails, try to install and activate again.
# If the second activation also fails, try to require as it may just as
# well be in $LOAD_PATH.
def setup_gem(name, options)
version = [options[:version]].compact
lib_name = options[:lib] || name
log "activating #{name}"
Gem.activate(name, *version)
rescue Gem::LoadError
log "activating #{name} failed, try to install"
install_gem(name, version, options)
end
# tell rubygems to install a gem
def install_gem(name, version, options)
installer = Gem::DependencyInstaller.new(options)
temp_argv(options[:extconf]) do
log "installing #{name}"
installer.install(name, *version)
end
Gem.activate(name, *version)
log "install and final activation successful"
rescue Gem::GemNotFoundException => ex
log "installation failed: #{ex}, use normal require"
require(options[:lib] || name)
log "require successful, cannot verify version though"
end
# prepare ARGV for rubygems installer
def temp_argv(extconf)
if extconf ||= @options[:extconf]
old_argv = ARGV.clone
ARGV.replace(extconf.split(' '))
end
yield
ensure
ARGV.replace(old_argv) if extconf
end
private
def log(msg)
return unless @verbose
if defined?(Log)
Log.info(msg)
else
puts(msg)
end
end
def rubyforge; 'http://gems.rubyforge.org/' end
def github; 'http://gems.github.com/' end
end
end
innate-2013.02.21/tasks/ycov.rake 0000644 0000041 0000041 00000004523 12166103251 016362 0 ustar www-data www-data begin
require 'yard'
task 'Show Documentation coverage'
task :ycov => ['.yardoc'] do
YARD::Registry.load_yardoc
code_objects = YARD::Registry.paths.map{|path| YARD::Registry.at(path) }
code_objects.delete_if{|obj| obj.type == :root }
without_doc, with_doc = code_objects.partition{|obj| obj.docstring.empty? }
documented = with_doc.size
undocumented = without_doc.size
total = documented + undocumented
percentage = (documented / 0.01) / total
puts "Documentation coverage is %d/%d (%3.1f%%)" % [documented, total, percentage]
end
task 'ycov-full' => ['.yardoc'] do
require 'builder'
YARD::Registry.load_yardoc
code_objects = YARD::Registry.paths.map{|path| YARD::Registry.at(path) }
code_objects.delete_if{|obj| obj.type == :root }
without_doc, with_doc = code_objects.partition{|obj| obj.docstring.empty? }
list_objects = lambda{|body, list|
body.table(:width => '100%') do |table|
list.group_by{|obj| obj.type }.
sort_by{|k,v| k.to_s }.each do |type, objects|
table.tr do |tr|
tr.th(type.to_s, :colspan => 2)
end
objects.sort_by{|obj| obj.path }.each do |obj|
table.tr do |tr|
tr.td obj.path
tr.td "#{obj.file} +#{obj.line}"
end
end
end
end
}
File.open('ycov.html', 'w+') do |ycov|
builder = Builder::XmlMarkup.new(:target => ycov, :indent=>2)
builder.html do |html|
html.head do |head|
head.title 'YARD Coverage report'
end
html.body do |body|
body.h1 'YARD Coverage report'
body.h2 "#{without_doc.size} Undocumented objects"
list_objects[body, without_doc]
body.h2 "#{with_doc.size} Documented objects"
list_objects[body, with_doc]
end
end
end
end
file '.yardoc' => FileList['lib/**/*.rb'] do
files = ['lib/**/*.rb']
options = ['--no-output', '--private']
YARD::CLI::Yardoc.run(*(options + files))
end
desc 'Generate YARD documentation'
task :yardoc => ['.yardoc'] do
files = ['lib/**/*.rb']
options = [
'--output-dir', 'ydoc',
'--readme', PROJECT_README,
'--db', '.yardoc',
'--private']
YARD::CLI::Yardoc.run(*(options + files))
end
rescue LoadError
# you'll survive
end
innate-2013.02.21/tasks/grancher.rake 0000644 0000041 0000041 00000000332 12166103251 017165 0 ustar www-data www-data begin
require 'grancher/task'
Grancher::Task.new do |g|
g.branch = 'gh-pages'
g.push_to = 'origin'
g.message = 'Updated website'
g.directory 'ydoc', 'doc'
end
rescue LoadError
# oh well :)
end
innate-2013.02.21/tasks/release.rake 0000644 0000041 0000041 00000002211 12166103251 017012 0 ustar www-data www-data namespace :release do
task :prepare => [:reversion, :authors, :gemspec]
task :all => ['release:github', 'release:gemcutter']
desc 'Release on github'
task :github => :prepare do
name, version = GEMSPEC.name, GEMSPEC.version
sh('git', 'add',
'MANIFEST', 'CHANGELOG', 'AUTHORS',
"#{name}.gemspec",
"lib/#{name}/version.rb")
puts <<-INSTRUCTIONS
================================================================================
I added the relevant files, you can commit them, tag the commit, and push:
git commit -m 'Version #{version}'
git tag -a -m '#{version}' '#{version}'
git push
================================================================================
INSTRUCTIONS
end
desc 'Release on gemcutter'
task :gemcutter => ['release:prepare', :package] do
name, version = GEMSPEC.name, GEMSPEC.version
puts <<-INSTRUCTIONS
================================================================================
To publish to gemcutter do following:
gem push pkg/#{name}-#{version}.gem
================================================================================
INSTRUCTIONS
end
end
innate-2013.02.21/tasks/bacon.rake 0000644 0000041 0000041 00000003461 12166103251 016464 0 ustar www-data www-data require 'fileutils'
desc 'Run all bacon specs with pretty output'
task :bacon do
require 'open3'
require 'scanf'
require 'matrix'
specs = PROJECT_SPECS
some_failed = false
specs_size = specs.size
len = specs.map{|s| s.size }.sort.last
total_tests = total_assertions = total_failures = total_errors = 0
totals = Vector[0, 0, 0, 0]
red, yellow, green = "\e[31m%s\e[0m", "\e[33m%s\e[0m", "\e[32m%s\e[0m"
left_format = "%4d/%d: %-#{len + 11}s"
spec_format = "%d specifications (%d requirements), %d failures, %d errors"
specs.each_with_index do |spec, idx|
print(left_format % [idx + 1, specs_size, spec])
Open3.popen3(FileUtils::RUBY, '-w', spec) do |sin, sout, serr|
out = sout.read.strip
err = serr.read.strip
# this is conventional, see spec/innate/state/fiber.rb for usage
if out =~ /^Bacon::Error: (needed .*)/
puts(yellow % ("%6s %s" % ['', $1]))
else
total = nil
out.each_line do |line|
scanned = line.scanf(spec_format)
next unless scanned.size == 4
total = Vector[*scanned]
break
end
if total
totals += total
tests, assertions, failures, errors = total_array = total.to_a
if tests > 0 && failures + errors == 0
puts((green % "%6d passed") % tests)
else
some_failed = true
puts(red % " failed")
puts out unless out.empty?
puts err unless err.empty?
end
else
some_failed = true
puts(red % " failed")
puts out unless out.empty?
puts err unless err.empty?
end
end
end
end
total_color = some_failed ? red : green
puts(total_color % (spec_format % totals.to_a))
exit 1 if some_failed
end
innate-2013.02.21/tasks/gem.rake 0000644 0000041 0000041 00000000762 12166103251 016153 0 ustar www-data www-data task :gemspec => [:manifest, :changelog] do
gemspec_file = "#{GEMSPEC.name}.gemspec"
File.open(gemspec_file, 'w+'){|gs| gs.puts(GEMSPEC.to_ruby) }
end
desc "package and install from gemspec"
task :install => [:gemspec] do
sh "gem build #{GEMSPEC.name}.gemspec"
sh "gem install #{GEMSPEC.name}-#{GEMSPEC.version}.gem"
end
desc "uninstall the gem"
task :uninstall => [:clean] do
sh %{gem uninstall -x #{GEMSPEC.name}}
end
Gem::PackageTask.new(GEMSPEC) do |pkg|
pkg.need_tar = true
end
innate-2013.02.21/README.md 0000644 0000041 0000041 00000042523 12166103251 014672 0 ustar www-data www-data # Innate
Innate is the core of Ramaze, but useful on its own.
## Philosophy
The philosophy behind Innate is to provide a simple web framework that:
* Stays below 2000 easily readable lines of code
* Has Rack as the only dependency
* Provides the default helpers
* Is easy to encapsulate and reuse in other contexts as a simple rack app
* Has a rock-solid and fast implementation
* Scores at least 95% in rcov
* Is fully documented using YARD
## Innate vs. Ramaze
Numerous people asked where Innate fits into the picture of Ramaze and when it
would be appropriate to use Innate alone.
The answer to this is not as simple as I thought, given that Ramaze improves on
it a lot by taking full advantage of the encapsulation.
Innate started out as I grew increasingly annoyed by the many hacks and add-ons
that diluted the original simplicity of Ramaze as we discovered ways to do
things better, so I went on to create something that is impossible to dilute and
simply works as a multiplier.
It does work standalone, and it might be suitable for applications that just
need the little extra over plain old Rack, making it easy to deploy and rely on
the stability that comes with simple code.
It's also the starting point if you want to study the inner workings of Ramaze
without being distracted, all you need to keep in mind is Rack.
If all you need is a couple of ERB templates and a few nodes then Innate is the
way to go.
Upgrading to Ramaze later is quite easy, just change a couple of lines and the
power of your code multiplies (again).
The split between Innate and Ramaze is clear cut and gives Ramaze freedom to
expand in any direction (and I have quite some ideas where to take it).
Ramaze adds things that require other dependencies, caching with memcached or
sequel, logging with analogger or growl, templating with haml or erubis, just to
name a few.
Ramaze also adds Apps to the mix, and it is easier to understand them when the
concepts of what's going on inside an App are completely abstracted by Innate.
To summarize, Innate really keeps it simple, acts as a learning tool and
encourages everybody to build on top of it whatever they want.
## Features
* Powerful Helper system
* Nodes[1] simply include Innate::Node, so class inheritance is your choice.
* The only hard dependency is Rack
* Easy to get started
* Compatible with major Ruby implementations[2].
* Usage of Fiber[3] instead of Thread if possible.
* Namespaced serializable configuration system
* Simple testing without need of a running server
* No clutter in your application directory structure, scales from a single file
upwards
* Seamless integration with Rack middleware
* No patching of ruby core or stdlib.
* Direct access to the current Request, Response, and Session from anywhere via
Trinity
* Works out of the box with ERB the templating engine.
* Support for all rack-compatible web-servers.
* Dynamic content-representation.
[1]: What you may think of as Controller.
[2]: This includes: Ruby 1.8, Ruby 1.9.1, JRuby, Rubinius
[3]: Fiber is available on 1.9 only at this point.
## Usage
A simple example of using Innate that also shows you how to add your custom
middleware, write specs and the overall concept:
require 'innate'
Innate.setup_middleware
Innate.map('/') do |env|
Rack::Response.new(['Hello, World!']).finish
end
Innate::Mock.get('/')
And another example, using Node with a normal server:
require 'innate'
class Hi
include Innate::Node
map '/'
def index
"Hello, World!"
end
end
Innate.start :adapter => :mongrel
## Installation
### Via git (recommended)
Installing Innate from git is highly recommended, since it gives you easy
access to alternate branches, bugfixes, and new features.
git clone git://github.com/Ramaze/innate.git
Do not forget to add the innate/lib directory to your `RUBYLIB` environment
variable.
For unixish systems you may want to add it to `~/.bashrc` or the equivalent for
your shell:
export RUBYLIB="~/path/to/innate/lib:$RUBYLIB"
### Via gem install
gem install innate
### Direct download
Download the latest tarball from [here](http://github.com/Ramaze/innate/tarball/master).
## Concepts
First let's see about the good old MVC:
### Model
Innate doesn't have any ties to models, it does not offer helpers or rake tasks
or whatever you may be expecting, there is no M, use whatever you like.
Innate is, however, known to be compatible with the ORMs listed below:
* ActiveRecord
* DataMapper
* M4DBI
* Og
* Sequel
Please consider giving us a heads up about what worked for you if it isn't in
the list yet.
### View
Innate supports multiple templating engines and it is very easy to add your
own. At the moment we offer following engines out of the box:
* ERB
* Etanni
### Controller
Innate follows a different approach than most frameworks, making the controller
subclassing obsolete. To make an object accessible from the outside simply
include Innate::Node and map it to the location you would like to serve.
## Differences from Ramaze
Innate throws a lot overboard; it doesn't provide all the bells and whistles
that you may be used to. This makes Ramaze the way to go for larger
applications.
For this reason, Innate is not only a standalone framework, it is also the core
of Ramaze.
Ramaze started out without any of the benefits that Rack gives us these days,
especially regarding the server handlers, request/response, and middleware.
Still it tried to provide everything one might need with the least effort,
leading to a lot dependencies (we had things like bacon, simple_http, gettext,
mime types, ...)
### Configuration
Innate provides the Innate::Options DSL, similar in some aspects to the old
Ramaze::Global, but a lot more flexible.
Options has namespaces, inheritance, defaults, triggers, documentation, and a
sane name.
The definition syntax roughly resembles Ramaze::Global.
We break with the tradition where all options one would ever need were provided
in one file. It made maintenance rather difficult and the code hard to follow.
So the new approach is to put options where they belong, alongside the class or
module they are used in.
There are some things still in Innate.options, but they have large impact on the
whole system.
Options doesn't do things like merging env variables or parsing ARGV, these are
things that Ramaze adds.
What makes Options especially useful is that you can use it in your own
application to configure it without using diverse routes like putting config
into counter-intuitive yaml files, using global variables, or relying on yet
another dependency.
A small example:
module Blog
include Innate::Optioned
options.dsl do
o "Title of the blog", :title, "My Blog"
o "Syntax highlighting engine for blog posts", :syntax, :coderay
end
class Articles
Innate.node '/'
def index
"Welcome to #{Blog.options.title}"
end
end
end
### Controller
Away with controllers, long live the Node.
Nodes are objects that include Innate::Node and are then considered rack
applications that get automatically hooked into the routing.
Since every existing Ramaze application relies on Ramaze::Controller and normal
subclassing is not without merits as well we keep that part entirely in Ramaze,
Controller simply includes Innate::Node and makes it suitable for the usage
within Apps.
#### Layouts
Since layouts were an afterthought in Ramaze, they were made normal actions
like every other on the respective controllers, leading to lots of confusion
over the correct way to use layouts, the Controller::layout syntax in respect
to the real location of layouts, how to exclude/include single actions, where
layouts should be stored, how to prevent lookup from external requests, ...
I made layouts just as important as views and methods for the Action in Innate,
and they have their own root directory to live in and will not be considered as
a normal view template, so they cannot be accidentally be rendered as their own
actions.
This strikes me as important, because I consider layouts to be superior to
Ezamar elements and equal to render_partial or render_template, just about
every application uses them, so they should be handled in the best way possible.
The root directory for layouts is in line with the other default locations:
proto
|-- layout
|-- model
|-- node
|-- public
`-- view
While none of these directories is necessary, they are the default locations and
should be included in a new proto for Ramaze (except that ramaze uses
`/controller` instead of `/node`.
Innate will not have project generating capabilities, so we just have to
document it very well and provide some example apps.
#### Provides
This is a major new feature stolen from Merb and adapted for the ease of use of
Innate/Ramaze.
It won't have all the capabilities one might be used to out of the box, but
extending them is easy.
Having "provides" means that every Action has different ways of being rendered,
depending on so-called wishes, that's what people usually call
content-representation.
A wish may be anything related to the request object, and by default it will
trigger on the filename extension asked for.
This enables you to create a single action that can be rendered in
json/rss/atom/yaml/xml/xhtml/html/wap or different languages...
The dispatching in Node depends on the filename extension by default, but more
decision paths can be added to Action by overriding some defaults.
Layouts map to wishes just like views, so every content representation can have
a suitable layout as well.
This is very alien to old Ramaze, which always has a 1:1 mapping between actions
and their views and how they are rendered, which made people wonder how to serve
sass as css or how to respond with json for a AJAX request until they finally
were pointed to setting content-type, using respond and setting up custom
routes.
I hope this feature makes things simpler for people who care about it while it
can be ignored by people who don't.
### More specifics
Here I try to list the most important things that Ramaze will offer but that
are not included in Innate itself in terms of globs:
* cache.rb and cache/*.rb
* current/response.rb
* tool/{create,mime,localize,daemonize,record,project_creator}.rb
* spec/helper/*.rb
* snippets/**/*.rb
* gestalt.rb
* store/default.rb
* contrib.rb or any contribs
* adapter/*.rb (superseded by a lightweight adapter.rb)
* template/ezamar*/*
* bacon.rb
* dispatcher.rb
* dispatcher/*.rb
There might be a couple of things I've forgotten, but that's what a quick
glance tells me.
Let's go through them one by one and consider what's gonna happen to them:
### Cache
Caching is a very important concern and one of the most difficult things to get
right for any web application.
Innate defines the caching API that enables everybody to add caches with very
little code.
Innate provides caching by the following means:
* DRb
* Hash
* Marshal
* YAML
Ramaze adds:
* Memcached
* Sequel
And as time goes on there will be many more.
### Response
Very little code, it just provides some options regarding default headers and easy
ways to reset the response.
Ramaze adds some more convenient methods.
### Tools
Innate doesn't provide any of the stuff in ramaze/tool and it was removed from
Ramaze as well, some of the reasoning is below.
#### Tool::Create
This has been used by `bin/ramaze --create`, bougyman is working on a new
`bin/ramaze` which won't use it, so we removed it.
#### Tool::ProjectCreator
Dependency for Tool::Create, removed as well.
##### Tool::Daemonize
Nothing but issues with this one although it is just a very thin wrapper for
the daemons gem. Nobody has contributed to this so far despite the issues and
it seems that there are a lot of different solutions for this problem.
This was removed from Ramaze and Innate. You may use the daemonize functionality
from rackup.
##### Ramaze::Record
Well, this might be the most obvious candidate for removal, maybe it can be
revived as middleware. The functionality itself was in the adapter and even
that's only a few lines. But so far I have never seen any usage of it.
##### Tool::Localize
Despite being quite popular it has many issues and is totally unusable if you
don't have full knowledge about what is going to be served.
I and a lot of other people have used this over time and it has proven itself
to be a very easy and straightforward way of doing localization.
It think it is better suited as middleware which can be included into
rack-contrib and doesn't rely on the normal session but a simple unobfuscated
cookie.
Innate does not attempt to do anything related to localization. Ramaze builds
localization on top of Helper::Localize which does a much better job.
##### Tool::MIME
This one was removed, Rack::Mime is the way to go.
### Spec helpers
Over the years, Ramaze has collected a wide variety of spec helpers that are
not really compatible with each other and rely on real request/response with a
running server.
Innate provides a better alternative via Innate::Mock for specs, the output
formatting is done in a rake task.
There is some work in progress to integrate Innate and Ramaze with the rack-test
library which will allow us to run specs with webrat (which is able to run using
selenium and possibly watir in a DRY way).
Rack-test will provide us also with xpath checks, multipart requests, digest
authorization, etc.
### Snippets
Innate abandons the snippets, keeping your core clean.
Ramaze has still a lot of these snippets and will continue to, although I will
constantly strive to reduce them slowly.
### Gestalt
Gestalt has been the first "templating engine" for Ramaze and is still used in
some fractions of the code and various applications. There are a lot of other
html/xml builders out there these days so I think this is no good choice for
inclusion into Innate. I will keep it inside Ramaze.
### Ramaze::Store::Default
This has been removed from Innate and Ramaze.
It started out as a simple wrapper for YAML::Store to make the tutorial easier,
but I think it gives a wrong impression of being anything else.
It's very slow, might raise exceptions under heavy load and a plain YAML::Store
or PStore or any other persistence mechanism is generally a better choice, so
there is no need to keep this around.
### Contrib
Ramaze has some things in contrib, some of them used widely, others not at
all.
I'm still going through these, putting what is suitable for a wider audience
into rack-contrib, including what fits into the Ramaze concept into Ramaze, but
none of these will find its way into Innate.
One exception, the file cache has been added to Innate already and the sequel
cache is in Ramaze proper.
The gzip filter has a more powerful and better maintained equivalent in
Rack::Deflater.
The profiling hook is obsolete as well, there is an equivalent in rack-contrib.
The emailer is really light-weight and but lacks support for many things you
will need, I'm working on a new Helper::Email that integrates with Mailit (a
fork of MailFactory).
Things I'll not touch for now are `facebook` and `gettext`.
The sequel related stuff will have to be removed and might find a place
somewhere else, (somebody start a sequel-contrib already!).
The `gems` was refactored and put into `ramaze/setup.rb`, where it provides you
with painless first-start experience.
### Adapters
These are entirely the responsibility of Rack/Innate now, Ramaze doesn't need to
worry about that. WEBrick will remain the default adapter since it is in the
Ruby stdlib.
### Templating
The basic functionality for templating is provided by Innate, it only provides the
`None`, `Etanni` and `ERB` templating engines. The other engines are in Ramaze.
#### Ezamar
`Ezamar` has become a standalone project. It has been stable since a long time and
is suitable for other uses.
The battle for the place of the default templating engine in Ramaze is still
going on, competitors are `ERB`, `Ezamar`, and `Nagoro`.
### Bacon
Bacon is still a dependency for specs, but we don't ship it anymore, the stable
release includes all features we need.
### Dispatcher
Innate uses a stripped down version of the Ramaze dispatcher. The Ramaze
dispatcher was strongly influenced by Nitro, but proved to be a difficult
part. We are now using Rack's URLMap directly, and have a minimal dispatching
mechanism directly in Node (like we used to have one in Controller).
A lot of the functionality that used to be in the different dispatchers is now
provided by Rack middleware.
The Dispatcher itself isn't needed anymore. It used to setup
Request/Response/Session, which was superseded by Current, this again is now
superseded by STATE::wrap.
We are going to remove all the other dispatchers as well, providing default
ways to provide the same functionality, and various middleware to use.
#### Dispatcher::Action
This dispatcher was used to initiate the controller dispatching, this is now
not needed anymore.
#### Dispatcher::Directory
This will also be removed. There is a directory listing middleware already.
#### Dispatcher::Error
There's middleware for this as well, and a canonical way of routing errors to
other actions. This used to be one of the most difficult parts of Ramaze and
it was removed to make things simpler.
#### Dispatcher::File
This is a combination of the `ETag` and `ConditionalGet` middlewares, ergo Innate
and Ramaze will not serve static files themselves anymore, but leave the job to
Rack or external servers.
innate-2013.02.21/example/ 0000755 0000041 0000041 00000000000 12166103251 015040 5 ustar www-data www-data innate-2013.02.21/example/session.rb 0000644 0000041 0000041 00000001037 12166103251 017051 0 ustar www-data www-data require 'innate'
class Hello
Innate.node '/'
TEMPLATE = '
Session example
Session example
Value is: #{ session[:value] }
#{ a :increment }
#{ a :decrement }
'.strip
def index
session[:value] = 0
TEMPLATE
end
def increment
session[:value] = session[:value].to_i + 1
TEMPLATE
end
def decrement
session[:value] = session[:value].to_i - 1
TEMPLATE
end
end
Innate.start
innate-2013.02.21/example/app/ 0000755 0000041 0000041 00000000000 12166103251 015620 5 ustar www-data www-data innate-2013.02.21/example/app/todo/ 0000755 0000041 0000041 00000000000 12166103251 016565 5 ustar www-data www-data innate-2013.02.21/example/app/todo/spec/ 0000755 0000041 0000041 00000000000 12166103251 017517 5 ustar www-data www-data innate-2013.02.21/example/app/todo/spec/todo.rb 0000644 0000041 0000041 00000003517 12166103251 021017 0 ustar www-data www-data require 'innate/spec'
FileUtils.rm_f('todo.pstore')
require 'start'
require 'hpricot'
describe Todo do
behaves_like :mock, :multipart
it 'starts out without tasks' do
doc = Hpricot(get('/').body)
doc.at(:table).inner_text.strip.should.be.empty
end
it 'adds a task and redirects back' do
got = post('/create', multipart('title' => 'first task'))
got.status.should == 302
got['Location'].should == 'http://example.org/'
end
it 'shows the task as pending' do
doc = Hpricot(get('/').body)
doc.at('td/input[@name=title]')['value'].should == 'first task'
doc.at('td/input[@name=done]')['checked'].should.be.nil
end
it 'updates the task title and redirects back' do
got = post('/update', multipart('id' => 'first task', 'title' => 'wash dishes'))
got.status.should == 302
got['Location'].should == 'http://example.org/'
end
it 'shows the changed task title' do
doc = Hpricot(get('/').body)
doc.at('td/input[@name=title]')['value'].should == 'wash dishes'
doc.at('td/input[@name=done]')['checked'].should.be.nil
end
it 'marks the task as done and redirects back' do
mp = multipart('id' => 'wash dishes', 'title' => 'wash dishes', 'done' => 'on')
got = post('/update', mp)
got.status.should == 302
got['Location'].should == 'http://example.org/'
end
it 'shows the task as done' do
doc = Hpricot(get('/').body)
doc.at('td/input[@name=title]')['value'].should == 'wash dishes'
doc.at('td/input[@name=done]')['checked'].should == 'checked'
end
it 'deletes the task and redirects back' do
got = post('/delete', multipart('id' => 'wash dishes'))
got.status.should == 302
got['Location'].should == 'http://example.org/'
end
it 'shows no tasks' do
doc = Hpricot(get('/').body)
doc.at(:table).inner_text.strip.should.be.empty
end
end
innate-2013.02.21/example/app/todo/start.rb 0000644 0000041 0000041 00000001663 12166103251 020255 0 ustar www-data www-data require 'rubygems'
require 'innate'
require 'pstore'
LIST = PStore.new('todo.pstore')
class Todo
Innate.node '/'
layout 'default'
def index
@list = sync{|list| list.roots.map{|key| [key, list[key]] }}
end
def create
redirect_referer unless request.post? and title = request[:title]
title.strip!
sync{ LIST[title] = false } unless title.empty?
redirect_referer
end
def update
id, title, done = request[:id, :title, :done]
redirect_referer unless request.post? and id and title
done = !!done
title.strip!
if id == title
sync{ LIST[id] = done }
elsif title != ''
sync{ LIST.delete(id); LIST[title] = done }
end
redirect_referer
end
def delete
redirect_referer unless request.post? and id = request[:id]
sync{ LIST.delete(id) }
redirect_referer
end
private
def sync
Innate.sync{ LIST.transaction{ yield(LIST) }}
end
end
Innate.start
innate-2013.02.21/example/app/todo/view/ 0000755 0000041 0000041 00000000000 12166103251 017537 5 ustar www-data www-data innate-2013.02.21/example/app/todo/view/index.xhtml 0000644 0000041 0000041 00000002045 12166103251 021725 0 ustar www-data www-data
innate-2013.02.21/example/app/todo/layout/ 0000755 0000041 0000041 00000000000 12166103251 020102 5 ustar www-data www-data innate-2013.02.21/example/app/todo/layout/default.xhtml 0000644 0000041 0000041 00000000475 12166103251 022612 0 ustar www-data www-data
Innate TodoList
Organize your life and learn Innate
#{ @content }
innate-2013.02.21/example/app/retro_games.rb 0000644 0000041 0000041 00000002255 12166103251 020460 0 ustar www-data www-data require 'innate'
require 'yaml/store'
STORE = YAML::Store.new('games.yaml')
def STORE.[](key) transaction{|s| super } end
def STORE.[]=(key, value) transaction{|s| super } end
def STORE.each(&block)
YAML.load_file('games.yaml').sort_by{|k,v| -v }.each(&block)
end
STORE['Pacman'] = 1
class Games
Innate.node('/')
def index
TEMPLATE
end
def create
STORE[request[:name]] ||= 0 if request.post?
redirect_referrer
end
def vote(name)
STORE[name] += 1
redirect_referrer
end
TEMPLATE = <<-'T'.strip
Top Retro Games
Vote on your favorite Retro Game
-
#{ a("Vote", r(:vote, u(name))) }
#{ h "%5d => %s" % [votes, name] }
T
end
Innate.start
innate-2013.02.21/example/app/whywiki_erb/ 0000755 0000041 0000041 00000000000 12166103251 020143 5 ustar www-data www-data innate-2013.02.21/example/app/whywiki_erb/spec/ 0000755 0000041 0000041 00000000000 12166103251 021075 5 ustar www-data www-data innate-2013.02.21/example/app/whywiki_erb/spec/wiki.rb 0000644 0000041 0000041 00000000553 12166103251 022370 0 ustar www-data www-data require 'innate'
require 'innate/spec'
require 'yaml/store'
base = File.join(File.dirname(__FILE__), '..')
DB = YAML::Store.new(db_file = "#{base}/spec/wiki.yaml")
require "start"
Innate.config.app.root = base
describe 'Wiki' do
it 'should have index page' do
page = Innate::Mock.get('/')
page.body.should == ''
end
FileUtils.rm_f(db_file)
end
innate-2013.02.21/example/app/whywiki_erb/start.rb 0000644 0000041 0000041 00000001436 12166103251 021631 0 ustar www-data www-data # The minimal _why wiki in Innate with ERB
%w[rubygems innate erb maruku yaml/store].each{|l| require(l) }
DB = YAML::Store.new('wiki.yaml') unless defined?(DB)
class Wiki
Innate.node '/'
layout 'wiki'
provide :html, :engine => :ERB
def index(page = 'Home')
@page = page
@text = 'foo'
sync{
@text = DB[page].to_s.dup
@text.gsub!(/\[\[(.*?)\]\]/) do
%(#{h($1)})
end
}
end
def edit(page)
@page = page
@text = sync{ DB[page].to_s }
end
def save
page, text = request[:page, :text]
sync{ DB[page] = text } if request.post? and page and text
redirect(r(page))
end
private
def sync
Innate.sync{ DB.transaction{ yield }}
end
end
Innate.start
innate-2013.02.21/example/app/whywiki_erb/view/ 0000755 0000041 0000041 00000000000 12166103251 021115 5 ustar www-data www-data innate-2013.02.21/example/app/whywiki_erb/view/edit.erb 0000644 0000041 0000041 00000000345 12166103251 022536 0 ustar www-data www-data <%= a("< #@page", @page) %>
innate-2013.02.21/example/app/whywiki_erb/view/index.erb 0000644 0000041 0000041 00000000375 12166103251 022723 0 ustar www-data www-data <% unless @page == 'Home' %>
<%= a('< Home', :Home) %>
<% end %>
<%= h @page %>
<% if @text.empty? %>
<%= a("Create #@page", :edit, @page) %>
<% else %>
<%= a("Edit #@page", :edit, @page) %>
<%= Maruku.new(@text).to_html %>
<% end %>
innate-2013.02.21/example/app/whywiki_erb/layout/ 0000755 0000041 0000041 00000000000 12166103251 021460 5 ustar www-data www-data innate-2013.02.21/example/app/whywiki_erb/layout/wiki.html.erb 0000644 0000041 0000041 00000000653 12166103251 024064 0 ustar www-data www-data
MicroWiki <%= h @page %>
<%= @content %>
innate-2013.02.21/example/howto_spec.rb 0000644 0000041 0000041 00000001162 12166103251 017537 0 ustar www-data www-data require 'rubygems'
require 'innate'
class SpecMe
Innate.node '/'
def index
"I should be at /"
end
def foo
response['Content-Type'] = 'text/css'
"I should be at /foo"
end
end
require 'innate/spec'
describe 'An example spec' do
behaves_like :mock
should 'respond to /' do
got = get('/')
got.status.should == 200
got.body.should == "I should be at /"
got['Content-Type'].should == 'text/html'
end
should 'respond to /foo' do
got = get('/foo')
got.status.should == 200
got.body.should == "I should be at /foo"
got['Content-Type'].should == 'text/css'
end
end
innate-2013.02.21/example/custom_middleware.rb 0000644 0000041 0000041 00000001267 12166103251 021102 0 ustar www-data www-data require 'rubygems'
require File.expand_path('../../lib/innate', __FILE__)
class Demo
Innate.node '/'
def index
'Hello, World!'
end
def empty
response.status = 405
''
end
end
Innate.options.mode = :dev
Innate.middleware(:dev) do
# Makes sure all requests and responses conform to Rack protocol
use Rack::Lint
# Avoid showing empty failure pages, give information when it happens.
use Rack::ShowStatus
# Catch exceptions inside Innate and give nice status info
use Rack::ShowExceptions
# Log access
use Rack::CommonLogger
# Reload modified files before request
use Rack::Reloader
# Start up the application
run Innate.core
end
Innate.start
innate-2013.02.21/example/hello.rb 0000644 0000041 0000041 00000000151 12166103251 016465 0 ustar www-data www-data require 'innate'
class Hello
Innate.node '/'
def index
'Hello, World!'
end
end
Innate.start
innate-2013.02.21/example/link.rb 0000644 0000041 0000041 00000000617 12166103251 016326 0 ustar www-data www-data require 'innate'
class Linking
Innate.node '/'
def index
"Index links to " + a('Help?', :help)
end
def help
"Help links to " + Different.a('A Different Node', :another)
end
end
class Different
Innate.node '/link_to'
def another
a('Another links even deeper', 'and/deeper')
end
def and__deeper
Linking.a('Back to Linking Node', :index)
end
end
Innate.start
innate-2013.02.21/example/provides.rb 0000644 0000041 0000041 00000001402 12166103251 017215 0 ustar www-data www-data require 'rubygems'
require 'innate'
require 'yaml'
ARTICLES = {
'hello' => {
:author => 'manveru',
:title => 'Hello, World!',
:text => 'Some text'
}
}
class BlogArticles
Innate.node('/')
# provide a content representation for requests to /.yaml
# If you request `/list.yaml`, you will get the `ARTICLES object serialized
# to YAML.
provide(:yaml, :type => 'text/yaml'){|action, value| value.to_yaml }
# Since there will always be an `html` representation (the default), you have
# to take care of it. If you simply want to return an empty page, use following.
provide(:html){|action, value| '' }
# The return value of this method is the `value` in the provides above.
def list
return ARTICLES
end
end
Innate.start
innate-2013.02.21/Rakefile 0000644 0000041 0000041 00000002567 12166103251 015064 0 ustar www-data www-data require 'rake/clean'
require 'rubygems/package_task'
require 'time'
require 'date'
PROJECT_SPECS = FileList['spec/{innate,example}/**/*.rb'].exclude('spec/innate/cache/common.rb')
PROJECT_MODULE = 'Innate'
PROJECT_README = 'README.md'
PROJECT_VERSION = (ENV['VERSION'] || Date.today.strftime('%Y.%m.%d')).dup
DEPENDENCIES = {
'rack' => {:version => '~> 1.5.2'},
}
DEVELOPMENT_DEPENDENCIES = {
'bacon' => {:version => '~> 1.2.0'},
'rack-test' => {:version => '~> 0.6.2', :lib => 'rack/test'}
}
GEMSPEC = Gem::Specification.new{|s|
s.name = 'innate'
s.author = "Michael 'manveru' Fellinger"
s.summary = "Powerful web-framework wrapper for Rack."
s.description = "Simple, straight-forward base for web-frameworks."
s.email = 'm.fellinger@gmail.com'
s.homepage = 'http://github.com/manveru/innate'
s.platform = Gem::Platform::RUBY
s.version = PROJECT_VERSION
s.files = `git ls-files`.split("\n").sort
s.has_rdoc = true
s.require_path = 'lib'
s.rubyforge_project = "innate"
s.required_rubygems_version = '>= 1.3.1'
}
DEPENDENCIES.each do |name, options|
GEMSPEC.add_dependency(name, options[:version])
end
DEVELOPMENT_DEPENDENCIES.each do |name, options|
GEMSPEC.add_development_dependency(name, options[:version])
end
Dir['tasks/*.rake'].each{|f| import(f) }
task :default => [:bacon]
CLEAN.include('')
innate-2013.02.21/spec/ 0000755 0000041 0000041 00000000000 12166103251 014337 5 ustar www-data www-data innate-2013.02.21/spec/example/ 0000755 0000041 0000041 00000000000 12166103251 015772 5 ustar www-data www-data innate-2013.02.21/spec/example/session.rb 0000644 0000041 0000041 00000001170 12166103251 020001 0 ustar www-data www-data require File.expand_path('../../helper', __FILE__)
require File.expand_path('../../../example/session', __FILE__)
describe 'example/session' do
behaves_like :rack_test
it 'starts at 0' do
get('/').body.should =~ /Value is: 0/
end
it 'increments the counter' do
get('/increment').body.should =~ /Value is: 1/
get('/increment').body.should =~ /Value is: 2/
get('/increment').body.should =~ /Value is: 3/
end
it 'decrements the counter' do
get('/decrement').body.should =~ /Value is: 2/
get('/decrement').body.should =~ /Value is: 1/
get('/decrement').body.should =~ /Value is: 0/
end
end
innate-2013.02.21/spec/example/app/ 0000755 0000041 0000041 00000000000 12166103251 016552 5 ustar www-data www-data innate-2013.02.21/spec/example/app/retro_games.rb 0000644 0000041 0000041 00000001427 12166103251 021412 0 ustar www-data www-data require File.expand_path('../../../helper', __FILE__)
require File.expand_path('../../../../example/app/retro_games', __FILE__)
describe 'Retro-games app' do
behaves_like :rack_test
it 'lists the first game' do
get '/'
last_response.should =~ /1 => Pacman/
end
it 'has a form to add another game' do
get '/'
last_response.should =~ /