upmin-admin 0.0.39 → 0.1.0

data/lib/upmin/parameter.rb

@@ -0,0 +1,43 @@
+module Upmin
+  class Parameter
+    attr_reader :action
+    attr_reader :name
+
+    def initialize(action, parameter_name, options = {})
+      @action = action
+      @name = parameter_name.to_sym
+      @type = options[:type] if options[:type]
+    end
+
+    def model
+      return action.model
+    end
+
+    def title
+      return name.to_s.humanize
+    end
+
+    def label_name
+      name.to_s.capitalize.gsub("_", " ")
+    end
+
+    def type
+      return @type if defined?(@type)
+      @type = action.model.method(action.name).parameters.select do |param_type, param_name|
+        param_name == name
+      end.first.first || :req
+      return @type
+    end
+
+    def form_id
+      return "#{action.name}_#{name}"
+    end
+
+    def nil_form_id
+      return "#{form_id}_is_nil"
+    end
+
+    private
+
+  end
+end

data/lib/upmin/query.rb

@@ -0,0 +1,51 @@
+module Upmin
+  class Query
+
+    attr_reader :klass
+    attr_reader :search_options
+    attr_reader :page
+    attr_reader :per_page
+
+    delegate(:underscore_name, to: :klass)
+
+    def initialize(klass, search_options = {}, options = {})
+      if klass.active_record?
+        extend Upmin::ActiveRecord::Query
+      elsif klass.data_mapper?
+        extend Upmin::DataMapper::Query
+      else
+        raise ArgumentError.new(klass)
+      end
+
+      @klass = klass
+      @search_options = search_options
+      @page = options[:page]
+      @per_page = options[:per_page]
+    end
+
+    def results
+      raise NotImplementedError
+    end
+
+    def paginated_results
+      return @paginated_results if defined?(@paginated_results)
+      if page && per_page
+        pr = Upmin::Paginator.paginate(results, page, per_page)
+      else
+        pr = Upmin::Paginator.paginate(results)
+      end
+      @paginated_results = pr
+      return @paginated_results
+    end
+
+    def upmin_results
+      return @upmin_results if defined?(@upmin_results)
+      @upmin_results = paginated_results.map{ |r| r.upmin_model }
+      return @upmin_results
+    end
+
+
+    private
+
+  end
+end

data/lib/upmin/railtie.rb

@@ -1,12 +1,22 @@
+require 'rails/railtie'
+
 module Upmin
   require 'rails'
   class Railtie < Rails::Railtie
     initializer('upmin.insert_into_active_record') do
       ActiveSupport.on_load(:active_record) do
-        ::ActiveRecord::Base.send(:include, Upmin::Railties::ActiveRecord)
+        if defined?(ActiveRecord)
+          ::ActiveRecord::Base.send(:include, Upmin::Railties::ActiveRecord)
+        end
+
+        if defined?(DataMapper)
+          ::DataMapper::Resource.send(:include, Upmin::Railties::DataMapper)
+        end
         # ::ActiveRecord::Relation.send(:include, Upmin::ActiveRecordRelation)
       end
+    end
 
+    initializer('upmin.insert_view_helpers') do
       ActiveSupport.on_load(:action_controller) do
         ::ActionController::Base.send(:include, Upmin::Railties::Render)
         ::ActionController::Base.send(:include, Upmin::Railties::Paginator)

data/lib/upmin/railties/active_record.rb

@@ -4,60 +4,15 @@ module Upmin::Railties
   module ActiveRecord
     extend ::ActiveSupport::Concern
 
+    def upmin_model
+      klass = Upmin::Model.find_class(self.class)
+      return klass.new(self)
+    end
+
     included do
     end
 
     module ClassMethods
-
-      # Add a single attribute to upmin attributes. If this is called
-      # before upmin_attributes the attributes will not include any defaults
-      # attributes.
-      def upmin_attribute(attribute = nil)
-        @upmin_extra_attrs = [] unless defined?(@upmin_extra_attrs)
-        @upmin_extra_attrs << attribute.to_sym if attribute
-      end
-
-      # Sets the upmin_attributes to the provided attributes if any are
-      # provided.
-      # If no attributes are provided, and upmin_attributes hasn't been defined,
-      # then the upmin_attributes are set to the default attributes.
-      # Returns the upmin_attributes
-      def upmin_attributes(*attributes)
-        @upmin_extra_attrs = [] unless defined?(@upmin_extra_attrs)
-
-        if attributes.any?
-          @upmin_attributes = attributes.map{|a| a.to_sym}
-        end
-
-        @upmin_attributes ||= attribute_names.map{|a| a.to_sym}
-        return (@upmin_attributes + @upmin_extra_attrs).uniq
-      end
-
-
-      # Add a single action to upmin actions. If this is called
-      # before upmin_actions the actions will not include any defaults
-      # actions.
-      def upmin_action(action)
-        @upmin_actions ||= []
-
-        action = action.to_sym
-        @upmin_actions << action unless @upmin_actions.include?(action)
-      end
-
-      # Sets the upmin_actions to the provided actions if any are
-      # provided.
-      # If no actions are provided, and upmin_actions hasn't been defined,
-      # then the upmin_actions are set to the default actions.
-      # Returns the upmin_actions
-      def upmin_actions(*actions)
-        if actions.any?
-          # set the actions
-          @upmin_actions = actions.map{|a| a.to_sym}
-        end
-        @upmin_actions ||= []
-        return @upmin_actions
-      end
-
     end
   end
 end

data/lib/upmin/railties/data_mapper.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+
+module Upmin::Railties
+  module DataMapper
+    extend ::ActiveSupport::Concern
+
+    def upmin_model
+      klass = Upmin::Model.find_class(self.class)
+      return klass.new(self)
+    end
+
+    included do
+    end
+
+    module ClassMethods
+    end
+  end
+end

data/lib/upmin/railties/render.rb

@@ -2,105 +2,41 @@
 module Upmin::Railties
   module Render
 
-    def up_model(model, options = {})
-      options[:locals] ||= {}
-
-      upmin_model = Upmin::Model.new(model)
-      options[:locals][:upmin_model] ||= upmin_model
-
-      partials = RenderHelpers.model_partials(upmin_model, options)
-      return up_render(model, partials, options, :up_model)
-    end
-
-    def up_attribute(model, attr_name, options = {})
-      options[:locals] ||= {}
-      options[:locals][:model] ||= model
-      options[:locals][:attr_name] = attr_name
-
-      upmin_model = Upmin::Model.new(model)
-      options[:locals][:upmin_model] ||= upmin_model
-
-      options[:locals][:form_id] ||= upmin_model.attribute_form_id(attr_name)
-      # Only fill this in if it was never set so the user can override this.
-      if options[:locals][:editable].nil?
-        options[:locals][:editable] = upmin_model.attribute_editable?(attr_name)
+    # Render method that is used by upmin-admin. Tries to render partials in order, passing data in as the :object, along with options.
+    def up_render(data, options = {})
+      if data.is_a?(Upmin::Model)
+        options = RenderHelpers.model_options(data, options)
+        partials = RenderHelpers.model_partials(data, options)
+
+      elsif data.is_a?(Upmin::Attribute)
+        options = RenderHelpers.attribute_options(data, options)
+        partials = RenderHelpers.attribute_partials(data, options)
+
+      elsif data.is_a?(Upmin::Association)
+        options = RenderHelpers.association_options(data, options)
+        partials = RenderHelpers.association_partials(data, options)
+
+      elsif data.is_a?(Upmin::Action)
+        options = RenderHelpers.action_options(data, options)
+        partials = RenderHelpers.action_partials(data, options)
+
+      elsif data.is_a?(Upmin::Parameter)
+        options = RenderHelpers.parameter_options(data, options)
+        partials = RenderHelpers.parameter_partials(data, options)
+
+      elsif data.is_a?(Upmin::Query)
+        options = RenderHelpers.search_results_options(data, options)
+        partials = RenderHelpers.search_results_partials(data, options)
+
+      elsif data.superclass == Upmin::Model
+        # Probably rendering a search box
+        options = RenderHelpers.search_box_options(data, options)
+        partials = RenderHelpers.search_box_partials(data, options)
+
+      else
+        raise Upmin::ArgumentError.new(data)
       end
 
-
-      partials = RenderHelpers.attribute_partials(upmin_model, attr_name, options)
-
-      data = upmin_model.attribute(attr_name)
-      return up_render(data, partials, options, :up_attribute)
-    end
-
-    def up_association(model, assoc_name, options = {})
-      options[:locals] ||= {}
-      options[:locals][:model] ||= model
-      options[:locals][:assoc_name] = assoc_name
-
-      upmin_model = Upmin::Model.new(model)
-      options[:locals][:upmin_model] ||= upmin_model
-
-      partials = RenderHelpers.association_partials(upmin_model, assoc_name, options)
-
-      data = upmin_model.association(assoc_name, options)
-      return up_render([data].flatten, partials, options, :up_association)
-    end
-
-    def up_action(model, action_name, options = {})
-      options[:locals] ||= {}
-      options[:locals][:model] ||= model
-      options[:locals][:action_name] = action_name
-
-      upmin_model = Upmin::Model.new(model)
-      options[:locals][:upmin_model] ||= upmin_model
-
-      partials = RenderHelpers.action_partials(upmin_model, action_name, options)
-
-      data = upmin_model.action_parameters(action_name)
-      return up_render(data, partials, options, :up_action)
-    end
-
-    def up_search_results(ransack_search, ransack_results, options = {})
-      options[:locals] ||= {}
-      options[:locals][:klass] ||= Upmin::Klass.find(ransack_search.klass)
-      options[:locals][:ransack_search] ||= ransack_search
-      options[:locals][:ransack_results] ||= ransack_results
-
-      partials = RenderHelpers.search_results_partials(ransack_search, options)
-
-      return up_render(ransack_results, partials, options, :up_search_results)
-    end
-
-    def up_search_result(model, options = {})
-      options[:locals] ||= {}
-
-      upmin_model = Upmin::Model.new(model)
-      options[:locals][:upmin_model] ||= upmin_model
-
-      partials = RenderHelpers.search_result_partials(upmin_model, options)
-
-      return up_render(model, partials, options, :up_search_result)
-    end
-
-    def up_search_box(klass, options = {})
-      options[:locals] ||= {}
-
-      klass = Upmin::Klass.find(klass) unless klass.is_a?(Upmin::Klass)
-      if klass.nil?
-        raise "Invalid klass provided in `up_search_box`"
-      end
-
-      options[:locals][:klass] = klass
-
-      partials = RenderHelpers.search_box_partials(klass, options)
-
-      return up_render(klass, partials, options, :up_search_box)
-    end
-
-
-    # Generic render method that is used by all of the up_<something> methods. Tries to render the partials in order, passing data in as the :object, along with options.
-    def up_render(data, partials, options = {}, calling_method = nil)
       # Use options as the render hash, and set :object as the data being used for rendering.
       options[:object] = data
 
@@ -113,7 +49,7 @@ module Upmin::Railties
       end
 
       # If we get here we tried all of the partials and nothing matched. This *shouldn't* be possible but might happen if partials are deleted.
-      raise "Failed to find a matching partial while trying to render `#{calling_method}` with the following data: #{data.inspect}"
+      raise Upmin::MissingPartial.new(data)
     end
 
   end

data/lib/upmin/railties/render_helpers.rb

@@ -2,21 +2,33 @@
 module Upmin::Railties
   module RenderHelpers
 
-    def RenderHelpers.model_partials(upmin_model, options)
+    def RenderHelpers.model_partials(model, options = {})
       partials = []
       # Add "new_" in front of any partial for the partial for new view.
       # <options[:as]>
       # <model_name>
       # model
-      prefix = upmin_model.new_record? ? "new_" : ""
+      prefix = model.new_record? ? "new_" : ""
 
       partials << build_model_path(options[:as]) if options[:as]
-      partials << build_model_path(upmin_model.klass.name.underscore, prefix)
+      partials << build_model_path(model.underscore_name, prefix)
       partials << build_model_path(:model, prefix)
       return partials
     end
 
-    def RenderHelpers.attribute_partials(upmin_model, attr_name, options)
+    def RenderHelpers.model_options(model, options = {})
+      options[:locals] ||= {}
+      options[:locals][:model] ||= model
+      return options
+    end
+
+    def RenderHelpers.build_model_path(partial, prefix = "")
+      return build_path("models", "#{prefix}#{partial}")
+    end
+
+
+
+    def RenderHelpers.attribute_partials(attribute, options = {})
       partials = []
       # <options[:as]>
       # <model_name>_<attr_name>, eg: user_name
@@ -24,85 +36,148 @@ module Upmin::Railties
       # <attr_type>, eg: string
       # unknown
 
-      model_name = upmin_model.klass.name.underscore
-      attr_type = upmin_model.attribute_type(attr_name)
+      model_name = attribute.model.underscore_name
+      attr_type = attribute.type
 
       partials << build_attribute_path(options[:as]) if options[:as]
-      partials << build_attribute_path("#{model_name}_#{attr_name}")
+      partials << build_attribute_path("#{model_name}_#{attribute.name}")
       partials << build_attribute_path("#{model_name}_#{attr_type}")
       partials << build_attribute_path(attr_type)
       partials << build_attribute_path(:unknown)
       return partials
     end
 
-    # def RenderHelpers.action_partials(upmin_model, action, options)
-    #   partials = []
-    #   partials << build_action_path(:unknown)
-    #   return partials
-    # end
+    def RenderHelpers.attribute_options(attribute, options = {})
+      options[:locals] ||= {}
+      options[:locals][:model] ||= attribute.model
+      options[:locals][:attribute] = attribute
+      return options
+    end
+
+    def RenderHelpers.build_attribute_path(partial)
+      return build_path("attributes", partial)
+    end
+
 
 
     # NOTE: assoc_type is sketchy at best. It tries to determine it, but in some cases it has to be guessed at, so if you have polymorphic associations it will choose the data type of the first association it finds - eg if user.things returns [Order, Product, Review] it will use the type of "order"
-    def RenderHelpers.association_partials(upmin_model, assoc_name, options)
+    def RenderHelpers.association_partials(association, options = {})
       partials = []
       # <options[:as]>
       # <model_name>_<assoc_name>, eg: user_recent_orders
       # <model_name>_<assoc_type>, eg: user_orders
       # <attr_type>, eg: orders
       # associations
-      model_name = upmin_model.klass.name.underscore
-      assoc_type = upmin_model.association_type(assoc_name)
+      model_name = association.model.underscore_name
+      assoc_type = association.type
 
       partials << build_association_path(options[:as]) if options[:as]
-      partials << build_association_path("#{model_name}_#{assoc_name}")
+      partials << build_association_path("#{model_name}_#{association.name}")
       partials << build_association_path("#{model_name}_#{assoc_type}")
       partials << build_association_path(assoc_type)
       partials << build_association_path(:associations)
       return partials
     end
 
-    def RenderHelpers.action_partials(upmin_model, action_name, options)
+    def RenderHelpers.association_options(association, options = {})
+      options[:locals] ||= {}
+      options[:locals][:model] ||= association.model
+      options[:locals][:association] = association
+      return options
+    end
+
+    def RenderHelpers.build_association_path(partial)
+      return build_path("associations", partial)
+    end
+
+
+
+    def RenderHelpers.action_partials(action, options = {})
       partials = []
       # <options[:as]>
       # <model_name>_<action_name>, eg: order_refund
       # <action_name>, eg: refund
       # action
-      model_name = upmin_model.klass.name.underscore
+      model_name = action.model.underscore_name
 
       partials << build_action_path(options[:as]) if options[:as]
-      partials << build_action_path("#{model_name}_#{action_name}")
-      partials << build_action_path(action_name)
+      partials << build_action_path("#{model_name}_#{action.name}")
+      partials << build_action_path(action.name)
       partials << build_action_path(:action)
       return partials
     end
 
-    def RenderHelpers.search_results_partials(ransack_search, options)
+    def RenderHelpers.action_options(action, options = {})
+      options[:locals] ||= {}
+      options[:locals][:model] ||= action.model
+      options[:locals][:action] = action
+      return options
+    end
+
+    def RenderHelpers.build_action_path(partial)
+      return build_path("actions", partial)
+    end
+
+
+
+    def RenderHelpers.parameter_partials(parameter, options = {})
       partials = []
       # <options[:as]>
-      # <model_name # plural>, eg: orders
-      # results
-      model_name_plural = ransack_search.klass.name.underscore.pluralize
-
-      partials << build_search_result_path(options[:as]) if options[:as]
-      partials << build_search_result_path(model_name_plural)
-      partials << build_search_result_path(:results)
+      # <model_name>_<action_name>_<param_name>, eg: order_refund_amount
+      # <action_name>_<param_name>, eg: refund_amount
+      # <param_name>, eg: amount
+      # <param_type>_parameter, eg: opt_parameter and req_parameter
+      model_name = parameter.model.underscore_name
+      action_name = parameter.action.name
+
+      partials << build_parameter_path(options[:as]) if options[:as]
+      partials << build_parameter_path("#{model_name}_#{action_name}_#{parameter.name}")
+      partials << build_parameter_path("#{action_name}_#{parameter.name}")
+      partials << build_parameter_path(parameter.name)
+      partials << build_parameter_path("#{parameter.type}_parameter")
       return partials
     end
 
-    def RenderHelpers.search_result_partials(upmin_model, options)
+    def RenderHelpers.parameter_options(parameter, options = {})
+      options[:locals] ||= {}
+      options[:locals][:model] ||= parameter.model
+      options[:locals][:action] ||= parameter.action
+      options[:locals][:parameter] = parameter
+      return options
+    end
+
+    def RenderHelpers.build_parameter_path(partial)
+      return build_path("parameters", partial)
+    end
+
+
+
+    def RenderHelpers.search_results_partials(query, options = {})
       partials = []
       # <options[:as]>
-      # <model_name # singular>, eg: order
+      # <model_name # plural>, eg: orders
       # results
-      model_name = upmin_model.klass.name.underscore
+      model_name_plural = query.underscore_name(:plural)
 
-      partials << build_search_result_path(options[:as]) if options[:as]
-      partials << build_search_result_path(model_name)
-      partials << build_search_result_path(:result)
+      partials << build_search_results_path(options[:as]) if options[:as]
+      partials << build_search_results_path(model_name_plural)
+      partials << build_search_results_path(:results)
       return partials
     end
 
-    def RenderHelpers.search_box_partials(klass, options)
+    def RenderHelpers.search_results_options(query, options = {})
+      options[:locals] ||= {}
+      options[:locals][:query] = query
+      return options
+    end
+
+    def RenderHelpers.build_search_results_path(partial)
+      return build_path("search_results", partial)
+    end
+
+
+
+    def RenderHelpers.search_box_partials(klass, options = {})
       partials = []
       # <options[:as]>
       # ransack_search_box
@@ -112,30 +187,21 @@ module Upmin::Railties
       return partials
     end
 
-
-    def RenderHelpers.build_model_path(partial_name, prefix = "")
-      return "#{root_path}/models/#{prefix}#{partial_name}"
+    def RenderHelpers.search_box_options(klass, options = {})
+      options[:locals] ||= {}
+      options[:locals][:klass] = klass
+      return options
     end
 
-    def RenderHelpers.build_attribute_path(partial_name)
-      return "#{root_path}/attributes/#{partial_name}"
+    def RenderHelpers.build_search_box_path(partial)
+      return build_path("search_boxes", partial)
     end
 
-    def RenderHelpers.build_action_path(partial_name)
-      partial_name = partial_name.to_s.gsub(/[!?]/, "")
-      return "#{root_path}/actions/#{partial_name}"
-    end
 
-    def RenderHelpers.build_association_path(partial_name)
-      return "#{root_path}/associations/#{partial_name}"
-    end
-
-    def RenderHelpers.build_search_result_path(partial_name)
-      return "#{root_path}/search_results/#{partial_name}"
-    end
 
-    def RenderHelpers.build_search_box_path(partial_name)
-      return "#{root_path}/search_boxes/#{partial_name}"
+    def RenderHelpers.build_path(folder, partial)
+      partial = partial.to_s.gsub(/[!?]/, "")
+      "#{root_path}/#{folder}/#{partial}"
     end
 
     def RenderHelpers.root_path