upmin 0.0.34

data/config/routes.rb

@@ -0,0 +1,19 @@
+Upmin::Engine.routes.draw do
+  root to: "models#dashboard"
+
+  scope :models do
+    # TODO(jon): Put dashboards elsewhere prob.. whatever for now.
+    get "/", as: :upmin_dashboard, controller: :models, action: :dashboard
+
+    scope "/:model_name" do
+      match "/", as: :upmin_search, controller: :models, action: :search, via: [:get, :post]
+
+      scope "/:id" do
+        get "/", as: :upmin_model, controller: :models, action: :show
+        put "/", controller: :models, action: :update
+
+        post "/:method", as: :upmin_action, controller: :models, action: :action
+      end
+    end
+  end
+end

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,44 @@
+require "upmin/engine"
+
+require "upmin/model"
+
+# For displaying views and finding children
+require "upmin/graph/collection_node"
+require "upmin/graph/data_node"
+require "upmin/graph/model_node"
+
+# Monkey patch code into rails
+require "upmin/railties/active_record"
+# require "upmin/active_record_relation"
+require "upmin/railties/render"
+require "upmin/railties/render_helpers"
+require "upmin/railtie"
+
+# gems and stuff we use
+require "ransack"
+require "typhoeus"
+require "haml"
+require "sass-rails"
+
+module Upmin
+
+  def Upmin.api_key=(api_key)
+    @@api_key = api_key
+    # Upmin.notify_upmin
+  end
+
+  def Upmin.api_key
+    if (defined? @@api_key)
+      return @@api_key
+    else
+      raise "Upmin API key is not set."
+    end
+  end
+
+  # def Upmin.notify_upmin
+  #   # TODO(jon): Add if prod check here (and maybe other spots?)
+  #   resp = Typhoeus.get(init_url, followlocation: true, params: { api_key: Upmin.api_key })
+  #   puts JSON.parse(resp.body)
+  # end
+
+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/graph/collection_node.rb

@@ -0,0 +1,72 @@
+module Upmin::Graph
+  class CollectionNode
+    def initialize(collection, options = {})
+      @collection = collection
+      @options = options
+    end
+
+    def collection
+      return @collection
+    end
+    alias_method :object, :collection
+
+    def options
+      return @options
+    end
+
+    def depth
+      return options[:depth] ||= 0
+    end
+
+    def editable?
+      return options[:editable] if options[:editable]
+      return options[:editable] = false
+    end
+
+    def type
+      return options[:type] ||= determine_type
+    end
+
+    def method_name
+      return options[:method_name] || nil
+    end
+
+    def nodes
+      return @nodes ||= create_nodes
+    end
+
+    private
+      def determine_type
+        # TODO(jon): Maybe optimize multi-type collections? Prob don't need this much work to figure them out.
+        if collection.any?
+          klasses = collection.map{|c| c.class.to_s.underscore.to_sym}
+          if klasses.uniq.length == 1
+            return "#{klasses.first}_collection".to_sym
+          end
+        end
+
+        if method_name
+          return "#{method_name.to_s.singularize}_collection"
+        else
+          return :unknown_collection
+        end
+      end
+
+      def create_nodes
+        nodes = []
+        node_options = {
+          depth: depth,
+          editable: editable?
+        }
+        collection.each do |collection_item|
+          if collection_item.is_a?(ActiveRecord::Base)
+            nodes << ModelNode.new(collection_item, node_options)
+          else
+            nodes << DataNode.new(collection_item, node_options)
+          end
+        end
+        return nodes
+      end
+
+  end
+end

data/lib/upmin/graph/data_node.rb

@@ -0,0 +1,69 @@
+module Upmin::Graph
+  class Upmin::Graph::DataNode
+    def initialize(data, options = {})
+      @data = data
+      @options = options
+    end
+
+    def data
+      return @data
+    end
+    alias_method :object, :data
+
+    def options
+      return @options
+    end
+
+    def depth
+      return options[:depth] ||= 0
+    end
+
+    def editable?
+      return options[:editable] unless options[:editable].nil?
+      return options[:editable] = false
+    end
+
+    def type
+      return options[:type] ||= determine_type
+    end
+
+    def method_name
+      return options[:method_name] || nil
+    end
+
+    def parent_name
+      return options[:parent_name] || nil
+    end
+
+    def form_name
+      return "#{parent_name}[#{method_name}]"
+    end
+
+    def form_id
+      return "#{parent_name}_#{method_name}"
+    end
+
+
+
+    private
+
+    def determine_type
+      # Preferably this gets set by the model, but in the case that it isn't we try to determine it with the data
+      class_name = data.class.to_s.underscore.to_sym
+      if class_name == :false_class || class_name == :true_class
+        return :boolean
+      elsif class_name == :nil_class
+        return :unknown
+      elsif class_name == :fixnum
+        return :integer
+      elsif class_name == :big_decimal
+        return :decimal
+      elsif class_name == :"active_support/time_with_zone"
+        return :datetime
+      else
+        # TODO(jon): Determine if we need more for things like binary, date, timestamp, etc.
+        return class_name
+      end
+    end
+  end
+end

data/lib/upmin/graph/model_node.rb

@@ -0,0 +1,151 @@
+module Upmin::Graph
+  class ModelNode
+    def initialize(model, options = {})
+      @model = model
+      @options = options
+    end
+
+    def model
+      return @model
+    end
+    alias_method :object, :model
+
+    def options
+      return @options
+    end
+
+    def depth
+      return options[:depth] ||= 0
+    end
+
+    def editable?
+      return options[:editable] if options[:editable]
+      return options[:editable] = true
+    end
+
+    def type
+      return options[:type] ||= determine_type
+    end
+
+    def method_name
+      return options[:method_name] || nil
+    end
+
+    def name
+      return model.upmin_name(:singular)
+    end
+
+    def title
+      # TODO(jon): Add block option for custom defined titles
+      return "#{name} # #{model.id}"
+    end
+
+    def color
+      return model.upmin_color
+    end
+
+    def path_hash
+      return {
+        model_name: model.class.to_s,
+        id: model.id
+      }
+    end
+
+    # TODO(jon): Add the following methods:
+
+
+    def attributes
+      return @attributes ||= create_attributes
+    end
+
+    def children
+      if depth >= 1
+        return [] # nothing beyond a depth of 2
+      else
+        return @children ||= create_children
+      end
+    end
+
+    def singletons
+      return @singletons if @singletons
+      create_children # backfill this if not defined
+      return @singletons
+    end
+
+    def collections
+      return @collections if @collections
+      create_children # backfill this if not defined
+      return @collections
+    end
+
+    def type_prefix
+      name = model.class.to_s.underscore
+      return name
+    end
+
+    def type_suffix
+      if depth == 0
+        return "_model"
+      elsif depth >= 1
+        return "_model_nested"
+      # else
+      #   return "_model_badge"
+      end
+    end
+
+    private
+      def determine_type
+        return "#{type_prefix}#{type_suffix}".to_sym
+      end
+
+      def create_attributes
+        attributes = {}
+        editable = (depth == 0)
+
+        model.upmin_attributes.each do |u_attr|
+          attributes[u_attr] = DataNode.new(
+            model.upmin_get_attr(u_attr), {
+            depth: depth + 1,
+            editable: editable && model.upmin_attr_editable?(u_attr),
+            type: model.upmin_attr_type(u_attr),
+            method_name: u_attr,
+            parent_name: model.class.to_s.underscore
+          })
+        end
+        return attributes
+      end
+
+      def create_children
+        singletons = {}
+        collections = {}
+
+        model.upmin_associations.each do |association|
+          puts "Association=#{association}"
+          v = model.upmin_get_assoc(association)
+          puts "Value for assoc is: #{v} #{v.inspect}"
+          options = {
+            depth: depth + 1,
+            editable: (depth == 0),
+            method_name: association.to_sym
+          }
+          puts options.inspect
+          puts options.inspect
+          puts options.inspect
+          puts options.inspect
+
+          if v.nil?
+            singletons[association] = DataNode.new(nil, options.merge(type: :unknown))
+          elsif v.is_a?(ActiveRecord::Base)
+            singletons[association] = ModelNode.new(v, options)
+          else
+            collections[association] = CollectionNode.new(v, options)
+          end
+        end
+
+        @singletons = singletons
+        @collections = collections
+        return @singletons.merge(@collections)
+      end
+
+  end
+end

data/lib/upmin/graph/node.rb

@@ -0,0 +1,98 @@
+# module Upmin
+#   module Graph
+#   end
+# end
+
+# class Upmin::Graph::Node
+#   def initialize(model, depth = 0)
+#     @model = model
+#     @depth = depth
+#   end
+
+#   def model
+#     return @model
+#   end
+
+#   def depth
+#     return @depth
+#   end
+
+#   def attributes
+#     return @attributes ||= create_attributes
+#   end
+
+#   def children
+#     if @depth >= 2
+#       return [] # nothing beyond a depth of 2
+#     else
+#       return @children ||= create_children
+#     end
+#   end
+
+#   private
+#     def create_attributes
+#       attributes = []
+#       model.upmin_attributes.each do |u_attr|
+#         attributes << {
+#           name: u_attr.to_sym,
+#           value: model.upmin_get(u_attr),
+#           editable: depth == 0 && model.upmin_attr_editable?(u_attr),
+#           type: model.upmin_attr_type(u_attr)
+#         }
+#       end
+#       return attributes
+#     end
+
+#     def create_children
+#       @singletons = []
+#       @collections = []
+#       model.upmin_associations.each do |association|
+#         puts "Association=#{association}"
+#         v = model.upmin_get_assoc(association)
+#         puts "Value for assoc is: #{v} #{v.inspect}"
+#         options = {
+#           depth: depth + 1,
+#           editable: false
+#         }
+
+#         if v.nil?
+#           @singletons << DataNode.new(nil, depth: depth + 1)
+#         elsif true
+
+#         else
+
+#         end
+
+#         hash = {
+#           name: association.to_sym,
+#         }
+#         if v.nil?
+#           # TODO(jon): Make this work better
+#           @singletons << hash.merge({
+#             value: nil,
+#             editable: false,
+#             type: :nil
+#           })
+#         elsif v.is_a?(ActiveRecord::Base)
+#           @singletons << hash.merge({
+#             value: Node.new(v, depth + 1),
+#             editable: false,
+#             type: v.class.to_s.underscore.to_sym
+#           })
+#         else # Assume it is a collection or nil
+#           type = :nil
+#           type = v.first.class.to_s.underscore if v.any?
+#           type = "#{type}_collection".to_sym
+
+#           @collections << hash.merge({
+#             value: "",
+#             editable: false,
+#             type: type
+#           })
+#         end
+#       end
+
+#       return @singletons + @collections
+#     end
+
+# end