Capcode 0.8.9 → 0.9.0

data/lib/capcode/render/binary.rb

@@ -1,8 +0,0 @@
-module Capcode
-  module Helpers
-    def render_binary( f, opts ) #:nodoc:
-      @response['Content-Type'] = opts[:content_type]||opts['Content-Type']||"binary/octet-stream"
-      self.send(f) 
-    end
-  end
-end

data/lib/capcode/render/email.rb

@@ -1,73 +0,0 @@
-begin
-  require 'mail'
-rescue LoadError => e
-  raise MissingLibrary, "mail could not be loaded (is it installed?): #{e.message}"
-end
-
-module Capcode
-  module Helpers
-    def render_email( f, _ ) #:nodoc:
-      if @smtp.nil?
-        @smtp = { :server => "127.0.0.1", :port => 25 }.merge(Capcode.get( :smtp ) || {})
-      end
-
-      # Set SMTP info
-      conf = Mail::Configuration.instance.defaults
-      conf.smtp @smtp[:server], @smtp[:port]
-      
-      # Create mail
-      mail = Mail.new()
-
-      # Mail Header
-      mail.from = f[:from]
-      mail.subject = f[:subject] if f.has_key?(:subject)      
-      [:to, :cc, :bcc].each do |t|
-        next unless f.has_key?(t) and not f[t].nil?
-        if f[t].class == Array
-          mail[t] = f[t]
-        else
-          mail[t] = f[t].to_s.split( ',' ).map { |x| x.strip }
-        end
-      end
-      mail.message_id = f[:message_id] if f.has_key?(:message_id)      
-      
-      # Mail Body
-      if f[:body].class == String
-        mail.body = f[:body]
-      elsif f[:body].class == Hash
-        if f[:body].has_key?(:html)
-          mail.html_part = Mail::Part.new
-          mail.html_part.content_type = f[:body][:html].delete(:content_type) { |_| 'text/html' }
-          mail.html_part.body = render( f[:body][:html] )
-        end
-        if f[:body].has_key?(:text)
-          mail.text_part = Mail::Part.new
-          mail.text_part.body = render( f[:body][:text] )
-        end        
-      end
-      
-      # Mail Attachment
-      if f.has_key?(:file)
-        f[:file] = [f[:file]] unless f[:file].class == Array
-        f[:file].each do |file|
-          data = {}
-          if file.class == Hash
-            data[:filename] = file.delete(:filename) if file.has_key?(:filename)
-            data[:mime_type] = file.delete(:mime_type) if file.has_key?(:mime_type)
-            data[:data] = self.send(file[:data])
-          else 
-            data = { :data => render( :static => file, :exact_path => false ), :filename => File.basename(file) }
-          end
-          mail.add_file(data)
-        end
-      end
-
-      begin
-        mail.deliver!
-        render f[:ok]
-      rescue
-        render f[:error]
-      end
-    end
-  end
-end

data/lib/capcode/render/erb.rb

@@ -1,59 +0,0 @@
-require 'erb'
-
-module Capcode
-  module Helpers
-    # Set the path to ERB files. If this path is not set, Capcode will search in the static path.
-    # This method is deprecated and will be removed in version 1.0
-    def self.erb_path=( p )
-      warn "Capcode::Helpers.erb_path is deprecated and will be removed in version 1.0, please use `set :erb'"
-      Capcode.set :erb, p
-    end
-    
-    def get_binding #:nodoc:
-      binding
-    end
-    
-    def render_erb( f, opts ) #:nodoc:
-      if @erb_path.nil?
-        @erb_path = Capcode.get( :erb ) || Capcode.static()
-      end
-      
-      f = f.to_s
-      if f.include? '..'
-        return [403, {}, '403 - Invalid path']
-      end
-      
-      if /Windows/.match( ENV['OS'] )
-        unless( /.:\\/.match( @erb_path[0] ) )
-          @erb_path = File.expand_path( File.join(".", @erb_path) )
-        end
-      else
-        unless( @erb_path[0].chr == "/" )
-          @erb_path = File.expand_path( File.join(".", @erb_path) )
-        end
-      end
-
-      # Get Layout
-      layout = opts.delete(:layout)||:layout
-      layout_file = File.join( @erb_path, layout.to_s+".rhtml" )
-
-      # Get file
-      f = f + ".rhtml" if File.extname( f ) != ".rhtml"
-      file = File.join( @erb_path, f )
-      
-      if( File.exist?( file ) )
-        if( File.exist?( layout_file ) )
-          ERB.new(open(layout_file).read).result( get_binding { |*args| 
-            #@@__ARGS__ = args
-            Capcode::Helpers.args = args
-            ERB.new(open(file).read).result(binding) 
-          } )
-        else
-          ERB.new(open(file).read).result(binding)
-        end
-      else
-        raise Capcode::RenderError, "Error rendering `erb', #{file} does not exist !"
-      end
-    end
-  end
-end

data/lib/capcode/render/haml.rb

@@ -1,60 +0,0 @@
-begin
-  require 'haml'
-rescue LoadError => e
-  raise MissingLibrary, "Haml could not be loaded (is it installed?): #{e.message}"
-end
-
-module Capcode
-  module Helpers
-    # Set the path to Haml files. If this path is not set, Capcode will search in the static path.
-    # This method is deprecated and will be removed in version 1.0
-    def self.haml_path=( p )
-      warn "Capcode::Helpers.haml_path is deprecated and will be removed in version 1.0, please use `set :haml'"
-      Capcode.set :haml, p
-    end
-    
-    def render_haml( f, opts ) #:nodoc:
-      if @haml_path.nil?
-        @haml_path = Capcode.get( :haml ) || Capcode.static()
-      end
-      
-      f = f.to_s
-      if f.include? '..'
-        return [403, {}, '403 - Invalid path']
-      end
-      
-      if /Windows/.match( ENV['OS'] )
-        unless( /.:\\/.match( @haml_path[0] ) )
-          @haml_path = File.expand_path( File.join(".", @haml_path) )
-        end
-      else
-        unless( @haml_path[0].chr == "/" )
-          @haml_path = File.expand_path( File.join(".", @haml_path) )
-        end
-      end
-      
-      # Get Layout file
-      layout = opts.delete(:layout)||:layout
-      layout_file = File.join( @haml_path, layout.to_s+".haml" )
-      
-      # Get HAML File
-      f = f + ".haml" if File.extname( f ) != ".haml"
-      file = File.join( @haml_path, f )
-      
-      # Render
-      if( File.exist?( file ) )
-        if( File.exist?( layout_file ) )
-          Haml::Engine.new( open( layout_file ).read ).to_html(self) { |*args| 
-            #@@__ARGS__ = args
-            Capcode::Helpers.args = args
-            Haml::Engine.new( open( file ).read ).render(self) 
-          }
-        else
-          Haml::Engine.new( open( file ).read ).to_html( self )
-        end
-      else
-        raise Capcode::RenderError, "Error rendering `haml', #{file} does not exist !"
-      end
-    end
-  end
-end

data/lib/capcode/render/json.rb

@@ -1,14 +0,0 @@
-begin
-  require 'json'
-rescue LoadError => e
-  raise MissingLibrary, "Json could not be loaded (is it installed?): #{e.message}"
-end
-
-module Capcode
-  module Helpers
-    def render_json( f, opts ) #:nodoc:
-      @response['Content-Type'] = 'application/json'
-      f.to_json
-    end
-  end
-end

data/lib/capcode/render/markaby.rb

@@ -1,38 +0,0 @@
-begin
-  require 'markaby'
-rescue LoadError => e
-  raise MissingLibrary, "Markaby could not be loaded (is it installed?): #{e.message}"
-end
-
-Markaby::Builder.set(:indent, 2)
-
-module Capcode
-  class Mab < Markaby::Builder
-    include Views
-  end
-  
-  module Helpers
-    def render_markaby( f, opts ) #:nodoc:
-      f = f.to_s
-      layout = opts.delete(:layout)||:layout
-
-      assigns = {}
-      self.instance_variables.delete_if {|x| ["@response", "@env", "@request"].include?(x) }.each do |ivar|
-        assigns[ivar.gsub( /^@/, "" )] = self.instance_variable_get(ivar)
-      end
-
-      __mab = Mab.new(assigns.merge( opts ), self) { 
-        if self.respond_to?(layout)
-          self.send(layout.to_s) { |*args| 
-            # @@__ARGS__ = args
-            Capcode::Helpers.args = args
-            self.send(f) 
-          }
-        else
-          self.send(f) 
-        end
-      }
-      __mab.to_s  
-    end
-  end
-end

data/lib/capcode/render/mustache.rb

@@ -1,37 +0,0 @@
-begin
-  require 'mustache'
-rescue LoadError => e
-  raise MissingLibrary, "Mustache could not be loaded (is it installed?): #{e.message}"
-end
-
-module Capcode
-  module Helpers
-    def render_mustache( f, opts ) #:nodoc:
-      mustache_path = Capcode.get( :mustache ) || Capcode.static() 
-      
-      name = Mustache.classify(f.to_s)
-      
-      if Capcode::Views.const_defined?(name)
-        klass = Capcode::Views.const_get(name)
-      else
-        klass = Mustache
-        klass.template_file = mustache_path + "/" + f.to_s + ".mustache"
-      end
-      
-      klass.template_extension = 'mustache'
-      klass.template_path = mustache_path
-      
-      instance = klass.new
-      
-      instance_variables.each do |name|
-        instance.instance_variable_set(name, instance_variable_get(name))
-      end
-
-      opts.each do |k, v|
-        instance[k] = v
-      end
-      
-      instance.to_html
-    end
-  end
-end

data/lib/capcode/render/none.rb

@@ -1,7 +0,0 @@
-module Capcode
-  module Helpers
-    def render_none( f = "", _ ) #:nodoc:
-      return [204, {}, f]
-    end
-  end
-end

data/lib/capcode/render/redirect.rb

@@ -1,7 +0,0 @@
-module Capcode
-  module Helpers
-    def render_redirect( f, _ ) #:nodoc:
-      redirect(f)
-    end
-  end
-end

data/lib/capcode/render/sass.rb

@@ -1,48 +0,0 @@
-begin
-  require 'sass'
-rescue LoadError => e
-  raise MissingLibrary, "Sass could not be loaded (is it installed?): #{e.message}"
-end
-
-module Capcode
-  module Helpers
-    # Set the path to Sass files. If this path is not set, Capcode will search in the static path.
-    # This method is deprecated and will be removed in version 1.0
-    def self.sass_path=( p )
-      warn "Capcode::Helpers.sass_path is deprecated and will be removed in version 1.0, please use `set :sass'"
-      Capcode.set :sass, p
-    end
-    
-    def render_sass( f, _ ) #:nodoc:
-      if @sass_path.nil?
-        @sass_path = Capcode.get( :sass ) || Capcode.static() 
-      end
-      
-      f = f.to_s
-      if f.include? '..'
-        return [403, {}, '403 - Invalid path']
-      end
-      
-      if /Windows/.match( ENV['OS'] )
-        unless( /.:\\/.match( @sass_path[0] ) )
-          @sass_path = File.expand_path( File.join(".", @sass_path) )
-        end
-      else
-        unless( @sass_path[0].chr == "/" )
-          @sass_path = File.expand_path( File.join(".", @sass_path) )
-        end
-      end
-      
-      # Get File
-      f = f + ".sass" if File.extname( f ) != ".sass"
-      file = File.join( @sass_path, f )
-
-      # Render
-      if( File.exist?( file ) )
-        Sass::Engine.new( open( file ).read ).to_css
-      else
-        raise Capcode::RenderError, "Error rendering `sass', #{file} does not exist !"
-      end
-    end
-  end
-end

data/lib/capcode/render/static.rb

@@ -1,14 +0,0 @@
-module Capcode
-  module Helpers
-    def render_static( f, opts = { :exact_path => true } ) #:nodoc:
-      if Capcode.static.nil? or f.include? '..'
-        return [403, {}, '403 - Invalid path']
-      end
-      if !opts.keys.include?(:exact_path) or opts[:exact_path] == true
-        redirect File.join( static[:uri], f )
-      else
-        File.read( File.join( static[:path], f ) ).to_s
-      end
-    end
-  end
-end

data/lib/capcode/render/webdav.rb

@@ -1,49 +0,0 @@
-# From rack_dav
-require 'builder'
-require 'time'
-require 'uri'
-require 'rexml/document'
-require 'webrick/httputils'
-
-begin
-  require 'rack_dav/builder_namespace'
-  require 'rack_dav/http_status'
-  require 'rack_dav/resource'
-  require 'rack_dav/file_resource'
-  require 'rack_dav/handler'
-  require 'rack_dav/controller'
-rescue LoadError => e
-  raise MissingLibrary, "Rack_Dav could not be loaded (is it installed?): #{e.message}"
-end 
-
-
-module Capcode
-  module Helpers
-    
-    def render_webdav( f, opts )
-		  options = {
-		    :resource_class => RackDAV::FileResource,
-		    :root => f
-		  }.merge(opts)
-		  		
-		  request = Rack::Request.new(env)
-		  response = Rack::Response.new
-    
-		  begin
-		    controller = RackDAV::Controller.new(request, response, options.dup)		    
-		    controller.send(request.request_method.downcase)
-		  rescue RackDAV::HTTPStatus::Status => status
-		    response.status = status.code
-		  end
-      
-		  # Strings in Ruby 1.9 are no longer enumerable.  Rack still expects the response.body to be
-		  # enumerable, however.
-		  response.body = [response.body] if not response.body.respond_to? :each
-      
-		  response.status = response.status ? response.status.to_i : 200
-		  response.finish
-		  
-		  [response.status, response.header, response.body]
-		end
-  end
-end

data/lib/capcode/render/xml.rb

@@ -1,119 +0,0 @@
-class XML #:nodoc: all
-  class TagError < ArgumentError
-  end
-  
-  class DSL
-    def initialize( helper, &block )
-      @__x_d_level = 0
-      @__x_d_helper = helper
-      @__x_d_helper.instance_variables.each do |ivar|
-        self.instance_variable_set(ivar, @__x_d_helper.instance_variable_get(ivar))
-      end
-      @__x_d_builder = ""
-      instance_eval(&block) if block
-    end
-
-    def __
-      " "*@__x_d_level
-    end
-
-    def _(x)
-      @__x_d_builder << __ << x << "\n"
-    end
-    
-    def tag!(sym, *args, &block)
-      tag = {
-        :bra => "<",
-        :ket => " />",
-        :name => sym.id2name,
-        :close => block_given?(),
-        :attrs => "",
-        :value => ""
-      }
-              
-      args.each do |a|
-        if a.class == Hash
-          a.each do |k, v|
-            tag[:attrs] << " #{k.to_s}='#{v}'"
-          end
-        elsif a.class == String
-          tag[:close] = true
-          tag[:value] << a << "\n"
-        end
-      end
-      
-      if tag[:name].match( /\?$/ )
-        tag[:name].gsub!( /\?$/, "" )
-        tag[:bra] = "<?"
-        tag[:ket] = "?>"
-        
-        if tag[:close] == true
-          raise XML::TagError, "Malformated traitment tag!"
-        end
-      end
-
-      @__x_d_builder << __ << tag[:bra] << "#{tag[:name]}#{tag[:attrs]}"
-      if tag[:close]
-        @__x_d_builder << ">\n"
-      else
-        @__x_d_builder << tag[:ket] << "\n"
-      end
-      
-      @__x_d_level += 2
-      
-      @__x_d_builder << __ << tag[:value] if tag[:value].size > 0
-      instance_eval(&block) if block
-      
-      @__x_d_level -= 2
-      
-      if tag[:close]
-        @__x_d_builder << __ << "</#{tag[:name]}>\n"
-      end
-    end
-    
-    def cdata( x = "", &block )
-      @__x_d_builder << __ << "<![CDATA["
-      if x.match( /\n/ ) or block
-        @__x_d_level += 2
-        @__x_d_builder << "\n" << __ << x << "\n" if x.size > 0
-        instance_eval(&block) if block
-        @__x_d_level -= 2
-        @__x_d_builder << __ 
-      else
-        @__x_d_builder << x if x.size > 0
-      end
-      @__x_d_builder << "]]>\n"
-    end
-    
-    def to_s
-      @__x_d_builder
-    end
-    
-    def method_missing(sym, *args, &block)
-      if @__x_d_helper.respond_to?(sym, true)
-        @__x_d_helper.send(sym, *args, &block)
-      elsif instance_variables.include?(ivar = "@__x_d_#{sym}")
-        instance_variable_get(ivar)
-      elsif !@__x_d_helper.nil? && @__x_d_helper.instance_variables.include?(ivar)
-        @__x_d_helper.instance_variable_get(ivar)
-      else
-        tag!(sym, *args, &block)
-      end
-    end
-  end
-end
-
-module Capcode
-  class XML::DSL #:nodoc:
-    include Views
-  end
-  
-  module Helpers
-    def render_xml( f, _ ) #:nodoc:
-      r = XML::DSL.new( self ) do
-        self.send(f.to_s)
-      end
-      r.to_s
-    end
-  end
-end