merb-admin 0.8.1 → 0.8.3

data/app/views/main/new.html.erb

@@ -1,16 +1,16 @@
-        <div id="content-main">
-        <%= form_for(@object, :action => url(:merb_admin_create, :model_name => @abstract_model.to_param)) do %>
-          <div>
-<%= partial('properties', :properties => @properties) -%>
-<%= partial('belongs_to', :with => @abstract_model.belongs_to_associations, :as => :association) -%>
-<%= partial('has_one', :with => @abstract_model.has_one_associations, :as => :association) -%>
-<%= partial('has_many', :with => @abstract_model.has_many_associations, :as => :association) -%>
-            <div class="submit-row" >
-              <%= submit "Save", :class => "default", :name => "_save" %>
-              <%= submit "Save and add another", :name => "_add_another" %>
-              <%= submit "Save and continue editing", :name => "_continue" %>
-            </div>
-          </div>
-        <% end =%>
-
-        </div>
+        <div id="content-main">
+        <%= form_for(@object, :action => url(:merb_admin_create, :model_name => @abstract_model.to_param)) do %>
+          <div>
+<%= partial('properties', :properties => @properties) -%>
+<%= partial('belongs_to', :with => @abstract_model.belongs_to_associations, :as => :association) -%>
+<%= partial('has_one', :with => @abstract_model.has_one_associations, :as => :association) -%>
+<%= partial('has_many', :with => @abstract_model.has_many_associations, :as => :association) -%>
+            <div class="submit-row" >
+              <%= submit "Save", :class => "default", :name => "_save" %>
+              <%= submit "Save and add another", :name => "_add_another" %>
+              <%= submit "Save and continue editing", :name => "_continue" %>
+            </div>
+          </div>
+        <% end =%>
+
+        </div>

data/config/init.rb

@@ -0,0 +1,30 @@
+#
+# ==== Standalone MerbAdmin configuration
+#
+# This configuration/environment file is only loaded by bin/slice, which can be
+# used during development of the slice. It has no effect on this slice being
+# loaded in a host application. To run your slice in standalone mode, just
+# run 'slice' from its directory. The 'slice' command is very similar to
+# the 'merb' command, and takes all the same options, including -i to drop
+# into an irb session for example.
+#
+# The usual Merb configuration directives and init.rb setup methods apply,
+# including use_orm and before_app_loads/after_app_loads.
+#
+# If you need need different configurations for different environments you can
+# even create the specific environment file in config/environments/ just like
+# in a regular Merb application.
+#
+# In fact, a slice is no different from a normal # Merb application - it only
+# differs by the fact that seamlessly integrates into a so called 'host'
+# application, which in turn can override or finetune the slice implementation
+# code and views.
+
+use_test :rspec
+use_template_engine :erb
+
+Merb::Config.use do |c|
+  c[:exception_details] = true
+  c[:reload_templates] = true
+  c[:reload_classes] = true
+end

data/config/router.rb

@@ -0,0 +1,4 @@
+# This file is here so slice can be testing as a stand alone application.
+
+Merb::Router.prepare do
+end

data/lib/abstract_model.rb

@@ -1,86 +1,84 @@
-require 'generic_support'
-
-module MerbAdmin
-  class AbstractModel
-    # Returns all models for a given Merb app
-    def self.all
-      @models = []
-      orm = Merb.orm
-      case orm
-      when :activerecord, :sequel
-        Dir.glob(Merb.dir_for(:model) / Merb.glob_for(:model)).each do |filename|
-          File.read(filename).scan(/class ([\w\d_\-:]+)/).flatten.each do |model_name|
-            add_model(model_name)
-          end
-        end
-      when :datamapper
-        DataMapper::Model.descendants.each do |model|
-          add_model(model.to_s)
-        end
-      else
-        raise "MerbAdmin does not support the #{orm} ORM"
-      end
-      @models.sort!{|x, y| x.model.to_s <=> y.model.to_s}
-    end
-
-    def self.add_model(model_name)
-      model = lookup(model_name)
-      @models << new(model) if model
-    end
-
-    # Given a string +model_name+, finds the corresponding model class
-    def self.lookup(model_name)
-      return nil if MerbAdmin[:excluded_models].include?(model_name)
-      begin
-        model = Object.full_const_get(model_name)
-      rescue NameError
-        raise "MerbAdmin could not find model #{model_name}"
-      end
-
-      case Merb.orm
-      when :activerecord
-        model if superclasses(model).include?(ActiveRecord::Base)
-      when :datamapper
-        model if model.include?(DataMapper::Resource)
-      when :sequel
-        model if superclasses(model).include?(Sequel::Model)
-      else
-        nil
-      end
-    end
-
-    attr_accessor :model
-
-    def initialize(model)
-      model = self.class.lookup(model.to_s.camel_case) unless model.is_a?(Class)
-      orm = Merb.orm
-      @model = model
-      self.extend(GenericSupport)
-      case orm
-      when :activerecord
-        require 'active_record_support'
-        self.extend(ActiverecordSupport)
-      when :datamapper
-        require 'datamapper_support'
-        self.extend(DatamapperSupport)
-      when :sequel
-        require 'sequel_support'
-        self.extend(SequelSupport)
-      else
-        raise "MerbAdmin does not support the #{orm} ORM"
-      end
-    end
-
-    private
-
-    def self.superclasses(klass)
-      superclasses = []
-      while klass
-        superclasses << klass.superclass if klass && klass.superclass
-        klass = klass.superclass
-      end
-      superclasses
-    end
-
-  end
-end
+require 'generic_support'
+
+module MerbAdmin
+  class AbstractModel
+    # Returns all models for a given Merb app
+    def self.all
+      @models = []
+      orm = Merb.orm
+      case orm
+      when :activerecord, :sequel
+        Dir.glob(Merb.dir_for(:model) / Merb.glob_for(:model)).each do |filename|
+          File.read(filename).scan(/class ([\w\d_\-:]+)/).flatten.each do |model_name|
+            add_model(model_name)
+          end
+        end
+      when :datamapper
+        DataMapper::Model.descendants.each do |model|
+          add_model(model.to_s)
+        end
+      else
+        raise "MerbAdmin does not support the #{orm} ORM"
+      end
+      @models.sort!{|x, y| x.model.to_s <=> y.model.to_s}
+    end
+
+    def self.add_model(model_name)
+      model = lookup(model_name)
+      @models << new(model) if model
+    end
+
+    # Given a string +model_name+, finds the corresponding model class
+    def self.lookup(model_name)
+      return nil if MerbAdmin[:excluded_models].include?(model_name)
+      begin
+        model = Object.full_const_get(model_name)
+      rescue NameError
+        raise "MerbAdmin could not find model #{model_name}"
+      end
+
+      case Merb.orm
+      when :activerecord
+        model if superclasses(model).include?(ActiveRecord::Base)
+      when :sequel
+        model if superclasses(model).include?(Sequel::Model)
+      else
+        model
+      end
+    end
+
+    attr_accessor :model
+
+    def initialize(model)
+      model = self.class.lookup(model.to_s.camel_case) unless model.is_a?(Class)
+      orm = Merb.orm
+      @model = model
+      self.extend(GenericSupport)
+      case orm
+      when :activerecord
+        require 'active_record_support'
+        self.extend(ActiverecordSupport)
+      when :datamapper
+        require 'datamapper_support'
+        self.extend(DatamapperSupport)
+      when :sequel
+        require 'sequel_support'
+        self.extend(SequelSupport)
+      else
+        raise "MerbAdmin does not support the #{orm} ORM"
+      end
+    end
+
+    private
+
+    def self.superclasses(klass)
+      superclasses = []
+      while klass
+        superclasses << klass.superclass if klass && klass.superclass
+        klass = klass.superclass
+      end
+      superclasses
+    end
+
+  end
+end

data/lib/active_record_support.rb

@@ -1,147 +1,147 @@
-require 'active_record'
-
-module MerbAdmin
-  class AbstractModel
-    module ActiverecordSupport
-      def get(id)
-        model.find_by_id(id).extend(InstanceMethods)
-      rescue ActiveRecord::RecordNotFound
-        nil
-      end
-
-      def count(options = {})
-        model.count(options.reject{|key, value| [:sort, :sort_reverse].include?(key)})
-      end
-
-      def first(options = {})
-        model.first(merge_order(options)).extend(InstanceMethods)
-      end
-
-      def all(options = {})
-        model.all(merge_order(options))
-      end
-
-      def paginated(options = {})
-        page = options.delete(:page) || 1
-        per_page = options.delete(:per_page) || MerbAdmin[:per_page]
-
-        page_count = (count(options).to_f / per_page).ceil
-
-        options.merge!({
-          :limit => per_page,
-          :offset => (page - 1) * per_page
-        })
-
-        [page_count, all(options)]
-      end
-
-      def create(params = {})
-        model.create(params).extend(InstanceMethods)
-      end
-
-      def new(params = {})
-        model.new(params).extend(InstanceMethods)
-      end
-
-      def destroy_all!
-        model.all.each do |object|
-          object.destroy
-        end
-      end
-
-      def has_many_associations
-        associations.select do |association|
-          association[:type] == :has_many
-        end
-      end
-
-      def has_one_associations
-        associations.select do |association|
-          association[:type] == :has_one
-        end
-      end
-
-      def belongs_to_associations
-        associations.select do |association|
-          association[:type] == :belongs_to
-        end
-      end
-
-      def associations
-        model.reflect_on_all_associations.map do |association|
-          {
-            :name => association.name,
-            :pretty_name => association.name.to_s.gsub('_', ' ').capitalize,
-            :type => association.macro,
-            :parent_model => association_parent_model_lookup(association),
-            :parent_key => association_parent_key_lookup(association),
-            :child_model => association_child_model_lookup(association),
-            :child_key => association_child_key_lookup(association),
-          }
-        end
-      end
-
-      def properties
-        model.columns.map do |property|
-          {
-            :name => property.name.to_sym,
-            :pretty_name => property.human_name,
-            :type => property.type,
-            :length => property.limit,
-            :nullable? => property.null,
-            :serial? => property.primary,
-          }
-        end
-      end
-
-      private
-
-      def merge_order(options)
-        @sort ||= options.delete(:sort) || "id"
-        @sort_order ||= options.delete(:sort_reverse) ? "desc" : "asc"
-        options.merge(:order => ["#{@sort} #{@sort_order}"])
-      end
-
-      def association_parent_model_lookup(association)
-        case association.macro
-        when :belongs_to
-          association.klass
-        when :has_one, :has_many
-          association.active_record
-        else
-          raise "Unknown association type"
-        end
-      end
-
-      def association_parent_key_lookup(association)
-        [:id]
-      end
-
-      def association_child_model_lookup(association)
-        case association.macro
-        when :belongs_to
-          association.active_record
-        when :has_one, :has_many
-          association.klass
-        else
-          raise "Unknown association type"
-        end
-      end
-
-      def association_child_key_lookup(association)
-        case association.macro
-        when :belongs_to
-          ["#{association.class_name.snake_case}_id".to_sym]
-        when :has_one, :has_many
-          [association.primary_key_name.to_sym]
-        else
-          raise "Unknown association type"
-        end
-      end
-
-      module InstanceMethods
-      end
-
-    end
-  end
-end
+require 'active_record'
+
+module MerbAdmin
+  class AbstractModel
+    module ActiverecordSupport
+      def get(id)
+        model.find_by_id(id).extend(InstanceMethods)
+      rescue ActiveRecord::RecordNotFound
+        nil
+      end
+
+      def count(options = {})
+        model.count(options.reject{|key, value| [:sort, :sort_reverse].include?(key)})
+      end
+
+      def first(options = {})
+        model.first(merge_order(options)).extend(InstanceMethods)
+      end
+
+      def all(options = {})
+        model.all(merge_order(options))
+      end
+
+      def paginated(options = {})
+        page = options.delete(:page) || 1
+        per_page = options.delete(:per_page) || MerbAdmin[:per_page]
+
+        page_count = (count(options).to_f / per_page).ceil
+
+        options.merge!({
+          :limit => per_page,
+          :offset => (page - 1) * per_page
+        })
+
+        [page_count, all(options)]
+      end
+
+      def create(params = {})
+        model.create(params).extend(InstanceMethods)
+      end
+
+      def new(params = {})
+        model.new(params).extend(InstanceMethods)
+      end
+
+      def destroy_all!
+        model.all.each do |object|
+          object.destroy
+        end
+      end
+
+      def has_many_associations
+        associations.select do |association|
+          association[:type] == :has_many
+        end
+      end
+
+      def has_one_associations
+        associations.select do |association|
+          association[:type] == :has_one
+        end
+      end
+
+      def belongs_to_associations
+        associations.select do |association|
+          association[:type] == :belongs_to
+        end
+      end
+
+      def associations
+        model.reflect_on_all_associations.map do |association|
+          {
+            :name => association.name,
+            :pretty_name => association.name.to_s.gsub('_', ' ').capitalize,
+            :type => association.macro,
+            :parent_model => association_parent_model_lookup(association),
+            :parent_key => association_parent_key_lookup(association),
+            :child_model => association_child_model_lookup(association),
+            :child_key => association_child_key_lookup(association),
+          }
+        end
+      end
+
+      def properties
+        model.columns.map do |property|
+          {
+            :name => property.name.to_sym,
+            :pretty_name => property.human_name,
+            :type => property.type,
+            :length => property.limit,
+            :nullable? => property.null,
+            :serial? => property.primary,
+          }
+        end
+      end
+
+      private
+
+      def merge_order(options)
+        @sort ||= options.delete(:sort) || "id"
+        @sort_order ||= options.delete(:sort_reverse) ? "desc" : "asc"
+        options.merge(:order => ["#{@sort} #{@sort_order}"])
+      end
+
+      def association_parent_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          association.klass
+        when :has_one, :has_many
+          association.active_record
+        else
+          raise "Unknown association type"
+        end
+      end
+
+      def association_parent_key_lookup(association)
+        [:id]
+      end
+
+      def association_child_model_lookup(association)
+        case association.macro
+        when :belongs_to
+          association.active_record
+        when :has_one, :has_many
+          association.klass
+        else
+          raise "Unknown association type"
+        end
+      end
+
+      def association_child_key_lookup(association)
+        case association.macro
+        when :belongs_to
+          ["#{association.class_name.snake_case}_id".to_sym]
+        when :has_one, :has_many
+          [association.primary_key_name.to_sym]
+        else
+          raise "Unknown association type"
+        end
+      end
+
+      module InstanceMethods
+      end
+
+    end
+  end
+end