upmin 0.0.34

data/lib/upmin/model.rb

@@ -0,0 +1,131 @@
+module Upmin
+  class Model
+
+    attr_accessor :rails_model
+    attr_accessor :color
+
+    def initialize(rails_model, options = {})
+      self.rails_model = rails_model
+
+      if options[:color]
+        self.color = options[:color]
+      end
+    end
+
+    def to_s
+      return rails_model.to_s
+    end
+
+    def name
+      return rails_model.name
+    end
+
+    def u_name
+      return rails_model.upmin_name
+    end
+
+    def form_name
+      return rails_model.name.underscore
+    end
+    alias_method :partial_name, :form_name
+
+    # Wrapper methods that the normal model would have access to
+    def find(id)
+      return rails_model.find(id)
+    end
+
+    def search(*args)
+      return self.rails_model.ransack(*args)
+    end
+    alias_method :ransack, :search
+
+    def upmin_methods
+      return self.rails_model.upmin_methods
+    end
+
+
+    # Methods that perform actions on an instance but require some prep and logic ahead of time that shouldn't be injected into the active record.
+    def perform_action(instance, method, arguments)
+      raise "Invalid method: #{method}" unless upmin_methods.include?(method.to_sym)
+
+      params = instance.method(method).parameters
+      args_to_send = []
+      params.each do |type, name|
+        if type == :req
+          raise "Missing argument: #{name}" unless arguments[name]
+          args_to_send << arguments[name]
+          puts "Added: #{arguments[name].inspect}"
+        elsif type == :opt
+          puts arguments.inspect
+          args_to_send << arguments[name] if arguments[name]
+          puts "Added: #{arguments[name].inspect}"
+        else # :block or ??
+          next
+        end
+      end
+      return instance.send(method, *args_to_send)
+    end
+
+
+    # Methods for determinining attributes, and their types.
+    def attributes
+      return @attributes if defined?(@attributes)
+
+      attributes = {}
+      rails_model.upmin_attributes.each do |u_attr|
+        attributes[u_attr] = {}
+        attributes[u_attr][:type] = get_attr_type(u_attr)
+      end
+
+      return @attributes = attributes
+    end
+
+    def get_attr_type(attr_name)
+      if uc = rails_model.columns_hash[attr_name.to_s]
+        return uc.type
+      else
+        return :unknown
+      end
+    end
+
+
+    ## Generic Class Methods
+    def Model.find(name)
+      return all.select{|a| a.to_s == name.to_s}.first
+    end
+
+    # TODO(jon): Store this in the future so it doesn't have to be looked up every call.
+    def Model.all
+      return @models_array if defined?(@models_array)
+      models_array = []
+      colors = [
+        :light_blue,
+        :blue_green,
+        :red,
+        :yellow,
+        :orange,
+        :purple,
+        :dark_blue,
+        :dark_red,
+        :green
+      ]
+
+      rails_models.each_with_index do |rails_model, i|
+        ac_model = Model.new(rails_model, color: colors[i % colors.length])
+        models_array << ac_model
+      end
+
+      return @models_array = models_array
+    end
+
+    def Model.rails_models
+      ::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/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,156 @@
+require 'active_support/concern'
+
+module Upmin::Railties
+  module ActiveRecord
+    extend ::ActiveSupport::Concern
+
+    included do
+      after_save :notify_upmin_of_save
+    end
+
+    def notify_upmin_of_save
+      # TODO(jon): Add after_save notifications.
+    end
+
+    def upmin_attributes
+      return self.class.upmin_attributes
+    end
+
+    def upmin_associations
+      return self.class.upmin_associations
+    end
+
+    def upmin_collection_reflections
+      return self.class.upmin_collection_reflections
+    end
+
+    def upmin_name(type = :plural)
+      return self.class.upmin_name(type)
+    end
+
+    def upmin_color
+      return self.class.upmin_color
+    end
+
+    def upmin_attr_editable?(attr_name)
+      return false if attr_name.to_sym == :id
+      return false if attr_name.to_sym == :created_at
+      return false if attr_name.to_sym == :updated_at
+      # TODO(jon): Add a way to lock this later
+      return self.respond_to?("#{attr_name}=")
+    end
+
+    def upmin_attr_type(attr_name)
+      if uc = self.class.columns_hash[attr_name.to_s]
+        return uc.type
+      else
+        return :unknown
+      end
+    end
+
+    def upmin_get_attr(attr_name)
+      return send(attr_name)
+    end
+
+    def upmin_get_assoc(assoc_name)
+      assoc_name = assoc_name.to_sym
+      if upmin_collection_reflections.include?(assoc_name)
+        return send(assoc_name).limit(5)
+      else
+        return send(assoc_name)
+      end
+    end
+
+    module ClassMethods
+
+      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
+
+      def upmin_actions(*actions)
+        if actions.any?
+          @upmin_actions = actions.map{|a| a.to_sym}
+        end
+        return @upmin_actions
+      end
+
+      # Alias for upmin_actions
+      def upmin_methods(*methods)
+        return upmin_actions(*methods)
+      end
+
+
+      def upmin_associations(*associations)
+        if associations.any?
+          @upmin_associations = associations.map{|a| a.to_sym}
+        end
+        return @upmin_associations if defined?(@upmin_associations)
+
+        # TODO(jon): Make this handle through relationships and ignore those.
+        upmin_associations = []
+        ignored_associations = []
+        self.reflect_on_all_associations.each do |reflection|
+          upmin_associations << reflection.name.to_sym
+          if reflection.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+            ignored_associations << reflection.options[:through]
+          end
+        end
+        return @upmin_associations = upmin_associations - ignored_associations
+      end
+
+      def upmin_collection_reflections
+        return @upmin_collection_reflections if defined?(@upmin_collection_reflections)
+        collections = self.reflect_on_all_associations.select do |r|
+          r.collection?
+        end.map do |r|
+          r.name
+        end
+        return @upmin_collection_reflections = collections
+      end
+
+      # def upmin_collections(*collections)
+      #   if collections.any?
+      #     @upmin_collections = collections.map{|a| a.to_sym}
+      #   end
+      #   return @upmin_collections if defined?(@upmin_collections)
+
+      #   @upmin_collections = []
+      #   ignored_collections
+      #   self.reflect_on_all_associations.each do |reflection|
+      #     @upmin_collections.name.to_sym << if reflection.collection?
+      #     if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      #       # We need to figure out what collection to ignore.
+      #       @upmin_collections.name.to_sym
+      #     end
+      #   end
+      #   return @upmin_collections
+      # end
+
+      def upmin_actions(*actions)
+        if actions.any?
+          @upmin_actions = actions.map{|a| a.to_sym}
+        end
+        @upmin_actions ||= []
+        return @upmin_actions
+      end
+
+      def upmin_name(type = :plural)
+        names = name.split(/(?=[A-Z])/)
+        if type == :plural
+          names[names.length-1] = names.last.pluralize
+        end
+        return names.join(" ")
+      end
+
+      def upmin_color
+        return @upmin_color if defined?(@upmin_color)
+        return @upmin_color = Upmin::Model.find(self.name).color
+      end
+
+    end
+  end
+end

data/lib/upmin/railties/render.rb

@@ -0,0 +1,56 @@
+
+module Upmin::Railties
+  module Render
+    def upmin_render(model_or_node, options = {})
+      if model_or_node.is_a?(::ActiveRecord::Base)
+        upmin_render_node(Upmin::Graph::ModelNode.new(model_or_node), options)
+
+      else # is a node
+        upmin_render_node(model_or_node, options)
+      end
+    end
+
+    def upmin_render_search_box(upmin_model, options = {})
+      partials = RenderHelpers.partials_for_search_box(upmin_model, options)
+
+      partials.each do |partial|
+        begin
+          return render(
+            partial: partial,
+            object: upmin_model, # this doesn't work with nil
+            locals: {
+              upmin_model: upmin_model,
+              options: options
+            }
+          )
+        rescue ActionView::MissingTemplate => e
+        end
+      end
+      raise "Failed to find a matching partial, even with fallback :unknown partials"
+    end
+
+
+
+    def upmin_render_node(node, options = {})
+      partials = RenderHelpers.partials_for(node, options)
+
+      # TODO(jon): Update this to use something like https://coderwall.com/p/ftbmsa instead of a rescue
+      partials.each do |partial|
+        puts "Trying #{partial}"
+        begin
+          return render(
+            partial: partial,
+            object: node.object, # this doesn't work with nil
+            locals: {
+              node: node,
+              options: options,
+              RenderHelpers.object_name(partial) => node.object
+            }
+          )
+        rescue ActionView::MissingTemplate => e
+        end
+      end
+      raise "Failed to find a matching partial, even with fallback :unknown partials"
+    end
+  end
+end

data/lib/upmin/railties/render_helpers.rb

@@ -0,0 +1,57 @@
+
+module Upmin::Railties
+  module RenderHelpers
+    def RenderHelpers.partials_for(node, options)
+      partials = []
+      partials << options[:partial] if options[:partial]
+      partials << build_path(options[:as]) if options[:as]
+      partials << build_path(node.type)
+
+      if node.is_a?(Upmin::Graph::ModelNode)
+        partials << build_path("unknown#{node.type_suffix}")
+      elsif node.is_a?(Upmin::Graph::CollectionNode)
+        # TODO(jon): Maybe add in support for method_name later
+        if node.type != :unknown_collection
+          partials << build_path(:unknown_collection)
+        end
+      elsif node.is_a?(Upmin::Graph::DataNode)
+        # TODO(jon): Maybe add in support for method_name later
+        if node.type != :unknown
+          partials << build_path(:unknown)
+        end
+      else
+        # WTF? Add unknown as a backup, but this likely isn't even a node.
+        partials << build_path(:unknown)
+      end
+
+      return partials
+    end
+
+    def RenderHelpers.partials_for_search_box(upmin_model, options)
+      partials = []
+      partials << options[:partial] if options[:partial]
+      partials << build_search_box_path(options[:as]) if options[:as]
+      partials << build_search_box_path(upmin_model.partial_name)
+      partials << build_search_box_path(:unknown)
+      return partials
+    end
+
+    def RenderHelpers.build_path(partial)
+      return "upmin/types/#{partial}"
+    end
+
+
+    def RenderHelpers.build_search_box_path(partial)
+      return "upmin/search_boxes/#{partial}"
+    end
+
+    def RenderHelpers.object_name(partial)
+      if match = partial.match(/.*\/(.*)/)
+        return match.captures.first
+      else
+        raise "Unable to match object name for the partial #{partial}."
+      end
+    end
+
+  end
+end

data/lib/upmin/version.rb

@@ -0,0 +1,3 @@
+module Upmin
+  VERSION = "0.0.34"
+end

data/test/controllers/upmin/model_controller_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+module Upmin
+  class ModelControllerTest < ActionController::TestCase
+    test "should get updated_since" do
+      get :updated_since
+      assert_response :success
+    end
+
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.