bento 0.0.1 → 0.0.2

data/README.rdoc

@@ -1,62 +1,82 @@
 = 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.
+== Installation
+Install the gem with bundler:
+  gem install bundler
+  add gem 'bento' to your Gemfile
+  bundle install
 
-== 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
+When you are done, you are ready to add Bento to any of your models using the generator:
+  rails generate bento MODEL
+  rake db:migrate
+Replace MODEL by the class name you want to use as your account-like model, like Account, Site, etc.
+This will create a model (if one does not exist) and configure it with default Bento options.
+The generator will also create a migration file (if you're running ActiveRecord) and configure your routes.
 
-== 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
+== Getting started
+=== Model
+This is a walkthrough with all steps you need to setup a Bento resource, including model, migration and route files.
+Bento must be set up within the model (or models) you want to use. Bento routes must be created inside your config/routes.rb file.
+We're assuming here you want a Account model with the default Bento options.
+  class Account < ActiveRecord::Base
+    bento
+  end
+Bento doesn't use attr_accessible or attr_protected inside its modules, so be sure to define attributes as accessible or protected in your model.
+
+=== Routes
+Configure your routes after setting up your model. Open your config/routes.rb file and add:
+  bento_for :accounts
+This will use your Account model to create a set of needed routes (you can see them by running `rake routes`).
+
+This will add bento_for :accounts to your routes file. If you want to add another model just rename or add the argument(s) to bento_for.
+  bento_for :accounts, :sites
+
+=== Controllers
+You can tell your controllers to scope your resource to the current account.
+  class AccountsController < Bento::AccountsController
     scoped_to_account
   end
+If you're defining your own controller you must generate views as described below.
+If your current_user respond to admin? All the actions will only be accessible by users that respond with true.
 
-=== Admin managed account
-Bento can give you a complete CRUD for creating accounts. Use
+=== Views
+Bento gives you a complete CRUD for managing accounts. To customize the views 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:
+=== Helpers
+Bento will create the following helpers to use inside your controllers and views:
+  current_account
+Where account would be anything your model is named.
+The helper depends on a current_user-helper being defined (as is the case if you're using Devise).
 
-1) Create your custom accounts controller, AccountsController
-    class AccountsController < Bento::AccountsController
+=== Override specific pieces
+The default behavior is to redirect to the accounts show view after creation.
+This can be changed by overriding the after_create_url method:
+  class AccountsController < Bento::AccountsController
+    protected
+    def after_create_url
+      account_path(resource)
     end
+  end
 
-2) Tell the router to use this controller:
-    resources :accounts
+== Navigating the source
+  The gem has a basic set of cucumber features along with a rails app.
+  Check them out to see some examples on how to use Bento in your application.
 
-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.
+== Disclaimer
+* The gem is still in early beta, be careful.
+* Forces you to have a User-model.
+* Only works with Rails 3 and ActiveRecord.
 
 == 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.
+
+== TODO:
+* Be able to nest other routes in bento_for.
+* Remove the requirement to generate view files when overriding the accounts controller.
+* Make is possible to have another user model then User.
+* Make it possible for a user to belong to more then one account.

data/lib/bento/controllers/account_scopable.rb

@@ -7,11 +7,40 @@ module Bento
       end
 
       module InstanceMethods
+        private
+
         def begin_of_association_chain
-          current_user.account
+          @account ||= current_account
+        end
+
+        def current_account
+          if not_responding_to_admin? or admin?
+            account_by_param_or_session
+          else
+            current_user.account
+          end
+        end
+
+        def admin?
+          respond_to_admin? and current_user.admin?
+        end
+
+        def not_responding_to_admin?
+          (not respond_to_admin?)
+        end
+
+        def respond_to_admin?
+          current_user.respond_to?(:admin?)
         end
 
-        private :begin_of_association_chain
+        def account_by_param_or_session
+          if account_id then Account.find(account_id) else current_user.account end
+        end
+
+        def account_id
+          key, value = params.find { |key, value| key.to_s.ends_with?("account_id") }
+          value
+        end
       end
     end
   end

data/lib/bento/controllers/helpers.rb

@@ -1,17 +1,21 @@
 module Bento
   module Controllers
     module Helpers
-      def self.included(base)
-        base.helper_method :current_account
-      end
+      mattr_accessor :resource_names
+      @@resource_names = []
+
+      def self.define_helpers(resource_name)
+        @@resource_names << resource_name.to_s.singularize
 
-      def current_account
-        current_user.account if current_user
+        ActiveSupport.on_load(:action_controller) do
+          @@resource_names.uniq.each do |name|
+            define_method("current_#{name}") do
+              current_user.send(name) if current_user
+            end
+            helper_method "current_#{name}"
+          end
+        end
       end
     end
   end
-end
-
-class ActionController::Base
-  include Bento::Controllers::Helpers
 end

data/lib/bento/models/account.rb

@@ -1,53 +1,34 @@
+Dir["#{File.expand_path(File.dirname(__FILE__))}/modules/*.rb"].each {|f| require f}
+
 module Bento
   module Models
     module Account
+      DEFAULT_MODULES = %w[validations user_association]
+      ALL_MODULES = DEFAULT_MODULES + %w[trial user_accessors]
+
       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
+        def bento(*modules)
+          module_names(modules).each { |name| include account_module(name) }
         end
 
         private
 
-        def method_missing(*args)
-          option = args.shift.to_s.sub(/^extend_with_/, '').chop.to_sym
-          available = args.flatten
+        def module_names(modules)
+          if modules.include?(:all)
+            ALL_MODULES
+          elsif modules.empty?
+            DEFAULT_MODULES
+          else
+            modules
+          end
+        end
 
-          (available.is_a?(Array) and available.empty?) or available.include?(:all) or available.include?(option)
+        def account_module(name)
+          "Bento::Models::Modules::#{name.to_s.camelcase}".constantize
         end
       end
     end

data/lib/bento/models/modules/trial.rb

@@ -0,0 +1,15 @@
+module Bento
+  module Models
+    module Modules
+      module Trial
+        def self.included(base)
+          base.class_eval do
+            define_method("trial_days_remaining") do
+              created_at.advance(:days => 30).to_date - Date.today
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bento/models/modules/user_accessors.rb

@@ -0,0 +1,26 @@
+module Bento
+  module Models
+    module Modules
+      module UserAccessors
+        USER_ACCESSORS = [:first_name, :last_name, :email, :password, :password_confirmation]
+
+        def self.included(base)
+          base.class_eval do
+            include ::Bento::Models::Modules::UserAssociation
+            attr_accessor *USER_ACCESSORS
+            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
+      end
+    end
+  end
+end

data/lib/bento/models/modules/user_association.rb

@@ -0,0 +1,13 @@
+module Bento
+  module Models
+    module Modules
+      module UserAssociation
+        def self.included(base)
+          base.class_eval do
+            has_many :users
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bento/models/modules/validations.rb

@@ -0,0 +1,14 @@
+module Bento
+  module Models
+    module Modules
+      module Validations
+        def self.included(base)
+          base.class_eval do
+            validates_presence_of :name
+            validates_uniqueness_of :name, :allow_blank => true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bento/rails/routes.rb

@@ -0,0 +1,24 @@
+module ActionDispatch::Routing
+  class Mapper
+    def bento_for(*resource_names)
+      resource_names.map!(&:to_sym)
+      resource_names.each do |resource_name|
+        Bento::Controllers::Helpers.define_helpers(resource_name)
+
+        resources(resource_name, :controller => account_controller(resource_name)) do
+          collection { get :sign_up }
+        end
+      end
+    end
+
+    protected
+
+    def account_controller(resource_name)
+      if resource_name == :accounts and not overridden_accounts_contoller? then "bento/accounts" else nil end
+    end
+
+    def overridden_accounts_contoller?
+      File.exist?(Rails.root.join("app", "controllers", "accounts_controller.rb"))
+    end
+  end
+end

data/lib/bento/rails.rb

@@ -1,3 +1,5 @@
+require 'bento/rails/routes'
+
 module Bento
   class Engine < ::Rails::Engine
   end

data/lib/bento/version.rb

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

data/lib/generators/active_record/bento_generator.rb

@@ -15,7 +15,7 @@ module ActiveRecord
 
       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}"
+        migration_template "add_migration.rb", "db/migrate/bento_add_#{name}_id_to_#{table_name}"
       end
 
       def inject_bento_content

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

@@ -1,6 +1,6 @@
-class BentoAddAccountIdToAccounts < ActiveRecord::Migration
+class BentoAdd<%= name.classify %>IdTo<%= name.classify %>s < ActiveRecord::Migration
   def self.up
-    add_column :users, :account_id, :integer
+    add_column :users, :<%= name %>_id, :integer
   end
 
   def self.down

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

@@ -1,18 +1,17 @@
-class BentoCreateAccounts < ActiveRecord::Migration
+class BentoCreate<%= name.classify %>s < ActiveRecord::Migration
   def self.up
-    create_table :accounts do |t|
+    create_table :<%= name.pluralize %> 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
+    add_index :<%= name.pluralize %>, :name, :unique => true
   end
 
   def self.down
-    drop_table :accounts
+    drop_table :<%= name.pluralize %>
   end
 end

data/lib/generators/bento/bento_generator.rb

@@ -8,6 +8,10 @@ module Bento
            "configuration plus a migration file."
 
       hook_for :orm
+
+      def add_bento_routes
+        route "bento_for :#{table_name}"
+      end
     end
   end
 end

data/lib/generators/bento/orm_helpers.rb

@@ -5,7 +5,7 @@ module Bento
 <<-CONTENT
   # Include all bento modules. Others available are:
   # :all, :validations, :user_accessors, :user_association, :user_accessors, :trial
-  bento_account
+  bento
 
 CONTENT
       end

data/spec/bento/controllers/helpers_spec.rb

@@ -1,4 +1,28 @@
 require 'spec_helper'
 
+class AccountController < ActionController::Base; end
+
 describe Bento::Controllers::Helpers do
+  subject { AccountController.new }
+  let(:account) { Account.make }
+  let(:site) { Site.make }
+  let(:user) { User.make(:account => account, :site => site) }
+
+  before do
+    AccountController.send(:include, Bento::Controllers::Helpers)
+    subject.stubs(:current_user).returns(user)
+  end
+
+  describe ".define_helpers" do
+    it "defines the method current_<resource>" do
+      Bento::Controllers::Helpers.define_helpers(:site)
+      subject.current_site.should == site
+    end
+  end
+
+  describe "#current_account" do
+    it "returns the current users account" do
+      subject.current_account.should == account
+    end
+  end
 end

data/spec/bento/models/account_spec.rb

@@ -1,23 +1,11 @@
 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
+class Bento::AccountTest < ActiveRecord::Base;                  set_table_name("accounts");   end
+class NoOptionsTestAccount < Bento::AccountTest;                bento;                        end
+class AllTestAccount < Bento::AccountTest;                      bento(:all);                  end
+class ServeralOptionsAccessorsTestAccount < Bento::AccountTest; bento(:trial, :validations);  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) }
@@ -25,64 +13,13 @@ describe Bento::Models::Account do
     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 respond_to(:users) }
     it { should_not respond_to(:trial_days_remaining) }
     it { should_not respond_to(:build_user) }
   end
@@ -90,36 +27,9 @@ describe Bento::Models::Account do
   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/bento/models/modules/trial_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+class TrialTestAccount < ActiveRecord::Base
+  set_table_name("accounts")
+  attr_accessible :name, :created_at
+  bento(:trial)
+end
+
+describe Bento::Models::Modules::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) }
+
+  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