activerecord-tablefree 3.0.1 → 3.1.0

data/features/support/env.rb

@@ -1,9 +1,9 @@
-#require 'bundler'
+# require 'bundler'
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  warn e.message
+  warn 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
 

data/features/support/paths.rb

@@ -15,11 +15,11 @@ module NavigationHelpers
     else
       begin
         page_name =~ /the (.*) page/
-        path_components = $1.split(/\s+/)
-        self.send(path_components.push('path').join('_').to_sym)
+        path_components = Regexp.last_match(1).split(/\s+/)
+        send(path_components.push('path').join('_').to_sym)
       rescue Object => e
-        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
-          "Now, go and add a mapping in #{__FILE__}"
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" \
+              "Now, go and add a mapping in #{__FILE__}"
       end
     end
   end

data/features/support/rails.rb

@@ -1,7 +1,7 @@
 PROJECT_ROOT     = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
 APP_NAME         = 'testapp'.freeze
-BUNDLE_ENV_VARS = %w(RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE)
-ORIGINAL_BUNDLE_VARS = Hash[ENV.select{ |key,value| BUNDLE_ENV_VARS.include?(key) }]
+BUNDLE_ENV_VARS = %w[RUBYOPT BUNDLE_PATH BUNDLE_BIN_PATH BUNDLE_GEMFILE].freeze
+ORIGINAL_BUNDLE_VARS = Hash[ENV.select { |key, _value| BUNDLE_ENV_VARS.include?(key) }]
 
 ENV['RAILS_ENV'] = 'test'
 
@@ -32,7 +32,7 @@ module RailsCommandHelpers
   end
 
   def framework_major_version
-    framework_version.split(".").first.to_i
+    framework_version.split('.').first.to_i
   end
 
   def new_application_command(app_name)
@@ -40,13 +40,12 @@ module RailsCommandHelpers
   end
 
   def generator_command
-    framework_major_version >= 3 ? "rails generate" : "script/generate"
+    framework_major_version >= 3 ? 'rails generate' : 'script/generate'
   end
 
   def runner_command
-    framework_major_version >= 3 ? "rails runner" : "script/runner"
+    framework_major_version >= 3 ? 'rails runner' : 'script/runner'
   end
-
 end
 
 World(RailsCommandHelpers)

data/features/support/selectors.rb

@@ -7,11 +7,11 @@ module HtmlSelectorsHelpers
   #
   def selector_for(locator)
     case locator
-    when "the page"
-      "html > body"
+    when 'the page'
+      'html > body'
     else
-      raise "Can't find mapping from \"#{locator}\" to a selector.\n" +
-        "Now, go and add a mapping in #{__FILE__}"
+      raise "Can't find mapping from \"#{locator}\" to a selector.\n" \
+            "Now, go and add a mapping in #{__FILE__}"
     end
   end
 end

data/lib/activerecord-tablefree.rb

@@ -1,8 +1,13 @@
-# See #ActiveRecord::Tablefree
+require 'cgi'
+require 'active_record'
+
 require 'activerecord-tablefree/version'
+require 'activerecord-tablefree/cast_type'
+require 'activerecord-tablefree/schema_cache'
+require 'activerecord-tablefree/connection'
+require 'activerecord-tablefree/transaction'
 
 module ActiveRecord
-
   # = ActiveRecord::Tablefree
   #
   # Allow classes to behave like ActiveRecord models, but without an associated
@@ -29,26 +34,24 @@ module ActiveRecord
   #  end
   #
   module Tablefree
-    require 'active_record'
 
     class NoDatabase < StandardError; end
     class Unsupported < StandardError; end
 
-    def self.included( base ) #:nodoc:
+    def self.included(base) #:nodoc:
       base.send :extend, ActsMethods
     end
 
     module ActsMethods #:nodoc:
-
       # A model that needs to be tablefree will call this method to indicate
       # it.
-      def has_no_table(options = {:database => :fail_fast})
-        raise ArgumentError.new("Invalid database option '#{options[:database]}'") unless [:fail_fast, :pretend_success].member? options[:database]
+      def has_no_table(options = { database: :fail_fast })
+        raise ArgumentError, "Invalid database option '#{options[:database]}'" unless %i[fail_fast pretend_success].member? options[:database]
         # keep our options handy
         class_attribute :tablefree_options
         self.tablefree_options = {
-          :database => options[:database],
-          :columns_hash => {}
+          database: options[:database],
+          columns_hash: {}
         }
 
         # extend
@@ -66,20 +69,18 @@ module ActiveRecord
       def tablefree?
         false
       end
-
     end
 
     module SingletonMethods
-
       # Used internally by ActiveRecord 5.  This is the special hook that makes everything else work.
       def load_schema!
         @columns_hash = tablefree_options[:columns_hash].except(*ignored_columns)
         @columns_hash.each do |name, column|
           define_attribute(
-              name,
-              connection.lookup_cast_type_from_column(column),
-              default: column.default,
-              user_provided_default: false
+            name,
+            connection.lookup_cast_type_from_column(column),
+            default: column.default,
+            user_provided_default: false
           )
         end
       end
@@ -97,12 +98,12 @@ module ActiveRecord
         end
       end
 
-      def destroy(*args)
+      def destroy(*_args)
         case tablefree_options[:database]
         when :pretend_success
-          self.new()
+          new
         when :fail_fast
-          raise NoDatabase.new("Can't #destroy on Tablefree class")
+          raise NoDatabase, "Can't #destroy on Tablefree class"
         end
       end
 
@@ -111,33 +112,32 @@ module ActiveRecord
         when :pretend_success
           []
         when :fail_fast
-          raise NoDatabase.new("Can't #destroy_all on Tablefree class")
+          raise NoDatabase, "Can't #destroy_all on Tablefree class"
         end
       end
 
       case ActiveRecord::VERSION::MAJOR
       when 5
-        def find_by_sql(*args)
+        def find_by_sql(*_args)
           case tablefree_options[:database]
           when :pretend_success
             []
           when :fail_fast
-            raise NoDatabase.new("Can't #find_by_sql on Tablefree class")
+            raise NoDatabase, "Can't #find_by_sql on Tablefree class"
           end
-
         end
       else
-        raise Unsupported.new("Unsupported ActiveRecord version")
+        raise Unsupported, 'Unsupported ActiveRecord version'
       end
 
-      def transaction(&block)
-#        case tablefree_options[:database]
-#        when :pretend_success
-          @_current_transaction_records ||= []
-          yield
-#        when :fail_fast
-#          raise NoDatabase.new("Can't #transaction on Tablefree class")
-#        end
+      def transaction
+        #        case tablefree_options[:database]
+        #        when :pretend_success
+        @_current_transaction_records ||= []
+        yield
+        #        when :fail_fast
+        #          raise NoDatabase.new("Can't #transaction on Tablefree class")
+        #        end
       end
 
       def tablefree?
@@ -150,123 +150,43 @@ module ActiveRecord
     end
 
     module ClassMethods
-
       def from_query_string(query_string)
-        unless query_string.blank?
+        if query_string.blank?
+          new
+        else
           params = query_string.split('&').collect do |chunk|
             next if chunk.empty?
             key, value = chunk.split('=', 2)
             next if key.empty?
             value = value.nil? ? nil : CGI.unescape(value)
-            [ CGI.unescape(key), value ]
+            [CGI.unescape(key), value]
           end.compact.to_h
 
           new(params)
-        else
-          new
         end
       end
 
       def connection
-        conn = Object.new()
-        def conn.quote_table_name(*_args)
-          ""
-        end
-        def conn.quote_column_name(*_args)
-          ""
-        end
-        def conn.substitute_at(*_args)
-          nil
-        end
-        def conn.schema_cache(*_args)
-          schema_cache = Object.new()
-          def schema_cache.columns_hash(*_args)
-            Hash.new()
-          end
-          schema_cache
-        end
-        # Fixes Issue #17. https://github.com/softace/activerecord-tablefree/issues/17
-        # The following method is from the ActiveRecord gem: /lib/active_record/connection_adapters/abstract/database_statements.rb .
-        # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-        #
-        # The +limit+ may be anything that can evaluate to a string via #to_s. It
-        # should look like an integer, or a comma-delimited list of integers, or
-        # an Arel SQL literal.
-        #
-        # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
-        # Returns the sanitized limit parameter, either as an integer, or as a
-        # string which contains a comma-delimited list of integers.
-        def conn.sanitize_limit(limit)
-          if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
-            limit
-          elsif limit.to_s.include?(',')
-            Arel.sql limit.to_s.split(',').map{ |i| Integer(i) }.join(',')
-          else
-            Integer(limit)
-          end
-        end
-
-        # Called by bound_attributes in /lib/active_record/relation/query_methods.rb
-        # Returns a SQL string with the from, join, where, and having clauses, in addition to the limit and offset.
-        def conn.combine_bind_parameters(**_args)
-          ""
-        end
-
-        def conn.lookup_cast_type_from_column(*_args)
-          lct = Object.new
-          def lct.assert_valid_value(*_args)
-            true
-          end
-          # Needed for Rails 5.0
-          def lct.serialize(args)
-            args
-          end
-          def lct.deserialize(args)
-            args
-          end
-          def lct.cast(args)
-            args
-          end
-          def lct.changed?(*_args)
-            false
-          end
-          def lct.changed_in_place?(*_args)
-            false
-          end
-          lct
-        end
-
-        # This is used in the StatementCache object. It returns an object that
-        # can be used to query the database repeatedly.
-        def conn.cacheable_query(arel) # :nodoc:
-          if prepared_statements
-            ActiveRecord::StatementCache.query visitor, arel.ast
-          else
-            ActiveRecord::StatementCache.partial_query visitor, arel.ast, collector
-          end
-        end
-        conn
+        @_connection ||= ActiveRecord::Tablefree::Connection.new
       end
-
     end
 
     module InstanceMethods
-
       def to_query_string(prefix = nil)
-        attributes.to_a.collect{|(name,value)| escaped_var_name(name, prefix) + "=" + escape_for_url(value) if value }.compact.join("&")
+        attributes.to_a.collect { |(name, value)| escaped_var_name(name, prefix) + '=' + escape_for_url(value) if value }.compact.join('&')
       end
 
       def quote_value(_value, _column = nil)
-        ""
+        ''
       end
 
-      %w(create create_record _create_record update update_record _update_record).each do |method_name|
-        define_method(method_name) do |*args|
+      %w[create create_record _create_record update update_record _update_record].each do |method_name|
+        define_method(method_name) do |*_args|
           case self.class.tablefree_options[:database]
           when :pretend_success
             true
           when :fail_fast
-            raise NoDatabase.new("Can't ##{method_name} a Tablefree object")
+            raise NoDatabase, "Can't ##{method_name} a Tablefree object"
           end
         end
       end
@@ -277,42 +197,39 @@ module ActiveRecord
           @destroyed = true
           freeze
         when :fail_fast
-          raise NoDatabase.new("Can't #destroy a Tablefree object")
+          raise NoDatabase, "Can't #destroy a Tablefree object"
         end
       end
 
-      def reload(*args)
+      def reload(*_args)
         case self.class.tablefree_options[:database]
         when :pretend_success
           self
         when :fail_fast
-          raise NoDatabase.new("Can't #reload a Tablefree object")
+          raise NoDatabase, "Can't #reload a Tablefree object"
         end
       end
 
-      def add_to_transaction
-      end
+      def add_to_transaction; end
 
       private
 
-        def escaped_var_name(name, prefix = nil)
-          prefix ? "#{URI.escape(prefix)}[#{URI.escape(name)}]" : URI.escape(name)
-        end
+      def escaped_var_name(name, prefix = nil)
+        prefix ? "#{CGI.escape(prefix)}[#{CGI.escape(name)}]" : CGI.escape(name)
+      end
 
-        def escape_for_url(value)
-          case value
-            when true then "1"
-            when false then "0"
-            when nil then ""
-            else URI.escape(value.to_s)
-          end
-        rescue
-          ""
+      def escape_for_url(value)
+        case value
+        when true then '1'
+        when false then '0'
+        when nil then ''
+        else CGI.escape(value.to_s)
         end
-
+      rescue
+        ''
+      end
     end
-
   end
 end
 
-ActiveRecord::Base.send( :include, ActiveRecord::Tablefree )
+ActiveRecord::Base.send(:include, ActiveRecord::Tablefree)

data/lib/activerecord-tablefree/cast_type.rb

@@ -0,0 +1,28 @@
+module ActiveRecord::Tablefree
+  class CastType
+    def assert_valid_value(*_args)
+      true
+    end
+
+    # Needed for Rails 5.0
+    def serialize(args)
+      args
+    end
+
+    def deserialize(args)
+      args
+    end
+
+    def cast(args)
+      args
+    end
+
+    def changed?(*_args)
+      false
+    end
+
+    def changed_in_place?(*_args)
+      false
+    end
+  end
+end

data/lib/activerecord-tablefree/connection.rb

@@ -0,0 +1,70 @@
+module ActiveRecord::Tablefree
+  class Connection
+    def quote_table_name(*_args)
+      ''
+    end
+
+    def quote_column_name(*_args)
+      ''
+    end
+
+    def substitute_at(*_args)
+      nil
+    end
+
+    def schema_cache(*_args)
+      @_schema_cache ||= ActiveRecord::Tablefree::SchemaCache.new
+    end
+
+    # Fixes Issue #17. https://github.com/softace/activerecord-tablefree/issues/17
+    # The following method is from the ActiveRecord gem:
+    #   /lib/active_record/connection_adapters/abstract/database_statements.rb .
+    # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
+    #
+    # The +limit+ may be anything that can evaluate to a string via #to_s. It
+    # should look like an integer, or a comma-delimited list of integers, or
+    # an Arel SQL literal.
+    #
+    # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
+    # Returns the sanitized limit parameter, either as an integer, or as a
+    # string which contains a comma-delimited list of integers.
+    def sanitize_limit(limit)
+      if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
+        limit
+      elsif limit.to_s.include?(',')
+        Arel.sql limit.to_s.split(',').map { |i| Integer(i) }.join(',')
+      else
+        Integer(limit)
+      end
+    end
+
+    # Called by bound_attributes in /lib/active_record/relation/query_methods.rb
+    # Returns a SQL string with the from, join, where, and having clauses,
+    #   in addition to the limit and offset.
+    def combine_bind_parameters(**_args)
+      ''
+    end
+
+    def lookup_cast_type_from_column(*_args)
+      @_cast_type ||= ActiveRecord::Tablefree::CastType.new
+    end
+
+    def current_transaction
+      @_current_transaction ||= ActiveRecord::Tablefree::Transaction.new
+    end
+
+    def execute(*_args)
+      {}
+    end
+
+    # This is used in the StatementCache object. It returns an object that
+    # can be used to query the database repeatedly.
+    def cacheable_query(arel) # :nodoc:
+      if prepared_statements
+        ActiveRecord::StatementCache.query visitor, arel.ast
+      else
+        ActiveRecord::StatementCache.partial_query visitor, arel.ast, collector
+      end
+    end
+  end
+end