bento 0.0.1

data/README.rdoc

@@ -0,0 +1,62 @@
+= Bento
+Bento is a Rails account management engine.
+
+== Disclaimer
+Don't expect everything to work as described below. The gem is still in early beta.
+
+== Requirements
+Currently it has a lot of pre conditions. The goal is to get rid of as many of them as possible but right new Bento expects the following:
+* Your model for managing accounts is named Account (Bento can generate it for you)
+* The account model has a name and a plan column (Bento can generate the migrations too)
+* You have a model named User to keep track of users
+- The users has a first_name, last_name, email and password fields
+
+== Installation
+ gem install bento
+ rails generate bento account
+ rake db:migrate
+
+== Basic Usage
+Bento sets up the following routes that you can use, complete with views and controllers:
+* [GET] sign_up_accounts - account and user creation in once
+* [GET] new_accounts - for just account creation
+* [GET] accounts - show
+* [GET] account - index
+* [POST] accounts - create
+* [PUT] account - update
+* [DELETE] account - destroy
+
+== Views and controllers
+=== Access the current account:
+There is a current_account helper in your controllers and views which returns the currently logged in user's account.
+
+=== Automatic scoping
+If you're using inherited_resources in your controllers you can do the below to scope your resource to the current account.
+  class MyController < ApplicationController
+    scoped_to_account
+  end
+
+=== Admin managed account
+Bento can give you a complete CRUD for creating accounts. Use
+  rails generate bento:views
+If your current_user respond to admin? These actions will only be accessible by users that respond with true.
+
+== Configuring controllers
+
+You can customize the accounts controller by following these steps:
+
+1) Create your custom accounts controller, AccountsController
+    class AccountsController < Bento::AccountsController
+    end
+
+2) Tell the router to use this controller:
+    resources :accounts
+
+3) And since we changed the controller, it won't use the gem's views so make sure to make some and put in app/views/accounts.
+
+== Credits and contributors
+
+* The contributors of the awesome Devise gem from which I've borrowed a lot of ideas and patterns.
+* Elabs for sponsoring
+* Jonas Nicklas for helping me boot strap the engine.
+* All the gems that this gem depends on.

data/lib/bento.rb

@@ -0,0 +1,6 @@
+module Bento
+  require "bento/rails"
+  require "bento/models/account"
+  require "bento/controllers/helpers"
+  require "bento/controllers/account_scopable"
+end

data/lib/bento/controllers/account_scopable.rb

@@ -0,0 +1,22 @@
+module Bento
+  module Controllers
+    module AccountScopable
+      def scoped_to_account(*args, &block)
+        inherit_resources(*args)
+        include AccountScopable::InstanceMethods
+      end
+
+      module InstanceMethods
+        def begin_of_association_chain
+          current_user.account
+        end
+
+        private :begin_of_association_chain
+      end
+    end
+  end
+end
+
+class ActionController::Base
+  extend Bento::Controllers::AccountScopable
+end

data/lib/bento/controllers/helpers.rb

@@ -0,0 +1,17 @@
+module Bento
+  module Controllers
+    module Helpers
+      def self.included(base)
+        base.helper_method :current_account
+      end
+
+      def current_account
+        current_user.account if current_user
+      end
+    end
+  end
+end
+
+class ActionController::Base
+  include Bento::Controllers::Helpers
+end

data/lib/bento/models/account.rb

@@ -0,0 +1,59 @@
+module Bento
+  module Models
+    module Account
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        USER_ACCESSORS = [:first_name, :last_name, :email, :password, :password_confirmation]
+
+        def bento_account(*options)
+          if extend_with_validations?(options)
+            validates_presence_of :name
+          end
+
+          if extend_with_user_accessors?(options)
+            attr_accessor *USER_ACCESSORS
+          end
+
+          if extend_with_user_association?(options)
+            has_many :users
+          end
+
+          if extend_with_trial?(options)
+            define_method("trial_days_remaining") do
+              created_at.advance(:days => 30).to_date - Date.today
+            end
+          end
+
+          if extend_with_user_association?(options) and extend_with_user_accessors?(options)
+            before_validation :build_user, :on => :create
+
+            define_method("build_user") do
+              user_attributes = USER_ACCESSORS.inject({}) { |h, key| h.merge(key => send(key)) }
+              if user_attributes.values.any?
+                @user ||= users.build(user_attributes)
+                @user.tap(&:valid?).errors.each { |attribute, message| errors.add(attribute, message) }
+                @user
+              end
+            end
+          end
+        end
+
+        private
+
+        def method_missing(*args)
+          option = args.shift.to_s.sub(/^extend_with_/, '').chop.to_sym
+          available = args.flatten
+
+          (available.is_a?(Array) and available.empty?) or available.include?(:all) or available.include?(option)
+        end
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include Bento::Models::Account
+end

data/lib/bento/rails.rb

@@ -0,0 +1,4 @@
+module Bento
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/bento/version.rb

@@ -0,0 +1,3 @@
+module Bento
+  VERSION = "0.0.1"
+end

data/lib/generators/active_record/bento_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators/active_record'
+require 'generators/bento/orm_helpers'
+
+module ActiveRecord
+  module Generators
+    class BentoGenerator < ActiveRecord::Generators::Base
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+
+      include Bento::Generators::OrmHelpers
+      source_root File.expand_path("../templates", __FILE__)
+
+      def generate_model
+        invoke "active_record:model", [name], :migration => false unless model_exists?
+      end
+
+      def copy_bento_migration
+        migration_template "create_migration.rb", "db/migrate/bento_create_#{table_name}"
+        migration_template "add_migration.rb", "db/migrate/bento_add_account_id_to_#{table_name}"
+      end
+
+      def inject_bento_content
+        inject_into_class model_path, class_name, model_contents + <<-CONTENT
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :name, :plan, :first_name, :last_name, :email, :password_confirmation, :password
+CONTENT
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/add_migration.rb

@@ -0,0 +1,9 @@
+class BentoAddAccountIdToAccounts < ActiveRecord::Migration
+  def self.up
+    add_column :users, :account_id, :integer
+  end
+
+  def self.down
+    remove_column :users, :column_name
+  end
+end

data/lib/generators/active_record/templates/create_migration.rb

@@ -0,0 +1,18 @@
+class BentoCreateAccounts < ActiveRecord::Migration
+  def self.up
+    create_table :accounts do |t|
+      t.string :name
+      t.string :plan
+<% for attribute in attributes -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+      t.timestamps
+    end
+
+    add_index :accounts, :name, :unique => true
+  end
+
+  def self.down
+    drop_table :accounts
+  end
+end

data/lib/generators/bento/bento_generator.rb

@@ -0,0 +1,13 @@
+module Bento
+  module Generators
+    class BentoGenerator < Rails::Generators::NamedBase
+      namespace "bento"
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Generates a model with the given NAME (if one does not exist) with bento " <<
+           "configuration plus a migration file."
+
+      hook_for :orm
+    end
+  end
+end

data/lib/generators/bento/orm_helpers.rb

@@ -0,0 +1,22 @@
+module Bento
+  module Generators
+    module OrmHelpers
+      def model_contents
+<<-CONTENT
+  # Include all bento modules. Others available are:
+  # :all, :validations, :user_accessors, :user_association, :user_accessors, :trial
+  bento_account
+
+CONTENT
+      end
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+    end
+  end
+end

data/lib/generators/bento/views_generator.rb

@@ -0,0 +1,14 @@
+module Bento
+  module Generators
+    class ViewsGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../../../app/views", __FILE__)
+      desc "Copies all Bento views to your application."
+
+      argument :scope, :required => false, :default => nil, :desc => "The scope to copy views to"
+
+      def copy_views
+        directory "bento", "app/views/#{scope}"
+      end
+    end
+  end
+end

data/spec/bento/controllers/helpers_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Bento::Controllers::Helpers do
+end

data/spec/bento/models/account_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+class Bento::AccountTest < ActiveRecord::Base
+  set_table_name("accounts")
+  attr_accessible :name, :plan, :first_name, :last_name, :email, :password_confirmation, :password, :created_at
+end
+class NoOptionsTestAccount < Bento::AccountTest;                bento_account;                                     end
+class AllTestAccount < Bento::AccountTest;                      bento_account(:all);                               end
+class ValidationsTestAccount < Bento::AccountTest;              bento_account(:validations);                       end
+class UserAccessorsTestAccount < Bento::AccountTest;            bento_account(:user_accessors);                    end
+class UserAssociationTestAccount < Bento::AccountTest;          bento_account(:user_association);                  end
+class AllUserTestAccount < Bento::AccountTest;                  bento_account(:user_accessors, :user_association); end
+class ServeralOptionsAccessorsTestAccount < Bento::AccountTest; bento_account(:user_accessors, :validations);      end
+class TrialTestAccount < Bento::AccountTest;                    bento_account(:trial);                             end
+
+describe Bento::Models::Account do
+  let(:account_params) do
+    { :name => "Hashrocket", :first_name => "Obie", :last_name => "Fernandez", :email => "obie@hashrocket.com", :password => "test1234" }
+  end
+
+  context "all" do
+    subject { AllTestAccount.new }
+    it { should be_invalid_without(:name) }
+    it { should have_user_accessors }
+    it { should respond_to(:users) }
+    it { should respond_to(:trial_days_remaining) }
+    it { should respond_to(:build_user) }
+
+    describe ".build_user" do
+      context "all user attributes are blank" do
+        it "creates the account without the user" do
+          account = AllTestAccount.new(:name => "Elabs")
+          account.save.should be_true
+          User.find_by_account_id(account.id).should be_nil
+        end
+      end
+
+      context "at least one user attributes is present" do
+        context "successfully creating a user" do
+          subject do
+            account = AllTestAccount.create!(account_params)
+            account.users.first
+          end
+
+          its(:email) { should == "obie@hashrocket.com" }
+          its(:first_name) { should == "Obie" }
+          its(:last_name) { should == "Fernandez" }
+        end
+
+        context "unsuccessfully creating a user" do
+          subject { AllTestAccount.new(account_params.merge(:email => "")).tap(&:valid?) }
+          it { subject.errors.should include(:email) }
+        end
+      end
+    end
+
+    describe "#trial_days_remaining" do
+      subject { TrialTestAccount.create!(:name => "Account", :created_at => 6.days.ago).trial_days_remaining }
+      it("returns the number of days that are left in the trial") { should == 24 }
+    end
+  end
+
+  context "no options" do
+    subject { NoOptionsTestAccount.new }
+    it { should be_invalid_without(:name) }
+    it { should have_user_accessors }
+    it { should respond_to(:users) }
+    it { should respond_to(:trial_days_remaining) }
+    it { should respond_to(:build_user) }
+  end
+
+  context "validations" do
+    subject { ValidationsTestAccount.new }
+    it { should be_invalid_without(:name) }
+    it { should_not have_user_accessors }
+    it { should_not respond_to(:users) }
+    it { should_not respond_to(:trial_days_remaining) }
+    it { should_not respond_to(:build_user) }
+  end
+
+  context "user accessors" do
+    subject { UserAccessorsTestAccount.new }
+    it { should_not be_invalid_without(:name) }
+    it { should have_user_accessors }
+    it { should_not respond_to(:users) }
+    it { should_not respond_to(:trial_days_remaining) }
+    it { should_not respond_to(:build_user) }
+  end
+
+  context "several options" do
+    subject { ServeralOptionsAccessorsTestAccount.new }
+    it { should be_invalid_without(:name) }
+    it { should have_user_accessors }
+    it { should_not respond_to(:users) }
+    it { should_not respond_to(:trial_days_remaining) }
+    it { should_not respond_to(:build_user) }
+  end
+
+  context "user association" do
+    subject { UserAssociationTestAccount.new }
+    it { should_not be_invalid_without(:name) }
+    it { should_not have_user_accessors }
+    it { should respond_to(:users) }
+    it { should_not respond_to(:trial_days_remaining) }
+    it { should_not respond_to(:build_user) }
+  end
+
+  context "trial" do
+    subject { TrialTestAccount.new }
+    it { should_not be_invalid_without(:name) }
+    it { should_not have_user_accessors }
+    it { should_not respond_to(:users) }
+    it { should respond_to(:trial_days_remaining) }
+    it { should_not respond_to(:build_user) }
+  end
+
+  context "user accessors and user association" do
+    subject { AllUserTestAccount.new }
+    it { should_not be_invalid_without(:name) }
+    it { should have_user_accessors }
+    it { should respond_to(:users) }
+    it { should_not respond_to(:trial_days_remaining) }
+    it { should respond_to(:build_user) }
+  end
+end

data/spec/proof_of_concepts_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe RailsApp do
+  it "reach it's own files" do
+    visit "/"
+    page.body.should include("Welcome to the app that's using Bento")
+  end
+
+  it "loads app" do
+    Bento::AccountsController.should == Bento::AccountsController
+  end
+
+  it "mounts the new accounts route" do
+    visit "/accounts/new"
+    page.status_code.should == 200
+  end
+end