renee 0.3.11 → 0.4.0.pre1

data/Rakefile

@@ -1,13 +1,113 @@
 require 'rake/testtask'
-require 'yard'
 
-Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
-  t.verbose = true
+ROOT = File.expand_path(File.dirname(__FILE__))
+
+task :default => :test
+
+def lsh(cmd, &block)
+  out, code = lsh_with_code(cmd, &block)
+  code == 0 ? out : raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
+end
+
+def lsh_with_code(cmd, &block)
+  cmd << " 2>&1"
+  outbuf = ''
+  outbuf = `#{cmd}`
+  if $? == 0
+    block.call(outbuf) if block
+  end
+  [outbuf, $?]
+end
+
+renee_gems = %w[
+  renee-core
+  renee-render
+  renee-url-generation
+  renee-session
+  renee
+].freeze
+
+desc "build #{renee_gems.join(', ')} gems"
+task :build do
+  renee_gems.each do |g|
+    lsh "mkdir -p pkg && gem build #{g}.gemspec && mv *.gem pkg"
+    puts "#{g} built"
+  end
+end
+
+task :release => [:build, :yard] do
+  require File.join(ROOT, 'lib', 'renee', 'version')
+  version_tag = "v#{Renee::VERSION}"
+  begin
+    raise("#{version_tag} has already been committed") if lsh('git tag').split(/\n/).include?(version_tag)
+    sh "git tag #{version_tag}"
+    puts "adding tag #{version_tag}"
+    renee_gems.each do |g|
+      sh "gem push pkg/#{g}-#{Renee::VERSION}.gem"
+      puts "#{g} pushed"
+    end
+    sh "git push"
+    sh "git push --tags"
+  rescue
+    puts "something went wrong"
+    sh "git tag -d #{version_tag}"
+    raise
+  end
+end
+
+task :install => :build do
+  require File.join(ROOT, 'lib', 'renee', 'version')
+  renee_gems.each do |g|
+    lsh "gem install pkg/#{g}-#{Renee::VERSION}.gem"
+    puts "#{g} installed"
+  end
+end
+
+task :bundle do
+  renee_gems.each do |g|
+    sh "env BUNDLE_GEMFILE=Gemfile-#{g} bundle"
+  end
+end
+
+renee_gems_tasks = Hash[renee_gems.map{|rg| [rg, :"test_#{rg.gsub('-', '_')}"]}].freeze
+
+desc "Run tests for all renee stack gems"
+task :test do
+  renee_gems_tasks.values.each do |task|
+    Rake::Task[task].invoke
+  end
 end
 
-desc "Generate documentation for the Padrino framework"
-task :doc do
-  YARD::CLI::Yardoc.new.run
-end
+renee_gems_tasks.each do |g, tn|
+  desc "Run tests for #{g} (shell out)"
+  task tn do
+    sh "env BUNDLE_GEMFILE=Gemfile-#{g} bundle exec rake test-#{g}"
+  end
+
+  Rake::TestTask.new("test-#{g}") do |t|
+    t.libs.push "lib"
+    t.test_files = FileList[File.expand_path("../test/#{g}/**/*_test.rb", __FILE__)]
+    t.verbose = true
+  end
+end
+
+desc "Generate YARD documentation"
+task :'yard' do
+  require 'yard'
+  Dir['*.gemspec'].to_a.each do |gemspec|
+    spec = Gem::Specification.load(gemspec)
+    puts "spec #{spec.inspect}"
+    task_name = :"yard:#{spec.name}"
+    rb_files = spec.files.select{|f| f[/^lib/]}
+    readme = spec.name == 'renee' ? "README.md" : "README-#{spec.name}.md"
+    pid = fork do # yard has some shared state somewhere. poor poor yard.
+      YARD::Rake::YardocTask.new(task_name) do |t|
+        t.options = ['-o', File.expand_path("../site/public/docs/#{spec.name}", __FILE__), '--readme', readme, '--no-private', '--markup', 'markdown']
+        t.files   = rb_files
+      end
+      Rake::Task[task_name].execute
+    end
+    _, status = Process.waitpid2(pid)
+    raise unless status.success?
+  end
+end

data/TODO.txt

@@ -0,0 +1,45 @@
+[ ] accept handling
+[ ] content-type / mime-type handling, registration
+[ ] serving static files from a public folder?
+[ ] exception handling in requests? handling not founds gracefully in dev?
+[ ] integration with models
+[ ] how do helpers work? how do extensions work?
+[ ] caching helpers
+[ ] auth helpers
+[ ] support for better stacktraces (i.e showexceptions)
+[ ] default registered middlewares? (method::override or rack::head or sessions)
+[ ] configurable forced encodings to default things to utf-8?
+[ ] request logger (sql, rendering, etc)
+[ ] context passing between multiple renee's, clearly, env is a big part of this.
+[ ] the marketing site for this whole thing
+[ ] more examples
+[ ] through documentation
+[ ] sinatra-like streaming API?
+
+Helpers and functionality in sinatra, worth discussing if we should include similar:
+
+ * Helper for accessing the session?
+   - session
+     * What does rack::session give you? is it any good?
+
+ * Helper for setting content type
+   - content_type :json
+     * this is equiv to headers(:content_type =>  ... ), see above
+     ** kind of except this is mime-type intelligent
+
+ * Send a file as a response
+   send_file "some/file.txt"
+   yes!
+
+ * Support for cache_control, expires, last_modified, etag
+   cache_control :public, :must_revalidate, :max_age => 60
+   expires 500, :public, :must_revalidate
+   etag(value, options = {})
+   last_modified(time)
+   see above!
+
+
+ * mime-type provides?
+ yes!
+ * user_agent filtering helpers?
+ yes !

data/config.ru

@@ -0,0 +1,26 @@
+require 'renee'
+require 'haml'
+require 'rdiscount'
+require 'rack/codehighlighter'
+require 'rack/google-analytics'
+require 'coderay'
+
+views = Dir[File.expand_path('../site/views/*.md', __FILE__)].map { |f| f[/\/([^\/]+)\.md/, 1] }
+
+run Renee {
+  path('concept') { redirect! '/' }
+  views.each { |view|
+    path = view == 'index' ? '' : view
+    path("/#{path}").get {
+      title = (view == 'index') ? '' : " — #{view.split('-').join(' ')}"
+      render! view, :locals => {:title_part => title }
+    }
+  }
+}.setup {
+  use Rack::Static, :urls => ['/css', '/img', '/doc'], :root => 'site/public'
+  use Rack::Codehighlighter, :coderay, :element => "pre>code", :pattern => /\A:::(\w+)\s*\n/
+  use Rack::GoogleAnalytics, :tracker => 'UA-26317661-1'
+
+  views_path File.expand_path('../site/views', __FILE__)
+  default_layout 'layouts/app'
+}

data/examples/blog/blog.rb

@@ -7,7 +7,9 @@ class Blog
   end
 
   def new_post(title, contents)
-    @posts << Post.new(self, @post_id += 1, title, contents)
+    post = Post.new(self, @post_id += 1, title, contents)
+    @posts << post
+    post
   end
 
   def find_post(id)

data/examples/blog/config.ru

@@ -13,28 +13,33 @@ run Renee {
   var :integer do |id|
     @post = @blog.find_post(id)
     halt 404 unless @post
-    path('edit') { render! 'edit' }
-
-    get { render! 'show' }
-    delete { @post.delete!; halt :ok }
-    put {
-      @post.title = request['title'] if request['title']
+    path('edit').get.render! 'edit' # show editor
+    get.render! 'show'              # show post
+    delete do
+      @post.delete!
+      redirect! "/"
+    end
+    put do
+      @post.title = request['title']       if request['title']
       @post.contents = request['contents'] if request['contents']
-      halt :ok
-    }
+      redirect! "/#{@post.id}"
+    end
   end
 
-  post {
-    if request['title'] && request['contents']
-      @blog.new_post(request['title'], request['contents'])
-      halt :created
-    else
-      halt :bad_request
-    end
-  }
+  post do
+    halt :bad_request, "No title specified"    unless request['title']
+    halt :bad_request, "No contents specified" unless request['contents']
+    post = @blog.new_post(request['title'], request['contents'])
+    redirect! "/#{post.id}"
+  end
 
-  extension('json') { get { halt @blog.posts.map{ |p| {:contents => p.contents} }.to_json } }
-  no_extension      { get { render! 'index' } }
+  get do
+    case extension
+    when 'json' then halt @blog.posts.map { |p| {:contents => p.contents} }.to_json
+    else             render! 'index'
+    end
+  end
 }.setup {
+  use Rack::MethodOverride
   views_path File.expand_path(File.dirname(__FILE__) + "/views")
-}
+}

data/examples/blog/views/edit.erb

@@ -1 +1,10 @@
-Editing <%= @post.title %>
+Editing <%= @post.title %>
+
+<form action="/<%= @post.id%>" method="post">
+  <input type="hidden" name="_method" value="put" />
+
+  Title
+  <input name=title value="<%= @post.title %>"><br/>
+  <textarea name=contents><%= @post.contents %></textarea><br/>
+  <input type=submit>
+</form>

data/examples/blog/views/show.erb

@@ -2,4 +2,9 @@
 
 <p><%= @post.contents %></p>
 
+<a href="/<%= @post.id %>/edit">Edit</a>
+<form method="post" action="/<%= @post.id %>">
+  <input type="hidden" name="_method" value="delete" />
+  <input data-confirm='Are you sure?' value="Delete" type="submit" />
+</form>
 <a href="/">See all posts</a>

data/lib/renee.rb

@@ -1,5 +1,8 @@
-require 'renee_core'
-require 'renee_render'
+require 'renee/version'
+require 'renee/core'
+require 'renee/render'
+require 'renee/session'
+require 'renee/url_generation'
 
 # Method for creating new Renee applications.
 # @see http://reneerb.com
@@ -8,7 +11,9 @@ require 'renee_render'
 #       halt "hello renee"
 #     }
 def Renee(&blk)
-  Class.new(Renee::Application).app(&blk)
+  app_class = Class.new(Renee::Application)
+  app_class.app(&blk)
+  app_class
 end
 
 # Top-level Renee constant.
@@ -16,6 +21,8 @@ module Renee
   # Main class for a Renee application. This class should be subclasses if you want to define your own Renee
   # implementations.
   class Application < Core
-    include Renee::Render
+    include Render
+    include URLGeneration
+    include Session
   end
 end

data/lib/renee/core.rb

@@ -0,0 +1,98 @@
+require 'rack'
+
+require 'renee/version'
+require 'renee/core/matcher'
+require 'renee/core/chaining'
+require 'renee/core/response'
+require 'renee/core/exceptions'
+require 'renee/core/rack_interaction'
+require 'renee/core/request_context'
+require 'renee/core/transform'
+require 'renee/core/routing'
+require 'renee/core/responding'
+require 'renee/core/env_accessors'
+require 'renee/core/plugins'
+
+# Top-level Renee constant
+module Renee
+  # @example
+  #     Renee.core { path('/hello') { halt :ok } }
+  def self.core(&blk)
+    cls = Class.new(Renee::Core)
+    cls.app(&blk) if blk
+    cls
+  end
+
+  # The top-level class for creating core application.
+  # For convience you can also used a method named #Renee
+  # for decalaring new instances.
+  class Core
+    # Current version of Renee::Core
+    VERSION = Renee::VERSION
+
+    # Error raised if routing fails. Use #continue_routing to continue routing.
+    NotMatchedError = Class.new(RuntimeError)
+
+    # Class methods that are included in new instances of {Core} 
+    module ClassMethods
+      include Plugins
+
+      # The application block used to create your application.
+      attr_reader :application_block
+
+      # Provides a rack interface compliant call method. This method creates a new instance of your class and calls
+      # #call on it.
+      def call(env)
+        new.call(env)
+      end
+
+      # Allows you to set the #application_block on your class.
+      # @yield The application block
+      def app(&app)
+        @application_block = app
+        setup do
+          register_variable_type :integer, IntegerMatcher
+          register_variable_type :int, :integer
+        end
+      end
+
+      # Runs class methods on your application.
+      def setup(&blk)
+        instance_eval(&blk)
+        self
+      end
+
+      # The currently available variable types you've defined.
+      def variable_types
+        @variable_types ||= {}
+      end
+
+      # Registers a new variable type for use within {Renee::Core::Routing#variable} and others.
+      # @param [Symbol] name The name of the variable.
+      # @param [Regexp] matcher A regexp describing what part of an arbitrary string to capture.
+      # @return [Renee::Core::Matcher] A matcher
+      def register_variable_type(name, matcher)
+        matcher = case matcher
+        when Matcher then matcher
+        when Array   then Matcher.new(matcher.map{|m| variable_types[m]})
+        when Symbol  then variable_types[matcher]
+        else              Matcher.new(matcher)
+        end
+        matcher.name = name
+        variable_types[name] = matcher
+      end
+    end
+
+    include Chaining
+    include RequestContext
+    include Routing
+    include Responding
+    include RackInteraction
+    include Transform
+    include EnvAccessors
+
+    class << self
+      include ClassMethods
+    end
+  end
+end

data/lib/renee/core/chaining.rb

@@ -0,0 +1,66 @@
+module Renee
+  class Core
+    # Module for creating chainable methods. To use this within your own modules, first `include Chaining`, then,
+    # mark methods you want to be available with `chain_method :method_name`.
+    # @example
+    #    module MoreRoutingMethods
+    #      include Chaining
+    #      def other_routing_method
+    #        # ..
+    #      end
+    #      chain_method :other_routing_method
+    #
+    module Chaining
+      # @private
+      class ChainingProxy
+        def initialize(target, m, args = nil)
+          @target, @calls = target, []
+          @calls << [m, args]
+        end
+
+        def method_missing(m, *args, &blk)
+          @calls << [m, args]
+          if blk.nil? && @target.class.respond_to?(:chainable?) && @target.class.chainable?(m)
+            self
+          else
+            inner_args = []
+            ret = nil
+            callback = proc do |*callback_args|
+              inner_args.concat(callback_args)
+              if @calls.size == 0
+                ret = blk.call(*inner_args) if blk
+              else
+                call = @calls.shift
+                ret = call.at(1) ? @target.send(call.at(0), *call.at(1), &callback) : @target.send(call.at(0), &callback) 
+              end
+            end
+            ret = callback.call
+            ret
+          end
+        end
+      end
+
+      # @private
+      module ClassMethods
+        def chainable?(m)
+          method_defined?(:"#{m}_chainable")
+        end
+
+        def chainable(*methods)
+          methods.each do |m|
+            define_method(:"#{m}_chainable") { }
+          end
+        end
+
+      end
+
+      def create_chain_proxy(method_name, *args)
+        ChainingProxy.new(self, method_name, args)
+      end
+
+      def self.included(o)
+        o.extend(ClassMethods)
+      end
+    end
+  end
+end