active_scaffold 3.4.43 → 3.5.0

data/lib/active_scaffold/orm_checks.rb

@@ -0,0 +1,109 @@
+module ActiveScaffold
+  module OrmChecks
+    class << self
+      def active_record?(klass)
+        return unless defined? ActiveRecord
+        klass < ActiveRecord::Base
+      end
+
+      def mongoid?(klass)
+        return unless defined? Mongoid
+        klass < Mongoid::Document
+      end
+
+      def tableless?(klass)
+        klass < ActiveScaffold::Tableless
+      end
+
+      def table_name(klass)
+        if active_record? klass
+          klass.table_name
+        elsif mongoid? klass
+          klass.collection.name
+        end
+      end
+
+      def quoted_table_name(klass)
+        klass.quoted_table_name if active_record? klass
+      end
+
+      def columns(klass)
+        if active_record? klass
+          klass.columns
+        elsif mongoid? klass
+          klass.fields.values
+        else
+          []
+        end
+      end
+
+      def columns_hash(klass)
+        if active_record? klass
+          klass.columns_hash
+        elsif mongoid? klass
+          klass.fields
+        else
+          []
+        end
+      end
+
+      def reflect_on_all_associations(klass)
+        if active_record? klass
+          klass.reflect_on_all_associations
+        elsif mongoid? klass
+          klass.relations.values
+        else
+          []
+        end
+      end
+
+      def content_columns(klass)
+        if active_record? klass
+          klass.content_columns
+        elsif mongoid? klass
+          klass.fields.reject { |field, _| field == '_id' }.values
+        else
+          []
+        end
+      end
+
+      def type_for_attribute(klass, column_name)
+        if active_record? klass
+          if klass.respond_to? :type_for_attribute
+            klass.type_for_attribute column_name.to_s
+          else # Rails.version < 4.2
+            klass.column_types[column_name.to_s]
+          end
+        elsif mongoid? klass
+          klass.fields[column_name.to_s].type
+        end
+      end
+
+      def column_type(klass, column_name)
+        if active_record? klass
+          type_for_attribute(klass, column_name).type
+        elsif mongoid? klass
+          type_for_attribute(klass, column_name)
+        end
+      end
+    end
+
+    %i[active_record? mongoid? tableless?].each do |method|
+      define_method method do
+        ActiveScaffold::OrmChecks.send method, active_record_class
+      end
+    end
+
+    %i[_table_name _quoted_table_name _columns _columns_hash _reflect_on_all_associations _content_columns].each do |method|
+      define_method method do
+        ActiveScaffold::OrmChecks.send method.to_s[1..-1], active_record_class
+      end
+    end
+
+    %i[type_for_attribute column_type].each do |method|
+      define_method method do |column_name|
+        ActiveScaffold::OrmChecks.send method, active_record_class, column_name
+      end
+    end
+  end
+end

data/lib/active_scaffold/paginator.rb

@@ -1,7 +1,7 @@
 require 'forwardable'
 
 class Paginator
-  VERSION = '1.0.9'
+  VERSION = '1.0.9'.freeze
 
   class ArgumentError < ::ArgumentError; end
   class MissingCountError < ArgumentError; end

data/lib/active_scaffold/responds_to_parent.rb

@@ -9,12 +9,12 @@ module ActiveScaffold
       return unless performed?
 
       # Either pull out a redirect or the request body
-      script =  if response.headers['Location']
-                  "document.location.href = '#{self.class.helpers.escape_javascript response.headers.delete('Location').to_s}'"
-                else
-                  response.body || ''
+      script = if response.headers['Location']
+                 "document.location.href = '#{self.class.helpers.escape_javascript response.headers.delete('Location').to_s}'"
+               else
+                 response.body || ''
                 end
-      response.status = 200 if (300...400).include? response.status
+      response.status = 200 if (300...400).cover? response.status
 
       # Eval in parent scope and replace document location of this frame
       # so back button doesn't replay action on targeted forms
@@ -27,9 +27,6 @@ module ActiveScaffold
         with(window.parent) { setTimeout(function() { window.eval('#{self.class.helpers.escape_javascript script}'); window.loc && loc.replace('about:blank'); }, 1) }
       </script></body></html>"
 
-      # We're returning HTML instead of JS or XML now
-      response.headers['Content-Type'] = 'text/html; charset=UTF-8'
-
       # Clear out the previous render to prevent double render and then render
       if respond_to?(:erase_results, true)
         erase_results
@@ -37,8 +34,13 @@ module ActiveScaffold
         instance_variable_set(:@_response_body, nil)
       end
 
-      render :text => script
+      # We're returning HTML instead of JS now
+      if Rails.version < '4.1'
+        render text: script, content_type: 'text/html' # remove when rails 4.0 is not supported
+      else
+        render html: script.html_safe, content_type: 'text/html' # rubocop:disable Rails/OutputSafety
+      end
     end
-    alias_method :respond_to_parent, :responds_to_parent
+    alias respond_to_parent responds_to_parent
   end
 end

data/lib/active_scaffold/tableless.rb

@@ -1,25 +1,29 @@
 class ActiveScaffold::Tableless < ActiveRecord::Base
   class AssociationScope < ActiveRecord::Associations::AssociationScope
-    def column_for(table_name, column_name, alias_tracker = nil)
-      klass = alias_tracker ? alias_tracker.connection.klass : self.klass
-      if table_name == klass.table_name
-        klass.columns_hash[column_name]
-      elsif alias_tracker && (klass = alias_tracker.instance_variable_get(:@assoc_klass))
-        klass.columns_hash[column_name]
-      else # rails < 4.1
-        association.klass.columns_hash[column_name]
-      end
-    end
-
     if defined?(ActiveRecord::Associations::AssociationScope::INSTANCE) # rails >= 4.1
       INSTANCE = respond_to?(:create) ? create : new # create for rails >= 4.2
       def self.scope(association, connection)
         INSTANCE.scope association, connection
       end
+    end
 
-      def add_constraints(scope, owner, assoc_klass, refl, tracker)
-        tracker.instance_variable_set(:@assoc_klass, assoc_klass)
-        super
+    if Rails.version < '5.0.0'
+      def column_for(table_name, column_name, alias_tracker = nil)
+        klass = alias_tracker ? alias_tracker.connection.klass : self.klass
+        if table_name == klass.table_name
+          klass.columns_hash[column_name]
+        elsif alias_tracker && (klass = alias_tracker.instance_variable_get(:@assoc_klass))
+          klass.columns_hash[column_name]
+        else # rails < 4.1
+          association.klass.columns_hash[column_name]
+        end
+      end
+
+      if Rails.version >= '4.1'
+        def add_constraints(scope, owner, assoc_klass, refl, tracker)
+          tracker.instance_variable_set(:@assoc_klass, assoc_klass)
+          super
+        end
       end
     end
   end
@@ -30,10 +34,19 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
       super(nil, *args)
       @klass = klass
     end
+
+    def columns(table_name)
+      klass.columns
+    end
   end
 
   class Column < ActiveRecord::ConnectionAdapters::Column
-    if instance_method(:initialize).arity == -4 # rails >= 4.2
+    if Rails.version >= '5.0.0'
+      def initialize(name, default, sql_type = nil, null = true)
+        metadata = ActiveRecord::Base.connection.send :fetch_type_metadata, sql_type
+        super(name, default, metadata, null)
+      end
+    elsif Rails.version >= '4.2.0'
       def initialize(name, default, sql_type = nil, null = true)
         cast_type = ActiveRecord::Base.connection.send :lookup_cast_type, sql_type
         super(name, default, cast_type, sql_type, null)
@@ -41,15 +54,10 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     end
   end
 
-  module Association
-    def self.included(base)
-      base.alias_method_chain :association_scope, :tableless
-      base.alias_method_chain :target_scope, :tableless
-    end
-
-    def association_scope_with_tableless
+  module Tableless
+    def association_scope
       @association_scope ||= overrided_association_scope if klass < ActiveScaffold::Tableless
-      association_scope_without_tableless
+      super
     end
 
     def overrided_association_scope
@@ -60,8 +68,8 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
       end
     end
 
-    def target_scope_with_tableless
-      target_scope_without_tableless.tap do |scope|
+    def target_scope
+      super.tap do |scope|
         if klass < ActiveScaffold::Tableless
           class << scope; include RelationExtension; end
         end
@@ -69,30 +77,49 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     end
   end
 
+  module Association
+    def self.included(base)
+      base.prepend Tableless
+    end
+  end
+
+  module TablelessCollectionAssociation
+    def get_records
+      klass < ActiveScaffold::Tableless ? scope.to_a : super
+    end
+  end
+
   module CollectionAssociation
     def self.included(base)
-      base.alias_method_chain :get_records, :tableless if Rails.version >= '4.2'
+      base.prepend TablelessCollectionAssociation if Rails.version >= '4.2'
     end
-    def get_records_with_tableless
-      klass < ActiveScaffold::Tableless ? scope.to_a : get_records_without_tableless
+  end
+
+  module TablelessSingularAssociation
+    def get_records
+      klass < ActiveScaffold::Tableless ? scope.limit(1).to_a : super
     end
   end
 
   module SingularAssociation
     def self.included(base)
-      base.alias_method_chain :get_records, :tableless if Rails.version >= '4.2'
-    end
-    def get_records_with_tableless
-      klass < ActiveScaffold::Tableless ? scope.limit(1).to_a : get_records_without_tableless
+      base.prepend TablelessSingularAssociation
     end
   end
 
   module RelationExtension
     attr_reader :conditions
 
-    def initialize(klass, table)
-      super
-      @conditions ||= []
+    if Rails.version >= '5.0'
+      def initialize(klass, table, predicate_builder, values = {})
+        super
+        @conditions ||= []
+      end
+    else
+      def initialize(klass, table)
+        super
+        @conditions ||= []
+      end
     end
 
     def initialize_copy(other)
@@ -101,7 +128,7 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     end
 
     def where(opts, *rest)
-      unless opts.blank?
+      if opts.present?
         opts = opts.with_indifferent_access if opts.is_a? Hash
         @conditions << (rest.empty? ? opts : [opts, *rest])
       end
@@ -140,7 +167,9 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
     private
 
     def relation
-      ActiveScaffold::Tableless::Relation.new(self, arel_table)
+      args = [self, arel_table]
+      args << predicate_builder if Rails.version >= '5.0.0'
+      ActiveScaffold::Tableless::Relation.new(*args)
     end
   end
 
@@ -162,17 +191,28 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
         super
       end
     end
-    def self.initialize_find_by_cache
-      self.find_by_statement_cache = Hash.new { |h, k| h[k] = StatementCache.new(k) }
+    if Rails.version >= '5.0'
+      def self.initialize_find_by_cache
+        @find_by_statement_cache = {
+          true => Hash.new { |h, k| h[k] = StatementCache.new(k) },
+          false => Hash.new { |h, k| h[k] = StatementCache.new(k) }
+        }
+      end
+    else
+      def self.initialize_find_by_cache
+        self.find_by_statement_cache = Hash.new { |h, k| h[k] = StatementCache.new(k) }
+      end
     end
   end
 
   def self.columns
     @tableless_columns ||= []
   end
+
   def self.table_name
     @table_name ||= ActiveModel::Naming.plural(self)
   end
+
   def self.table_exists?
     true
   end
@@ -210,12 +250,10 @@ class ActiveScaffold::Tableless < ActiveRecord::Base
   def _create_record #:nodoc:
     run_callbacks(:create) {}
   end
-  alias_method :create_record, :_create_record # for rails4 < 4.0.6, < 4.1.2
-  alias_method :create, :_create_record # for rails3
+  alias create_record _create_record # for rails4 < 4.0.6, < 4.1.2
 
   def _update_record(*) #:nodoc:
     run_callbacks(:update) {}
   end
-  alias_method :update_record, :_update_record # for rails4 < 4.0.6, < 4.1.2
-  alias_method :update, :_update_record # for rails3
+  alias update_record _update_record # for rails4 < 4.0.6, < 4.1.2
 end

data/lib/active_scaffold/version.rb

@@ -1,8 +1,8 @@
 module ActiveScaffold
   module Version
     MAJOR = 3
-    MINOR = 4
-    PATCH = 43
+    MINOR = 5
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/generators/active_scaffold/controller_generator.rb

@@ -0,0 +1,49 @@
+# require 'rails/generators/rails/scaffold_controller/scaffold_controller_generator'
+
+module ActiveScaffold
+  module Generators
+    class ControllerGenerator < Rails::Generators::NamedBase # metagenerator
+      include Rails::Generators::ResourceHelpers
+
+      source_root File.expand_path('../../templates', __FILE__)
+
+      check_class_collision :suffix => 'Controller'
+
+      class_option :orm, :banner => 'NAME', :type => :string, :required => true,
+                         :desc => 'ORM to generate the controller for'
+
+      desc <<-DESC.strip_heredoc
+      Description:
+          Stubs out a active_scaffolded controller. Pass the model name,
+          either CamelCased or under_scored.
+          The controller name is retrieved as a pluralized version of the model
+          name.
+
+          To create a controller within a module, specify the model name as a
+          path like 'parent_module/controller_name'.
+
+          This generates a controller class in app/controllers and invokes helper,
+          template engine and test framework generators.
+
+      Example:
+          `rails generate active_scaffold:controller CreditCard`
+
+          Credit card controller with URLs like /credit_card/debit.
+              Controller:      app/controllers/credit_cards_controller.rb
+              Functional Test: test/functional/credit_cards_controller_test.rb
+              Helper:          app/helpers/credit_cards_helper.rb
+      DESC
+
+      def create_controller_files
+        template 'controller.rb', File.join('app/controllers', class_path, "#{controller_file_name}_controller.rb")
+        template 'helper.rb', File.join('app/helpers', class_path, "#{controller_file_name}_helper.rb")
+      end
+
+      hook_for :test_framework, :as => :scaffold
+
+      def create_view_root_folder
+        empty_directory File.join('app/views', controller_file_path)
+      end
+    end
+  end
+end

data/lib/generators/active_scaffold/install_generator.rb

@@ -0,0 +1,45 @@
+require 'rails/generators/base'
+# require 'generators/active_scaffold_controller/active_scaffold_controller_generator'
+
+module ActiveScaffold
+  module Generators
+    class InstallGenerator < Rails::Generators::Base # metagenerator
+      desc 'Add concerns to routes and require lines to assets manifest files'
+
+      def add_concern_routes
+        route 'concern :active_scaffold, ActiveScaffold::Routing::Basic.new(association: true)'
+        route 'concern :active_scaffold_association, ActiveScaffold::Routing::Association.new'
+      end
+
+      def add_to_javascript_manifest
+        file = 'app/assets/javascripts/application.js'
+        unless File.exist?(file)
+          say_status :missing, file, :red
+          return if options[:pretend]
+          raise Thor::Error, "JS file #{file} is required for ActiveScaffold"
+        end
+        original_js = File.binread(file)
+        if original_js.include?('require active_scaffold')
+          say_status('skipped', 'insert into app/assets/javascripts/application.js', :yellow)
+        else
+          insert_into_file 'app/assets/javascripts/application.js', :after => %r{//= require +.*ujs['"]?\n} do
+            "//= require active_scaffold\n"
+          end
+        end
+      end
+
+      def add_to_stylesheet_manifest
+        file = 'app/assets/stylesheets/application.css'
+        return unless File.exist?(file)
+        original_css = File.binread(file)
+        if original_css =~ /require active_scaffold$/
+          say_status('skipped', 'insert into app/assets/stylesheets/application.css', :yellow)
+        else
+          insert_into_file 'app/assets/stylesheets/application.css', :before => %r{[ ]*\*/} do
+            " *= require active_scaffold\n"
+          end
+        end
+      end
+    end
+  end
+end