upmin-admin 0.0.39 → 0.1.0

data/app/views/upmin/partials/search_results/_results.html.haml

@@ -1,2 +1,9 @@
-- results.each do |result|
-  = up_search_result(result)
+- query.upmin_results.each do |result|
+  %a.search-result-link{href: result.path}
+    .upmin-model{class: result.color}
+      %dl.dl-horizontal
+        - result.attributes.each do |attribute|
+          %dt
+            = attribute.label_name
+          %dd
+            = attribute.value

data/lib/upmin/action.rb

@@ -0,0 +1,50 @@
+module Upmin
+  class Action
+    include Upmin::AutomaticDelegation
+
+    attr_reader :model
+    attr_reader :name
+
+    def initialize(model, action_name, options = {})
+      @model = model
+      @name = action_name.to_sym
+    end
+
+    def title
+      return name.to_s.humanize
+    end
+
+    def path
+      return upmin_action_path(klass: model.model_class_name, id: model.id, method: name)
+    end
+
+    def parameters
+      return @parameters if defined?(@parameters)
+      @parameters = []
+      model.method(name).parameters.each do |param_type, param_name|
+        @parameters << Upmin::Parameter.new(self, param_name, type: param_type)
+      end
+      return @parameters
+    end
+    alias_method :arguments, :parameters
+
+    def perform(arguments)
+      array = []
+      parameters.each do |parameter|
+        if parameter.type == :req
+          unless arguments[parameter.name]
+            raise Upmin::MissingArgument.new(parameter.name)
+          end
+          array << arguments[parameter.name]
+        elsif parameter.type == :opt
+          array << arguments[parameter.name] if arguments[parameter.name]
+        else # :block - skip it
+        end
+      end
+      return model.send(name, *array)
+    end
+
+    private
+
+  end
+end

data/lib/upmin/active_record/association.rb

@@ -0,0 +1,47 @@
+module Upmin::ActiveRecord
+  module Association
+
+    def type
+      return @type if defined?(@type)
+
+      if reflection
+        @type = reflection.foreign_type.to_s.gsub(/_type$/, "")
+        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 reflection
+        return reflection.collection?
+      elsif value
+        return value.responds_to?(:each)
+      else
+        return false
+      end
+    end
+
+
+    private
+
+      def reflection
+        return @reflection if defined?(@reflection)
+        @reflection = model.model_class.reflect_on_all_associations.select do |r|
+            r.name == name
+        end.first
+        return @reflection
+      end
+
+  end
+end

data/lib/upmin/active_record/model.rb

@@ -0,0 +1,54 @@
+module Upmin::ActiveRecord
+  module Model
+    extend ActiveSupport::Concern
+
+    def new_record?
+      return model.new_record?
+    end
+
+    def to_key
+      return model.to_key
+    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.find(*args)
+      end
+
+      def default_attributes
+        return model_class.attribute_names.map(&:to_sym)
+      end
+
+      def attribute_type(attribute)
+        adapter = model_class.columns_hash[attribute.to_s]
+        return adapter.type if adapter
+        return :unknown
+      end
+
+      def associations
+        return @associations if defined?(@associations)
+
+        all = []
+        ignored = []
+        model_class.reflect_on_all_associations.each do |reflection|
+          all << reflection.name.to_sym
+
+          # We need to remove the ignored later because we don't know the order they come in.
+          if reflection.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+            ignored << reflection.options[:through]
+          end
+        end
+
+        return @associations = (all - ignored).uniq
+      end
+
+    end
+
+  end
+end

data/lib/upmin/active_record/query.rb

@@ -0,0 +1,12 @@
+module Upmin::ActiveRecord
+  module Query
+
+    def results
+      return klass.model_class.ransack(search_options).result(distinct: true)
+    end
+
+    private
+
+
+  end
+end

data/lib/upmin/admin.rb

@@ -1,12 +1,30 @@
 require "upmin"
 require "upmin/engine"
 
-require "upmin/klass"
+require "upmin/automatic_delegation"
+require "upmin/configuration"
+require "upmin/errors"
+require "upmin/paginator"
+
 require "upmin/model"
+require "upmin/attribute"
+require "upmin/association"
+require "upmin/action"
+require "upmin/parameter"
+require "upmin/query"
 
-require "upmin/paginator"
+# ActiveRecord Specifics.
+if defined?(ActiveRecord)
+  Dir["#{File.dirname(__FILE__)}/active_record/**/*.rb"].each { |f| require f }
+end
+
+# DataMapper Specifics
+if defined?(DataMapper)
+  Dir["#{File.dirname(__FILE__)}/data_mapper/**/*.rb"].each { |f| require f }
+end
 
 # Monkey patch code into rails
+require "upmin/railties/data_mapper"
 require "upmin/railties/active_record"
 require "upmin/railties/paginator"
 require "upmin/railties/render"
@@ -19,6 +37,9 @@ require "ransack"
 require "haml"
 require "sass-rails"
 
+
+require "ostruct"
+
 # If WillPaginate is present we just use it, but by default upmin-admin uses Kaminari
 require "kaminari" unless defined?(WillPaginate)
 
@@ -28,3 +49,4 @@ module Upmin
   module Admin
   end
 end
+

data/lib/upmin/association.rb

@@ -0,0 +1,73 @@
+module Upmin
+  class Association
+    attr_reader :model
+    attr_reader :name
+
+    def initialize(model, assoc_name, options = {})
+      if model.class.active_record?
+        extend Upmin::ActiveRecord::Association
+      elsif model.class.data_mapper?
+        extend Upmin::DataMapper::Association
+      else
+        raise ArgumentError.new(model)
+      end
+
+      @model = model
+      @name = assoc_name.to_sym
+    end
+
+    def value
+      # TODO(jon): Add some way to handle exceptions.
+      return model.send(name)
+    end
+
+    def title
+      return name.to_s.humanize
+    end
+
+    def upmin_values(options = {})
+      options[:limit] ||= 5
+      if collection?
+        vals = [value.limit(options[:limit])].flatten
+      else
+        vals = [value]
+      end
+
+      return vals.map(&:upmin_model)
+    end
+
+    def type
+      raise NotImplementedError
+    end
+
+    def collection?
+      raise NotImplementedError
+    end
+
+    def empty?
+      if collection?
+        return value.count == 0
+      else
+        return ![value].flatten.any?
+      end
+    end
+
+
+
+    private
+
+      def infer_type_from_value
+        if first = [value].flatten.first
+          type = first.class.name.underscore
+          if collection?
+            return type.pluralize.to_sym
+          else
+            return type.to_sym
+          end
+        else
+          return :unknown
+        end
+      end
+
+  end
+end

data/lib/upmin/attribute.rb

@@ -0,0 +1,87 @@
+module Upmin
+  class Attribute
+    attr_reader :model
+    attr_reader :name
+
+    def initialize(model, attr_name, options = {})
+      @model = model
+      @name = attr_name.to_sym
+    end
+
+    def value
+      # TODO(jon): Add some way to handle exceptions.
+      return model.send(name)
+    end
+
+    def type
+      # TODO(jon): Add a way to override with widgets?
+      return @type if defined?(@type)
+
+      # Try to get it from the model_class
+      @type = model.class.attribute_type(name)
+
+      # If we still don't know the type, try to infer it from the value
+      if @type == :unknown
+        @type = infer_type_from_value
+      end
+
+      return @type
+    end
+
+    def editable?
+      case name.to_sym
+      when :id
+        return false
+      when :created_at
+        return false
+      when :created_on
+        return false
+      when :updated_at
+        return false
+      when :updated_on
+        return false
+      else
+        # TODO(jon): Add a way to declare which attributes are editable and which are not later.
+        return model.respond_to?("#{name}=")
+      end
+    end
+
+    def errors?
+      return model.errors[name].any?
+    end
+
+    def label_name
+      return name.to_s.gsub(/_/, " ").capitalize
+    end
+
+    def form_id
+      return "#{model.underscore_name}_#{name}"
+    end
+
+    def nilable_id
+      return "#{form_id}_is_nil"
+    end
+
+
+    private
+
+      def infer_type_from_value
+        class_sym = value.class.to_s.underscore.to_sym
+        if class_sym == :false_class || class_sym == :true_class
+          return :boolean
+        elsif class_sym == :nil_class
+          return :unknown
+        elsif class_sym == :fixnum
+          return :integer
+        elsif class_sym == :big_decimal
+          return :decimal
+        elsif class_sym == :"active_support/time_with_zone"
+          return :datetime
+        else
+          # This should prevent any classes from being skipped, but we may not have an exhaustive list yet.
+          return class_sym
+        end
+      end
+
+  end
+end

data/lib/upmin/automatic_delegation.rb

@@ -0,0 +1,76 @@
+module Upmin
+  module AutomaticDelegation
+    extend ActiveSupport::Concern
+
+    # Delegates missing instance methods to the source model.
+    def method_missing(method, *args, &block)
+      if delegatable?(method)
+        self.class.delegate(method, to: :model)
+        send(method, *args, &block)
+      else
+        return super
+      end
+    end
+
+    def delegatable?(method)
+      return model.respond_to?(method)
+    end
+
+    def delegated?(method)
+      return self.class.delegated?(method)
+    end
+
+    def respond_to?(method)
+      super || delegatable?(method)
+    end
+
+    def method(method_name)
+      if delegated?(method_name)
+        return model.method(method_name)
+      else
+        return super(method_name)
+      end
+    rescue NameError => e
+      if delegatable?(method_name)
+        self.class.delegate(method_name, to: :model)
+        return method(method_name)
+      else
+        super(method_name)
+      end
+    end
+
+    module ClassMethods
+      # Proxies missing class methods to the source class.
+      def method_missing(method, *args, &block)
+        return super unless delegatable?(method)
+
+        model_class.send(method, *args, &block)
+      end
+
+      def delegatable?(method)
+        @test ||={}
+        @test[method] ||= 0
+        @test[method] += 1
+        return false if @test[method] > 2
+        model_class? && model_class.respond_to?(method)
+      end
+
+      def delegate(method, *args)
+        @delegated ||= []
+        @delegated << method.to_sym
+        super(method, *args)
+      end
+
+      def delegated?(method)
+        @delegated ||= []
+        return @delegated.include?(method.to_sym)
+      end
+
+      # Avoids reloading the model class when ActiveSupport clears autoloaded
+      # dependencies in development mode.
+      def before_remove_const
+      end
+    end
+
+  end
+end