ultra-smart-hub 0.0.1

data/rails_admin-3.3.0/lib/rails_admin/abstract_model.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'rails_admin/support/datetime'
+
+module RailsAdmin
+  class AbstractModel
+    cattr_accessor :all
+    attr_reader :adapter, :model_name
+
+    class << self
+      def reset
+        @@all = nil
+      end
+
+      def all(adapter = nil)
+        @@all ||= Config.models_pool.collect { |m| new(m) }.compact
+        adapter ? @@all.select { |m| m.adapter == adapter } : @@all
+      end
+
+      alias_method :old_new, :new
+      def new(m)
+        m = m.constantize unless m.is_a?(Class)
+        (am = old_new(m)).model && am.adapter ? am : nil
+      rescue *([LoadError, NameError] + (defined?(ActiveRecord) ? ['ActiveRecord::NoDatabaseError'.constantize, 'ActiveRecord::ConnectionNotEstablished'.constantize] : []))
+        puts "[RailsAdmin] Could not load model #{m}, assuming model is non existing. (#{$ERROR_INFO})" unless Rails.env.test?
+        nil
+      end
+
+      @@polymorphic_parents = {}
+
+      def polymorphic_parents(adapter, model_name, name)
+        @@polymorphic_parents[adapter.to_sym] ||= {}.tap do |hash|
+          all(adapter).each do |am|
+            am.associations.select(&:as).each do |association|
+              (hash[[association.klass.to_s.underscore, association.as].join('_').to_sym] ||= []) << am.model
+            end
+          end
+        end
+        @@polymorphic_parents[adapter.to_sym][[model_name.to_s.underscore, name].join('_').to_sym]
+      end
+
+      # For testing
+      def reset_polymorphic_parents
+        @@polymorphic_parents = {}
+      end
+    end
+
+    def initialize(model_or_model_name)
+      @model_name = model_or_model_name.to_s
+      ancestors = model.ancestors.collect(&:to_s)
+      if ancestors.include?('ActiveRecord::Base') && !model.abstract_class? && model.table_exists?
+        initialize_active_record
+      elsif ancestors.include?('Mongoid::Document')
+        initialize_mongoid
+      end
+    end
+
+    # do not store a reference to the model, does not play well with ActiveReload/Rails3.2
+    def model
+      @model_name.constantize
+    end
+
+    def quoted_table_name
+      table_name
+    end
+
+    def quote_column_name(name)
+      name
+    end
+
+    def to_s
+      model.to_s
+    end
+
+    def config
+      Config.model self
+    end
+
+    def to_param
+      @model_name.split('::').collect(&:underscore).join('~')
+    end
+
+    def param_key
+      @model_name.split('::').collect(&:underscore).join('_')
+    end
+
+    def pretty_name
+      model.model_name.human
+    end
+
+    def where(conditions)
+      model.where(conditions)
+    end
+
+    def each_associated_children(object)
+      associations.each do |association|
+        case association.type
+        when :has_one
+          child = object.send(association.name)
+          yield(association, [child]) if child
+        when :has_many
+          children = object.send(association.name)
+          yield(association, Array.new(children))
+        end
+      end
+    end
+
+    def format_id(id)
+      id
+    end
+
+    def parse_id(id)
+      id
+    end
+
+  private
+
+    def initialize_active_record
+      @adapter = :active_record
+      require 'rails_admin/adapters/active_record'
+      extend Adapters::ActiveRecord
+    end
+
+    def initialize_mongoid
+      @adapter = :mongoid
+      require 'rails_admin/adapters/mongoid'
+      extend Adapters::Mongoid
+    end
+
+    def parse_field_value(field, value)
+      value.is_a?(Array) ? value.map { |v| field.parse_value(v) } : field.parse_value(value)
+    end
+
+    class StatementBuilder
+      def initialize(column, type, value, operator)
+        @column = column
+        @type = type
+        @value = value
+        @operator = operator
+      end
+
+      def to_statement
+        return if [@operator, @value].any? { |v| v == '_discard' }
+
+        unary_operators[@operator] || unary_operators[@value] ||
+          build_statement_for_type_generic
+      end
+
+    protected
+
+      def get_filtering_duration
+        FilteringDuration.new(@operator, @value).get_duration
+      end
+
+      def build_statement_for_type_generic
+        build_statement_for_type || begin
+          case @type
+          when :date
+            build_statement_for_date
+          when :datetime, :timestamp, :time
+            build_statement_for_datetime_or_timestamp
+          end
+        end
+      end
+
+      def build_statement_for_type
+        raise 'You must override build_statement_for_type in your StatementBuilder'
+      end
+
+      def build_statement_for_integer_decimal_or_float
+        case @value
+        when Array
+          val, range_begin, range_end = *@value.collect do |v|
+            next unless v.to_i.to_s == v || v.to_f.to_s == v
+
+            @type == :integer ? v.to_i : v.to_f
+          end
+          case @operator
+          when 'between'
+            range_filter(range_begin, range_end)
+          else
+            column_for_value(val) if val
+          end
+        else
+          if @value.to_i.to_s == @value || @value.to_f.to_s == @value
+            @type == :integer ? column_for_value(@value.to_i) : column_for_value(@value.to_f)
+          end
+        end
+      end
+
+      def build_statement_for_date
+        start_date, end_date = get_filtering_duration
+        if start_date
+          start_date = begin
+            start_date.to_date
+          rescue StandardError
+            nil
+          end
+        end
+        if end_date
+          end_date = begin
+            end_date.to_date
+          rescue StandardError
+            nil
+          end
+        end
+        range_filter(start_date, end_date)
+      end
+
+      def build_statement_for_datetime_or_timestamp
+        start_date, end_date = get_filtering_duration
+        start_date = start_date.beginning_of_day if start_date.is_a?(Date)
+        end_date = end_date.end_of_day if end_date.is_a?(Date)
+        range_filter(start_date, end_date)
+      end
+
+      def unary_operators
+        raise 'You must override unary_operators in your StatementBuilder'
+      end
+
+      def range_filter(_min, _max)
+        raise 'You must override range_filter in your StatementBuilder'
+      end
+
+      class FilteringDuration
+        def initialize(operator, value)
+          @value = value
+          @operator = operator
+        end
+
+        def get_duration
+          case @operator
+          when 'between'   then between
+          when 'today'     then today
+          when 'yesterday' then yesterday
+          when 'this_week' then this_week
+          when 'last_week' then last_week
+          else default
+          end
+        end
+
+        def today
+          [Date.today, Date.today]
+        end
+
+        def yesterday
+          [Date.yesterday, Date.yesterday]
+        end
+
+        def this_week
+          [Date.today.beginning_of_week, Date.today.end_of_week]
+        end
+
+        def last_week
+          [1.week.ago.to_date.beginning_of_week,
+           1.week.ago.to_date.end_of_week]
+        end
+
+        def between
+          [@value[1], @value[2]]
+        end
+
+        def default
+          [default_date, default_date]
+        end
+
+      private
+
+        def default_date
+          Array.wrap(@value).first
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/active_record/association.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class Association
+        attr_reader :association, :model
+
+        def initialize(association, model)
+          @association = association
+          @model = model
+        end
+
+        def name
+          association.name.to_sym
+        end
+
+        def pretty_name
+          name.to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          association.macro
+        end
+
+        def field_type
+          if polymorphic?
+            :polymorphic_association
+          else
+            :"#{association.macro}_association"
+          end
+        end
+
+        def klass
+          if options[:polymorphic]
+            polymorphic_parents(:active_record, association.active_record.name.to_s, name) || []
+          else
+            association.klass
+          end
+        end
+
+        def primary_key
+          return nil if polymorphic?
+
+          value =
+            case type
+            when :has_one
+              association.klass.primary_key
+            else
+              association.association_primary_key
+            end
+
+          if value.is_a? Array
+            :id
+          else
+            value.to_sym
+          end
+        end
+
+        def foreign_key
+          if association.options[:query_constraints].present?
+            association.options[:query_constraints].map(&:to_sym)
+          elsif association.foreign_key.is_a?(Array)
+            association.foreign_key.map(&:to_sym)
+          else
+            association.foreign_key.to_sym
+          end
+        end
+
+        def foreign_key_nullable?
+          return true if foreign_key.nil? || type != :has_many
+
+          (column = klass.columns_hash[foreign_key.to_s]).nil? || column.null
+        end
+
+        def foreign_type
+          options[:foreign_type].try(:to_sym) || :"#{name}_type" if options[:polymorphic]
+        end
+
+        def foreign_inverse_of
+          nil
+        end
+
+        def key_accessor
+          case type
+          when :has_many, :has_and_belongs_to_many
+            :"#{name.to_s.singularize}_ids"
+          when :has_one
+            :"#{name}_id"
+          else
+            if foreign_key.is_a?(Array)
+              :"#{name}_id"
+            else
+              foreign_key
+            end
+          end
+        end
+
+        def as
+          options[:as].try :to_sym
+        end
+
+        def polymorphic?
+          options[:polymorphic] || false
+        end
+
+        def inverse_of
+          options[:inverse_of].try :to_sym
+        end
+
+        def read_only?
+          (klass.all.instance_exec(&scope).readonly_value if scope.is_a?(Proc) && scope.arity == 0) ||
+            association.nested? ||
+            false
+        end
+
+        def nested_options
+          model.nested_attributes_options.try { |o| o[name.to_sym] }
+        end
+
+        def association?
+          true
+        end
+
+        delegate :options, :scope, to: :association, prefix: false
+        delegate :polymorphic_parents, to: RailsAdmin::AbstractModel
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/active_record/object_extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      module ObjectExtension
+        def assign_attributes(attributes)
+          super if attributes
+        end
+      end
+    end
+  end
+end

data/rails_admin-3.3.0/lib/rails_admin/adapters/active_record/property.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RailsAdmin
+  module Adapters
+    module ActiveRecord
+      class Property
+        attr_reader :property, :model
+
+        def initialize(property, model)
+          @property = property
+          @model = model
+        end
+
+        def name
+          property.name.to_sym
+        end
+
+        def pretty_name
+          property.name.to_s.tr('_', ' ').capitalize
+        end
+
+        def type
+          if serialized?
+            :serialized
+          else
+            property.type
+          end
+        end
+
+        def length
+          property.limit
+        end
+
+        def nullable?
+          property.null
+        end
+
+        def serial?
+          model.primary_key == property.name
+        end
+
+        def association?
+          false
+        end
+
+        def read_only?
+          model.readonly_attributes.include? property.name.to_s
+        end
+
+      private
+
+        def serialized?
+          model.type_for_attribute(property.name).instance_of?(::ActiveRecord::Type::Serialized)
+        end
+      end
+    end
+  end
+end