bootstrap-on 0.0.0

data/lib/bootstrap-on/bs_admin_page.rb

@@ -0,0 +1,55 @@
+module Padrino
+  module Generators
+    ##
+    # Defines the generator for creating a new admin page.
+    #
+    class BsAdminPage < Thor::Group
+      attr_accessor :default_orm
+
+      # Add this generator to our padrino-gen
+      Padrino::Generators.add_generator(:bs_admin_page, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      # Defines the "banner" text for the CLI.
+      def self.banner; "padrino g bs_admin_page [model]"; end
+
+      # Include related modules
+      include Thor::Actions
+      include Padrino::Generators::Actions
+      include Padrino::Generators::Admin::Actions
+
+      desc "Description:\n\n\tpadrino g bs_admin_page [model(s)] - Generates a new Padrino Admin page with Twitter Bootstrapped integrated"
+
+      argument :models, :desc => "The name(s) of your model(s)", :type => :array
+      class_option :skip_migration, :aliases => "-s", :default => false, :type => :boolean
+      class_option :root, :desc => "The root destination", :aliases => '-r', :type => :string
+      class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
+
+      # Show help if no argv given
+      require_arguments!
+
+      # Create controller for admin
+      def create_controller
+        self.destination_root = options[:root]
+        if in_app_root?
+          models.each do |model|
+            @orm = default_orm || Padrino::Admin::Generators::Orm.new(model, adapter)
+            self.behavior = :revoke if options[:destroy]
+            empty_directory destination_root("/admin/views/#{@orm.name_plural}")
+
+            template "templates/page/controller.rb.tt",       destination_root("/admin/controllers/#{@orm.name_plural}.rb")
+            template "templates/#{ext}/page/_form.#{ext}.tt", destination_root("/admin/views/#{@orm.name_plural}/_form.#{ext}")
+            template "templates/#{ext}/page/edit.#{ext}.tt",  destination_root("/admin/views/#{@orm.name_plural}/edit.#{ext}")
+            template "templates/#{ext}/page/index.#{ext}.tt", destination_root("/admin/views/#{@orm.name_plural}/index.#{ext}")
+            template "templates/#{ext}/page/new.#{ext}.tt",   destination_root("/admin/views/#{@orm.name_plural}/new.#{ext}")
+
+            options[:destroy] ? remove_project_module(@orm.name_plural) : add_project_module(@orm.name_plural)
+          end
+        else
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)"
+        end
+      end
+    end # AdminPage
+  end # Generators
+end # Padrino

data/lib/bootstrap-on/templates/account/activerecord.rb.tt

@@ -0,0 +1,38 @@
+class <%= @model_name %> < ActiveRecord::Base
+  attr_accessor :password, :password_confirmation
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  validates_presence_of     :password_confirmation,      :if => :password_required
+  validates_length_of       :password, :within => 4..40, :if => :password_required
+  validates_confirmation_of :password,                   :if => :password_required
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before_save :encrypt_password, :if => :password_required
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.has_password?(password) ? account : nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password)
+  end
+
+  def password_required
+    crypted_password.blank? || password.present?
+  end
+end

data/lib/bootstrap-on/templates/account/couchrest.rb.tt

@@ -0,0 +1,66 @@
+class <%= @model_name %> < CouchRest::Model::Base
+  attr_accessor :password, :password_confirmation
+
+  # Properties
+  property :name
+  property :surname
+  property :email
+  property :crypted_password
+  property :role
+
+  view_by :email
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  validates_presence_of     :password_confirmation,      :if => :password_required
+  validates_length_of       :password, :within => 4..40, :if => :password_required
+  validates_confirmation_of :password,                   :if => :password_required
+  validates_length_of       :email,    :within => 3..100
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+  validate                  :unique_email_validator
+
+  # Callbacks
+  before_save :encrypt_password, :if => :password_required
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = find_by_email(email)
+    account if account && account.has_password?(password)
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  ##
+  # This method is used by AuthenticationHelper
+  #
+  def self.find_by_id(id)
+    get(id)
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password)
+  end
+
+  def password_required
+    crypted_password.blank? || password.present?
+  end
+
+  def unique_email_validator
+    account = self.class.find_by_email(email)
+
+    # didn't find email in the database
+    return if account.nil?
+
+    # account with same email in database is this account
+    return if has_key?('_id') && self['_id'] == account['_id']
+
+    errors.add(:email, "is not unique")
+  end
+end

data/lib/bootstrap-on/templates/account/datamapper.rb.tt

@@ -0,0 +1,55 @@
+class <%= @model_name %>
+  include DataMapper::Resource
+  include DataMapper::Validate
+  attr_accessor :password, :password_confirmation
+
+  # Properties
+  property :id,               Serial
+  property :name,             String
+  property :surname,          String
+  property :email,            String
+  property :crypted_password, String, :length => 70
+  property :role,             String
+
+  # Validations
+  validates_presence_of      :email, :role
+  validates_presence_of      :password,                          :if => :password_required
+  validates_presence_of      :password_confirmation,             :if => :password_required
+  validates_length_of        :password, :min => 4, :max => 40,   :if => :password_required
+  validates_confirmation_of  :password,                          :if => :password_required
+  validates_length_of        :email,    :min => 3, :max => 100
+  validates_uniqueness_of    :email,    :case_sensitive => false
+  validates_format_of        :email,    :with => :email_address
+  validates_format_of        :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before :save, :encrypt_password
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.has_password?(password) ? account : nil
+  end
+
+  ##
+  # This method is used by AuthenticationHelper
+  #
+  def self.find_by_id(id)
+    get(id) rescue nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  private
+  def password_required
+    crypted_password.blank? || password.present?
+  end
+
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password) if password.present?
+  end
+end

data/lib/bootstrap-on/templates/account/mini_record.rb.tt

@@ -0,0 +1,41 @@
+class <%= @model_name %> < ActiveRecord::Base
+  attr_accessor :password, :password_confirmation
+
+  # Fields
+  field :name, :surname, :email, :crypted_password, :role
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  validates_presence_of     :password_confirmation,      :if => :password_required
+  validates_length_of       :password, :within => 4..40, :if => :password_required
+  validates_confirmation_of :password,                   :if => :password_required
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before_save :encrypt_password, :if => :password_required
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.has_password?(password) ? account : nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password)
+  end
+
+  def password_required
+    crypted_password.blank? || password.present?
+  end
+end

data/lib/bootstrap-on/templates/account/mongoid.rb.tt

@@ -0,0 +1,53 @@
+class <%= @model_name %>
+  include Mongoid::Document
+  attr_accessor :password, :password_confirmation
+
+  # Fields
+  field :name,             :type => String
+  field :surname,          :type => String
+  field :email,            :type => String
+  field :crypted_password, :type => String
+  field :role,             :type => String
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  validates_presence_of     :password_confirmation,      :if => :password_required
+  validates_length_of       :password, :within => 4..40, :if => :password_required
+  validates_confirmation_of :password,                   :if => :password_required
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before_save :encrypt_password, :if => :password_required
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.has_password?(password) ? account : nil
+  end
+
+  ##
+  # This method is used by AuthenticationHelper
+  #
+  def self.find_by_id(id)
+    find(id) rescue nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(self.password)
+  end
+
+  def password_required
+    crypted_password.blank? || self.password.present?
+  end
+end

data/lib/bootstrap-on/templates/account/mongomapper.rb.tt

@@ -0,0 +1,46 @@
+class <%= @model_name %>
+  include MongoMapper::Document
+  attr_accessor :password, :password_confirmation
+
+  # Keys
+  key :name,             String
+  key :surname,          String
+  key :email,            String
+  key :crypted_password, String
+  key :role,             String
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  validates_presence_of     :password_confirmation,      :if => :password_required
+  validates_length_of       :password, :within => 4..40, :if => :password_required
+  validates_confirmation_of :password,                   :if => :password_required
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before_save :encrypt_password, :if => :password_required
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = first(:email => email) if email.present?
+    account && account.has_password?(password) ? account : nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(crypted_password) == password
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password)
+  end
+
+  def password_required
+    crypted_password.blank? || password.present?
+  end
+end

data/lib/bootstrap-on/templates/account/seeds.rb.tt

@@ -0,0 +1,28 @@
+# Seed add you the ability to populate your db.
+# We provide you a basic shell for interaction with the end user.
+# So try some code like below:
+#
+#   name = shell.ask("What's your name?")
+#   shell.say name
+#
+email     = shell.ask "Which email do you want use for logging into admin?"
+password  = shell.ask "Tell me the password to use:"
+
+shell.say ""
+
+account = <%= @model_name %>.create(:email => email, :name => "Foo", :surname => "Bar", :password => password, :password_confirmation => password, :role => "admin")
+
+if account.valid?
+  shell.say "================================================================="
+  shell.say "<%= @model_name %> has been successfully created, now you can login with:"
+  shell.say "================================================================="
+  shell.say "   email: #{email}"
+  shell.say "   password: #{password}"
+  shell.say "================================================================="
+else
+  shell.say "Sorry but some thing went wrong!"
+  shell.say ""
+  account.errors.full_messages.each { |m| shell.say "   - #{m}" }
+end
+
+shell.say ""

data/lib/bootstrap-on/templates/account/sequel.rb.tt

@@ -0,0 +1,52 @@
+class <%= @model_name %> < ::Sequel::Model
+
+  plugin :validation_helpers
+
+  attr_accessor :password, :password_confirmation
+
+  def validate
+    validates_presence     :email
+    validates_presence     :role
+    validates_presence     :password if password_required
+    validates_presence     :password_confirmation if password_required
+    validates_length_range 4..40, :password unless password.blank?
+    errors.add(:password_confirmation, 'must confirm password') if !password.blank? && password != password_confirmation
+    validates_length_range 3..100, :email unless email.blank?
+    validates_unique       :email unless email.blank?
+    validates_format       /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :email unless email.blank?
+    validates_format       /[A-Za-z]/, :role unless role.blank?
+  end
+
+  # Callbacks
+  def before_save
+    encrypt_password
+  end
+
+  ##
+  # This method is for authentication purpose
+  #
+  def self.authenticate(email, password)
+    account = filter(:email => email).first
+    account && account.has_password?(password) ? account : nil
+  end
+
+  ##
+  # Replace AR method
+  #
+  def self.find_by_id(id)
+    self[id] rescue nil
+  end
+
+  def has_password?(password)
+    ::BCrypt::Password.new(self.crypted_password) == password
+  end
+
+  private
+  def encrypt_password
+    self.crypted_password = ::BCrypt::Password.create(password) if password.present?
+  end
+
+  def password_required
+    self.crypted_password.blank? || password.present?
+  end
+end