synfeld 0.0.4

data/lib/synfeld/base.rb

@@ -0,0 +1,281 @@
+module Synfeld # :nodoc:
+
+  #
+  # See the synopsis section of README.rdoc for usage.
+  # 
+  # See the README.rdoc for an overview of an Synfeld::App, and see the Rack::Mount project for 
+  # more information on Rack::Mount style routing. 
+  #
+  # Variables of note:
+  #
+  #   @response
+  #      a hash with keys :body, :headers, :status_code, the 3 items all rack handlers are expected to set.
+  #      Body is a string, status code is an http status code integer, and headers is a hash that
+  #      should conform to rack's contract.
+  #
+  #   @env
+  #      The rack env passed into this apps #call method
+  #
+  #   @params
+  #      The params as determined by the matching Rack::Mount route.
+  #
+  #   @root_dir
+  #      This dir is prepended to relative paths to locate files.
+  #
+  #   @logger
+  #      Either you pass in the @logger that synfeld uses, or it sets one up on STDOUT.
+  #
+  class App
+    attr_accessor :response, :params, :env, :root_dir, :logger
+
+    # Options:
+    #   :logger => where to log to.
+    #              Note this is not the same thing as the rack access log (although you
+    #              can pass that logger in if you want). Default: Logger.new(STDOUT)
+    def initialize(opts = {})
+
+      @logger = opts[:logger]
+      if self.logger.nil?
+        @logger = Logger.new(STDOUT)
+        puts "WARNING: Synfeld not configured with a logger, using STDOUT. Won't have much to say if running as a daemon."
+      end
+
+      @root_dir = opts[:root_dir] 
+      if self.root_dir.nil?
+        raise "You have to pass in the location of the 'root_dir', where all the files in your synfeld app are located" 
+      end
+
+      Kernel.at_exit {self.whine("Alright, I'm outta here.")}
+    end
+    
+    #
+    #            RACK PLUMBING
+    #
+
+    # Return self as a rackup-able rack application.
+    def as_rack_app
+      #routes = Rack::Mount::RouteSet.new_without_optimizations do |set|
+      routes = Rack::Mount::RouteSet.new do |set|
+        @set = set
+        self.add_routes
+        add_route %r{^.*$},  :action => "render_static" 
+      end
+      return routes
+    end 
+
+    # The rack #call method
+    def call(env)
+      dup._call(env) # be thread-safe
+    end
+
+    #
+    #            ROUTING
+    #
+
+    @@__regex_colon = (RUBY_VERSION =~ /^1.8/)? ':' : '' # :nodoc:
+
+    # See the README for a full explanation of how to use this method.
+    def add_route(string_or_regex, opts = {})
+      raise "You have to provide an :action method to call" unless opts[:action]
+      method = (opts.delete(:method) || 'GET').to_s.upcase
+      # Adapt string_or_regex into a rack-mount regex route. If it is a string, convert it to a
+      # rack-mount compatable regex. In paths that look like /some/:var/in/path, convert the ':var'
+      # bits to rack-mount variables.
+      if string_or_regex.is_a?(String)
+        regex_string = "^" + string_or_regex.gsub(/:(([^\/]+))/){|s| "(?#{@@__regex_colon}<#{$1}>.*)" } + "$"
+        regex = %r{#{regex_string}}
+        #puts regex_string # dbg
+      else
+        regex = string_or_regex
+      end
+
+      # Add the route to rack-mount
+      @set.add_route(self,
+                    {:path_info => regex, :request_method => method.upcase},
+                    opts)
+    end
+
+    #
+    #            ACCESSORS & SUGAR
+    #
+
+    # The name of the action method bound to the route that mathed the incoming request.
+    def action
+      self.params[:action]
+    end
+
+    protected
+
+      def _call(env) # :nodoc:
+        begin
+          start_time = Time.now.to_f 
+          @env = env
+          @params = env[ Rack::Mount::Const::RACK_ROUTING_ARGS ]
+          @response = {
+            :status_code => 200,
+            :headers => {'Content-Type' => 'text/html'},
+            :body => nil
+          }
+
+          action = self.action
+          if self.respond_to?(action)
+            result = self.send(self.action)
+          else
+            result = self.no_action
+          end
+          
+          if result.is_a?(String)
+            response[:body] = result
+          else
+            raise "You have to set the response body" if response[:body].nil?
+          end
+
+          response[:headers]["Content-Length"] = response[:body].size.to_s
+
+          logger.debug("It took #{Time.now.to_f - start_time} sec for #{self.class} to handle request.")
+          [response[:status_code], response[:headers], Array(response[:body])]
+        rescue Exception => e
+          # It seems like we should get this next line for free from the CommonLogger, so I guess
+          # I'm doing something wrong, missing some piece of rack middleware or something. Until I
+          # figure it out, I'm explicitly logging the exception manually.
+          self.whine "#{e.class}, #{e}\n\t#{e.backtrace.join("\n\t")} "
+          raise e
+        end
+      end
+      # :startdoc:
+
+
+      #
+      #            EXCEPTIONS
+      #
+
+      # send an error message to the log prepended by "Synfeld: " 
+      def whine msg
+        logger.error("Synfeld laments: " + msg)
+        return msg
+      end
+
+
+      # Overrideable method that handles a missing action that was defined by a route
+      def no_action
+        self.response[:body] = "Action '#{self.action}' not found in '#{self.class}'"
+        self.response[:status_code] = 500
+      end
+
+      # Overrideable method that handles 404
+      def no_route
+          self.response[:body] = "route not found for: '#{self.env['REQUEST_URI']}'"
+          self.response[:status_code] = 404
+      end
+
+      #
+      #            RENDERING
+      #
+
+      # Render an html file. 'fn' is a full path, or a path relative to @root_dir.
+      def render_html(fn)
+        F.read(full_path(fn))
+      end
+
+      # Serve up a blob of json (just sets Content-Type to 'text/javascript' and 
+      # sets the body to the json passed in to this method).
+      def render_json(json)
+        self.response[:headers]['Content-Type'] = 'text/javascript'
+        self.response[:body] = json
+      end
+
+      # Render a haml file. 'fn' is a full path, or a path relative to @root_dir.
+      # 'locals' is a hash definining variables to be passed to the template.
+      def render_haml(fn, locals = {})
+
+        if not defined? Haml
+          begin
+            require 'haml'
+          rescue LoadError => x
+            return self.whine("Haml is not installed, required in order to render '#{fn}'")
+          end
+        end
+
+        Haml::Engine.new(F.read(full_path(fn)) ).render(Object.new, locals)
+      end
+
+      # Render an erb file. 'fn' is a full path, or a path relative to @root_dir.
+      # 'locals' is a hash definining variables to be passed to the template.
+      def render_erb(fn, locals = {})
+
+        if not defined? Erb
+          begin
+            require 'erb'
+          rescue LoadError => x
+            return self.whine("Erb is not installed, required in order to render '#{fn}'")
+          end
+        end
+
+        template = ERB.new F.read(full_path(fn))
+
+        bind = binding
+        locals.each do |n,v| 
+          raise "Locals must be symbols. Not a symbol: #{n.inspect}" unless n.is_a?(Symbol) 
+          eval("#{n} = locals[:#{n}]", bind)
+        end
+        template.result(bind)
+      end
+
+      def render_static
+        fn = F.expand_path(F.join(root_dir, self.env['REQUEST_URI']))
+        #puts fn # dbg
+        if F.exist?(fn) and not F.directory?(fn)
+          self.content_type!(fn.split('.').last)
+          F.read(fn)
+        else
+          return self.no_route
+        end
+      end
+
+      #
+      #            UTIL
+      #
+
+      # Given a file extention, determine the 'Content-Type' and then set the
+      # @response[:headers]['Content-Type']. Unrecognized extentions are
+      # set to content type of 'text/plain'.
+      def content_type!(ext)
+        case ext.downcase
+        when 'haml'; t = 'text/html'
+        when 'erb'; t = 'text/html'
+# I believe all the rest are determined accurately by the Rack::Mime.mime_type call in the else clause below.
+#        when 'html'; t = 'text/html'
+#        when 'js'; t = 'text/javascript'
+#        when 'css'; t = 'text/css'
+#        when 'png'; t = 'image/png'
+#        when 'gif'; t = 'image/gif'
+#        when 'jpg'; t = 'image/jpeg'
+#        when 'jpeg'; t = 'image/jpeg'
+        else t = Rack::Mime.mime_type('.' + ext, 'text/plain')
+        end
+        #puts("----#{ext}:" + t.inspect) # dbg
+        (self.response[:headers]['Content-Type'] = t) if t
+      end
+
+      # Return fn if a file by that name exists. If not, concatenate the @root_dir with the fn, and
+      # return that if it exists. Raise if the actual file cannot be determined. 
+      #
+      # NOTE: no effort is made to protect access to files outside of your application's root
+      # dir. If you permit filepaths as request parameters, then it is up to you to make sure
+      # that they do not point to some sensitive part of your file-system. 
+      def full_path(fn)
+        if F.exist?(fn)
+          return fn
+        elsif F.exist?(full_fn = F.join(self.root_dir, fn))
+          return full_fn
+        else
+          raise "Could not find file '#{fn}' (full path '#{full_fn}')" 
+        end
+      end
+
+  end # class App
+
+end # mod Synfeld
+
+
+

data/lib/synfeld.rb

@@ -0,0 +1,17 @@
+F = ::File 
+
+# base ruby requires
+require 'rubygems'
+require 'logger'
+
+# gems dependencies
+require 'rubygems'
+
+require 'rack'
+require 'rack/mount'
+require 'rack/mime'
+
+# my files (require_all_libs_relative_to is a bones util method in synfeld_info.rb)
+require F.join(File.dirname(__FILE__), 'synfeld_info')
+Synfeld.require_all_libs_relative_to(__FILE__)
+

data/lib/synfeld_info.rb

@@ -0,0 +1,51 @@
+#
+# See README.txt for usage.
+#
+module Synfeld
+
+  # :stopdoc:
+
+  VERSION = '0.0.4'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+  # :startdoc:
+  
+end  # module Synfeld
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib synfeld]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

data/spec/synfeld_spec.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Synfeld do
+end
+
+# EOF

data/synfeld.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{synfeld}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Steven Swerling"]
+  s.date = %q{2009-09-25}
+  s.description = %q{Synfeld is a web application framework that does practically nothing.
+
+Synfeld is little more than a small wrapper for Rack::Mount (see http://github.com/josh/rack-mount). If you want a web framework that is mostly just going to serve up json blobs, and occasionally serve up some simple content (eg. help files) and media, Synfeld makes that easy. 
+
+The sample app below shows pretty much everything there is to know about synfeld, in particular:
+
+* How to define routes.
+* Simple rendering of erb, haml, html, json, and static files.
+* In the case of erb and haml, passing variables into the template is demonstrated.
+* A dymamic action where the status code, headers, and body are created 'manually.'
+* The erb demo link also demos the rendering of a partial (not visible in the code below, you have to look at the template file examples/public/erb_files/erb_test.erb).}
+  s.email = %q{sswerling@yahoo.com}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc", "README.txt"]
+  s.files = [".gitignore", "History.txt", "README.rdoc", "README.txt", "Rakefile", "TODO", "TODO-rack-mount", "example/public/erb_files/erb_test.erb", "example/public/haml_files/haml_test.haml", "example/public/haml_files/home.haml", "example/public/html_files/html_test.html", "example/public/images/beef_interstellar_thm.jpg", "example/public/images/rails.png", "example/try_me.rb", "example/try_me.ru", "lib/synfeld.rb", "lib/synfeld/base.rb", "lib/synfeld_info.rb", "rackmount-test.ru", "spec/spec_helper.rb", "spec/synfeld_spec.rb", "synfeld.gemspec", "test/test_synfeld.rb"]
+  s.homepage = %q{http://tab-a.slot-z.net}
+  s.rdoc_options = ["--inline-source", "--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{synfeld}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Synfeld is a web application framework that does practically nothing}
+  s.test_files = ["test/test_synfeld.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rack>, [">= 0"])
+      s.add_runtime_dependency(%q<rack-router>, [">= 0"])
+      s.add_development_dependency(%q<bones>, [">= 2.5.1"])
+    else
+      s.add_dependency(%q<rack>, [">= 0"])
+      s.add_dependency(%q<rack-router>, [">= 0"])
+      s.add_dependency(%q<bones>, [">= 2.5.1"])
+    end
+  else
+    s.add_dependency(%q<rack>, [">= 0"])
+    s.add_dependency(%q<rack-router>, [">= 0"])
+    s.add_dependency(%q<bones>, [">= 2.5.1"])
+  end
+end

data/tasks/ann.rake

@@ -0,0 +1,80 @@
+
+begin
+  require 'bones/smtp_tls'
+rescue LoadError
+  require 'net/smtp'
+end
+require 'time'
+
+namespace :ann do
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  file PROJ.ann.file do
+    ann = PROJ.ann
+    puts "Generating #{ann.file}"
+    File.open(ann.file,'w') do |fd|
+      fd.puts("#{PROJ.name} version #{PROJ.version}")
+      fd.puts("    by #{Array(PROJ.authors).first}") if PROJ.authors
+      fd.puts("    #{PROJ.url}") if PROJ.url.valid?
+      fd.puts("    (the \"#{PROJ.release_name}\" release)") if PROJ.release_name
+      fd.puts
+      fd.puts("== DESCRIPTION")
+      fd.puts
+      fd.puts(PROJ.description)
+      fd.puts
+      fd.puts(PROJ.changes.sub(%r/^.*$/, '== CHANGES'))
+      fd.puts
+      ann.paragraphs.each do |p|
+        fd.puts "== #{p.upcase}"
+        fd.puts
+        fd.puts paragraphs_of(PROJ.readme_file, p).join("\n\n")
+        fd.puts
+      end
+      fd.puts ann.text if ann.text
+    end
+  end
+
+  desc "Create an announcement file"
+  task :announcement => ['ann:prereqs', PROJ.ann.file]
+
+  desc "Send an email announcement"
+  task :email => ['ann:prereqs', PROJ.ann.file] do
+    ann = PROJ.ann
+    from = ann.email[:from] || Array(PROJ.authors).first || PROJ.email
+    to   = Array(ann.email[:to])
+
+    ### build a mail header for RFC 822
+    rfc822msg =  "From: #{from}\n"
+    rfc822msg << "To: #{to.join(',')}\n"
+    rfc822msg << "Subject: [ANN] #{PROJ.name} #{PROJ.version}"
+    rfc822msg << " (#{PROJ.release_name})" if PROJ.release_name
+    rfc822msg << "\n"
+    rfc822msg << "Date: #{Time.new.rfc822}\n"
+    rfc822msg << "Message-Id: "
+    rfc822msg << "<#{"%.8f" % Time.now.to_f}@#{ann.email[:domain]}>\n\n"
+    rfc822msg << File.read(ann.file)
+
+    params = [:server, :port, :domain, :acct, :passwd, :authtype].map do |key|
+      ann.email[key]
+    end
+
+    params[3] = PROJ.email if params[3].nil?
+
+    if params[4].nil?
+      STDOUT.write "Please enter your e-mail password (#{params[3]}): "
+      params[4] = STDIN.gets.chomp
+    end
+
+    ### send email
+    Net::SMTP.start(*params) {|smtp| smtp.sendmail(rfc822msg, from, to)}
+  end
+end  # namespace :ann
+
+desc 'Alias to ann:announcement'
+task :ann => 'ann:announcement'
+
+CLOBBER << PROJ.ann.file
+
+# EOF

data/tasks/bones.rake

@@ -0,0 +1,20 @@
+
+if HAVE_BONES
+
+namespace :bones do
+
+  desc 'Show the PROJ open struct'
+  task :debug do |t|
+    atr = if t.application.top_level_tasks.length == 2
+      t.application.top_level_tasks.pop
+    end
+
+    if atr then Bones::Debug.show_attr(PROJ, atr)
+    else Bones::Debug.show PROJ end
+  end
+
+end  # namespace :bones
+
+end  # HAVE_BONES
+
+# EOF