glamping 0.1.0

data/lib/glamping/boot.rb

@@ -0,0 +1,90 @@
+# == About glamping/boot.rb (also known as <tt>boot.rb</tt>)
+# If you don't like putting everthing into the same file and don't
+# won't to cludder your file with many <tt>require</tt>'s, you should
+# look at <tt>boot.rb</tt>.
+#
+# === Using
+#   require 'rubygems'
+#   require 'glamping/boot'
+#   Glamping.boot(binding)
+# 
+# === Directory Structure
+#   app/
+#       controllers/
+#       helpers/
+#       models/
+#       views/
+#   
+#   public/
+#          cache/
+#   config/
+#          database.yml
+#          schema.rb
+#   
+#   sample_app.rb
+#
+# === Notes
+# * <tt>boot.rb</tt> will automatically initialize a Glamping application
+#   based on the filename. So in this example, it will be named <tt>SampleApp</tt>
+# * If you need databases, simply create the file <tt>config/database.yml</tt>:
+#     adapter: mysql
+#     host: localhost
+#     username: db_user
+#     password: db_pass
+#     database: sample_app
+# * ActiveRecord won't be loaded at all unless <tt>config/database.yml</tt>
+#   is provided.
+# * By adding <tt>sessions: true</tt> into <tt>config/database.yml</tt>,
+#   your application gets session support (See glamping/session.rb[link:files/lib/glamping/session_rb.html]).
+# * The cache path will be set to <tt>public/cache/</tt> (See Glamping::Helpers::PageCaching)
+# * The view path will be set to <tt>app/views/</tt>.
+# * All files in <tt>public/</tt> will be served at /.
+require 'glamping'
+Glamping.class_eval do
+  BOOT = %q{
+  root = ENV["GLAMPING_ROOT"] || File.dirname(File.expand_path(__FILE__))
+  app_name = File.basename(__FILE__, ".rb").split('_').map{|word|word.capitalize}.join
+  Glamping.goes(app_name)
+  app = Object.const_get(app_name)
+  app.config.views = File.join(root,"app","views")
+  app.config.public = File.join(root, "public")
+  app.config.cache = File.join(app.config.public, "cache")
+  
+  require 'glamping/db' if d=File.exists?(database_file = "config/database.yml")
+  
+  (Dir["app/*/"] - ["app/views/"]).each do |mod_name|
+    mod = app.const_get(File.basename(mod_name).capitalize)
+    Dir[mod_name + "**/*.rb"].each do |file|
+      mod.module_eval File.read(file)
+    end
+  end
+  
+  if d
+    require 'yaml'
+    f = YAML.load(File.read(database_file))
+    s = f.delete("session") || f.delete("sessions")
+    app::Models::Base.establish_connection(f)
+    
+    if s
+      require 'glamping/session'
+      app.send(:include, Glamping::Session)
+      Glamping::Models::Session.create_schema
+    end
+    if File.exists?(a="config/schema.rb")
+      app::Models::AutoMigration.auto_migrate(File.read(a))
+    else
+      app::Models.create_schema
+    end
+  end
+  app.create if app.respond_to? :create
+  }
+  
+  # A magically method which enables directory structure, connects
+  # to the database, running migrations and adds session-support.
+  #
+  # Should always be called with <tt>binding</tt>.
+  #   Glamping.boot(binding)
+  def self.boot(b)
+    eval(BOOT,b)
+  end
+end

data/lib/glamping/db.rb

@@ -0,0 +1,333 @@
+class MissingLibrary < Exception # :nodoc:
+end
+begin
+    require 'active_record'
+rescue LoadError => e
+    raise MissingLibrary, "ActiveRecord could not be loaded (is it installed?): #{e.message}"
+end
+
+$AR_EXTRAS = %q{
+  Base = ActiveRecord::Base unless const_defined? :Base
+
+  def Y; ActiveRecord::Base.verify_active_connections!; self; end
+
+  class SchemaInfo < Base
+  end
+
+  def self.V(n)
+    @final = [n, @final.to_i].max
+    m = (@migrations ||= [])
+    Class.new(ActiveRecord::Migration) do
+      meta_def(:version) { n }
+      meta_def(:inherited) { |k| m << k }
+    end
+  end
+
+  def self.create_schema(opts = {})
+    opts[:assume] ||= 0
+    opts[:version] ||= @final
+    if @migrations
+      unless SchemaInfo.table_exists?
+        ActiveRecord::Schema.define do
+          create_table SchemaInfo.table_name do |t|
+            t.column :version, :float
+          end
+        end
+      end
+
+      si = SchemaInfo.find(:first) || SchemaInfo.new(:version => opts[:assume])
+      if si.version < opts[:version]
+        @migrations.each do |k|
+          k.migrate(:up) if si.version < k.version and k.version <= opts[:version]
+          k.migrate(:down) if si.version > k.version and k.version > opts[:version]
+        end
+        si.update_attributes(:version => opts[:version])
+      end
+    end
+  end
+  
+  module AutoMigration
+    def self.migrate(s=nil, &blk)
+      s=blk if block_given?
+      case s
+      when String
+        eval(s)
+      when File
+        eval(s.read)
+      when Proc
+        module_eval(&s)
+      end
+    end
+    
+    class << self
+      alias :<< :migrate
+    end
+    
+    @@tables_in_schema, @@indexes_in_schema = [], []
+
+    def self.auto_migrate(s=nil, &blk)
+      self.migrate(s, &blk)
+      self.cleanup
+    end
+
+    def self.cleanup
+      drop_unused_tables
+      drop_unused_indexes
+    end
+
+    def self.method_missing(method, *args, &block)
+      case method
+      when :create_table
+        auto_create_table(method, *args, &block)
+      when :add_index
+        auto_add_index(method, *args, &block)
+      else
+        method_missing_without_auto_migration(method, *args, &block) 
+      end
+    end
+    
+    def self.method_missing_without_auto_migration(method, *args, &block)
+      ActiveRecord::Migration.send(method, *args, &block)
+    end
+
+    def self.auto_create_table(method, *args, &block)
+      table_name = args.shift.to_s    
+      options    = args.pop || {}
+      (@@tables_in_schema ||= []) << table_name
+
+      # Table doesn't exist, create it
+      unless ActiveRecord::Base.connection.tables.include?(table_name)
+        return method_missing_without_auto_migration(method, *[table_name, options], &block)
+      end
+
+      # Grab database columns
+      fields_in_db = ActiveRecord::Base.connection.columns(table_name).inject({}) do |hash, column|
+        hash[column.name] = column
+        hash
+      end
+
+      # Grab schema columns (lifted from active_record/connection_adapters/abstract/schema_statements.rb)
+      table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(ActiveRecord::Base.connection)
+      table_definition.primary_key(options[:primary_key] || "id") unless options[:id] == false
+      yield table_definition
+      fields_in_schema = table_definition.columns.inject({}) do |hash, column|
+        hash[column.name.to_s] = column
+        hash
+      end
+
+      # Add fields to db new to schema
+      (fields_in_schema.keys - fields_in_db.keys).each do |field|
+        column = fields_in_schema[field]
+        add_column table_name, column.name, column.type.to_sym, :limit => column.limit, :precision => column.precision, 
+          :scale => column.scale, :default => column.default, :null => column.null
+      end
+
+      # Remove fields from db no longer in schema
+      (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
+        column = fields_in_db[field]
+        remove_column table_name, column.name
+      end
+
+      # Change field type if schema is different from db
+      (fields_in_schema.keys & fields_in_db.keys).each do |field|
+        if (field != 'id') && (fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym)
+          change_column table_name, fields_in_schema[field].name.to_sym, fields_in_schema[field].type.to_sym
+        end
+      end
+    end
+
+    def self.auto_add_index(method, *args, &block)      
+      table_name = args.shift.to_s
+      fields     = Array(args.shift).map(&:to_s)
+      options    = args.shift
+
+      index_name = options[:name] if options  
+      index_name ||= "index_#{table_name}_on_#{fields.join('_and_')}"
+
+      (@@indexes_in_schema ||= []) << index_name
+
+      unless ActiveRecord::Base.connection.indexes(table_name).detect { |i| i.name == index_name }
+        method_missing_without_auto_migration(method, *[table_name, fields, options], &block)
+      end
+    end
+
+    def self.drop_unused_tables
+      (ActiveRecord::Base.connection.tables - @@tables_in_schema - [SchemaInfo.table_name, "sessions"]).each do |table|
+        drop_table table
+      end
+    end
+
+    def self.drop_unused_indexes
+      @@tables_in_schema.each do |table_name|
+        indexes_in_db = ActiveRecord::Base.connection.indexes(table_name).map(&:name)
+        (indexes_in_db - @@indexes_in_schema & indexes_in_db).each do |index_name|
+          remove_index table_name, :name => index_name
+        end
+      end
+    end
+  end
+}
+
+module Glamping
+  # Models is an empty Ruby module for housing model classes derived
+  # from ActiveRecord::Base.  As a shortcut, you may derive from Base
+  # which is an alias for ActiveRecord::Base.
+  #
+  #   module Glamping::Models
+  #     class Post < Base; belongs_to :user end
+  #     class User < Base; has_many :posts end
+  #   end
+  #
+  # == Where Models are Used
+  #
+  # Models are used in your controller classes.  However, if your model class
+  # name conflicts with a controller class name, you will need to refer to it
+  # using the Models module.
+  #
+  #   module Glamping::Controllers
+  #     class Post < R '/post/(\d+)'
+  #       def get(post_id)
+  #         @post = Models::Post.find post_id
+  #         render :index
+  #       end
+  #     end
+  #   end
+  #
+  # == Regular Migration
+  # It's very easy to use migration in Glamping (and Camping). Just add
+  # a class in your <tt>Models</tt>. Remember that all tables begins with
+  # the name of your app.
+  #
+  #   class InitialSchema < V 0.1
+  #     def self.up
+  #       create_table :sample_app_posts do |t|
+  #         t.string     :title
+  #         t.text       :content
+  #         t.timestamps
+  #       end
+  #     end
+  #  
+  #     def self.down
+  #       drop_table :sample_app_posts
+  #     end
+  #   end
+  #
+  # When you later need to add some more tables you just write another
+  # migration, but now increase the number to <tt>0.2</tt>.
+  #
+  #   class AddComments < V 0.2
+  #     def self.up
+  #       create_table :sample_app_comments do |t|
+  #         t.integer   :post_id, :null => false
+  #         t.string    :author
+  #         t.text      :content
+  #        end
+  #     end
+  #   
+  #     def self.down
+  #       drop_table :sample_app_comments
+  #     end
+  #   end
+  #
+  # === Running the migrations
+  # (Please read glamping/boot.rb[link:files/lib/glamping/boot_rb.html]
+  # when using <tt>boot.rb</tt>)
+  #
+  # In order to run the migrates, you call the <tt>create_schema</tt>
+  # method. It's a good idea to put this in the <tt>create</tt> method.
+  #
+  #   def SampleApp.create
+  #     SampleApp::Models.create_schema
+  #   end
+  #
+  # == Auto Migration
+  # Auto Migration is a fine alternative to regular migrations. It was
+  # originally a plugin by PJ Hyett (link[http://errtheblog.com/posts/65-automatically]),
+  # and the version included here is 99% equal. Please note that there
+  # is impossible to rename a column when using auto migration.
+  #
+  # === Running the migration
+  # (Please read glamping/boot.rb[link:files/lib/glamping/boot_rb.html]
+  # when using <tt>boot.rb</tt>)
+  # 
+  # A good idea is to put all your migration into one file, and then
+  # run <tt>auto_migration(File.open("schema.rb"))</tt>.
+  #
+  #   # in schema.rb
+  #   create_table Post.table_name do |t|
+  #     t.string     :title
+  #     t.text       :content
+  #     t.timestamps
+  #   end
+  #
+  #   # in your main file
+  #   def SampleApp.create
+  #     SampleApp::Models::AutoMigration.auto_migrate(File.open("schema.rb"))
+  #   end
+  #
+  # Whenever this file changes, it magically migrate everything for you.
+  # In this example I'm using <tt>Post.table_name</tt> in stead of
+  # <tt>:sample_app_posts</tt>, this is because the schema is loaded
+  # _after_ all the models.
+  #
+  # <tt>auto_migration</tt> is essentially only a <tt>migration</tt> and
+  # <tt>cleanup</tt> in the same method, so if you have migrations spread
+  # over several files do something like this:
+  #
+  #   def SampleApp.create
+  #     files = Dir["migrations/*.rb"]
+  #     files.each do |f|
+  #       SampleApp::Models::AutoMigration.migrate(File.open(f))
+  #     end
+  #     SampleApp::Models::AutoMigration.cleanup
+  #   end
+  #
+  # === The Auto Migration License
+  # Copyright (c) 2007 PJ Hyett
+  #
+  # Permission is hereby granted, free of charge, to any person obtaining
+  # a copy of this software and associated documentation files (the
+  # "Software"), to deal in the Software without restriction, including
+  # without limitation the rights to use, copy, modify, merge, publish,
+  # distribute, sublicense, and/or sell copies of the Software, and to
+  # permit persons to whom the Software is furnished to do so, subject to
+  # the following conditions:
+  #
+  # The above copyright notice and this permission notice shall be
+  # included in all copies or substantial portions of the Software.
+  #
+  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+  # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+  # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+  # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+  # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+  
+  module Models
+    A = ActiveRecord
+    # Base is an alias for ActiveRecord::Base.  The big warning I'm going to give you
+    # about this: *Base overloads table_name_prefix.*  This means that if you have a
+    # model class Blog::Models::Post, it's table name will be <tt>blog_posts</tt>.
+    #
+    # ActiveRecord is not loaded if you never reference this class.  The minute you
+    # use the ActiveRecord or Glamping::Models::Base class, then the ActiveRecord library
+    # is loaded.
+    Base = A::Base
+
+    # The default prefix for Glamping model classes is the topmost module name lowercase
+    # and followed with an underscore.
+    #
+    #   Tepee::Models::Page.table_name_prefix
+    #     #=> "tepee_pages"
+    #
+    def Base.table_name_prefix
+        "#{name[/\w+/]}_".downcase.sub(/^(#{A}|glamping)_/i,'')
+    end
+    module_eval $AR_EXTRAS
+  end
+end
+Glamping::S.sub! /def\s*Y[;\s]*self[;\s]*end/, $AR_EXTRAS
+Object.constants.map{|c|Object.const_get(c)}.each do |c|
+  c::Models.module_eval $AR_EXTRAS if c.respond_to?(:goes)
+end

data/lib/glamping/session.rb

@@ -0,0 +1,132 @@
+# == About glamping/session.rb
+#
+# This file contains two modules which supply basic sessioning to your Glamping app.
+# Again, we're dealing with a pretty little bit of code: approx. 60 lines.
+# 
+# * Glamping::Models::Session is a module which adds a single <tt>sessions</tt> table
+#   to your database.
+# * Glamping::Session is a module which you will mix into your application (or into
+#   specific controllers which require sessions) to supply a <tt>@state</tt> variable
+#   you can use in controllers and views.
+#
+# For a basic tutorial, see the *Getting Started* section of the Glamping::Session module.
+0 # Just a dummy-code for stupid RDOC...
+module Glamping::Models
+# A database table for storing Glamping sessions.  Contains a unique 32-character hashid, a
+# creation timestamp, and a column of serialized data called <tt>ivars</tt>. 
+class Session < Base
+    serialize :ivars
+    set_primary_key :hashid
+
+    def []=(k, v) # :nodoc:
+        self.ivars[k] = v
+    end
+    def [](k) # :nodoc:
+        self.ivars[k] rescue nil
+    end
+
+  protected
+    RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+    def before_create
+      rand_max = RAND_CHARS.size
+      sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
+      write_attribute('hashid', sid)
+    end
+
+    # Generates a new session ID and creates a row for the new session in the database.
+    def self.generate cookies
+        sess = Session.create :ivars => Glamping::H[]
+        cookies.camping_sid = sess.hashid
+        sess
+    end
+
+    # Gets the existing session based on the <tt>camping_sid</tt> available in cookies.
+    # If none is found, generates a new session.
+    def self.persist cookies
+        session = nil
+        if cookies.camping_sid
+            session = Glamping::Models::Session.find_by_hashid cookies.camping_sid
+        end
+        unless session
+            session = Glamping::Models::Session.generate cookies
+        end
+        session
+    end
+
+    # Builds the session table in the database.  To be used in your application's
+    # <tt>create</tt> method.
+    #
+    # Like so:
+    #
+    #   def Blog.create
+    #       Glamping::Models::Session.create_schema
+    #       unless Blog::Models::Post.table_exists?
+    #           ActiveRecord::Schema.define(&Blog::Models.schema)
+    #       end
+    #   end
+    #
+    def self.create_schema
+        #unless table_exists?
+            ActiveRecord::Schema.define do
+                create_table :sessions, :force => true, :id => false do |t|
+                    t.column :hashid,      :string,  :limit => 32, :null => false
+                    t.column :created_at,  :datetime
+                    t.column :ivars,       :text
+                end
+                add_index :sessions, [:hashid], :unique => true
+            end
+            reset_column_information
+        #end
+    end
+end
+end
+
+module Glamping
+# The Glamping::Session module is designed to be mixed into your application or into specific
+# controllers which require sessions.  This module defines a <tt>service</tt> method which
+# intercepts all requests handed to those controllers.
+#
+# == Getting Started
+# (Please read glamping/boot.rb[link:files/lib/glamping/boot_rb.html]
+# when using <tt>boot.rb</tt>)
+#
+# To get sessions working for your application:
+#
+# 1. <tt>require 'camping/session'</tt>
+# 2. Mixin the module: <tt>module YourApp; include Glamping::Session end</tt>
+# 3. In your application's <tt>create</tt> method, add a call to <tt>Glamping::Models::Session.create_schema</tt>
+# 4. Throughout your application, use the <tt>@state</tt> var like a hash to store your application's data. 
+# 
+# If you are unfamiliar with the <tt>create</tt> method, see 
+# http://code.whytheluckystiff.net/camping/wiki/GiveUsTheCreateMethod.
+#
+# == A Few Notes
+#
+# * The session ID is stored in a cookie. Look in <tt>@cookies.camping_sid</tt>.
+# * The session data is stored in the <tt>sessions</tt> table in your database.
+# * All mounted Glamping apps using this class will use the same database table.
+# * However, your application's data is stored in its own hash.
+# * Session data is only saved if it has changed. 
+# * Sessions are loaded from DB at *every* requests
+module Session
+    # This <tt>service</tt> method, when mixed into controllers, intercepts requests
+    # and wraps them with code to start and close the session.  If a session isn't found
+    # in the database it is created.  The <tt>@state</tt> variable is set and if it changes,
+    # it is saved back into the database.
+    def service(*a)
+        session = Glamping::Models::Session.persist @cookies
+        app = self.class.name.gsub(/^(\w+)::.+$/, '\1')
+        @state = (session[app] ||= Glamping::H[])
+        hash_before = Marshal.dump(@state).hash
+        return super(*a)
+    ensure
+        if session
+            hash_after = Marshal.dump(@state).hash
+            unless hash_before == hash_after
+                session[app] = @state
+                session.save
+            end
+        end
+    end
+end
+end