upmin-admin 0.0.35

data/lib/tasks/accordive_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :accordive_rails do
+#   # Task goes here
+# end

data/lib/tasks/upmin_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :upmin do
+#   # Task goes here
+# end

data/lib/upmin.rb

@@ -0,0 +1,18 @@
+require "upmin/engine"
+
+require "upmin/klass"
+require "upmin/model"
+
+# Monkey patch code into rails
+require "upmin/railties/active_record"
+require "upmin/railties/render"
+require "upmin/railties/render_helpers"
+require "upmin/railtie"
+
+# gems and stuff we use
+require "ransack"
+require "haml"
+require "sass-rails"
+
+module Upmin
+end

data/lib/upmin/engine.rb

@@ -0,0 +1,7 @@
+# require 'haml-rails'
+
+module Upmin
+  class Engine < ::Rails::Engine
+    isolate_namespace Upmin
+  end
+end

data/lib/upmin/klass.rb

@@ -0,0 +1,165 @@
+module Upmin
+  class Klass
+
+    attr_accessor :model
+    attr_accessor :color
+
+    def initialize(model, options = {})
+      self.model = model
+
+      if options[:color]
+        self.color = options[:color]
+      end
+    end
+
+    # Exposing a model method, but wrapping the result in
+    # an Upmin::Model
+    def find(*args)
+      return Upmin::Model.new(model.find(*args))
+    end
+
+    def ransack(*args)
+      return model.ransack(*args)
+    end
+
+
+    # Returns all of the upmin attributes for the ActiveRecord model
+    # referenced by this Klass object.
+    def attributes
+      return model.upmin_attributes
+    end
+
+    # Returns the type for an attribute by checking the columns
+    # hash. If no match can be found, :unknown is returned.
+    # NOTE - the Upmin::Model version of this will look at the
+    # actual contents of the attr_name if :unknown is returned,
+    # so this version is more accurate if you can use it.
+    def attribute_type(attr_name)
+      if connection_adapter = model.columns_hash[attr_name.to_s]
+        return connection_adapter.type
+      else
+        return :unknown
+      end
+    end
+
+
+    # Returns all of the upmin actions for the ActiveRecord model
+    # referenced by this Klass object.
+    def actions
+      return model.upmin_actions
+    end
+
+    # Returns all associations that are not used in through associations
+    # eg - an Order's products, but not an order's product_orders that link the two.
+    def associations
+      return @associations if defined?(@associations)
+
+      all = []
+      ignored = []
+      model.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
+    end
+
+    # Tries to find an association type based on the reflection
+    def association_type(assoc_name)
+      reflection = reflections.select { |r| r.name == assoc_name.to_sym }.first
+
+      if reflection
+        return reflection.foreign_type.to_s.gsub(/_type$/, "").pluralize.to_sym
+      else
+        return :unknown
+      end
+    end
+
+    def plural_associations
+      return model.reflect_on_all_associations
+        .select{ |r| r.collection? }
+        .map{ |r| r.name.to_sym }
+    end
+
+    def reflections
+      return model.reflect_on_all_associations
+    end
+
+
+
+    ## Methods for prettying up things to display them in views etc.
+
+    # Returns the class name, split at camelCase,
+    # with the last word pluralized if it is plural.
+    def humanized_name(type = :plural)
+      names = model.name.split(/(?=[A-Z])/)
+      if type == :plural
+        names[names.length-1] = names.last.pluralize
+      end
+      return names.join(" ")
+    end
+
+    # Returns the class name, capitalized as it would be with User.name or OrderShipment.name - "User", or "OrderShipment"
+    def name
+      return model.name
+    end
+
+    def path_hash
+      return {
+        klass: klass.name
+      }
+    end
+
+
+
+    ## Class Methods
+
+    # Takes a Rails ActiveRecord or the name of one and returns an
+    # Upmin::Klass instance of the model.
+    def Klass.find(model)
+      return all.select{|k| k.name == model.to_s}.first
+    end
+
+    # Returns an array of all Klass instances
+    def Klass.all
+      return @all if defined?(@all)
+      all = []
+
+      models.each_with_index do |model, i|
+        klass = Klass.new(model, color: colors[i % colors.length])
+        all << klass
+      end
+
+      return @all = all
+    end
+
+    def Klass.colors
+      return [
+        :light_blue,
+        :blue_green,
+        :red,
+        :yellow,
+        :orange,
+        :purple,
+        :dark_blue,
+        :dark_red,
+        :green
+      ]
+    end
+
+    def Klass.models
+      # If Rails
+      ::Rails.application.eager_load!
+      rails_models = ::ActiveRecord::Base.descendants.select do |m|
+        m.to_s != "ActiveRecord::SchemaMigration"
+      end
+
+      return rails_models
+    end
+
+  end
+end

data/lib/upmin/model.rb

@@ -0,0 +1,133 @@
+module Upmin
+  class Model
+
+    attr_accessor :instance
+    attr_accessor :klass
+
+    def initialize(instance, options = {})
+      self.instance = instance
+      self.klass = Upmin::Klass.find(instance.class.name)
+    end
+
+    ## Methods for rendering in views
+    def title
+      return "#{klass.humanized_name(:singular)} # #{instance.id}"
+    end
+
+    def color
+      return klass.color
+    end
+
+    def path_hash
+      return {
+        klass: klass.name,
+        id: instance.id
+      }
+    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
+      end
+
+      return type
+    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}=")
+    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)
+    end
+
+    def attribute_form_id(attr_name)
+      return "#{klass.name.underscore}_#{attr_name}"
+    end
+
+    def attribute_label_name(attr_name)
+      return attr_name.to_s.gsub(/_/, " ").capitalize
+    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
+      end
+      return type
+    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
+      end
+      return association
+    end
+
+    def action_parameters(action)
+      instance.method(action).parameters
+    end
+
+    def perform_action(action, arguments)
+      unless klass.actions.include?(action.to_sym)
+        raise "Invalid action: #{action}"
+      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
+      end
+      return instance.send(action, *params_array)
+    end
+
+
+  end
+end

data/lib/upmin/railtie.rb

@@ -0,0 +1,19 @@
+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)
+        # ::ActiveRecord::Relation.send(:include, Upmin::ActiveRecordRelation)
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        ::ActionController::Base.send(:include, Upmin::Railties::Render)
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        ::ActionView::Base.send(:include, Upmin::Railties::Render)
+      end
+    end
+  end
+end

data/lib/upmin/railties/active_record.rb

@@ -0,0 +1,62 @@
+require 'active_support/concern'
+
+module Upmin::Railties
+  module ActiveRecord
+    extend ::ActiveSupport::Concern
+
+    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)
+        upmin_attributes unless defined?(@upmin_attributes)
+
+        attribute = attribute.to_sym
+        @upmin_attributes << attribute unless @upmin_attributes.include?(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)
+        if attributes.any?
+          @upmin_attributes = attributes.map{|a| a.to_sym}
+        end
+        @upmin_attributes ||= attribute_names.map{|a| a.to_sym}
+        return @upmin_attributes
+      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?(attribute)
+      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/render.rb

@@ -0,0 +1,120 @@
+
+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)
+      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
+
+      partials.each do |partial|
+        begin
+          options[:partial] = partial
+          return render(options)
+        rescue ActionView::MissingTemplate => e
+        end
+      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}"
+    end
+
+  end
+end