padrino-admin 0.8.5 → 0.9.0

data/lib/padrino-admin/orm/mongomapper.rb

@@ -1,65 +0,0 @@
-module Padrino
-  module Admin
-    module Orm
-      module MongoMapper
-        ##
-        # Here basic functions for interact with MongoMapper
-        # 
-        module Base
-
-          def self.included(base) #:nodoc:
-            base.send :include, Padrino::Admin::Orm::Abstract::Base
-            base.send :include, InstanceMethods
-            base.extend ClassMethods
-          end
-
-          module InstanceMethods
-          end # InstanceMethods
-
-          module ClassMethods
-            ##
-            # Return :activerecord
-            # 
-            def orm
-              :mongomapper
-            end
-          end # ClassMethods
-        end # Base
-
-        ##
-        # Here extension for Account for MongoMapper
-        # 
-        # Basically we need only to perform:
-        # 
-        # * Validations (email, password, role)
-        # * Generate crypted_password on save
-        # 
-        module Account
-
-          def self.included(base) #:nodoc:
-            super(base)
-            base.send :include, Padrino::Admin::Orm::Abstract::Account
-            base.send :attr_accessor, :password, :password_confirmation
-            # Properties
-            base.key :email,            String
-            base.key :crypted_password, String
-            base.key :salt,             String
-            base.key :role,             String
-            # Validations
-            base.validates_presence_of     :email, :role
-            base.validates_presence_of     :password,                   :if => :password_required
-            base.validates_presence_of     :password_confirmation,      :if => :password_required
-            base.validates_length_of       :password, :within => 4..40, :if => :password_required
-            base.validates_confirmation_of :password,                   :if => :password_required
-            base.validates_length_of       :email,    :within => 3..100
-            base.validates_uniqueness_of   :email,    :case_sensitive => false
-            base.validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
-            base.validates_format_of       :role,     :with => /[A-Za-z]/
-            # Callbacks
-            base.before_save :generate_password
-          end
-        end # Account
-      end # MongoMapper
-    end # Orm
-  end # Admin
-end # Padrino

data/lib/padrino-admin/utils/literal.rb

@@ -1,13 +0,0 @@
-module Padrino
-  module Admin
-    module Utils
-      # This module it's used for convert a string in a literal json variable
-      module Literal
-        # This method return a json literal variable
-        def to_l
-          Padrino::Admin::Config::Variable.new(self)
-        end
-      end
-    end
-  end
-end

data/test/fixtures/active_record.rb

@@ -1,29 +0,0 @@
-require 'active_record'
-
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
-
-ActiveRecord::Schema.define do
-  create_table :accounts, :force => true do |t|
-    t.column :id,               :integer
-    t.column :name,             :string
-    t.column :role,             :string
-    t.column :crypted_password, :string
-    t.column :salt,             :string
-    t.column :email,            :string
-  end
-
-  create_table :categories, :force => true do |t|
-    t.column :name, :string
-    t.column :account_id, :integer
-  end
-end
-
-class Account < ActiveRecord::Base
-  has_many :categories
-end
-
-class Category < ActiveRecord::Base
-  belongs_to :account
-end
-
-Padrino::Admin::Orm.register!

data/test/fixtures/mongo_mapper.rb

@@ -1,12 +0,0 @@
-require 'mongo_mapper'
-
-MongoMapper.connection = Mongo::Connection.new("127.0.0.1")
-MongoMapper.database = 'test'
-
-class Account
-  include MongoMapper::Document
-  key :name, String
-end
-
-Account.collection.remove
-Padrino::Admin::Orm.register!

data/test/fixtures/test_column_store.jml

@@ -1,11 +0,0 @@
-columns:
-  - method: name.upcase
-    header: Name Upcase
-    dataIndex: name
-  - method: surname
-  - method: category.name
-    dataIndex: categories.name
-  - method: email
-    header: E-mail
-    sortable: false
-  - method: role

data/test/generators/test_admin_uploader_generator.rb

@@ -1,56 +0,0 @@
-require File.dirname(__FILE__) + '/../helper'
-require 'thor/group'
-require 'fakeweb'
-require 'padrino-gen/generators/actions'
-Dir[File.dirname(__FILE__) + '/generators/{components}/**/*.rb'].each { |lib| require lib }
-
-class TestAdminUploaderGenerator < Test::Unit::TestCase
-  
-  def setup
-    `rm -rf /tmp/sample_project`
-    @project  = Padrino::Generators::Project.dup
-    @admin    = Padrino::Generators::AdminApp.dup
-    @uploader = Padrino::Generators::AdminUploader.dup
-  end
-
-  context 'the admin uploader generator' do
-
-    should 'fail outside app root' do
-      output = silence_logger { @uploader.start(['-r=/tmp/sample_project']) }
-      assert_match(/not at the root/, output)
-      assert_no_file_exists('/tmp/admin')
-    end
-
-    should 'fail if we don\'t have admin application' do
-      assert_nothing_raised { silence_logger { @project.start(['sample_project', '--root=/tmp']) } }
-      assert_raise(SystemExit) { silence_logger { @uploader.start(['-r=/tmp/sample_project']) } }
-    end
-
-    should 'correctyl generate a new padrino admin application for activerecord' do
-      assert_nothing_raised { silence_logger { @project.start(['sample_project', '--root=/tmp', '-d=activerecord']) } }
-      assert_nothing_raised { silence_logger { @admin.start(['--root=/tmp/sample_project']) } }
-      assert_nothing_raised { silence_logger { @uploader.start(['--root=/tmp/sample_project']) } }
-      assert_file_exists '/tmp/sample_project/admin/controllers/uploads.rb'
-      assert_file_exists '/tmp/sample_project/admin/views/uploads/grid.js.erb'
-      assert_file_exists '/tmp/sample_project/admin/views/uploads/store.jml'
-      assert_file_exists '/tmp/sample_project/lib/uploader.rb'
-      assert_match_in_file 'mount_uploader :file, Uploader', '/tmp/sample_project/app/models/upload.rb'
-      assert_match_in_file "\n# Uploader requirements\n# gem 'mini_magick'\ngem 'carrierwave'\n", "/tmp/sample_project/Gemfile"
-      assert_match_in_file "role.project_module :uploads, \"/admin/uploads.js\"", '/tmp/sample_project/admin/app.rb'
-    end
-
-    should 'correctyl generate a new padrino admin application for datamapper' do
-      assert_nothing_raised { silence_logger { @project.start(['sample_project', '--root=/tmp', '-d=datamapper']) } }
-      assert_nothing_raised { silence_logger { @admin.start(['--root=/tmp/sample_project']) } }
-      assert_nothing_raised { silence_logger { @uploader.start(['--root=/tmp/sample_project']) } }
-      assert_file_exists '/tmp/sample_project/admin/controllers/uploads.rb'
-      assert_file_exists '/tmp/sample_project/admin/views/uploads/grid.js.erb'
-      assert_file_exists '/tmp/sample_project/admin/views/uploads/store.jml'
-      assert_file_exists '/tmp/sample_project/lib/uploader.rb'
-      assert_match_in_file 'property :file, String, :auto_validation => false', '/tmp/sample_project/app/models/upload.rb'
-      assert_match_in_file 'mount_uploader :file, Uploader', '/tmp/sample_project/app/models/upload.rb'
-      assert_match_in_file "\n# Uploader requirements\n# gem 'mini_magick'\ngem 'carrierwave'\n", "/tmp/sample_project/Gemfile"
-      assert_match_in_file "role.project_module :uploads, \"/admin/uploads.js\"", '/tmp/sample_project/admin/app.rb'
-    end
-  end
-end

data/test/test_access_control.rb

@@ -1,99 +0,0 @@
-require 'helper'
-
-class TestAccessControl < Test::Unit::TestCase
-
-  def setup
-    load_fixture 'data_mapper'
-    @access = Class.new(Padrino::Admin::AccessControl::Base)
-
-    @access.roles_for :any do |role|
-      role.allow "/sessions"
-      role.deny  "/special"
-    end
-
-    @access.roles_for :admin do |role, account|
-      role.allow "/admin/base"
-      role.deny  "/admin/accounts/details"
-      role.deny  "/admin/accounts/details" # Only for check that we don't have two paths equal
-
-      role.project_module "Padrino's Dashboard" do |project|
-        project.menu :general_settings, "/admin/settings" do |submenu|
-          submenu.add :accounts, "/admin/accounts" do |submenu|
-            submenu.add :sub_accounts, "/admin/accounts/subaccounts"
-            submenu.add :sub_accounts, "/admin/accounts/subaccounts" # Only for check that we don't have two paths equal
-          end
-        end
-      end
-    end
-
-    @access.roles_for :editor, :admin do |role, account|
-      role.project_module :categories do |project|
-        account.categories.each do |category|
-          project.menu category.name, "/admin/categories/#{category.id}.js"
-        end
-        project.menu :foo
-      end
-    end
-  end
-
-  context 'for authorization functionality' do
-
-    should 'check empty auths' do
-      empty = Class.new(Padrino::Admin::AccessControl::Base)
-      assert empty.auths.can?("/foo/bar")
-      assert ! empty.auths.cannot?("/foo/bar")
-    end
-
-    should 'check auths without account' do
-      assert_equal ["/sessions"], @access.auths.allowed
-      assert_equal ["/special"],  @access.auths.denied
-    end
-
-    should 'act as can can' do
-      assert @access.auths.can?("/sessions")
-      assert @access.auths.cannot?("/special")
-      assert ! @access.auths.can?("/special")
-    end
-
-    should 'check auths for an editor' do
-      assert_equal ["/special"], @access.auths(Account.editor).denied
-      assert_equal ["/sessions"] + 
-                   Account.editor.categories.collect { |c| "/admin/categories/#{c.id}.js" }.uniq, 
-                   @access.auths(Account.editor).allowed
-    end
-
-    should 'allow and deny paths for admin' do
-      allowed = ["/sessions", "/admin/base", "/admin/settings", "/admin/accounts", "/admin/accounts/subaccounts"] +
-                Account.admin.categories.collect { |c| "/admin/categories/#{c.id}.js" }.uniq
-      assert_equal ["/special", "/admin/accounts/details"], @access.auths(Account.admin).denied
-      assert_equal allowed, @access.auths(Account.admin).allowed
-    end
-
-    should 'allow and deny paths for editor' do
-      assert_equal ["/special"], @access.auths(Account.editor).denied
-      assert_equal ["/sessions"] + Account.editor.categories.collect { |c| "/admin/categories/#{c.id}.js" }.uniq, @access.auths(Account.editor).allowed
-    end
-  end
-
-  context 'for project modules functionality do' do
-
-    should 'have empty modules if no account given' do
-      assert_equal [], @access.auths.project_modules
-    end
-
-    should 'check modules uids' do
-      assert_equal [:padrinosdashboard, :categories], @access.auths(Account.admin).project_modules.collect(&:uid)
-      assert_equal [:categories], @access.auths(Account.editor).project_modules.collect(&:uid)
-    end
-
-    should 'check a module config' do
-      menu = Account.editor.categories.map { |c| { :text => c.name, :handler => "function(){ Admin.app.load('/admin/categories/#{c.id}.js') }" } }
-      assert_equal [{ :text => "Categories", :menu => menu + ["Foo"] }], @access.auths(Account.editor).project_modules.collect(&:config)
-    end
-
-    should 'check config handlers' do
-      assert_kind_of Padrino::Admin::Config::Variable, @access.auths(Account.editor).project_modules.collect(&:config).first[:menu].first[:handler]
-    end
-  end
-
-end

data/test/test_active_record.rb

@@ -1,96 +0,0 @@
-require 'helper'
-
-class TestActiveRecord < Test::Unit::TestCase
-
-  def setup
-    load_fixture 'active_record'
-  end
-
-  context 'for activerecord account functionality' do
-
-    should 'check required fields' do
-      account = Account.create
-      assert ! account.valid?
-    end
-
-    should 'correctly create an account' do
-      account = Account.create(:email => "jack@metal.org", :role => "some", :password => "some", :password_confirmation => "some")
-      assert account.valid?
-    end
-
-    should 'correctly authenticate an account' do
-      account = Account.create(:email => "auth@lipsia.org", :role => "some", :password => "some", :password_confirmation => "some")
-      assert_equal "some", account.password_clean
-      account_r = Account.authenticate("auth@lipsia.org", "some")
-      assert_equal account_r, account
-    end
-  end
-
-  context 'for activerecord functionality' do
-
-    should 'have some standard methods' do
-      account = Account.new
-      assert_respond_to account, :new_record?
-      assert_respond_to account, :to_param
-      assert_respond_to account, :update_attributes
-      assert_respond_to account, :valid?
-      assert_respond_to Account, :human_local_attribute_name
-      assert_respond_to Account, :human_local_name
-      assert_respond_to Account, :properties
-      assert_respond_to Account, :count
-      assert_respond_to Account, :orm
-      assert_equal "Name", Account.human_local_attribute_name(:name)
-      assert_equal "Account", Account.human_local_name
-    end
-
-    should 'have errors_keys' do
-      account = Account.new
-      account.valid?
-      assert_equal [:email, :role, :password, :password_confirmation], account.errors_keys
-    end
-
-    should 'have columns names' do
-      property = Account.properties.first
-      assert_respond_to property, :name
-      assert_equal "id", property.name
-    end
-
-    should 'have table name' do
-      assert_equal "accounts", Account.table_name
-    end
-
-    should 'have orm defined' do
-      assert_equal :activerecord, Account.orm
-    end
-
-    should 'search correctly fields' do
-      accounts, categories = {}, {}
-
-      %w(gino paoli mario venuti franco).each do |name|
-        accounts[name] = Account.create(:email => "#{name}@foo.com", :role => name, :password => "some", :password_confirmation => "some")
-        assert_equal [accounts[name]], Account.ext_search(:query => name, :fields => "email,role").records
-        accounts
-      end
-
-      %w(rock soul classic rap jazz).each_with_index do |name, i|
-        categories[name] = Category.create(:name => name, :account_id => i+1)
-        assert_equal [categories[name]], Category.ext_search(:query => name, :fields => "name").records
-        accounts
-      end
-
-      # Make sure that our builtin count is correct
-      assert_equal 5, Account.ext_search({}).count
-      assert_equal 5, Account.ext_search({}).count
-
-      # Perform some search
-      assert_equal [accounts["venuti"]], Account.ext_search(:query => "en", :fields => "email,role").records
-      assert_equal [accounts["gino"], accounts["venuti"], accounts["franco"]], Account.ext_search(:query => "n", :fields => "email,role").records
-      assert_equal [accounts["venuti"], accounts["franco"]], Account.ext_search(:start => 3, :limit => 2).records
-      assert_equal [accounts["paoli"], accounts["venuti"]],  Account.ext_search(:start => 3, :limit => 2, :sort => "role", :dir => "asc").records
-
-      # Perform some extended search
-      assert_equal [accounts["venuti"]], Account.ext_search({ :query => "rap", :fields => "categories.name" }, :joins => :categories).records
-      assert_equal [accounts["franco"], accounts["mario"]], Account.ext_search({:start => 3, :limit => 2, :sort => "categories.name", :dir => "desc"}, :joins => :categories).records
-    end
-  end
-end

data/test/test_column_store.rb

@@ -1,87 +0,0 @@
-require 'helper'
-
-class TestColumnStore < Test::Unit::TestCase
-
-  def setup
-    load_fixture 'data_mapper'
-    config = YAML.load <<-YAML
-      columns:
-        - method: name.upcase
-          header: Name Upcase
-          dataIndex: name
-        - method: surname
-        - method: category.name
-          dataIndex: categories.name
-        - method: email
-          header: E-mail
-          sortable: false
-        - method: role
-    YAML
-    @column_store = Padrino::Admin::ColumnStore.new(Account, config)
-    @column_store_direct = Account.column_store("test/fixtures/test_column_store.jml")
-  end
-
-  should 'have correct column fileds' do
-    result = [
-      {"name"=>"account[name]",
-       "header"=>"Name upcase",
-       "sortable"=>true,
-       "id"=>"account_name",
-       "dataIndex"=>"accounts.name"},
-      {"name"=>"account[surname]",
-       "header"=>"Surname",
-       "sortable"=>true,
-       "id"=>"account_surname",
-       "dataIndex"=>"accounts.surname"},
-      {"name"=>"category[name]",
-       "header"=>"Category.name",
-       "sortable"=>true,
-       "id"=>"category_name",
-       "dataIndex"=>"categories.name"},
-      {"name"=>"account[email]",
-       "header"=>"E-mail",
-       "sortable"=>false,
-       "id"=>"account_email",
-       "dataIndex"=>"accounts.email"},
-      {"name"=>"account[role]",
-       "header"=>"Role",
-       "sortable"=>true,
-       "id"=>"account_role",
-       "dataIndex"=>"accounts.role"}
-    ]
-    assert_equal result, @column_store.column_fields(false)
-    assert_equal result, @column_store_direct.column_fields(false)
-  end
-
-  should 'have correct store fields' do
-    result = [
-      {:mapping=>"account_name", :name=>"accounts.name"},
-      {:mapping=>"account_surname", :name=>"accounts.surname"},
-      {:mapping=>"category_name", :name=>"categories.name"},
-      {:mapping=>"account_email", :name=>"accounts.email"},
-      {:mapping=>"account_role", :name=>"accounts.role"}
-    ]
-    assert_equal result, @column_store.store_fields(false)
-    assert_equal result, @column_store_direct.store_fields(false)
-  end
-
-  should 'store data' do
-    result = {:results=>[
-      {"account_surname"=>"Not found",
-       "account_email"=>"d.dagostino@lipsiasoft.com",
-       "category_name"=>"Not found",
-       "id"=>1,
-       "account_role"=>"Admin",
-       "account_name"=>"DADDYE"},
-      {"account_surname"=>"Not found",
-       "account_email"=>"editor@lipsiasoft.com",
-       "category_name"=>"Not found",
-       "id"=>2,
-       "account_role"=>"Editor",
-       "account_name"=>"DEXTER"}
-    ], :count=>2}
-    assert_equal result, @column_store.store_data(:json => false, :fields => "name,role", :query => "d", :sort => :name, :dir => :asc, :limit => 2, :offset => 0)
-    assert_equal result, @column_store_direct.store_data(:json => false, :fields => "name,role", :query => "d", :sort => :name, :dir => :asc, :limit => 2, :offset => 0)
-  end
-
-end