flex_columns 1.0.0

data/lib/flex_columns/util/string_utils.rb

@@ -0,0 +1,31 @@
+module FlexColumns
+  module Util
+    # Contains a single method for abbreviating strings.
+    #
+    # Yes, this is very un-Ruby-like -- to define a separate utility function, rather than just adding a method to
+    # String. However, this method is used in such limited context (generating exception messages) that polluting the
+    # namespace of one of the most important classes in Ruby is probably a pretty bad idea.
+    class StringUtils
+      class << self
+        MAX_LENGTH_FOR_ABBREVIATED_STRING = 100
+        ABBREVIATED_STRING_SEPARATOR = "..."
+
+        # Returns a string of length no more than MAX_LENGTH_FOR_ABBREVIATED_STRING, by eliding, if necessary,
+        # characters from the middle. This is used when throwing exceptions: +flex_columns+ can generate very long
+        # strings of JSON data, and having many kilobytes (or even megabytes) of JSON make its way into an exception
+        # message is probably a really bad idea.
+        def abbreviated_string(s)
+          if s && s.length > MAX_LENGTH_FOR_ABBREVIATED_STRING
+            before_separator_length = ((MAX_LENGTH_FOR_ABBREVIATED_STRING - ABBREVIATED_STRING_SEPARATOR.length) / 2.0).floor
+            out = s[0..(before_separator_length - 1)] + ABBREVIATED_STRING_SEPARATOR
+            remaining = MAX_LENGTH_FOR_ABBREVIATED_STRING - out.length
+            out << s[(-remaining + 1)..-1]
+            out
+          else
+            s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flex_columns/version.rb

@@ -0,0 +1,4 @@
+module FlexColumns
+  # The current version of FlexColumns.
+  VERSION = "1.0.0"
+end

data/spec/flex_columns/helpers/database_helper.rb

@@ -0,0 +1,174 @@
+module FlexColumns
+  module Helpers
+    class DatabaseHelper
+      class InvalidDatabaseConfigurationError < StandardError; end
+
+      class << self
+        def maybe_database_gem_name
+          begin
+            dh = new
+            dh.database_gem_name
+          rescue InvalidDatabaseConfigurationError => idce
+            nil
+          end
+        end
+      end
+
+      def initialize
+        config # make sure we raise on instantiation if configuration is invalid
+      end
+
+      def database_type
+        case database_gem_name
+        when /mysql/i then :mysql
+        when /sqlite/i then :sqlite
+        when /pg/i, /postgres/i then :postgres
+        else raise "Unknown database type for Gem name: #{database_gem_name.inspect}"
+        end
+      end
+
+      def setup_activerecord!
+        require 'active_record'
+        require config[:require]
+        ::ActiveRecord::Base.establish_connection(config[:config])
+
+        require 'logger'
+        require 'stringio'
+        @logs = StringIO.new
+        ::ActiveRecord::Base.logger = Logger.new(@logs)
+
+        if config[:config][:adapter] == 'sqlite3'
+          sqlite_version = ::ActiveRecord::Base.connection.send(:sqlite_version).instance_variable_get("@version").inspect rescue "unknown"
+        end
+      end
+
+      def table_name(name)
+        "flexcols_spec_#{name}"
+      end
+
+      def database_gem_name
+        config[:database_gem_name]
+      end
+
+      private
+      def config
+        config_from_config_file || travis_ci_config_from_environment || invalid_config_file!
+      end
+
+      def config_from_config_file
+        return nil unless File.exist?(config_file_path)
+        require config_file_path
+
+        return nil unless defined?(FLEX_COLUMNS_SPEC_DATABASE_CONFIG)
+        return nil unless FLEX_COLUMNS_SPEC_DATABASE_CONFIG.kind_of?(Hash)
+
+        return nil unless FLEX_COLUMNS_SPEC_DATABASE_CONFIG[:require]
+        return nil unless FLEX_COLUMNS_SPEC_DATABASE_CONFIG[:database_gem_name]
+
+        return nil unless FLEX_COLUMNS_SPEC_DATABASE_CONFIG
+        FLEX_COLUMNS_SPEC_DATABASE_CONFIG
+      end
+
+      def travis_ci_config_from_environment
+        dbtype = (ENV['FLEX_COLUMNS_TRAVIS_CI_DATABASE_TYPE'] || '').strip.downcase
+        is_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+        if is_jruby
+          case dbtype
+          when 'mysql'
+            {
+              :require => 'activerecord-jdbcmysql-adapter',
+              :database_gem_name => 'activerecord-jdbcmysql-adapter',
+              :config => {
+                :adapter => 'jdbcmysql',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
+          when 'postgres', 'postgresql'
+            {
+              :require => 'activerecord-jdbcpostgresql-adapter',
+              :database_gem_name => 'activerecord-jdbcpostgresql-adapter',
+              :config => {
+                :adapter => 'jdbcpostgresql',
+                :database => 'myapp_test',
+                :username => 'postgres'
+              }
+            }
+          when 'sqlite'
+            {
+              :require => 'activerecord-jdbcsqlite3-adapter',
+              :database_gem_name => 'activerecord-jdbcsqlite3-adapter',
+              :config => {
+                :adapter => 'jdbcsqlite3',
+                :database => ':memory:'
+              }
+            }
+          when '', nil then nil
+          else
+            raise "Unknown Travis CI database type: #{dbtype.inspect}"
+          end
+        else
+          case dbtype
+          when 'postgres', 'postgresql'
+            {
+              :require => 'pg',
+              :database_gem_name => 'pg',
+              :config => {
+                :adapter => 'postgresql',
+                :database => 'myapp_test',
+                :username => 'postgres',
+                :min_messages => 'WARNING'
+              }
+            }
+          when 'mysql'
+            {
+              :require => 'mysql2',
+              :database_gem_name => 'mysql2',
+              :config => {
+                :adapter => 'mysql2',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
+          when 'sqlite'
+            {
+              :require => 'sqlite3',
+              :database_gem_name => 'sqlite3',
+              :config => {
+                :adapter => 'sqlite3',
+                :database => ':memory:',
+                :timeout => 500
+              }
+            }
+          when '', nil then nil
+          else
+            raise "Unknown Travis CI database type: #{dbtype.inspect}"
+          end
+        end
+      end
+
+      def config_file_path
+        @config_file_path ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_database_config.rb'))
+      end
+
+      def invalid_config_file!
+        raise Errno::ENOENT, %{In order to run specs for FlexColumns, you need to create a file at:
+
+#{config_file_path}
+
+...that defines a top-level FLEX_COLUMNS_SPEC_DATABASE_CONFIG hash, with members:
+
+  :require => 'name_of_adapter_to_require',
+  :database_gem_name => 'name_of_gem_for_adapter',
+  :config  => { ...whatever ActiveRecord::Base.establish_connection should be passed... }
+
+Alternatively, if you're running under Travis CI, you can set the environment variable
+FLEX_COLUMNS_TRAVIS_CI_DATABASE_TYPE to 'postgres', 'mysql', or 'sqlite', and it will
+use the correct configuration for testing on Travis CI.}
+      end
+    end
+  end
+end

data/spec/flex_columns/helpers/exception_helpers.rb

@@ -0,0 +1,20 @@
+module FlexColumns
+  module Helpers
+    module ExceptionHelpers
+      def capture_exception(required_class = Exception, &block)
+        e = nil
+        begin
+          block.call
+        rescue required_class => x
+          e = x
+        end
+
+        unless e
+          raise "Expected an exception of class #{required_class.inspect}, but none was raised"
+        end
+
+        e
+      end
+    end
+  end
+end

data/spec/flex_columns/helpers/system_helpers.rb

@@ -0,0 +1,47 @@
+require 'active_record'
+require 'active_record/migration'
+
+module FlexColumns
+  module Helpers
+    module SystemHelpers
+      def migrate(&block)
+        migration_class = Class.new(::ActiveRecord::Migration)
+        metaclass = migration_class.class_eval { class << self; self; end }
+        metaclass.instance_eval { define_method(:up, &block) }
+
+        ::ActiveRecord::Migration.suppress_messages do
+          migration_class.migrate(:up)
+        end
+      end
+
+      def define_model_class(name, table_name, &block)
+        model_class = Class.new(::ActiveRecord::Base)
+        ::Object.send(:remove_const, name) if ::Object.const_defined?(name)
+        ::Object.const_set(name, model_class)
+        model_class.table_name = table_name
+        model_class.class_eval(&block)
+      end
+
+      def create_standard_system_spec_tables!
+        migrate do
+          drop_table :flexcols_spec_users rescue nil
+          create_table :flexcols_spec_users do |t|
+            t.string :name, :null => false
+            t.text :user_attributes
+            t.text :more_attributes
+          end
+        end
+      end
+
+      def create_standard_system_spec_models!
+        define_model_class(:User, 'flexcols_spec_users') { }
+      end
+
+      def drop_standard_system_spec_tables!
+        migrate do
+          drop_table :flexcols_spec_users rescue nil
+        end
+      end
+    end
+  end
+end

data/spec/flex_columns/system/basic_system_spec.rb

@@ -0,0 +1,245 @@
+require 'flex_columns'
+require 'flex_columns/helpers/system_helpers'
+
+describe "FlexColumns basic operations" do
+  include FlexColumns::Helpers::SystemHelpers
+
+  before :each do
+    @dh = FlexColumns::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+
+    create_standard_system_spec_tables!
+  end
+
+  after :each do
+    drop_standard_system_spec_tables!
+  end
+
+  context "with a very simple column definition" do
+    before :each do
+      define_model_class(:User, 'flexcols_spec_users') do
+        flex_column :user_attributes do
+          field :wants_email
+        end
+      end
+    end
+
+    it "should be able to serialize and deserialize a very simple example" do
+      define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
+
+      user = ::User.new
+      user.name = 'User 1'
+      user.user_attributes['wants_email'] = 'sometimes'
+      user.user_attributes['wants_email'].should == 'sometimes'
+      user.save!
+
+      user.user_attributes['wants_email'].should == 'sometimes'
+
+      user2 = ::User.find(user.id)
+      user2.user_attributes['wants_email'].should == 'sometimes'
+      user2.user_attributes.keys.should == [ :wants_email ]
+    end
+
+    it "should store its data as standard JSON" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.user_attributes['wants_email'] = 'sometimes'
+      user.save!
+
+      bd = ::UserBackdoor.find(user.id)
+      bd.should be
+      bd.id.should == user.id
+
+      string = bd.user_attributes
+      string.should be
+      string.length.should > 0
+
+      contents = JSON.parse(string)
+      contents.class.should == Hash
+      contents.keys.should == [ 'wants_email' ]
+      contents['wants_email'].should == 'sometimes'
+    end
+
+    it "should not modify that JSON if you don't write to it with a different value, but should if you touch it" do
+      define_model_class(:UserBackdoor, 'flexcols_spec_users') { }
+
+      weirdly_spaced_json = '   {        "wants_email"  : "boop"    } '
+
+      user_bd = ::UserBackdoor.new
+      user_bd.name = 'User 1'
+      user_bd.user_attributes = weirdly_spaced_json
+      user_bd.save!
+
+      user = ::User.find(user_bd.id)
+      user.name.should == 'User 1'
+      user.wants_email.should == 'boop'
+      user.wants_email = 'boop'
+      user.save!
+
+      user_bd_again = ::UserBackdoor.find(user_bd.id)
+      user_bd_again.name.should == 'User 1'
+      user_bd_again.user_attributes.should == weirdly_spaced_json
+
+      user.user_attributes.touch!
+      user.save!
+
+      user_bd_again = ::UserBackdoor.find(user_bd.id)
+      user_bd_again.name.should == 'User 1'
+      user_bd_again.user_attributes.should == '{"wants_email":"boop"}'
+    end
+
+    it "should provide access to attributes as methods" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.user_attributes.wants_email = 'sometimes'
+      user.user_attributes.wants_email.should == 'sometimes'
+      user.user_attributes['wants_email'].should == 'sometimes'
+      user.save!
+
+      user.user_attributes.wants_email.should == 'sometimes'
+
+      user2 = ::User.find(user.id)
+      user2.user_attributes.wants_email.should == 'sometimes'
+      user2.user_attributes.keys.should == [ :wants_email ]
+    end
+
+    it "should delegate methods to attributes automatically" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = 'sometimes'
+      user.wants_email.should == 'sometimes'
+      user.user_attributes['wants_email'].should == 'sometimes'
+      user.save!
+
+      user.wants_email.should == 'sometimes'
+
+      user2 = ::User.find(user.id)
+      user2.wants_email.should == 'sometimes'
+      user2.user_attributes.keys.should == [ :wants_email ]
+    end
+
+    it "should have a reasonable class name for contents" do
+      class_name = ::User.new.user_attributes.class.name
+      class_name.should match(/^user::/i)
+      class_name.should match(/userattributes/i)
+      class_name.should match(/flexcontents/i)
+    end
+
+    it "should let you make flex-column accessors private one-by-one" do
+      define_model_class(:User, 'flexcols_spec_users') do
+        flex_column :user_attributes do
+          field :wants_email, :visibility => :private
+          field :another_thing
+        end
+      end
+
+      user = ::User.new
+      user.user_attributes.respond_to?(:wants_email).should_not be
+      lambda { user.user_attributes.wants_email }.should raise_error(NoMethodError)
+
+      user.user_attributes.send(:wants_email).should be_nil
+      user.user_attributes.send("wants_email=", "foobar").should == "foobar"
+      user.user_attributes.send(:wants_email).should == "foobar"
+
+      user.user_attributes.another_thing = 123
+      user.user_attributes.another_thing.should == 123
+
+      user.respond_to?(:wants_email).should_not be
+      user.respond_to?(:another_thing).should be
+    end
+
+    it "should let you make flex-column accessors private en masse, and override it one-by-one" do
+      define_model_class(:User, 'flexcols_spec_users') do
+        flex_column :user_attributes, :visibility => :private do
+          field :wants_email
+          field :another_thing, :visibility => :public
+        end
+      end
+
+      user = ::User.new
+      user.user_attributes.respond_to?(:wants_email).should_not be
+      lambda { user.user_attributes.wants_email }.should raise_error(NoMethodError)
+
+      user.user_attributes.send(:wants_email).should be_nil
+      user.user_attributes.send("wants_email=", "foobar").should == "foobar"
+      user.user_attributes.send(:wants_email).should == "foobar"
+
+      user.user_attributes.another_thing = 123
+      user.user_attributes.another_thing.should == 123
+
+      user.respond_to?(:wants_email).should_not be
+      user.respond_to?(:another_thing).should be
+    end
+
+    it "should return Symbols as Strings, so that saving to the database and reading from it doesn't produce a different result (since Symbols are stored in JSON as Strings)" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = :bonko
+      user.wants_email.should == 'bonko'
+      user.save!
+
+      user_again = ::User.find(user.id)
+      user_again.wants_email.should == 'bonko'
+    end
+
+    it "should allow storing an Array happily" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = [ 123, "foo", 47.2, { 'foo' => 'bar' } ]
+      user.save!
+
+      user_again = ::User.find(user.id)
+      user_again.wants_email.should == [ 123, 'foo', 47.2, { 'foo' => 'bar' } ]
+    end
+
+    it "should allow storing a Hash happily" do
+      user = ::User.new
+      user.name = 'User 1'
+      user.wants_email = { 'foo' => 47.2, '13' => 'bar', 'baz' => [ 'a', 'b', 'c' ] }
+      user.save!
+
+      user_again = ::User.find(user.id)
+      output = user_again.wants_email
+      output.class.should == Hash
+      output.keys.sort.should == [ '13', 'baz', 'foo' ].sort
+      output['13'].should == 'bar'
+      output['baz'].should == [ 'a', 'b', 'c' ]
+      output['foo'].should == 47.2
+    end
+
+    it "should remove keys entirely when they're set to nil, but not if they're set to false" do
+      define_model_class(:User, 'flexcols_spec_users') do
+        flex_column :user_attributes do
+          field :aaa
+          field :bbb
+        end
+      end
+
+      ::User.reset_column_information
+
+      user = ::User.new
+      user.name = 'User 1'
+      user.aaa = 'aaa1'
+      user.bbb = 'bbb1'
+      user.save!
+
+      user_bd = ::UserBackdoor.find(user.id)
+      JSON.parse(user_bd.user_attributes).keys.sort.should == %w{aaa bbb}.sort
+
+      user.aaa = false
+      user.save!
+
+      user_bd = ::UserBackdoor.find(user.id)
+      parsed = JSON.parse(user_bd.user_attributes)
+      parsed.keys.sort.should == %w{aaa bbb}.sort
+      parsed['aaa'].should == false
+
+      user.aaa = nil
+      user.save!
+
+      user_bd = ::UserBackdoor.find(user.id)
+      parsed = JSON.parse(user_bd.user_attributes)
+      parsed.keys.sort.should == %w{bbb}.sort
+    end
+  end
+end