padrino-admin 0.4.5 → 0.4.6

data/VERSION

@@ -1 +1 @@
-0.4.5
+0.4.6

data/lib/padrino-admin/ext_js/controller.rb

@@ -49,78 +49,56 @@ module Padrino
     #     end
     #
     module Controller
-      def self.column_store_for(model, &block)
-        ColumnStore.new(model, &block)
+      def self.column_store_for(model, config)
+        ColumnStore.new(model, config)
       end
 
       class ColumnStore #:nodoc:
         attr_reader :data
 
-        def initialize(model, &block) #:nodoc
+        def initialize(model, config) #:nodoc
           @model = model
-          @data = []
-          yield self
-        end
-
-        # Method for add columns to the Column Model
-        def add(*args)
-
-          # First we need to check that our method is a symbol
-          raise Padrino::ExtJs::ConfigError, "First args must be a symbol like: :name or :account.name" unless args[0].is_a?(Symbol)
-
-          # Construct our options
-          options = { :method => args[0] }
-
-          # If we have a second args that is not an hash maybe an header
-          options[:header]  = args[1].is_a?(String) || args[1].is_a?(Symbol) ? args[1].to_s : nil
-
-          args.each { |a| options.merge!(a) if a.is_a?(Hash)  }
+          @data = config["columns"].map do |column|
+
+            # Reformat our config
+            column["header"]     ||= column["method"].to_s
+            column["dataIndex"]  ||= column["method"]
+            column["sortable"]   ||= column["sortable"].nil? ? true : column["sortable"]
+            column["header"]       = @model.human_attribute_name(column["header"]) # try to translate with I18n the column name
+
+            # Try to reformat the dataIndex
+            data_indexes = Array(column["dataIndex"]).collect do |data_index|
+              if data_index =~ /\./ # if we have some like categories.names we use this
+                cols = data_index.split(".")
+                column["name"] ||= cols[0] + "[" + cols[1..-1].join("][") + "]" # accounts.name will be => accounts[name]
+              else
+                column["name"] ||= "#{@model.table_name.singularize}[#{data_index}]"
+                data_index = "#{@model.table_name}.#{data_index}"
+              end
+              data_index
+            end
 
-          # Add some defaults
-          options[:header]   ||= options[:method].to_s
-          options[:sortable]   = options[:sortable].nil? ? true : options[:sortable]
+            # Now we join our data indexes
+            column["dataIndex"] = data_indexes.compact.uniq.join(",")
 
-          # Try to translate header
-          options[:header] = @model.human_attribute_name(options[:header].to_s)
+            # Reformat mapping like a div id
+            column["mapping"] ||= column["name"].sub(/\[/,"_").sub(/\]$/, "").sub(/\]\[/,"_")
 
-          # Reformat DataIndex
-          # 
-          # If we don't have nothing we use the method
-          options[:dataIndex] ||= options[:method]
+            # Now is necessary for our columns an ID
+            # TODO: check duplicates here
+            column["id"] = column["mapping"]
+            
 
-          data_indexes = Array(options[:dataIndex]).collect do |data_index|
-            case data_index
-              when String then data_index
-              when Symbol
-                if data_index.missing_methods.size == 1
-                  options[:name] ||= "#{@model.table_name.singularize}[#{data_index}]"
-                  data_index = "#{@model.table_name}.#{data_index}"
-                else
-                  columns = data_index.missing_methods
-                  options[:name] ||= columns.at(0) + "[" + columns[1..-1].collect(&:to_s).join("][") + "]"
-                  data_index = columns[0..-2].collect { |c| c.to_s.pluralize }.join(".") + "." + columns.at(-1).to_s
-                end
-            end
-            data_index
+            # Finally we can return our column
+            column
           end
-
-          options[:dataIndex] = data_indexes.compact.uniq.join(",")
-
-          # Reformat mapping like a div id
-          options[:mapping] ||= options[:name].sub(/\[/,"_").sub(/\]$/, "").sub(/\]\[/,"_")
-          
-          # Now is necessary for our columns an ID
-          # TODO: check duplicates here
-          options[:id] = options[:mapping]
-
-          @data << options
         end
 
         # Return an array config for build an Ext.grid.ColumnModel() config
         def column_fields
           @data.map do |data|
-            data.delete(:method)
-            data.delete(:mapping)
+            data.delete("method")
+            data.delete("mapping")
             data
           end
         end
@@ -128,8 +106,8 @@ module Padrino
         # Return an array config for build an Ext.data.GroupingStore()
         def store_fields
           @data.map do |data|
-            hash = { :name => data[:dataIndex], :mapping => data[:mapping] }
-            hash.merge!(:type => data[:renderer]) if  data[:renderer] && [:date, :datetime, :time_to_date].include?(data[:renderer])
+            hash = { :name => data["dataIndex"], :mapping => data["mapping"] }
+            hash.merge!(:type => data["renderer"]) if  data["renderer"] && [:date, :datetime, :time_to_date].include?(data["renderer"])
             hash
           end
         end
@@ -138,7 +116,7 @@ module Padrino
         def store_data_from(collection)
           collection.map do |c|
             @data.dup.inject({ "id" => c.id }) do |options, data|
-              options[data[:mapping]] = (c.instance_eval(data[:method].to_s) rescue I18n.t("padrino.admin.labels.not_found"))
+              options[data["mapping"]] = (c.instance_eval(data["method"]) rescue I18n.t("padrino.admin.labels.not_found"))
               options
             end
           end

data/padrino-admin.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{padrino-admin}
-  s.version = "0.4.5"
+  s.version = "0.4.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
-  s.date = %q{2010-01-06}
+  s.date = %q{2010-01-07}
   s.description = %q{Admin View for Padrino applications}
   s.email = %q{nesquena@gmail.com}
   s.extra_rdoc_files = [
@@ -33,7 +33,6 @@ Gem::Specification.new do |s|
      "lib/padrino-admin/ext_js/controller.rb",
      "lib/padrino-admin/generators/backend.rb",
      "lib/padrino-admin/locale/en.yml",
-     "lib/padrino-admin/support.rb",
      "lib/padrino-admin/utils/crypt.rb",
      "padrino-admin.gemspec",
      "test/fixtures/active_record.rb",

data/test/test_controller.rb

@@ -4,25 +4,76 @@ class TestController < Test::Unit::TestCase
 
   def setup
     load_fixture 'data_mapper'
-    @column_store = Padrino::ExtJs::Controller.column_store_for(Account) do |cm|
-      cm.add :name.upcase,  "Name Upcase",     :sortable => true, :dataIndex => :name
-      cm.add :surname  # Not exist but it's not a problem
-      cm.add :category.name
-      cm.add :email,        "E-Mail",         :sortable => true
-      cm.add :role,                           :sortable => true
-    end
+    config = Padrino::ExtJs::Config.load <<-YAML
+      columns:
+        - method: name.upcase
+          header: Name Upcase
+          dataIndex: name
+        - method: surname
+        - method: category.name
+        - method: email
+          header: E-mail
+          sortable: false
+        - method: role
+    YAML
+    @column_store = Padrino::ExtJs::Controller.column_store_for(Account, config)
   end
 
   should 'have correct column fileds' do
-    assert_equal nil, @column_store.column_fields
+    result = [
+      {"name"=>"account[name]",
+       "sortable"=>true,
+       "header"=>"Name upcase",
+       "id"=>"account_name",
+       "dataIndex"=>"accounts.name"},
+      {"name"=>"account[surname]",
+       "sortable"=>true,
+       "header"=>"Surname",
+       "id"=>"account_surname",
+       "dataIndex"=>"accounts.surname"},
+      {"name"=>"category[name]",
+       "sortable"=>true,
+       "header"=>"Category.name",
+       "id"=>"category_name",
+       "dataIndex"=>"category.name"},
+      {"name"=>"account[email]",
+       "sortable"=>false,
+       "header"=>"E-mail",
+       "id"=>"account_email",
+       "dataIndex"=>"accounts.email"},
+      {"name"=>"account[role]",
+       "sortable"=>true,
+       "header"=>"Role",
+       "id"=>"account_role",
+       "dataIndex"=>"accounts.role"}]
+    assert_equal result, @column_store.column_fields
   end
 
   should 'have correct store fields' do
-    assert_equal nil, @column_store.store_fields
+    result = [
+      {:mapping=>"account_name", :name=>"accounts.name"},
+      {:mapping=>"account_surname", :name=>"accounts.surname"},
+      {:mapping=>"category_name", :name=>"category.name"},
+      {:mapping=>"account_email", :name=>"accounts.email"},
+      {:mapping=>"account_role", :name=>"accounts.role"}]
+    assert_equal result, @column_store.store_fields
   end
 
   should 'store data' do
-    assert_equal nil, @column_store.store_data(:fields => "name,role", :query => "d", :sort => :name, :dir => :asc, :limit => 2, :offset => 0)
+    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(:fields => "name,role", :query => "d", :sort => :name, :dir => :asc, :limit => 2, :offset => 0)
   end
 
 end

data/test/test_mongo_mapper.rb

@@ -20,8 +20,10 @@ class TestMongoMapper < Test::Unit::TestCase
 
     should 'correctly authenticate an account' do
       account = Account.create(:email => "auth@lipsia.org", :role => "some", :password => "some", :password_confirmation => "some")
+      assert account.valid?
+      assert ! account.id.nil?
       assert_equal "some", account.password_clean
-      account_r = Account.authenticate("auth@lipsia.org", "some")
+      account_r = Account.first(:conditions => { :email => "auth@lipsia.org" })
       assert_equal account_r, account
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: padrino-admin
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors: 
 - Padrino Team
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-06 00:00:00 +01:00
+date: 2010-01-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -121,7 +121,6 @@ files:
 - lib/padrino-admin/ext_js/controller.rb
 - lib/padrino-admin/generators/backend.rb
 - lib/padrino-admin/locale/en.yml
-- lib/padrino-admin/support.rb
 - lib/padrino-admin/utils/crypt.rb
 - padrino-admin.gemspec
 - test/fixtures/active_record.rb

data/lib/padrino-admin/support.rb

@@ -1,12 +0,0 @@
-class Symbol
-
-  def method_missing(method, *args)
-    super and return if method.to_s =~ /table_name/
-    (self.to_s + ".#{method}(#{args.collect(&:inspect).join(",")})").to_sym
-  end
-
-  def missing_methods
-    self.to_s.gsub(/(\(.*\))/,"").split(".")
-  end
-
-end