darkhelmet-sinatra_more 0.3.33

data/generators/components/mocks/mocha_mock_gen.rb

@@ -0,0 +1,8 @@
+module Sinatra
+  module MochaMockGen
+    def setup_mock
+      require_dependencies 'mocha', :env => :testing
+      insert_mocking_include "Mocha::API", :path => "test/test_config.rb"
+    end
+  end
+end

data/generators/components/mocks/rr_mock_gen.rb

@@ -0,0 +1,8 @@
+module Sinatra
+  module RrMockGen
+    def setup_mock
+      require_dependencies 'rr', :env => :testing
+      insert_mocking_include "RR::Adapters::RRMethods", :path => "test/test_config.rb"
+    end
+  end
+end

data/generators/components/orms/activerecord_orm_gen.rb

@@ -0,0 +1,99 @@
+module Sinatra
+  module ActiverecordOrmGen
+    
+    AR = <<-AR
+module ActiveRecordInitializer
+  def self.registered(app)
+    app.configure :development do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'sqlite3',
+        :database => 'your_dev_db_here'
+      )
+    end
+
+    app.configure :production do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'sqlite3',
+        :database => 'your_production_db_here'
+      )
+    end
+
+    app.configure :test do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'sqlite3',
+        :database => 'your_test_db_here'
+      )
+    end
+  end
+end
+AR
+
+RAKE = <<-RAKE
+require 'sinatra/base'
+require 'active_record'
+
+namespace :db do
+  desc "Migrate the database"
+  task(:migrate) do
+    load 'config/boot.rb'
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migrator.migrate("db/migrate")
+  end
+end
+RAKE
+
+
+   MIGRATION = <<-MIGRATION
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+       t.column :name, :string
+       t.column :username, :string
+       t.column :email, :string
+       t.column :crypted_password, :string
+       t.column :created_at, :datetime
+    end
+  end
+
+  def self.down
+    drop_table :users
+  end
+end
+MIGRATION
+
+  USER = <<-USER
+class User < ActiveRecord::Base
+  before_save :encrypt_password
+  
+  attr_accessor :password, :password_confirmation
+  
+  def validate
+    errors.add :password, "must not be empty" if self.crypted_password.blank? && password.blank?
+    errors.add :password, "must match password confirmation" unless password == password_confirmation
+  end
+  
+  def self.authenticate(username, password)
+    user = User.first(:conditions => { :username => username })
+    user && user.has_password?(password) ? user : nil
+  end
+  
+  def encrypt_password
+    self.crypted_password = BCrypt::Password.create(password)
+  end
+  
+  def has_password?(password)
+    BCrypt::Password.new(crypted_password) == password
+  end
+end
+USER
+    
+    def setup_orm
+      require_dependencies 'activerecord'
+      create_file("config/initializers/active_record.rb", AR)
+      create_file("Rakefile", RAKE)
+      create_file("db/migrate/001_create_users.rb", MIGRATION)
+      create_file("app/models/user.rb", USER)
+    end
+  end
+end

data/generators/components/orms/couchrest_orm_gen.rb

@@ -0,0 +1,64 @@
+module Sinatra
+  module CouchrestOrmGen
+    
+    COUCHREST = <<-COUCHREST
+module CouchRestInitializer
+  def self.registered(app)
+    app.configure(:development) { set :couchdb, CouchRest.database!('your_dev_db_here') }
+    app.configure(:production)  { set :couchdb, CouchRest.database!('your_production_db_here') }
+    app.configure(:test)        { set :couchdb, CouchRest.database!('your_test_db_here') }
+  end
+end
+COUCHREST
+
+  USER = <<-USER
+class User < CouchRest::ExtendedDocument
+  include CouchRest::Validation
+  
+  use_database app { couchdb }
+  
+  property :name
+  property :username
+  property :email
+  property :crypted_password
+  unique_id :id
+  
+  attr_accessor :password, :password_confirmation
+  validates_is_confirmed :password
+  
+  save_callback :before, :encrypt_password
+  
+  def self.find(id)
+    get(id)
+  end
+  
+  def self.id_for(username)
+    "user/\#{username}"
+  end
+  
+  def self.authenticate(username, password)
+    user = User.get(id_for(username))
+    user && user.has_password?(password) ? user : nil
+  end
+  
+  def id
+    self.class.id_for(username)
+  end
+  
+  def encrypt_password
+    self.crypted_password = BCrypt::Password.create(password)
+  end
+  
+  def has_password?(password)
+    BCrypt::Password.new(crypted_password) == password
+  end
+end
+USER
+    
+    def setup_orm
+      require_dependencies 'couchrest'
+      create_file("config/initializers/couch_rest.rb", COUCHREST)
+      create_file("app/models/user.rb", USER)
+    end
+  end
+end

data/generators/components/orms/datamapper_orm_gen.rb

@@ -0,0 +1,52 @@
+module Sinatra
+  module DatamapperOrmGen
+    
+    DM = <<-DM
+module DataMapperInitializer
+  def self.registered(app)
+    app.configure(:development) { DataMapper.setup(:default, 'your_dev_db_here') }
+    app.configure(:production)  { DataMapper.setup(:default, 'your_production_db_here') }
+    app.configure(:test)        { DataMapper.setup(:default, 'your_test_db_here') }
+  end
+end
+DM
+
+  USER = <<-USER
+class User
+  include DataMapper::Resource
+  
+  property :id,       Serial
+  property :name,     String
+  property :username, String
+  property :email,    String
+  property :crypted_password, String
+
+  attr_accessor :password, :password_confirmation
+  
+  before :save, :encrypt_password
+  
+  validates_present :password, :password_confirmation
+
+  def self.authenticate(username, password)
+    user = User.first(:username => username)
+    user && user.has_password?(password) ? user : nil
+  end
+  
+  def encrypt_password
+    self.crypted_password = BCrypt::Password.create(password)
+  end
+  
+  def has_password?(password)
+    BCrypt::Password.new(crypted_password) == password
+  end
+end
+User.auto_upgrade!
+USER
+    
+    def setup_orm
+      require_dependencies 'dm-core', 'dm-validations'
+      create_file("config/initializers/data_mapper.rb", DM)
+      create_file("app/models/user.rb", USER)
+    end
+  end
+end

data/generators/components/orms/mongomapper_orm_gen.rb

@@ -0,0 +1,101 @@
+module Sinatra
+  module MongomapperOrmGen
+    
+    MONGO = <<-MONGO
+class MongoDBConnectionFailure < RuntimeError; end
+
+module MongoDbInitializer
+  def self.registered(app)
+    app.configure :development do
+      MongoMapper.connection = Mongo::Connection.new('localhost')
+      MongoMapper.database = 'your_dev_db_here'
+    end
+
+    app.configure :production do
+      MongoMapper.connection = Mongo::Connection.new('localhost')
+      MongoMapper.database = 'your_production_db_here'
+    end
+
+    app.configure :test do
+      MongoMapper.connection = Mongo::Connection.new('localhost')
+      MongoMapper.database = 'your_test_db_here'
+    end
+  end
+end
+MONGO
+
+   CONCERNED = <<-CONCERN
+module MongoMapper
+  module Document
+    module ClassMethods
+      # TODO find a cleaner way for it to know where to look for dependencies
+      def concerned_with(*concerns)
+        concerns.each { |concern| require_dependency "./app/models/\#{name.underscore}/\#{concern}" }
+      end
+    end
+  end
+end
+CONCERN
+
+  USER = <<-USER
+class User
+  include MongoMapper::Document
+  concerned_with :authentications
+
+  key :name, String, :required => true
+  key :username, String, :required => true
+  key :email, String, :required => true
+  key :crypted_password, String, :required => true
+end
+USER
+
+  AUTH = <<-AUTH
+class User
+  attr_accessor :password, :password_confirmation
+  before_validation :password_checks
+  validate :validate_password
+
+  def password_checks
+    if password_required?
+      encrypt_password if password.present? && password == password_confirmation
+    end
+  end
+
+  def password_required?
+    crypted_password.blank? || !password.blank?
+  end
+
+  def encrypt_password
+    self.crypted_password = BCrypt::Password.create(password)
+  end
+
+  def has_password?(password)
+    BCrypt::Password.new(crypted_password) == password
+  end
+
+  def encrypt_password
+    return if password.blank?
+    self.crypted_password = BCrypt::Password.create(password)
+  end
+
+  def validate_password
+    errors.add :password, "must not be empty" if crypted_password.blank? && password.blank?
+    errors.add :password, "must match password confirmation" unless password == password_confirmation
+  end
+
+  def self.authenticate(username, password)
+    user = User.first(:conditions => { :username => username })
+    user && user.has_password?(password) ? user : nil
+  end
+end
+AUTH
+
+    def setup_orm
+      require_dependencies 'mongo_mapper'
+      create_file("config/initializers/mongo_db.rb", MONGO)
+      create_file("lib/ext/mongo_mapper.rb", CONCERNED)
+      create_file("app/models/user.rb", USER)
+      create_file("app/models/user/authentications.rb", AUTH)
+    end
+  end
+end

data/generators/components/orms/sequel_orm_gen.rb

@@ -0,0 +1,61 @@
+module Sinatra
+  module SequelOrmGen
+
+    SEQUEL = <<-SEQUEL
+module SequelInitializer
+  def self.registered(app)
+    Sequel::Model.plugin(:schema)
+    app.configure(:development) { Sequel.connect('your_dev_db_here') }
+    app.configure(:production)  { Sequel.connect('your_production_db_here') }
+    app.configure(:test)        { Sequel.connect('your_test_db_here') }
+  end
+end
+SEQUEL
+
+    USER = <<-USER
+    class User < Sequel::Model(:users)
+      unless table_exists?
+        set_schema do
+          primary_key :id
+          string :name
+          string :username
+          string :email
+          string :crypted_password
+        end
+        create_table
+      end
+
+      attr_accessor :password, :password_confirmation
+
+      def self.authenticate(username, password)
+        user = User.filter(:username => username).first
+        user && user.has_password?(password) ? user : nil
+      end
+
+      def encrypt_password
+        return if password.blank?
+        self.crypted_password = BCrypt::Password.create(password)
+      end
+
+      def has_password?(password)
+        BCrypt::Password.new(crypted_password) == password
+      end
+
+      def before_save
+        encrypt_password
+      end
+
+      def validate
+        errors.add :password, "must not be empty" if self.crypted_password.blank? && password.blank?
+        errors.add :password, "must match password confirmation" unless password == password_confirmation
+      end
+    end
+USER
+
+    def setup_orm
+      require_dependencies 'sequel'
+      create_file("config/initializers/sequel.rb", SEQUEL)
+      create_file("app/models/user.rb", USER)
+    end
+  end
+end

data/generators/components/renderers/erb_renderer_gen.rb

@@ -0,0 +1,7 @@
+module Sinatra
+  module ErbRendererGen    
+    def setup_renderer
+      require_dependencies 'erubis'
+    end
+  end
+end

data/generators/components/renderers/haml_renderer_gen.rb

@@ -0,0 +1,22 @@
+module Sinatra
+  module HamlRendererGen
+
+    SASS_INIT = (<<-SASS).gsub(/^ {4}/, '')
+    # Enables support for SASS template reloading for rack.
+    # See http://nex-3.com/posts/88-sass-supports-rack for more details.
+
+    module SassInitializer
+      def self.registered(app)
+        require 'sass/plugin/rack'
+        app.use Sass::Plugin::Rack
+      end
+    end
+    SASS
+
+    def setup_renderer
+      require_dependencies 'haml'
+      create_file("config/initializers/sass.rb", SASS_INIT)
+      empty_directory('public/stylesheets/sass')
+    end
+  end
+end

data/generators/components/scripts/jquery_script_gen.rb

@@ -0,0 +1,9 @@
+module Sinatra
+  module JqueryScriptGen
+
+    def setup_script
+      get("http://jqueryjs.googlecode.com/files/jquery-1.3.2.min.js", "public/javascripts/jquery.min.js")
+    end
+    
+  end
+end