scytrin-maveric 1.0.0 → 2

data/README

@@ -1,3 +1,5 @@
+- Maveric
+
 Maveric is a MVC overlay for Rack.
 
 The dominant idea behind Maveric is as little magic as possible, being as
@@ -7,7 +9,7 @@ The use of a Maveric is simple.
 
 class MyApp < Maveric
   def get
-    [200, {'Content-Type' => 'text/plain'}, 'Hello World!']
+    render {'<p>Hello World!</p>'}
   end
 end
 
@@ -21,24 +23,34 @@ By default the method used to generate a response is the lower case form of the
 http method. GET requests call #get, POST requests call #post, and so on. A 404
 is returned if a the appropriate method is not defined.
 
+-- Actions
 
-To extend this behaviour you may define one or more routes. Routes are handled
-internally by the application. Routes are defined in the manner of
-uri-templates.
-
-The first route matching the PATH_INFO of the request is used, and if there is a
-value labeled "action" and a method by that name is defined, that method will be
-used in preference to the default. If no method by that name is found, or no
-matching route is found, default behaviour takes place.
+To override this you may redefine #action= as needed.
 
 class MyApp < Maveric
-  route '/{action}'
+  def action= method
+    if method == :get and @request.path_info == '/'
+      @action = :index
+    else
+      super
+    end
+  end
   def index
-    [200, {'Content-Type' => 'text/plain'}, 'Hello World!']
+    render {'<p>Hello World!</p>'}
   end
 end
 
-env['PATH_INFO']    # => '/index'
-MyApp.call(env)[0]  # => 200
-env['PATH_INFO']    # => '/'
-MyApp.call(env)[0]  # => 404
+-- The Render Method
+
+Provides a simple way to format data.
+
+class MyApp < Maveric
+  module Views
+    def html data
+      '<p>'+data.to_s+'</p>'
+    end
+  end
+  def get
+    render :html { 'Hello World!' }
+  end
+end

data/lib/maveric.rb

@@ -1,245 +1,256 @@
+# Author: scytrin@stadik.net
+require 'uri'
 require 'rack'
-require 'addressable/uri'
-
-class Maveric < Rack::Response
-  # Simple logger. Defaults all output to STDERR.
-  class << LOG = Object.new
-    def method_missing(m, *a, &b)
-      l = a.first.is_a?(String) ? ': '+a.shift : ''
-      STDERR.puts m.to_s.upcase+':'+caller[0].gsub(/(.*):(.*):.*/,'\1:\2')+l
-      STDERR.puts '  '+a.map{|e|e.inspect}*', '
-    end
-  end
-  LOG.debug 'Building Maveric'
 
-  # Response generator proc
-  R = Hash.new{|h,k| Proc.new{|b| [k, {'Content-Type'=>'text/plain'}, [*b]] } }
-  R[303]    = proc{|l| [303, {'Location'=>l}, [] ] }
-  R[:html]  = proc{|b| [200, {'Content-Type'=>'text/html'}, [*b]] }
-  R[:json]  = proc{|b| [200, {'Content-Type'=>'application/json'}, [*b.to_json]] }
-
-  # Builds a URLMap from the provided hash as well as Maverics
-  #
-  # Maverics are appended to the end of a Rack::Cascade if there is a collision
-  # on the path.
-  def self.Map map
-    Controllers.each do |a|
-      m = a.mount || a.name.downcase.gsub(/^|::/,'/')
-      v = map[m]
-      if v.is_a? Rack::Cascade
-        v << a
-      else
-        v = !v ? a : Rack::Cascade.new([map[m],a]))
-        map[m] = v
+module Maveric
+  class Response < Exception
+    DEFAULT, @r = [500, 'text/plain'], {}
+    def self.[] e; @r[e]; end
+    def self.[]= e, v; @r[e]=v; end
+    def initialize err
+      @status, @headers, @body = if resp = Response[err] then resp else
+        [ DEFAULT[0],
+          { 'Content-Type' => DEFAULT[1],
+            'Content-Length' => err.length.to_s },
+          err]
       end
+      super @body
     end
-    Rack::URLMap.new(map)
+    def each; @body.each{|line| yield line }; end
+    def to_a; [@status, @headers, self]; end # to_splat in 1.9
+    alias_method :finish, :to_a
   end
 
-  ### Begin controller stuffs ###
+  module Views
+    attr_reader :maveric
+    TEMPLATES = {}
+  end
 
-  # Holds an array of all created controllers.
-  Controllers = []
-  # Helpers is included into Maverics on instatiation as well as the sandbox
-  # used during rendering.
-  module Helpers; end
-  # A utility modules to hold references to model related actions and objects.
-  module Models; end
-  # Views is included into the sandbox utilized during rendering.
-  module Views; end
+  module Helpers
+    protected
 
-  # Default headers for Maveric instantiation.
-  @header = {}
-  # An array of preperations to perform on a Maveric at initialization.
-  @preparations = []
+    # Powerhouse method to build a response. TODO: doc
+    def respond *args, &blk
+      headers = Hash === args.last ? args.pop : {}
+      seed = (Symbol === args.last && args.last) ? '' : args.pop
+      views, args = args.reverse.partition{|e| Symbol === e }
 
-  class << self
-    attr_reader :header, :preparations
-    attr_accessor :mount
+      bad = views.map{|e|e.to_s} - self.class::Views.instance_methods
+      raise ArgumentError, 'Invalid views: '+bad.inspect unless bad.empty?
+      warn 'Invalid arguments: '+args.inspect unless args.empty?
 
-    # When a Maveric is subclassed, default headers and preparations are
-    # inherited. The Views, Modules, and Helpers modules are also included
-    # into the subclass' corresponding modules. By default the mount point
-    # of the subclass is the class' transformed full name.
-    #
-    # For example: Object would be '/object', Module would be '/module',
-    # Maveric::LOG would be '/maveric/log', and Rack::Auth::OpenID would be
-    # '/rack/auth/openid'.
-    def inherited klass
-      ::Maveric::Controllers << klass
-      LOG.debug 'New MVC', klass
-      s = self
-      %w'Views Models Helpers'.each do |c|
-        klass.const_set(c, Module.new).module_eval{ include s.const_get(c) }
-      end
-      %w'@header @preparations'.each do |v|
-        klass.instance_variable_set v, s.instance_variable_get(v).dup
+      response = Rack::Response.new
+      response.headers.update self.class.headers
+      response.headers.update headers.
+        reject{|(k,v)| !k.is_a? String or !v.is_a? String }
+      response.extend self.class::Views
+      response.instance_variable_set '@maveric', self
+
+      catch :response do
+        yield response if block_given?
+        body = views.inject(seed){|b,v| response.__send__(v,b) }.to_s
+        response.length = Rack::Utils.bytesize body
+        response.body = body.to_a
+        return response.finish
       end
-      klass.instance_variable_set :@mount, klass.to_s.downcase.gsub(/^|:+/, '/')
-      super
     end
 
-    # As a short cut to utilizing Maverics, a call to this method would string
-    # the method calls of .new, #prepare, and #finish. The calls are
-    # encapsulated in a catch block with the key of :response.
-    def call env
-      LOG.debug 'MVC:Args', *env.values_at('HTTP_HOST','REQUEST_URI','SCRIPT_NAME','PATH_INFO')
-      # either throw(:response, [status,header,body]) or don't, pls
-      response = catch(:response){ new(env).prepare.finish }
-      LOG.debug 'MVC:Response', response
-      response
-    end
+    private
 
-    # This utility method is used to set up preparations for Maverics on
-    # instantiation. Preparations are inherited at the time of subclassing.
-    #
-    # If +name+ is the only argument, all preparations with the provided label
-    # is returned.
-    #
-    # If opts or a block is provided, it is interpreted as a call to create a
-    # new preparation. If a preparation with the given name already exists, an
-    # exception will be raised.
-    #
-    # A preparation is a hash with the keys +:name+ and +:run+ set at a
-    # minimum. +:name+ is set to the label provided as the first argument.
-    # +:run+ is set to the block provided, or nil.
-    #
-    # When preparations are run, if +:run: is set, the block is evaluated in
-    # the instances scope, otherwise the method named by +:name+ is called if
-    # it exists.
-    def preparation name, opts={}, &blk
-      unless name.is_a? String
-        raise ArgumentError, "name #{name.inspect} is not a string"
-      end
-      prep = @preparations.find{|e| e[:name] == name }
-      if opts or blk
-        if prep
-          raise "Preparation with the name #{name.inspect} already exists"+
-            " for #{self.inspect}."
-        else
-          @preparations << prep = opts.merge(:name => name, :run => blk)
-        end
-      end
-      prep
+    # Provides a simple way of generating a redirection response, relative to
+    # the current url.
+    def redirect uri
+      uri = URI(uri).normalize
+      uri = URI(@request.url).merge uri
+      [ 303, { 'Location'=>uri.to_s,
+          'Content-Type'=>'text/plain',
+          'Content-Length'=>'0'
+        }, [] ]
     end
   end
 
-  attr_reader :request, :action
 
-  def initialize env
+
+  # The current instance is stored in the passed environment under the key
+  # 'maveric'. A Rack::Request of the current request is provided at @request.
+  #
+  # If no action is provided, @action is set as :index.
+  def initialize env, action=nil, route=nil
+    env['maveric'] = self
     @request = Rack::Request.new env
-    @action = (@request.request_method||'get').downcase.to_sym
+    @route, @action = route, action || :index
     extend self.class::Helpers
-    super [], 200, self.class.header
-    LOG.debug 'MVC:Init', @action, self
+    self.init_hook if self.respond_to? :init_hook
+    p [ @request.script_name, @route, @action ]
   end
+  attr_reader :request, :route, :action
+
+
+  # Will return a 404 type Response if the set action is invalid. Will
+  # generate a new response if a previous one is not cached or +renew+ is true.
+  #
+  # If the response responds to :finish, it will return the result, otherwise
+  # the response itself will be returned.
+  def response renew=false
+    raise Response, 404 unless @action and respond_to? @action
+    @response = __send__ @action if not @response or renew
+  rescue Response
+    warn('Response: '+$!.inspect)
+    @response = $!.to_a
+  rescue
+    warn('Rescue: '+$!.inspect)
+    body = $!.message + "\n\t" + $@[0..10]*"\n\t"
+    @request.env['rack.errors'].puts body
+    body << "\n\t" << $@[11..-1]*"\n\t"
+    @request.env.sort.each{|(k,v)| body << "\n#{k}\n\t#{v.inspect}" }
+    @response = [ 500, {
+      'Content-Type' => 'text/plain',
+      'Content-Length' => body.length.to_s
+    }, body.to_a ]
+  end
+
+
+  # Methods provided to construct a maveric
+  module Class
+    # Default headers for Maveric instantiation.
+    attr_reader :routes, :headers
+    attr_writer :mount
+
+    def add_templates directory='templates/*'
+      Dir.glob directory do |file| p file
+        next unless File.readable? file               and tmpl = File.read(file)
+        next unless extn = File.extname(file)         and not extn.empty?
+        next unless name = File.basename(file, extn)  and not name.empty?
+        view = case extn
+        when '.haml'
+          require 'haml' rescue next
+          puts "Defining HAML template view " + name.inspect
+          haml = Haml::Engine.new tmpl
+          proc{|content| haml.render self, :content => content }
+        when '.erb'
+          require 'erb' rescue next
+          puts "Defining ERB template view " + name.inspect
+          erb = ERB.new tmpl
+          erb.filename = file
+          proc{|content| erb.result(binding) }
+        else
+          puts "Defining sprintf template view " + name.inspect
+          proc{|content| sprintf self, content }
+        end
 
-  def prepare
-    self.class.preparations.each do |prep|
-      next if prep.key? :except and !prep[:except].include?(@action)
-      next if prep.key? :accept and prep[:accept].include?(@action)
-      if prep[:run]
-        instance_eval &prep[:run]
-      elsif respond_to? prep[:name]
-        __send__ prep[:name]
-      else
-        warn "Bad preparation for #{prep.inspect} in #{self}."
+        self::Views::TEMPLATES[name] = view
+        self::Views.__send__ :define_method, name, &view
       end
     end
-    LOG.debug 'MVC:Prep', @action, self
-    return self
-  end
 
-  def finish action=@action
-    throw :response, Maveric::R[404]['Not Found, '+@request.fullpath] unless respond_to? @action
-    __send__ action
-    LOG.debug 'MVC:Fini', @action, self
-    super()
-  end
+    def call env
+      r, a = @routes.find{|(r,d)| r === env['PATH_INFO'] }
+      new(env, a, r).response
+    end
 
-  protected
-
-  # for starting content: use first arg unless a symbol, else i_eval given block
-  # iterate through rest of args, calling matching method with arg of content
-  # set @response.body to result... change?
-  def render *args, &blk
-    o = Object.new
-    o.extend self.class::Views
-    o.extend self.class::Helpers
-    instance_variables.each do |i|
-      o.instance_variable_set i, instance_variable_get(i)
+    def route d, *a
+      a.flatten.each{|r| @routes << [r, d] }
     end
-    seed = args.first and !args.first.is_a?(Symbol) ? args.shift :
-      block_given? ? o.instance_eval(&blk) : ''
-    result = args.inject(seed) do |memo, view|
-      next o.__send__(view, memo) if o.respond_to? view
-      warn "No view <#{view}> in #{self.inspect}"
-      memo
+
+    def mount
+      @mount || self.name.downcase.gsub(/^|::/, '/')
     end
-    @body = result || seed
-  end
 
-  
-  class URIProcessor
-    DEF_MATCH = '.*'
-    def initialize
-      #uri.extract_mapping(String pattern, URIProcessor proc)
-      @match = Hash.new(DEF_MATCH) #String of regex to match pattern
-      @restore = {} #Transform to usable
-      #URI.expand_template(String template, Hash mapping, URIProcessor proc)
-      @validate = {} #Boolean if acceptable
-      @transform = {} #Transform to uri encoding
-      yield self if block_given?
+    def inspect
+      "#<Maveric:#{self.name} '#{mount}'>"
     end
-    def match name, pattern=nil
-      return @match[name] = pattern if pattern
-      @match[name]
+
+    def self.extend_object obj
+      obj.instance_variable_set '@routes',  []
+      obj.instance_variable_set '@headers', Rack::Utils::HeaderHash.new
+      super
     end
-    def restore name, value=nil, &blk
-      return @restore[name] = blk if blk
-      return @restore[name].call(value) if value and @restore.key? name
-      value
+  end
+
+  @maverics = [] unless defined? @maverics
+  @last_hash = nil
+  @map = nil
+  class << self
+    attr_reader :maverics
+
+    # Generates a Rack::URLMap compatible hash composed of all maverics and
+    # their mount points.
+    def map
+      return @map if @map and @last_hash == @maverics.hash
+      @last_hash = @maverics.hash
+      @map = @maverics.inject({}) do |h,m|
+        h.store m.mount, m
+        h
+      end
     end
-    def validate name, value=nil, &blk
-      return @validate[name] = blk if blk
-      return @validate[name].call(value) if value and @validate.key? name
-      !!@match[name].match(value)
+
+    # Generates a Rack::URLMap from the result of Maveric.map
+    def urlmap
+      return @urlmap if @urlmap and @last_hash == @maverics.hash
+      @urlmap = Rack::URLMap.new self.map
     end
-    def transform name, value=nil, &blk
-      return @transform[name] = blk if blk
-      return @transform[name].call(value) if value and @transform.key? name
-      value
+
+    # Maps to a call to the result of Maveric.urlmap
+    def call env
+      self.urlmap.call env
     end
-  end
 
-  Router = Hash.new{|h,k|h[k]=[]}
-  def Router.route maveric, route=nil
-    if route
-      raise unless ::Maveric > maveric
-      self[maveric] << r = [route, URIProcessor.new]
-      return r
+    def new app
+      Rack::Cascade.new [app, self]
+    end
+
+    # When a maveric is subclassed, the superclass' headers inherited. Views
+    # and Helpers modules are also included into the subclass' corresponding
+    # modules.
+    #
+    # By default, the first class to inherit from Maveric is assigned the mount
+    # point of '/'.
+    #
+    # A maveric's default mount point is by default derived from it's full
+    # name. For example: Object would be '/object', Module would be '/module',
+    # and Rack::Auth::OpenID would be '/rack/auth/openid'.
+    def included obj
+      super
+      obj.extend Maveric::Class
+      %w'Helpers Views'.each do |name|
+        next if obj.const_defined?(name)
+        obj.const_set(name, Module.new).
+          instance_eval{ include Maveric.const_get(name) }
+      end
+      obj.mount = '/' if @maverics.empty?
+      @maverics << obj
     end
-    raise unless maveric.is_a? ::Maveric
-    self[maveric.class].find do |route, processor|
-      uri = Addressable::URI.parse(maveric.request.path_info)
-      map = uri.extract_mapping(route, processor)
-      break map if map and map.all?{|k,v| !v.empty? }
-    end || {}
-  end
 
-  # Add a route to the Maveric
-  def self.route pattern
-    Router.route self, pattern
+    def extend_object obj
+      warn 'Maveric should only be included.'
+      return obj
+    end
   end
+end
 
-  # Routing preparation for Maverics.
-  # Calls Router#route with the maveric as the argument.
-  # The resulting hash is assigned to @route.
-  # If the value of 'action' exists within @route and the maveric has such
-  # a named method, the value is assigned to @action.
-  preparation :route do
-    @route = Router.route self
-    LOG.debug 'MVC:Route', @route
-    a = @route['action'] and respond_to? a and @action = a.to_sym
+class Rack::Request
+  # Allows the request to provide the current maveric.
+  def maveric; @env['maveric']; end
+  # Allows the request to provide the current session.
+  def session; @env['rack.session']; end
+  # Same as the standard Rack::Request method.
+  def url; site_root + fullpath; end
+  # Provides the compliment to #fullpath.
+  def site_root
+    url = scheme + "://" + host
+    url << ":#{port}" if \
+      scheme == "https" && port != 443 || \
+      scheme == "http"  && port != 80
+    url
   end
 end
+
+Maveric::Response[401] = [401,
+  {'Content-Type'=>'text/plain','Content-Length'=>'13'},
+  ['Unauthorized.']]
+Maveric::Response[403] = [403,
+  {'Content-Type'=>'text/plain','Content-Length'=>'15'},
+  ['Not authorized.']]
+Maveric::Response[404] = [404,
+  {'Content-Type'=>'text/plain','Content-Length'=>'10'},
+  ['Not Found.']]

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: scytrin-maveric
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: "2"
 platform: ruby
 authors: 
-- blink
+- scytrin
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-05-09 00:00:00 -07:00
+date: 2009-05-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: addressable
+  name: rack
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -22,7 +23,7 @@ dependencies:
         version: "0"
     version: 
 description: 
-email: blinketje@gmail.com
+email: scytrin@gmail.com
 executables: []
 
 extensions: []
@@ -32,12 +33,12 @@ extra_rdoc_files:
 files: 
 - README
 - lib/maveric.rb
-has_rdoc: false
+has_rdoc: true
 homepage: http://maveric.rubyforge.org/
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement