activerecord-tablefree 3.0.0

data/features/step_definitions/tablefree.rb

@@ -0,0 +1,37 @@
+Given /^I delete all migrations$/ do
+  steps %{
+    When I successfully run `bash -c 'rm db/migrate/*.rb'`
+  }
+end
+
+Given /^I update my new user model to be tablefree$/ do
+  in_current_dir do
+    file_name = 'app/models/user.rb'
+    content = File.read(file_name)
+    if framework_version < "3.0"
+      content = "require 'activerecord-tablefree'\n" + content
+    end
+
+    content.gsub!(/^(class .* < ActiveRecord::Base)$/, "\\1\n" + <<-TABLELESS)
+  has_no_table
+  column :id, :integer
+  column :name, :string
+
+TABLELESS
+    File.open(file_name, 'w') { |f| f << content }
+  end
+end
+
+Given /^I update my users controller to render instead of redirect$/ do
+  in_current_dir do
+    transform_file('app/controllers/users_controller.rb') do |content|
+      ##Changes in #create method
+      content.gsub!(/@user = User.new\((.*?)\)/,
+                    '@user = User.new(\1); @user.id = 1')
+      content.gsub!("if @user.save",
+                    "if @user.valid?")
+      content.gsub!(/redirect_to([\( ])@user, .*?([\)]| \}|$)/,
+                    "render\\1:action => 'show'\\2")
+    end
+  end
+end

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,140 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should (not )?see "([^"]*)"$/ do |negate, text|
+  should_name = negate ? :should_not : :should
+  if page.respond_to? should_name
+    page.send should_name, have_content(text)
+  else
+    assert(negate ? page.has_no_content?(text) : page.has_content?(text))
+  end
+end
+
+Then /^(?:|I )should (not )?see \/([^\/]*)\/$/ do |negate, regexp|
+  regexp = Regexp.new(regexp)
+  should_name = negate ? :should_not : :should
+  if page.respond_to? should_name
+    page.send should_name, have_xpath('//*', :text => regexp)
+  else
+    assert(negate ? page.has_no_xpath?('//*', :text => regexp) : page.has_xpath?('//*', :text => regexp))
+  end
+end
+
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  expect(current_path).to eq path_to(page_name)
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')}
+
+  expect(actual_params).to eq expected_params
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end

data/features/support/env.rb

@@ -0,0 +1,15 @@
+#require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'aruba/cucumber'
+require 'capybara/cucumber'
+
+Before do
+  @aruba_timeout_seconds = 120
+end

data/features/support/paths.rb

@@ -0,0 +1,28 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+    when /the new user page/
+      '/users/new'
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.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__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/features/support/rails.rb

@@ -0,0 +1,52 @@
+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) }]
+
+ENV['RAILS_ENV'] = 'test'
+
+Before do
+  ENV['BUNDLE_GEMFILE'] = File.join(Dir.pwd, ENV['BUNDLE_GEMFILE']) unless ENV['BUNDLE_GEMFILE'].start_with?(Dir.pwd)
+  @framework_version = nil
+end
+
+After do
+  ORIGINAL_BUNDLE_VARS.each_pair do |key, value|
+    ENV[key] = value
+  end
+end
+
+When /^I reset Bundler environment variable$/ do
+  BUNDLE_ENV_VARS.each do |key|
+    ENV[key] = nil
+  end
+end
+
+module RailsCommandHelpers
+  def framework_version?(version_string)
+    framework_version =~ /^#{version_string}/
+  end
+
+  def framework_version
+    @framework_version ||= `rails -v`[/^Rails (.+)$/, 1]
+  end
+
+  def framework_major_version
+    framework_version.split(".").first.to_i
+  end
+
+  def new_application_command(app_name)
+    framework_major_version >= 3 ? "rails new #{app_name} --skip-sprockets --skip-javascript --skip-bundle" : "rails #{app_name}"
+  end
+
+  def generator_command
+    framework_major_version >= 3 ? "rails generate" : "script/generate"
+  end
+
+  def runner_command
+    framework_major_version >= 3 ? "rails runner" : "script/runner"
+  end
+
+end
+
+World(RailsCommandHelpers)

data/features/support/selectors.rb

@@ -0,0 +1,19 @@
+module HtmlSelectorsHelpers
+  # Maps a name to a selector. Used primarily by the
+  #
+  #   When /^(.+) within (.+)$/ do |step, scope|
+  #
+  # step definitions in web_steps.rb
+  #
+  def selector_for(locator)
+    case locator
+    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__}"
+    end
+  end
+end
+
+World(HtmlSelectorsHelpers)

data/gemfiles/rails50.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "mime-types", "< 2.0", :platform => :ruby_18
+gem "rubyzip", "< 1.0", :platform => :ruby_18
+gem "byebug"
+gem "rails", "~> 5.0.0"
+gem "jquery-rails"
+
+gemspec :path => "../"

data/gemfiles/rails51.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "mime-types", "< 2.0", :platform => :ruby_18
+gem "rubyzip", "< 1.0", :platform => :ruby_18
+gem "byebug"
+gem "rails", "~> 5.1.0"
+gem "jquery-rails"
+
+gemspec :path => "../"

data/init.rb

@@ -0,0 +1,4 @@
+# For use by Railed and de-Railed applications alike
+
+require 'active_record'
+require File.join(File.dirname(__FILE__), 'lib', 'activerecord-tablefree')

data/lib/activerecord-tablefree.rb

@@ -0,0 +1,318 @@
+# See #ActiveRecord::Tablefree
+require 'activerecord-tablefree/version'
+
+module ActiveRecord
+
+  # = ActiveRecord::Tablefree
+  #
+  # Allow classes to behave like ActiveRecord models, but without an associated
+  # database table. A great way to capitalize on validations. Based on the
+  # original post at http://www.railsweenie.com/forums/2/topics/724 (which seems
+  # to have disappeared from the face of the earth).
+  #
+  # = Example usage
+  #
+  #  class ContactMessage < ActiveRecord::Base
+  #
+  #    has_no_table
+  #
+  #    column :name,    :string
+  #    column :email,   :string
+  #    column :message, :string
+  #
+  #  end
+  #
+  #  msg = ContactMessage.new( params[:msg] )
+  #  if msg.valid?
+  #    ContactMessageSender.deliver_message( msg )
+  #    redirect_to :action => :sent
+  #  end
+  #
+  module Tablefree
+    require 'active_record'
+
+    class NoDatabase < StandardError; end
+    class Unsupported < StandardError; end
+
+    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]
+        # keep our options handy
+        class_attribute :tablefree_options
+        self.tablefree_options = {
+          :database => options[:database],
+          :columns_hash => {}
+        }
+
+        # extend
+        extend  ActiveRecord::Tablefree::SingletonMethods
+        extend  ActiveRecord::Tablefree::ClassMethods
+
+        # include
+        include ActiveRecord::Tablefree::InstanceMethods
+
+        # setup columns
+        include ActiveModel::AttributeAssignment
+        include ActiveRecord::ModelSchema
+      end
+
+      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
+          )
+        end
+      end
+
+      # Register a new column.
+      def column(name, sql_type = nil, default = nil, null = true)
+        cast_type = "ActiveRecord::Type::#{sql_type.to_s.camelize}".constantize.new
+        tablefree_options[:columns_hash][name.to_s] = ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, cast_type, sql_type.to_s, null)
+      end
+
+      # Register a set of columns with the same SQL type
+      def add_columns(sql_type, *args)
+        args.each do |col|
+          column col, sql_type
+        end
+      end
+
+      def destroy(*args)
+        case tablefree_options[:database]
+        when :pretend_success
+          self.new()
+        when :fail_fast
+          raise NoDatabase.new("Can't #destroy on Tablefree class")
+        end
+      end
+
+      def destroy_all(*_args)
+        case tablefree_options[:database]
+        when :pretend_success
+          []
+        when :fail_fast
+          raise NoDatabase.new("Can't #destroy_all on Tablefree class")
+        end
+      end
+
+      case ActiveRecord::VERSION::MAJOR
+      when 5
+        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")
+          end
+
+        end
+      else
+        raise Unsupported.new("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
+      end
+
+      def tablefree?
+        true
+      end
+
+      def table_exists?
+        false
+      end
+    end
+
+    module ClassMethods
+
+      def from_query_string(query_string)
+        unless query_string.blank?
+          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 ]
+          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
+      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("&")
+      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|
+          case self.class.tablefree_options[:database]
+          when :pretend_success
+            true
+          when :fail_fast
+            raise NoDatabase.new("Can't ##{method_name} a Tablefree object")
+          end
+        end
+      end
+
+      def destroy
+        case self.class.tablefree_options[:database]
+        when :pretend_success
+          @destroyed = true
+          freeze
+        when :fail_fast
+          raise NoDatabase.new("Can't #destroy a Tablefree object")
+        end
+      end
+
+      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")
+        end
+      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 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
+          ""
+        end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send( :include, ActiveRecord::Tablefree )