upmin-admin 0.0.39 → 0.1.0

data/lib/upmin/configuration.rb

@@ -0,0 +1,103 @@
+module Upmin
+  # Add Config Stuff to Upmin
+  class << self
+    attr_accessor :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration) if block_given?
+    end
+  end
+
+  class Configuration
+    attr_writer :colors
+
+    def initialize
+      ::Rails.application.eager_load!
+    end
+
+    def colors=(colors)
+      @custom_colors = true
+      @colors = colors
+    end
+
+    def colors
+      if defined?(@custom_colors)
+        return @colors
+      else
+        return default_colors
+      end
+    end
+
+    def models=(models)
+      @custom_models = true
+      @models = models
+    end
+
+    def models
+      if defined?(@custom_models)
+        return @models
+      else
+        return default_models
+      end
+    end
+
+    private
+
+      def default_models
+        def_models = []
+        orm_found = false
+
+        if defined?(Rails) && Rails.application
+          ::Rails.application.eager_load!
+        else
+          raise "We kinda need rails for a rails engine :("
+        end
+
+        if defined?(ActiveRecord)
+          orm_found = true
+          ::Rails.application.eager_load!
+          def_models += ::ActiveRecord::Base.descendants
+            .map(&:to_s)
+            .select{ |m| m != "ActiveRecord::SchemaMigration" }
+            .sort
+            .map(&:underscore)
+            .map(&:to_sym)
+        end
+
+        if defined?(DataMapper)
+          orm_found = true
+          ::Rails.application.eager_load!
+          def_models += ::DataMapper::Model.descendants.entries
+            .map(&:to_s)
+            .sort
+            .map(&:underscore)
+            .map(&:to_sym)
+        end
+
+        unless orm_found
+          raise UnsupportedObjectMapper.new
+        end
+
+        return def_models
+      end
+
+      def default_colors
+        return [
+          :light_blue,
+          :blue_green,
+          :red,
+          :yellow,
+          :orange,
+          :purple,
+          :dark_blue,
+          :dark_red,
+          :green
+        ]
+      end
+
+  end
+end

data/lib/upmin/data_mapper/association.rb

@@ -0,0 +1,57 @@
+module Upmin::DataMapper
+  module Association
+
+    def type
+      return @type if defined?(@type)
+
+      if relationship
+        # NOTE(jon): I believe many to one is the only type where child_model_name is incorrect, but I could be wrong.
+        if relationship.is_a?(DataMapper::Associations::ManyToOne::Relationship)
+          @type = relationship.parent_model_name
+        else
+          @type = relationship.child_model_name
+        end
+
+        @type = @type.underscore
+
+        if collection?
+          @type = @type.pluralize.to_sym
+        else
+          @type = @type.to_sym
+        end
+      else
+        @type = :unknown
+      end
+
+      if @type == :unknown
+        @type = infer_type_from_value
+      end
+
+      return @type
+    end
+
+    def collection?
+      if relationship
+        return relationship.max > 1
+      elsif value
+        return value.responts_to?(:each)
+      else
+        return false
+      end
+    end
+
+
+    private
+
+      def relationship
+        return @relationship if defined?(@relationship)
+
+        @relationship = model.model_class.relationships.select do |r|
+          r.name == name
+        end.first
+
+        return @relationship
+      end
+
+  end
+end

data/lib/upmin/data_mapper/model.rb

@@ -0,0 +1,62 @@
+module Upmin::DataMapper
+  module Model
+    extend ActiveSupport::Concern
+
+    def new_record?
+      return model.new?
+    end
+
+    def to_key
+      return [model.id]
+    end
+
+
+    module ClassMethods
+      # NOTE - ANY method added here must be added to the bottom of
+      # Upmin::Model. This ensures that an instance of the class was
+      # created, which in turn ensures that the correct module was
+      # included in the class.
+
+      def find(*args)
+        return model_class.get(*args)
+      end
+
+      def default_attributes
+        return model_class.properties.map(&:name)
+      end
+
+      def attribute_type(attribute)
+        property = model_class.properties.select{ |p| p.name == attribute }.first
+        type = property.class.to_s.demodulize.underscore.to_sym
+
+        case type
+        when :serial
+          return :integer
+        when :date_time
+          return :datetime
+        else
+          return type
+        end
+      end
+
+      def associations
+        return @associations if defined?(@associations)
+
+        all = []
+        ignored = []
+        model_class.relationships.each do |relationship|
+          all << relationship.name
+
+          # This may need dropped later if we find that it is more useful to show these.
+          if relationship.is_a?(DataMapper::Associations::ManyToMany::Relationship)
+            ignored << relationship.options[:through]
+          end
+        end
+
+        return @associations = (all - ignored).uniq
+      end
+
+    end
+
+  end
+end

data/lib/upmin/data_mapper/query.rb

@@ -0,0 +1,57 @@
+module Upmin::DataMapper
+  module Query
+
+    def results
+      return klass.model_class.all(prepared_search)
+    end
+
+    private
+
+      def prepared_search
+        return @prepared_search if defined?(@prepared_search)
+        @prepared_search = {}
+        if search_options
+          search_options.each do |key, value|
+            next if value.empty?
+
+            if op = create_operator(key)
+              @prepared_search[op] = value
+            else
+              raise InvalidSearchSuffix.new(key)
+            end
+          end
+        end
+        return @prepared_search
+      end
+
+      def create_operator(key)
+        if m = key.to_s.match(/(.*)_(#{valid_suffixes.join("|")})/)
+          target = m.captures.first
+          operator = operator_for(m.captures.second)
+          return DataMapper::Query::Operator.new(target, operator)
+        else
+          return nil
+        end
+      end
+
+      def valid_suffixes
+        return [
+          :gteq,
+          :lteq,
+          :cont
+        ]
+      end
+
+      def operator_for(suffix)
+        op_map = {
+          gteq: :gte,
+          lteq: :lte,
+          cont: :like
+        }
+        return op_map[suffix.to_sym]
+      end
+
+
+
+  end
+end

data/lib/upmin/engine.rb

@@ -3,5 +3,7 @@
 module Upmin
   class Engine < ::Rails::Engine
     isolate_namespace Upmin
+
+    config.autoload_paths << "#{::Rails.root}/app/upmin/models"
   end
 end

data/lib/upmin/errors.rb

@@ -0,0 +1,43 @@
+module Upmin
+  class InvalidAction < ArgumentError
+    def initialize(action)
+      super("Invalid action: #{action}")
+    end
+  end
+
+  class MissingArgument < ArgumentError
+    def initialize(arg)
+      super("Missing argument: #{arg}")
+    end
+  end
+
+  class ArgumentError < ArgumentError
+    def initialize(arg)
+      super("Invalid argument: #{arg}")
+    end
+  end
+
+  class MissingPartial < ::StandardError
+    def initialize(data)
+      super("Could not find a matching partial with the following data: #{data.as_json}")
+    end
+  end
+
+  class UnsupportedObjectMapper < ::StandardError
+    def initialize
+      super("The ORM or ODM you are using is not supported. Please create an issue on github if one doesn't exist - https://github.com/upmin/upmin-admin-ruby/issues")
+    end
+  end
+
+  class UninferrableAdminError < NameError
+    def initialize(klass)
+      super("Could not infer an Admin class for #{klass}.")
+    end
+  end
+
+  class UninferrableSourceError < NameError
+    def initialize(klass)
+      super("Could not infer a source for #{klass}.")
+    end
+  end
+end

data/lib/upmin/model.rb

@@ -1,137 +1,306 @@
 module Upmin
   class Model
+    include Upmin::Engine.routes.url_helpers
+    include Upmin::AutomaticDelegation
 
-    attr_accessor :instance
-    attr_accessor :klass
+    attr_reader :model
+    alias_method :object, :model
 
-    def initialize(instance, options = {})
-      self.instance = instance
-      self.klass = Upmin::Klass.find(instance.class.name)
+    def initialize(model = nil, options = {})
+      if self.class.active_record?
+        self.class.send(:include, Upmin::ActiveRecord::Model)
+      elsif self.class.data_mapper?
+        self.class.send(:include, Upmin::DataMapper::Model)
+      end
+
+      if model.is_a?(Hash)
+        unless model.has_key?(:id)
+          raise ":id or model instance is required."
+        end
+        @model = self.class.find(model[:id])
+      elsif model.nil?
+        @model = self.model_class.new
+      else
+        @model = model
+      end
+    end
+
+    def path
+      if new_record?
+        return upmin_new_model_path(klass: model_class_name)
+      else
+        return upmin_model_path(klass: model_class_name, id: id)
+      end
+    end
+
+    def create_path
+      return upmin_create_model_path(klass: model_class_name)
     end
 
-    ## Methods for rendering in views
     def title
-      return "#{klass.humanized_name(:singular)} # #{instance.id}"
+      return "#{humanized_name(:singular)} # #{id}"
+    end
+
+    def attributes
+      return @attributes if defined?(@attributes)
+      @attributes = []
+      self.class.attributes.each do |attr_name|
+        @attributes << Upmin::Attribute.new(self, attr_name)
+      end
+      return @attributes
+    end
+
+    def associations
+      return @associations if defined?(@associations)
+      @associations = []
+      self.class.associations.each do |assoc_name|
+        @associations << Upmin::Association.new(self, assoc_name)
+      end
+      return @associations
     end
 
+    def actions
+      return @actions if defined?(@actions)
+      @actions = []
+      self.class.actions.each do |action_name|
+        @actions << Upmin::Action.new(self, action_name)
+      end
+      return @actions
+    end
+
+
+    ###########################################################
+    ###  Delegated instance methods
+    ###########################################################
+
+    # TODO(jon): Delegations here weren't working in 3.2 so this is done with normal old methods.
+    # delegate(:color, to: :class)
     def color
-      return klass.color
-    end
-
-    def path_hash
-      return {
-        klass: klass.name,
-        id: instance.id
-      }
-    end
-
-    def new_record?
-      return instance.new_record?
-    end
-
-    ## Methods for getting attributes, associations, etc and anything relevant to them.
-
-
-    # Returns the type of an attribute. If it is nil and we can't
-    # figure it out from the db columns we just fall back to
-    # :unknown
-    def attribute_type(attr_name)
-      type = klass.attribute_type(attr_name)
-
-      if type == :unknown
-        # See if we can deduce it by looking at the data
-        data = attribute(attr_name)
-        class_sym = data.class.to_s.underscore.to_sym
-        if class_sym == :false_class || class_sym == :true_class
-          type = :boolean
-        elsif class_sym == :nil_class
-          type = :unknown
-        elsif class_sym == :fixnum
-          type = :integer
-        elsif class_sym == :big_decimal
-          type = :decimal
-        elsif class_sym == :"active_support/time_with_zone"
-          type = :datetime
-        else
-          # This should prevent any classes from being skipped, but we may not have an exhaustive list yet.
-          type = class_sym
-        end
+      return self.class.color
+    end
+    # delegate(:humanized_name, to: :class)
+    def humanized_name(type = :plural)
+      return self.class.humanized_name(type)
+    end
+    # delegate(:underscore_name, to: :class)
+    def underscore_name
+      return self.class.underscore_name
+    end
+    # delegate(:model_class, to: :class)
+    def model_class
+      return self.class.model_class
+    end
+    # delegate(:model_class_name, to: :class)
+    def model_class_name
+      return self.class.model_class_name
+    end
+
+
+
+
+    ###########################################################
+    ###  Class methods
+    ###########################################################
+
+    def Model.count(*args)
+      return model_class.count(*args)
+    end
+
+    def Model.find_class(model)
+      return find_or_create_class(model.to_s)
+    end
+
+    def Model.find_or_create_class(model_name)
+      ::Rails.application.eager_load!
+      return "Admin#{model_name}".constantize
+    rescue NameError
+      eval("class ::Admin#{model_name} < Upmin::Model; end")
+      return "Admin#{model_name}".constantize
+    end
+
+    # Returns all upmin models.
+    def Model.all
+      all = []
+      Upmin.configuration.models.each do |m|
+        all << find_or_create_class(m.to_s.camelize)
       end
+      return all
+    end
 
-      return type
+    def Model.model_class
+      @model_class ||= inferred_model_class
     end
 
-    # Returns whether or not the attr_name is an attribute that can be edited.
-    def attribute_editable?(attr_name)
-      attr_name = attr_name.to_sym
-      return false if attr_name == :id
-      return false if attr_name == :created_at
-      return false if attr_name == :updated_at
-      # TODO(jon): Add a way to declare which attributes are editable and which are not later.
-      return instance.respond_to?("#{attr_name}=")
+    def Model.model_class?
+      return model_class
+    rescue Upmin::UninferrableSourceError
+      return false
     end
 
-    # Returns the value of the attr_name method
-    def attribute(attr_name)
-      attr_name = attr_name.to_sym
-      # TODO(jon): Add some way to handle exceptions. Probably a custom error that we display.
-      return instance.send(attr_name)
+    def Model.model_class
+      return @model_class ||= inferred_model_class
     end
 
-    def attribute_form_id(attr_name)
-      return "#{klass.name.underscore}_#{attr_name}"
+    def Model.inferred_model_class
+      name = model_class_name
+      return name.constantize
+    rescue NameError => error
+      raise if name && !error.missing_name?(name)
+      raise Upmin::UninferrableSourceError.new(self)
     end
 
-    def attribute_label_name(attr_name)
-      return attr_name.to_s.gsub(/_/, " ").capitalize
+    def Model.model_class_name
+      raise NameError if name.nil? || name.demodulize !~ /Admin.+$/
+      return name.demodulize[5..-1]
     end
 
+    def Model.model_name
+      return ActiveModel::Name.new(model_class)
+    end
 
-    # Returns the type of an association. If we can't figure it
-    # out we fall back to :unknown
-    def association_type(assoc_name)
-      type = klass.association_type(assoc_name)
-      if type == :unknown && data = association(assoc_name).first
-        type = data.class.name.underscore
+    def Model.humanized_name(type = :plural)
+      names = model_class_name.split(/(?=[A-Z])/)
+      if type == :plural
+        names[names.length-1] = names.last.pluralize
       end
-      return type
+      return names.join(" ")
     end
 
-    def association(assoc_name, options = {})
-      association = instance.send(assoc_name)
-      if association.respond_to?(:each)
-        # We have a collection, at least we hope we do.
-        if options[:limit] && association.respond_to?(:limit)
-          association = association.limit(5)
-        end
+    def Model.underscore_name(type = :singular)
+      if type == :singular
+        return model_class_name.underscore
+      else
+        return model_class_name.pluralize.underscore
       end
-      return association
     end
 
-    def action_parameters(action)
-      instance.method(action).parameters
+    def Model.search_path
+      return Upmin::Engine.routes.url_helpers.upmin_search_path(klass: model_class_name)
+    end
+
+    def Model.color
+      return @color if defined?(@color)
+      @color = Model.next_color
+      return @color
+    end
+
+    def Model.colors
+      return Upmin.configuration.colors
     end
 
-    def perform_action(action, arguments)
-      unless klass.actions.include?(action.to_sym)
-        raise "Invalid action: #{action}"
+    def Model.next_color
+      @color_index ||= 0
+      next_color = colors[@color_index]
+      @color_index = (@color_index + 1) % colors.length
+      return next_color
+    end
+
+    # This is not currently used, but could be used to ensure colors are always the same.
+    def Model.color_index
+      return @color_index if defined?(@color_index)
+      @color_index = model_class_name.split("").map(&:ord).inject(:+) % colors.length
+      return @color_index
+    end
+
+
+    def Model.active_record?
+      if defined?(ActiveRecord)
+        return model_class.superclass == ::ActiveRecord::Base
+      else
+        return false
       end
+    end
 
-      params = action_parameters(action)
-      params_array = []
-      params.each do |param_type, param_name|
-        if param_type == :req
-          raise "Missing argument: #{param_name}" unless arguments[param_name]
-          params_array << arguments[param_name]
-        elsif param_type == :opt
-          params_array << arguments[param_name] if arguments[param_name]
-        else # :block or ??
-          next
-        end
+    def Model.data_mapper?
+      if defined?(DataMapper)
+        return model_class.is_a?(::DataMapper::Model)
+      else
+        return false
+      end
+    end
+
+
+
+    ###########################################################
+    ### Customization methods for Admin<Model> classes
+    ###########################################################
+
+    # Add a single attribute to upmin attributes.
+    # If this is called before upmin_attributes
+    # the attributes will not include any defaults
+    # attributes.
+    def Model.attribute(attribute = nil)
+      @extra_attrs = [] unless defined?(@extra_attrs)
+      @extra_attrs << attribute.to_sym if attribute
+    end
+
+    # Sets the attributes to the provided attributes # if any are any provided.
+    # If no attributes are provided then the
+    # attributes are set to the default attributes of
+    # the model class.
+    def Model.attributes(*attributes)
+      @extra_attrs = [] unless defined?(@extra_attrs)
+
+      if attributes.any?
+        @attributes = attributes.map{|a| a.to_sym}
+      end
+      @attributes ||= default_attributes
+
+      return (@attributes + @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 Model.action(action)
+      @actions ||= []
+
+      action = action.to_sym
+      @actions << action unless @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 Model.actions(*actions)
+      if actions.any?
+        # set the actions
+        @actions = actions.map{|a| a.to_sym}
       end
-      return instance.send(action, *params_array)
+      @actions ||= []
+      return @actions
     end
 
 
+
+    ###########################################################
+    ### Methods that need to be to be overridden. If the
+    ### Model.method_name version of these are ever called it
+    ### means that it wasn't overridden, or an instance of
+    ### the class hasn't been created yet.
+    ###########################################################
+
+    def Model.find(*args)
+      new
+      return find(*args)
+    end
+
+    def Model.default_attributes
+      new
+      return default_attributes
+    end
+
+    def Model.attribute_type(attribute)
+      new
+      return attribute_type(attribute)
+    end
+
+    def Model.associations
+      new
+      return associations
+    end
+
   end
 end