ardb 0.28.1 → 0.29.2

data/lib/ardb/has_slug.rb

@@ -1,107 +0,0 @@
-require 'much-plugin'
-
-module Ardb
-
-  module HasSlug
-    include MuchPlugin
-
-    DEFAULT_ATTRIBUTE    = :slug
-    DEFAULT_PREPROCESSOR = :downcase
-    DEFAULT_SEPARATOR    = '-'.freeze
-
-    plugin_included do
-      extend ClassMethods
-      include InstanceMethods
-
-      @ardb_has_slug_configs = Hash.new{ |h, k| h[k] = {} }
-    end
-
-    module ClassMethods
-
-      def has_slug(options = nil)
-        options ||= {}
-        raise(ArgumentError, "a source must be provided") unless options[:source]
-
-        attribute = (options[:attribute] || DEFAULT_ATTRIBUTE).to_sym
-        @ardb_has_slug_configs[attribute].merge!({
-          :source_proc       => options[:source].to_proc,
-          :preprocessor_proc => (options[:preprocessor] || DEFAULT_PREPROCESSOR).to_proc,
-          :separator         => options[:separator] || DEFAULT_SEPARATOR,
-          :allow_underscores => !!options[:allow_underscores]
-        })
-
-        # since the slug isn't written till an after callback we can't always
-        # validate presence of it
-        validates_presence_of(attribute, :on => :update)
-
-        if options[:skip_unique_validation] != true
-          validates_uniqueness_of(attribute, {
-            :case_sensitive => true,
-            :scope          => options[:unique_scope]
-          })
-        end
-
-        after_create :ardb_has_slug_generate_slugs
-        after_update :ardb_has_slug_generate_slugs
-      end
-
-      def ardb_has_slug_configs
-        @ardb_has_slug_configs
-      end
-
-    end
-
-    module InstanceMethods
-
-      private
-
-      def reset_slug(attribute = nil)
-        attribute ||= DEFAULT_ATTRIBUTE
-        self.send("#{attribute}=", nil)
-      end
-
-      def ardb_has_slug_generate_slugs
-        self.class.ardb_has_slug_configs.each do |attr_name, config|
-          slug_source = if !self.send(attr_name) || self.send(attr_name).to_s.empty?
-            self.instance_eval(&config[:source_proc])
-          else
-            self.send(attr_name)
-          end
-
-          generated_slug = Slug.new(slug_source, {
-            :preprocessor      => config[:preprocessor_proc],
-            :separator         => config[:separator],
-            :allow_underscores => config[:allow_underscores]
-          })
-          next if self.send(attr_name) == generated_slug
-          self.send("#{attr_name}=", generated_slug)
-          self.update_column(attr_name, generated_slug)
-        end
-      end
-
-    end
-
-    module Slug
-      def self.new(string, options = nil)
-        options ||= {}
-        preprocessor       = options[:preprocessor]
-        separator          = options[:separator]
-        allow_underscores  = options[:allow_underscores]
-        regexp_escaped_sep = Regexp.escape(separator)
-
-        slug = preprocessor.call(string.to_s.dup)
-        # Turn unwanted chars into the separator
-        slug.gsub!(/[^\w#{regexp_escaped_sep}]+/, separator)
-        # Turn underscores into the separator, unless allowing
-        slug.gsub!(/_/, separator) unless allow_underscores
-        # No more than one of the separator in a row.
-        slug.gsub!(/#{regexp_escaped_sep}{2,}/, separator)
-        # Remove leading/trailing separator.
-        slug.gsub!(/\A#{regexp_escaped_sep}|#{regexp_escaped_sep}\z/, '')
-        slug
-      end
-    end
-
-  end
-
-end

data/lib/ardb/migration_helpers.rb

@@ -1,77 +0,0 @@
-require 'ardb'
-
-module Ardb
-
-  module MigrationHelpers
-    module_function
-
-    def foreign_key(from_table, from_column, to_table, options={})
-      fk = ForeignKey.new(from_table, from_column, to_table, options)
-      execute(fk.add_sql)
-    end
-
-    def drop_foreign_key(*args)
-      from_table, from_column = args[0..1]
-      options = args.last.kind_of?(Hash) ? args.last : {}
-      fk = ForeignKey.new(from_table, from_column, nil, options)
-      execute(fk.drop_sql)
-    end
-
-    def remove_column_with_fk(table, column)
-      drop_foreign_key(table, column)
-      remove_column(table, column)
-    end
-
-    class ForeignKey
-      attr_reader :from_table, :from_column, :to_table, :to_column, :name, :adapter
-
-      def initialize(from_table, from_column, to_table, options=nil)
-        options ||= {}
-        @from_table  = from_table.to_s
-        @from_column = from_column.to_s
-        @to_table    = to_table.to_s
-        @to_column   = (options[:to_column] || 'id').to_s
-        @name        = (options[:name] || "fk_#{@from_table}_#{@from_column}").to_s
-        @adapter     = Ardb::Adapter.new(Ardb.config)
-      end
-
-      def add_sql
-        apply_data(@adapter.foreign_key_add_sql)
-      end
-
-      def drop_sql
-        apply_data(@adapter.foreign_key_drop_sql)
-      end
-
-      private
-
-      def apply_data(template_sql)
-        template_sql.
-          gsub(':from_table',  @from_table).
-          gsub(':from_column', @from_column).
-          gsub(':to_table',    @to_table).
-          gsub(':to_column',   @to_column).
-          gsub(':name',        @name)
-      end
-    end
-
-    # This file will setup the AR migration command recorder for being able to
-    # change our stuff, require it in an initializer
-
-    module RecorderMixin
-
-      def foreign_key(*args)
-        record(:foreign_key, args)
-      end
-
-      protected
-
-      def invert_foreign_key(args)
-        [ :drop_foreign_key, args ]
-      end
-
-    end
-
-  end
-
-end

data/lib/ardb/pg_json.rb

@@ -1,90 +0,0 @@
-require 'active_record'
-require 'active_support'
-
-# Allow ActiveRecord to work with PostgreSQL json/jsonb fields, which aren't
-# supported with ActiveRecord 3.2
-# https://github.com/romanbsd/activerecord-postgres-json/blob/master/lib/activerecord-postgres-json/activerecord.rb
-require 'active_record/connection_adapters/postgresql_adapter'
-
-module ActiveRecord
-  module ConnectionAdapters
-    PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:json]  = { :name => 'json' }
-    PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:jsonb] = { :name => 'jsonb' }
-
-    class PostgreSQLColumn < Column
-      # Adds the json type for the column.
-      def simplified_type_with_json(field_type)
-        case field_type
-        when 'json'
-          :json
-        when 'jsonb'
-          :jsonb
-        else
-          simplified_type_without_json(field_type)
-        end
-      end
-
-      alias_method_chain :simplified_type, :json
-
-      class << self
-        def extract_value_from_default_with_json(default)
-          case default
-          when "'{}'::json", "'{}'::jsonb"
-            '{}'
-          when "'[]'::json", "'[]'::jsonb"
-            '[]'
-          else
-            extract_value_from_default_without_json(default)
-          end
-        end
-
-        alias_method_chain :extract_value_from_default, :json
-      end
-
-    end
-
-    class TableDefinition
-      # Adds json type for migrations. So you can add columns to a table like:
-      #   create_table :people do |t|
-      #     ...
-      #     t.json :info
-      #     ...
-      #   end
-      def json(*args)
-        options = args.extract_options!
-        column_names = args
-        column_names.each { |name| column(name, 'json', options) }
-      end
-
-      def jsonb(*args)
-        options = args.extract_options!
-        column_names = args
-        column_names.each { |name| column(name, 'jsonb', options) }
-      end
-
-    end
-
-    class Table
-      # Adds json type for migrations. So you can add columns to a table like:
-      #   change_table :people do |t|
-      #     ...
-      #     t.json :info
-      #     ...
-      #   end
-      def json(*args)
-        options = args.extract_options!
-        column_names = args
-        column_names.each { |name| column(name, 'json', options) }
-      end
-
-      def jsonb(*args)
-        options = args.extract_options!
-        column_names = args
-        column_names.each { |name| column(name, 'jsonb', options) }
-      end
-
-    end
-
-  end
-
-end

data/test/support/postgresql/pg_json_migrations/20160519133432_create_pg_json_migrate_test.rb

@@ -1,13 +0,0 @@
-require 'ardb/migration_helpers'
-
-class CreatePgJsonMigrateTest < ActiveRecord::Migration
-  include Ardb::MigrationHelpers
-
-  def change
-    create_table :pg_json_test_records do |t|
-      t.json  :json_attribute
-    end
-    add_column :pg_json_test_records, :jsonb_attribute, :jsonb
-  end
-
-end

data/test/system/pg_json_tests.rb

@@ -1,85 +0,0 @@
-require 'assert'
-require 'ardb/pg_json'
-
-require 'json'
-require 'test/support/postgresql/setup_test_db'
-
-module Ardb; end
-module Ardb::PgJson
-
-  class SystemTests < PostgresqlDbTests
-    desc "Ardb postgresql json shim"
-    setup do
-      @ardb_config.migrations_path = 'pg_json_migrations'
-    end
-
-    should "add support for postgresql json columns to migrations" do
-      # this should migrate the db, adding a record that has json/jsonb columns
-      assert_nothing_raised do
-        silence_stdout{ Ardb.adapter.migrate_db }
-      end
-
-      results = ActiveRecord::Base.connection.execute(
-        "SELECT column_name, data_type " \
-        "FROM INFORMATION_SCHEMA.COLUMNS " \
-        "WHERE table_name = 'pg_json_test_records'"
-      ).to_a
-      exp = {
-        'column_name' => 'json_attribute',
-        'data_type'   => 'json',
-      }
-      assert_includes exp, results
-      exp = {
-        'column_name' => 'jsonb_attribute',
-        'data_type'   => 'jsonb'
-      }
-      assert_includes exp, results
-    end
-
-  end
-
-  class WithMigratedTableTests < SystemTests
-    setup do
-      silence_stdout{ Ardb.adapter.migrate_db }
-      @record_class = Class.new(ActiveRecord::Base) do
-        self.table_name = 'pg_json_test_records'
-      end
-    end
-
-    should "add support for postgresql 'json' attributes on records" do
-      values = [Factory.string, Factory.integer, nil]
-
-      record = @record_class.new
-      assert_nil record.json_attribute
-      assert_nil record.jsonb_attribute
-
-      hash = Factory.integer(3).times.inject({}) do |h, n|
-        h.merge!(Factory.string => values.sample)
-      end
-      record.json_attribute  = JSON.dump(hash)
-      record.jsonb_attribute = JSON.dump(hash)
-      assert_nothing_raised{ record.save! }
-      record.reload
-      assert_equal hash, JSON.load(record.json_attribute)
-      assert_equal hash, JSON.load(record.jsonb_attribute)
-
-      array = Factory.integer(3).times.map{ values.sample }
-      record.json_attribute  = JSON.dump(array)
-      record.jsonb_attribute = JSON.dump(array)
-      assert_nothing_raised{ record.save! }
-      record.reload
-      assert_equal array, JSON.load(record.json_attribute)
-      assert_equal array, JSON.load(record.jsonb_attribute)
-
-      value = values.sample
-      record.json_attribute  = JSON.dump(value)
-      record.jsonb_attribute = JSON.dump(value)
-      assert_nothing_raised{ record.save! }
-      record.reload
-      assert_equal value, JSON.load(record.json_attribute)
-      assert_equal value, JSON.load(record.jsonb_attribute)
-    end
-
-  end
-
-end

data/test/unit/has_slug_tests.rb

@@ -1,341 +0,0 @@
-require 'assert'
-require 'ardb/has_slug'
-
-require 'much-plugin'
-require 'ardb/record_spy'
-
-module Ardb::HasSlug
-
-  class UnitTests < Assert::Context
-    desc "Ardb::HasSlug"
-    setup do
-      source_attribute = @source_attribute = Factory.string.to_sym
-      slug_attribute   = @slug_attribute   = Factory.string.to_sym
-      @record_class = Ardb::RecordSpy.new do
-        include Ardb::HasSlug
-        attr_accessor source_attribute, slug_attribute, DEFAULT_ATTRIBUTE
-        attr_reader :slug_db_column_updates
-
-        def update_column(*args)
-          @slug_db_column_updates ||= []
-          @slug_db_column_updates << args
-        end
-      end
-    end
-    subject{ @record_class }
-
-    NON_WORD_CHARS = ((' '..'/').to_a + (':'..'@').to_a + ('['..'`').to_a +
-                     ('{'..'~').to_a - ['-', '_']).freeze
-
-    should have_imeths :has_slug
-    should have_imeths :ardb_has_slug_configs
-
-    should "use much-plugin" do
-      assert_includes MuchPlugin, Ardb::HasSlug
-    end
-
-    should "know its default attribute, preprocessor and separator" do
-      assert_equal :slug,     DEFAULT_ATTRIBUTE
-      assert_equal :downcase, DEFAULT_PREPROCESSOR
-      assert_equal '-',       DEFAULT_SEPARATOR
-    end
-
-    should "not have any has-slug configs by default" do
-      assert_equal({}, subject.ardb_has_slug_configs)
-    end
-
-    should "default the has slug config using `has_slug`" do
-      subject.has_slug :source => @source_attribute
-      string = Factory.string
-      record = subject.new.tap{ |r| r.send("#{@source_attribute}=", string) }
-
-      config = subject.ardb_has_slug_configs[DEFAULT_ATTRIBUTE]
-      assert_equal DEFAULT_SEPARATOR, config[:separator]
-      assert_false config[:allow_underscores]
-
-      source_proc = config[:source_proc]
-      assert_instance_of Proc, source_proc
-      exp = record.send(@source_attribute)
-      assert_equal exp, record.instance_eval(&source_proc)
-
-      upcase_string = string.upcase
-      preprocessor_proc = config[:preprocessor_proc]
-      assert_instance_of Proc, preprocessor_proc
-      exp = upcase_string.send(DEFAULT_PREPROCESSOR)
-      assert_equal exp, preprocessor_proc.call(upcase_string)
-    end
-
-    should "allow customizing the has slug config using `has_slug`" do
-      separator        = NON_WORD_CHARS.sample
-      allow_underscore = Factory.boolean
-      subject.has_slug({
-        :attribute         => @slug_attribute,
-        :source            => @source_attribute,
-        :preprocessor      => :upcase,
-        :separator         => separator,
-        :allow_underscores => allow_underscore
-      })
-
-      config = subject.ardb_has_slug_configs[@slug_attribute]
-      assert_equal separator,        config[:separator]
-      assert_equal allow_underscore, config[:allow_underscores]
-
-      value = Factory.string.downcase
-      preprocessor_proc = config[:preprocessor_proc]
-      assert_instance_of Proc, preprocessor_proc
-      assert_equal value.upcase, preprocessor_proc.call(value)
-    end
-
-    should "add validations using `has_slug`" do
-      subject.has_slug :source => @source_attribute
-      exp_attr_name = DEFAULT_ATTRIBUTE
-
-      validation = subject.validations.find{ |v| v.type == :presence }
-      assert_not_nil validation
-      assert_equal [exp_attr_name], validation.columns
-      assert_equal :update, validation.options[:on]
-
-      validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_not_nil validation
-      assert_equal [exp_attr_name], validation.columns
-      assert_equal true, validation.options[:case_sensitive]
-      assert_nil validation.options[:scope]
-    end
-
-    should "not add a unique validation if skipping unique validation" do
-      subject.has_slug({
-        :source                 => @source_attribute,
-        :skip_unique_validation => true
-      })
-
-      validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_nil validation
-    end
-
-    should "allow customizing its validations using `has_slug`" do
-      unique_scope = Factory.string.to_sym
-      subject.has_slug({
-        :source       => @source_attribute,
-        :unique_scope => unique_scope
-      })
-
-      validation = subject.validations.find{ |v| v.type == :uniqueness }
-      assert_not_nil validation
-      assert_equal unique_scope, validation.options[:scope]
-    end
-
-    should "add callbacks using `has_slug`" do
-      subject.has_slug :source => @source_attribute
-
-      callback = subject.callbacks.find{ |v| v.type == :after_create }
-      assert_not_nil callback
-      assert_equal [:ardb_has_slug_generate_slugs], callback.args
-
-      callback = subject.callbacks.find{ |v| v.type == :after_update }
-      assert_not_nil callback
-      assert_equal [:ardb_has_slug_generate_slugs], callback.args
-    end
-
-    should "raise an argument error if `has_slug` isn't passed a source" do
-      assert_raises(ArgumentError){ subject.has_slug }
-    end
-
-  end
-
-  class InitTests < UnitTests
-    desc "when init"
-    setup do
-      @preprocessor      = [:downcase, :upcase, :capitalize].sample
-      @separator         = NON_WORD_CHARS.sample
-      @allow_underscores = Factory.boolean
-
-      @record_class.has_slug(:source => @source_attribute)
-      @record_class.has_slug({
-        :attribute         => @slug_attribute,
-        :source            => @source_attribute,
-        :preprocessor      => @preprocessor,
-        :separator         => @separator,
-        :allow_underscores => @allow_underscores,
-      })
-
-      @record = @record_class.new
-
-      # create a string that has mixed case and an underscore so we can test
-      # that it uses the preprocessor and allow underscores options when
-      # generating a slug
-      @source_value = "#{Factory.string.downcase}_#{Factory.string.upcase}"
-      @record.send("#{@source_attribute}=", @source_value)
-
-      @exp_default_slug = Slug.new(@source_value, {
-        :preprocessor => DEFAULT_PREPROCESSOR.to_proc,
-        :separator    => DEFAULT_SEPARATOR
-      })
-      @exp_custom_slug = Slug.new(@source_value, {
-        :preprocessor      => @preprocessor.to_proc,
-        :separator         => @separator,
-        :allow_underscores => @allow_underscores
-      })
-    end
-    subject{ @record }
-
-    should "reset its slug using `reset_slug`" do
-      # reset the default attribute
-      subject.send("#{DEFAULT_ATTRIBUTE}=", Factory.slug)
-      assert_not_nil subject.send(DEFAULT_ATTRIBUTE)
-      subject.instance_eval{ reset_slug }
-      assert_nil subject.send(DEFAULT_ATTRIBUTE)
-
-      # reset a custom attribute
-      subject.send("#{@slug_attribute}=", Factory.slug)
-      assert_not_nil subject.send(@slug_attribute)
-      sa = @slug_attribute
-      subject.instance_eval{ reset_slug(sa) }
-      assert_nil subject.send(@slug_attribute)
-    end
-
-    should "default its slug attribute" do
-      subject.instance_eval{ ardb_has_slug_generate_slugs }
-      assert_equal 2, subject.slug_db_column_updates.size
-
-      exp = @exp_default_slug
-      assert_equal exp, subject.send(DEFAULT_ATTRIBUTE)
-      assert_includes [DEFAULT_ATTRIBUTE, exp], subject.slug_db_column_updates
-
-      exp = @exp_custom_slug
-      assert_equal exp,                    subject.send(@slug_attribute)
-      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
-    end
-
-    should "not set its slug if it hasn't changed" do
-      @record.send("#{DEFAULT_ATTRIBUTE}=", @exp_default_slug)
-      @record.send("#{@slug_attribute}=",   @exp_custom_slug)
-
-      subject.instance_eval{ ardb_has_slug_generate_slugs }
-      assert_nil subject.slug_db_column_updates
-    end
-
-    should "slug its slug attribute value if set" do
-      @record.send("#{@slug_attribute}=", @source_value)
-      # change the source attr to some random value, to avoid a false positive
-      @record.send("#{@source_attribute}=", Factory.string)
-      subject.instance_eval{ ardb_has_slug_generate_slugs }
-
-      exp = @exp_custom_slug
-      assert_equal exp, subject.send(@slug_attribute)
-      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
-    end
-
-    should "slug its source even if its already a valid slug" do
-      slug_source = Factory.slug
-      @record.send("#{@source_attribute}=", slug_source)
-      # ensure the preprocessor doesn't change our source
-      Assert.stub(slug_source, @preprocessor){ slug_source }
-
-      subject.instance_eval{ ardb_has_slug_generate_slugs }
-
-      exp = Slug.new(slug_source, {
-        :preprocessor      => @preprocessor.to_proc,
-        :separator         => @separator,
-        :allow_underscores => @allow_underscores
-      })
-      assert_equal exp, subject.send(@slug_attribute)
-      assert_includes [@slug_attribute, exp], subject.slug_db_column_updates
-    end
-
-  end
-
-  class SlugTests < UnitTests
-    desc "Slug"
-    setup do
-      @no_op_pp = proc{ |slug| slug }
-      @args = {
-        :preprocessor => @no_op_pp,
-        :separator    => '-'
-      }
-    end
-    subject{ Slug }
-
-    should have_imeths :new
-
-    should "always dup the given string" do
-      string = Factory.string
-      assert_not_same string, subject.new(string, @args)
-    end
-
-    should "not change strings that are made up of valid chars" do
-      string = Factory.string
-      assert_equal string, subject.new(string, @args)
-
-      string = "#{Factory.string}-#{Factory.string.upcase}"
-      assert_equal string, subject.new(string, @args)
-    end
-
-    should "turn invalid chars into a separator" do
-      string = Factory.integer(3).times.map do
-        "#{Factory.string(3)}#{NON_WORD_CHARS.sample}#{Factory.string(3)}"
-      end.join(NON_WORD_CHARS.sample)
-      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string, @args)
-    end
-
-    should "allow passing a custom preprocessor proc" do
-      string = "#{Factory.string}-#{Factory.string.upcase}"
-      exp = string.downcase
-      assert_equal exp, subject.new(string, @args.merge(:preprocessor => :downcase.to_proc))
-
-      preprocessor = proc{ |s| s.gsub(/[A-Z]/, 'a') }
-      exp = preprocessor.call(string)
-      assert_equal exp, subject.new(string, @args.merge(:preprocessor => preprocessor))
-    end
-
-    should "allow passing a custom separator" do
-      separator = NON_WORD_CHARS.sample
-
-      invalid_char = (NON_WORD_CHARS - [separator]).sample
-      string = "#{Factory.string}#{invalid_char}#{Factory.string}"
-      exp = string.gsub(/[^\w]+/, separator)
-      assert_equal exp, subject.new(string, @args.merge(:separator => separator))
-
-      # it won't change the separator in the strings
-      string = "#{Factory.string}#{separator}#{Factory.string}"
-      exp = string
-      assert_equal string, subject.new(string, @args.merge(:separator => separator))
-
-      # it will change the default separator now
-      string = "#{Factory.string}-#{Factory.string}"
-      exp = string.gsub('-', separator)
-      assert_equal exp, subject.new(string, @args.merge(:separator => separator))
-    end
-
-    should "change underscores into its separator unless allowed" do
-      string = "#{Factory.string}_#{Factory.string}"
-      assert_equal string.gsub('_', '-'), subject.new(string, @args)
-
-      exp = string.gsub('_', '-')
-      assert_equal exp, subject.new(string, @args.merge(:allow_underscores => false))
-
-      assert_equal string, subject.new(string, @args.merge(:allow_underscores => true))
-    end
-
-    should "not allow multiple separators in a row" do
-      string = "#{Factory.string}--#{Factory.string}"
-      assert_equal string.gsub(/-{2,}/, '-'), subject.new(string, @args)
-
-      # remove separators that were added from changing invalid chars
-      invalid_chars = (Factory.integer(3) + 1).times.map{ NON_WORD_CHARS.sample }.join
-      string = "#{Factory.string}#{invalid_chars}#{Factory.string}"
-      assert_equal string.gsub(/[^\w]+/, '-'), subject.new(string, @args)
-    end
-
-    should "remove leading and trailing separators" do
-      string = "-#{Factory.string}-#{Factory.string}-"
-      assert_equal string[1..-2], subject.new(string, @args)
-
-      # remove separators that were added from changing invalid chars
-      invalid_char = NON_WORD_CHARS.sample
-      string = "#{invalid_char}#{Factory.string}-#{Factory.string}#{invalid_char}"
-      assert_equal string[1..-2], subject.new(string, @args)
-    end
-
-  end
-
-end