bento 0.0.2 → 0.0.3

data/README.rdoc

@@ -14,6 +14,10 @@ Replace MODEL by the class name you want to use as your account-like model, like
 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.
 
+The migration files will by default set up the following database structure:
+  user has_many :accounts, :through => :bento_memberships
+  accounts has_many :users, :through => :bento_memberships
+
 == Getting started
 === Model
 This is a walkthrough with all steps you need to setup a Bento resource, including model, migration and route files.
@@ -28,6 +32,10 @@ Bento doesn't use attr_accessible or attr_protected inside its modules, so be su
 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`).
+You can nest other routes in bento_for just as you would with the standard resources routes method:
+  bento_for :accounts do
+    resources :projects
+  end
 
 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
@@ -61,8 +69,8 @@ This can be changed by overriding the after_create_url method:
   end
 
 == 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.
+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.
 
 == Disclaimer
 * The gem is still in early beta, be careful.
@@ -76,7 +84,32 @@ This can be changed by overriding the after_create_url method:
 * 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 it possible to create new users
+* Make it possible to completely remove users
+* Add inline documentation
 * Make is possible to have another user model then User.
-* Make it possible for a user to belong to more then one account.
+
+== License:
+
+(The MIT License)
+
+Copyright (c) 2011 Nicklas Ramhöj
+
+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.

data/lib/bento.rb

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

data/lib/bento/controllers/account_scopable.rb

@@ -1,50 +1,82 @@
 module Bento
   module Controllers
     module AccountScopable
-      def scoped_to_account(*args, &block)
-        inherit_resources(*args)
-        include AccountScopable::InstanceMethods
-      end
-
-      module InstanceMethods
-        private
-
-        def begin_of_association_chain
-          @account ||= current_account
-        end
-
-        def current_account
-          if not_responding_to_admin? or admin?
-            account_by_param_or_session
-          else
-            current_user.account
+      mattr_accessor :resource_names
+      @@resource_names = []
+
+      def self.define_methods(resource_name)
+        @@resource_names << resource_name.to_s.singularize
+        @@name = @@resource_names.first
+
+        ActiveSupport.on_load(:action_controller) do
+          class_eval do
+            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
           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
-
-        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
-end
+
+          @@resource_names.uniq.each do |name|
+            (class << self; self; end).send(:define_method, "scoped_to_#{name}") do
+              inherit_resources
+
+              class_eval do
+                private
+
+                # This is where things get scoped.
+                # If you're using inherit_resources it will automaticly
+                # call your associations on this method.
+                # In your own code you would just use current_<my account like model>-method.
+                def begin_of_association_chain
+                  begining = instance_variable_get("@#{@@name}".to_sym)
+                  return begining if begining
+
+                  begining = send("current_#{@@name}")
+                  instance_variable_set("@#{@@name}".to_sym, begining)
+                  begining
+                end
+
+                def bento_resource_by_param_or_session
+                  if bento_resource_id
+                    @@name.camelcase.constantize.find(bento_resource_id)
+                  else
+                    current_user.send(@@name)
+                  end
+                end
+
+                def bento_resource_id
+                  key, value = params.find { |key, value| key.to_s.ends_with?("#{@@name}_id") }
+                  value
+                end
+              end
+
+              class_eval <<-RUBY, __FILE__, __LINE__+1
+                private
+
+                def current_#{name}
+                  if current_user
+                    if current_user.#{name}
+                      current_user.#{name}
+                    elsif not_responding_to_admin? or admin?
+                      bento_resource_by_param_or_session
+                    end
+                  end
+                end
+              RUBY
+            end # define_method
+          end # @@resource_names.uniq.each
+        end # ActiveSupport.on_load
+      end # def self.define_helpers
+    end # module AccountScopable
+  end # module Controllers
+end # module Bento
 
 class ActionController::Base
   extend Bento::Controllers::AccountScopable

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

@@ -4,7 +4,8 @@ module Bento
       module UserAssociation
         def self.included(base)
           base.class_eval do
-            has_many :users
+            has_many :bento_memberships
+            has_many :users, :through => :bento_memberships
           end
         end
       end

data/lib/bento/models/user.rb

@@ -0,0 +1,24 @@
+module Bento
+  module Models
+    module User
+      def fake_belongs_to(singular)
+        singular = singular.to_s
+        plural = singular.pluralize
+
+        define_method(singular) do
+          send(plural).first
+        end
+
+        define_method("#{singular}=") do |record|
+          send(plural).each(&:destroy)
+          self.send(plural) << record
+        end
+      end
+    end
+  end
+end
+
+# TODO: only include in the user model
+class ActiveRecord::Base
+  extend Bento::Models::User
+end

data/lib/bento/rails/routes.rb

@@ -1,12 +1,17 @@
 module ActionDispatch::Routing
   class Mapper
-    def bento_for(*resource_names)
+    def bento_for(*resource_names, &block)
+      options = resource_names.extract_options!
       resource_names.map!(&:to_sym)
+
       resource_names.each do |resource_name|
         Bento::Controllers::Helpers.define_helpers(resource_name)
+        Bento::Controllers::AccountScopable.define_methods(resource_name)
+        resource_options = { :controller => account_controller(resource_name) }.merge(options)
 
-        resources(resource_name, :controller => account_controller(resource_name)) do
+        resources(resource_name, resource_options) do
           collection { get :sign_up }
+          yield if block_given?
         end
       end
     end

data/lib/bento/version.rb

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

data/lib/generators/active_record/bento_generator.rb

@@ -11,18 +11,18 @@ module ActiveRecord
 
       def generate_model
         invoke "active_record:model", [name], :migration => false unless model_exists?
+        create_file "app/models/bento_membership.rb", bento_membership_model_content
       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_#{name}_id_to_#{table_name}"
+        migration_template "bento_membership_migration.rb", "db/migrate/bento_create_bento_memberships"
       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
+        inject_into_class model_path, class_name, model_contents
+        inject_into_class user_path, "User", user_model_content
+        inject_into_class bento_membership_path, "BentoMembership", bento_membership_model_content
       end
     end
   end

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

@@ -0,0 +1,25 @@
+class BentoCreateBentoMemberships < ActiveRecord::Migration
+  def self.up
+    create_table :bento_memberships do |t|
+      t.integer :<%= name %>_id
+      t.integer :user_id
+      t.timestamps
+    end
+
+    add_index :bento_memberships, [:<%= name %>_id, :user_id], :unique => true
+
+    # If you know for sure that you don't want to be able
+    # to have users that belongs to several <%= name.pluralize %>
+    # please remove the above lines and uncomment the lines below
+
+    # add_column :users, :<%= name %>_id, :integer
+    # add_index :users, :<%= name %>_id
+  end
+
+  def self.down
+    drop_table :bento_memberships
+
+    # remove_column :users, :<%= name %>_id
+    # remove_index :users, :<%= name %>_id
+  end
+end

data/lib/generators/bento/orm_helpers.rb

@@ -7,6 +7,44 @@ module Bento
   # :all, :validations, :user_accessors, :user_association, :user_accessors, :trial
   bento
 
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :name
+CONTENT
+      end
+
+      def user_model_content
+<<-CONTENT
+  has_many :bento_memberships
+  has_many :#{table_name}, :through => :bento_memberships
+
+  #
+  # Remove this method call unless you want to work with
+  # the has_many :through association as if it was a simple
+  # belongs_to :#{class_name.underscore}.
+  #
+  # If you know for sure that you don't want to be able
+  # to have users that belongs to several #{table_name} you
+  # can of course edit the generated migration files to
+  # not create the join model table "bento_memberships" and instead
+  # add a #{class_name.underscore}_id to your User model.
+  #
+  # You also need to not use the :user_association module in bento
+  # for example to use all in your #{class_name} model change the
+  # call to bento from `bento :all` to bento `:validations, :user_accessors, :user_accessors, :trial`
+  # then you just remove the above relations and remove the "fake_" part below.
+  #
+  fake_belongs_to :#{class_name.underscore}
+CONTENT
+      end
+
+      def bento_membership_model_content
+<<-CONTENT
+class BentoMembership < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :#{class_name.underscore}
+
+  attr_accessible :#{class_name.underscore}_id, :user_id
+end
 CONTENT
       end
 
@@ -14,9 +52,21 @@ CONTENT
         File.exists?(File.join(destination_root, model_path))
       end
 
+      def bento_membership_exists?
+        File.exists?(File.join(destination_root, bento_membership_path))
+      end
+
       def model_path
         @model_path ||= File.join("app", "models", "#{file_path}.rb")
       end
+
+      def bento_membership_path
+        @bento_membership_path ||= File.join("app", "models", "bento_membership.rb")
+      end
+
+      def user_path
+        @user_path ||= File.join("app", "models", "user.rb")
+      end
     end
   end
 end

data/spec/bento/models/modules/user_accessors_spec.rb

@@ -7,6 +7,17 @@ class UserAccessorsTestAccount < ActiveRecord::Base
 end
 
 describe Bento::Models::Modules::UserAccessors do
+  before do
+    # Adding alias to get the relations to work with our custom made class
+
+    BentoMembership.class_eval do
+      attr_accessible :user_accessors_test_account_id
+      def user_accessors_test_account_id=(id)
+        self.account_id = id
+      end
+    end
+  end
+
   let(:account_params) do
     { :name => "Hashrocket", :first_name => "Obie", :last_name => "Fernandez", :email => "obie@hashrocket.com", :password => "test1234" }
   end
@@ -22,8 +33,7 @@ describe Bento::Models::Modules::UserAccessors do
     context "all user attributes are blank" do
       it "creates the account without the user" do
         account = UserAccessorsTestAccount.new(:name => "Elabs")
-        account.save.should be_true
-        User.find_by_account_id(account.id).should be_nil
+        expect { account.save.should be_true }.to_not change(User, :count)
       end
     end
 

data/spec/bento/models/user_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Bento::Models::User do
+  describe ".fake_belongs_to" do
+    let(:user) { User.make }
+    let(:account) { Account.make }
+    before do
+      User.class_eval { fake_belongs_to(:account) }
+      user.accounts << account
+    end
+
+    it "defines #account" do
+      user.account.should == account
+    end
+
+    it "defines #account=" do
+      other_account = Account.make
+      user.account = other_account
+
+      user.reload.account.should == other_account
+      user.accounts.length.should == 1
+    end
+  end
+end

data/spec/controllers/bento_for_custom_routes_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+class SitesController < ActionController::Base
+  def show;    render(:text => "s"); end
+  def index;   render(:text => "i"); end
+  def new;     render(:text => "n"); end
+  def edit;    render(:text => "e"); end
+  def create;  redirect_to sites_url; end
+  def update;  redirect_to sites_url; end
+  def destroy; redirect_to sites_url; end
+end
+
+describe SitesController do
+  describe "#bento_for" do
+    it "defines resource routes" do
+      with_routing do |map|
+        map.draw { bento_for :sites }
+
+        get(:show, :id => 1);    response.should be_success
+        get(:index);             response.should be_success
+        get(:new, :id => 1);     response.should be_success
+        get(:edit, :id => 1);    response.should be_success
+        put(:update, :id => 1);  response.should be_redirect
+        post(:create);           response.should be_redirect
+        put(:destroy, :id => 1); response.should be_redirect
+      end
+    end
+
+    it "allows the default options to resourcers" do
+      with_routing do |map|
+        map.draw { bento_for :sites, :only => %w[show new] }
+        get(:show, :id => 1); response.should be_success
+        get(:new);            response.should be_success
+        expect { get(:index) }.to raise_error
+      end
+    end
+  end
+end