incline 0.1.5

data/test/extensions/date_value_extensions_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+class DateValueExtensionsTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  def setup
+    # Create a test table.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+        t.date :tz_value
+        t.date :utc_value
+      end
+    end
+
+    # And then create a test model.
+    eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+  self.time_zone_aware_attributes = true
+  self.skip_time_zone_conversion_for_attributes << :utc_value
+end
+    EOM
+
+    @backup_ar_tz = ActiveRecord::Base.default_timezone
+    @backup_tm_tz = Time.zone.name
+    ActiveRecord::Base.default_timezone = :utc
+    Time.zone = 'EST'
+
+    # Store the model class for use.
+    @model_class = self.class.const_get TEST_TABLE_CLASS
+    @item = @model_class.new
+  end
+
+  def teardown
+    # Undefine the model class (or at least remove it from the Object namespace).
+    self.class.send :remove_const, TEST_TABLE_CLASS
+
+    # Remove the table from the database.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+    end
+
+    ActiveRecord::Base.default_timezone = @backup_ar_tz
+    Time.zone = @backup_tm_tz
+  end
+
+  test 'uses correct types' do
+    # Dates should not be TZ aware.
+    col = @model_class.columns.find{|c| c.name == 'tz_value'}
+    assert col
+    assert_not col.cast_type.is_a?(::ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
+    assert col.cast_type.is_a?(::ActiveRecord::Type::Date)
+
+    col = @model_class.columns.find{|c| c.name == 'utc_value'}
+    assert col
+    assert_not col.cast_type.is_a?(::ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
+    assert col.cast_type.is_a?(::ActiveRecord::Type::Date)
+  end
+
+  test 'accepts valid values' do
+    {
+        '2016-12-31'  => Date.new(2016,12,31),
+        '12/31/2016'  => Date.new(2016,12,31),
+        '16-12-31'    => Date.new(2016,12,31),
+        '12/31/16'    => Date.new(2016,12,31),
+        '1/1/2017'    => Date.new(2017,1,1),
+        '2017-1-1'    => Date.new(2017,1,1),
+        '01/01/2017'  => Date.new(2017,1,1),
+        '2017-01-01'  => Date.new(2017,1,1)
+    }.each do |s,v|
+      @item.utc_value = s
+      assert_equal v, @item.utc_value, "Should have accepted #{s.inspect}"
+
+      # Time zones should not apply to dates!
+      @item.tz_value = s
+      assert_equal v, @item.tz_value, "Should have accepted #{s.inspect}"
+    end
+
+  end
+
+  test 'rejects invalid values' do
+
+    [
+        '',
+        '  ',
+        '0000-00-00',
+        '2016-13-31',
+        '2016-12-32',
+        '2016-02-30',
+        '2/30/2016',
+    ].each do |val|
+      @item.tz_value = val
+      assert_nil @item.tz_value, "Should have rejected #{val.inspect}"
+      @item.utc_value = val
+      assert_nil @item.utc_value, "Should have rejected #{val.inspect}"
+    end
+
+  end
+
+end

data/test/extensions/decimal_value_extensions_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+
+class DecimalValueExtensionsTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  def setup
+    # Create a test table.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+        t.decimal :scaled_value, precision: 12, scale: 4
+        t.decimal :unscaled_value, precision: 12
+      end
+    end
+
+    # And then create a test model.
+    eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+end
+    EOM
+
+    # Store the model class for use.
+    @model_class = self.class.const_get TEST_TABLE_CLASS
+    @item = @model_class.new
+  end
+
+  def teardown
+    # Undefine the model class (or at least remove it from the Object namespace).
+    self.class.send :remove_const, TEST_TABLE_CLASS
+
+    # Remove the table from the database.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+    end
+  end
+
+  test 'accepts valid values' do
+    {
+        '1234'        => BigDecimal(1234, 12),
+        '1,234'       => BigDecimal(1234, 12),
+        '12.34'       => BigDecimal(12.34, 12),
+        '1,234.5678'  => BigDecimal(1234.5678, 12),
+        '1234567'     => BigDecimal(1234567.0, 12),
+        '1,234,567'   => BigDecimal(1234567.0, 12),
+        '0'           => BigDecimal(0.0, 12),
+        '0.0'         => BigDecimal(0.0, 12),
+        '+125'        => BigDecimal(125.0, 12),
+        '-125'        => BigDecimal(-125.0, 12),
+        '+1,234'      => BigDecimal(1234.0, 12),
+        '-1,234'      => BigDecimal(-1234.0, 12)
+    }.each do |s,v|
+      @item.scaled_value = s
+      assert_equal v.round(4), @item.scaled_value, "#{s.inspect} did not parse to #{v}"
+      @item.unscaled_value = s
+      assert_equal v.to_i, @item.unscaled_value, "#{s.inspect} did not parse to #{v}"
+    end
+    [ 0, 1234, 567.89 ].each do |v|
+      @item.scaled_value = v
+      assert_equal BigDecimal(v, 6).round(4), @item.scaled_value
+      @item.unscaled_value = v
+      assert_equal v.to_i, @item.unscaled_value
+    end
+  end
+
+  test 'rejects invalid values' do
+    [
+        '',
+        '1,2,3,4',
+        ',234',
+        '1,2345',
+        '0,001',
+    ].each do |v|
+      @item.scaled_value = v
+      assert_nil @item.scaled_value
+      @item.unscaled_value = v
+      assert_nil @item.unscaled_value
+    end
+  end
+
+
+
+
+end

data/test/extensions/erb_scaffold_generator_extensions_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class ErbScaffoldGeneratorExtensionsTest < ActiveSupport::TestCase
+
+  def setup
+    @gen = Erb::Generators::ScaffoldGenerator.new [ 'fake_item' ]
+  end
+
+  test 'should have the correct available_views' do
+    req = %w(index new edit show _list _form)
+    actual = @gen.send :available_views
+    req.each do |view|
+      assert actual.include?(view), "Missing '#{view}' view."
+    end
+  end
+
+end

data/test/extensions/float_value_extensions_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class FloatValueExtensionsTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  def setup
+    # Create a test table.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+        t.float :my_value
+      end
+    end
+
+    # And then create a test model.
+    eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+end
+    EOM
+
+    # Store the model class for use.
+    @model_class = self.class.const_get TEST_TABLE_CLASS
+    @item = @model_class.new
+  end
+
+  def teardown
+    # Undefine the model class (or at least remove it from the Object namespace).
+    self.class.send :remove_const, TEST_TABLE_CLASS
+
+    # Remove the table from the database.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+    end
+  end
+
+  test 'accepts valid values' do
+    {
+        '1234' => 1234.0,
+        '1,234' => 1234.0,
+        '12.34' => 12.34,
+        '1,234.5678' => 1234.5678,
+        '1234567' => 1234567.0,
+        '1,234,567' => 1234567.0,
+        '0' => 0.0,
+        '0.0' => 0.0,
+        '+125' => 125.0,
+        '-125' => -125.0,
+        '+1,234' => 1234.0,
+        '-1,234' => -1234.0
+    }.each do |s,v|
+      @item.my_value = s
+      assert_equal v, @item.my_value, "#{s.inspect} did not parse to #{v}"
+    end
+    [ 0, 1234, 567.89 ].each do |v|
+      @item.my_value = v
+      assert_equal v.to_f, @item.my_value
+    end
+  end
+
+  test 'rejects invalid values' do
+    [
+        '',
+        '1,2,3,4',
+        ',234',
+        '1,2345',
+        '0,001',
+    ].each do |v|
+      @item.my_value = v
+      assert_nil @item.my_value
+    end
+  end
+
+
+
+
+end

data/test/extensions/form_builder_extensions_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class FormBuilderExtensionsTest < ActiveSupport::TestCase
+
+  def setup
+    @builder = ActionView::Helpers::FormBuilder.new('my_object', Object.new, 'no template', { })
+  end
+
+  test 'should have additional methods' do
+    assert @builder.respond_to?(:date_picker)
+    assert @builder.respond_to?(:multi_input)
+    assert @builder.respond_to?(:currency_field)
+    assert @builder.respond_to?(:label_w_small)
+    assert @builder.respond_to?(:text_form_group)
+    assert @builder.respond_to?(:password_form_group)
+    assert @builder.respond_to?(:textarea_form_group)
+    assert @builder.respond_to?(:currency_form_group)
+    assert @builder.respond_to?(:static_form_group)
+    assert @builder.respond_to?(:datepicker_form_group)
+    assert @builder.respond_to?(:multi_input_form_group)
+    assert @builder.respond_to?(:check_box_form_group)
+    assert @builder.respond_to?(:select_form_group)
+    assert @builder.respond_to?(:recaptcha)
+  end
+
+  # TODO: Test output of various methods.
+
+end

data/test/extensions/integer_value_extensions_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class IntegerValueExtensionsTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  def setup
+    # Create a test table.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+        t.integer :my_value
+      end
+    end
+
+    # And then create a test model.
+    eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+end
+    EOM
+
+    # Store the model class for use.
+    @model_class = self.class.const_get TEST_TABLE_CLASS
+    @item = @model_class.new
+  end
+
+  def teardown
+    # Undefine the model class (or at least remove it from the Object namespace).
+    self.class.send :remove_const, TEST_TABLE_CLASS
+
+    # Remove the table from the database.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+    end
+  end
+
+  test 'accepts valid values' do
+    {
+        '1234' => 1234,
+        '1,234' => 1234,
+        '12.34' => 12,
+        '1,234.5678' => 1234,
+        '1234567' => 1234567,
+        '1,234,567' => 1234567,
+        '0' => 0,
+        '0.0' => 0,
+        '+125' => 125,
+        '-125' => -125,
+        '+1,234' => 1234,
+        '-1,234' => -1234
+    }.each do |s,v|
+      @item.my_value = s
+      assert_equal v, @item.my_value, "#{s.inspect} did not parse to #{v}"
+    end
+    [ 0, 1234, 567.89 ].each do |v|
+      @item.my_value = v
+      assert_equal v.to_i, @item.my_value
+    end
+  end
+
+  test 'rejects invalid values' do
+    [
+        '',
+        '1,2,3,4',
+        ',234',
+        '1,2345',
+        '0,001',
+    ].each do |v|
+      @item.my_value = v
+      assert_nil @item.my_value
+    end
+  end
+
+
+
+
+end

data/test/extensions/jbuilder_generator_extensions_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class JbuilderGeneratorExtensionsTest < ActiveSupport::TestCase
+
+  def setup
+    @gen = Rails::Generators::JbuilderGenerator.new [ 'fake_item' ]
+  end
+
+  test 'responds to available_views' do
+    assert @gen.respond_to?(:available_views, true)
+  end
+
+  test 'should have the correct available_views' do
+    req = %w(index show _details)
+    actual = @gen.send :available_views
+    req.each do |view|
+      assert actual.include?(view), "Missing '#{view}' view."
+    end
+  end
+
+end

data/test/extensions/jbuilder_template_extensions_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'json'
+
+class JbuilderTemplateExtensionsTest < ActiveSupport::TestCase
+
+  class TestClass
+
+    attr_reader :errors
+
+    def initialize
+      @errors = {
+          :base => [ 'something bad happened' ],
+          :name => 'is too long',
+          :code => [ 'is not uppercase', 'is too long' ]
+      }
+    end
+  end
+
+  def setup
+    @json = JbuilderTemplate.new(self)
+    @item = TestClass.new
+  end
+
+  test 'has extension methods' do
+    assert @json.respond_to?(:api_errors!)
+  end
+
+  test 'builds expected values' do
+    @json.api_errors! 'test_class', @item.errors
+    val = JSON.parse(@json.target!)
+
+    assert val.is_a?(::Hash)
+
+    assert val['error'].is_a?(::String)
+    assert_equal 'Test class ' + @item.errors[:base].first, val['error']
+
+    assert val['fieldErrors'].is_a?(::Array)
+    assert_equal 2, val['fieldErrors'].count
+    e = val['fieldErrors'].find{|v| v['name'] == 'test_class.name'}
+    assert e
+    assert_equal 'Name is too long', e['status']
+    e = val['fieldErrors'].find{|v| v['name'] == 'test_class.code'}
+    assert e
+    assert_equal "Code is not uppercase<br>\nCode is too long", e['status']
+  end
+
+end

data/test/extensions/main_app_extensions_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class MainAppExtensionsTest < ActiveSupport::TestCase
+
+  class TestClass
+    class Action2Class
+      include Incline::Extensions::MainApp
+
+      def action2
+        :action2
+      end
+    end
+
+    include Incline::Extensions::MainApp
+
+    attr_accessor :called
+
+    def initialize
+      self.called = false
+    end
+
+    def main_app
+      self.called = :main_app
+      @main_app ||= Action2Class.new
+    end
+
+    def action1
+      self.called = :action1
+    end
+
+  end
+
+  def setup
+    @item = TestClass.new
+  end
+
+  test 'main_app should be called automatically' do
+    # action1 belongs to the class itself.
+    assert_equal :action1, @item.action1
+    assert_equal :action1, @item.called
+
+    # action2 belongs to the :main_app object.
+    assert_equal :action2, @item.action2
+    assert_equal :main_app, @item.called
+
+    # and just to be sure, when a class does not define :main_app, we use rails.
+    # in this case the fake :main_app doesn't know :root_path and doesn't define
+    # its own :main_app, so it calls on rails to execute the method.
+    rp = Rails.application.class.routes.url_helpers.root_path
+    assert_equal rp, @item.main_app.root_path
+
+  end
+
+
+end

data/test/extensions/numeric_extensions_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+require 'bigdecimal'
+
+class NumericExtensionsTest < ActiveSupport::TestCase
+
+  test 'numeric types have to_human' do
+    assert Integer(123).respond_to?(:to_human)
+    assert Float(123).respond_to?(:to_human)
+    assert Rational(123).respond_to?(:to_human)
+    assert BigDecimal.new(123).respond_to?(:to_human)
+  end
+
+  test 'integers convert as expected' do
+    {
+        1 => '1',
+        10 => '10',
+        100 => '100',
+        1000 => '1 thousand',
+        1500 => '1.5 thousand',
+        1000000 => '1 million',
+        1050000 => '1.05 million',
+        1000000000 => '1 billion',
+        1245000000 => '1.25 billion', # verify that we are using round-to-nearest and not round-to-even.
+        1255000000 => '1.26 billion',
+        999999999 => '1000 million',  # less than a billion, but rounding will put it at 1 billion.
+        Integer('1234'.ljust(40,'0')) => '1.23 duodecillion'
+    }.each do |v, s|
+      assert_equal s, v.to_human
+    end
+  end
+
+  test 'floats convert as expected' do
+    {
+        0.375 => '0.38',
+        1.0 => '1',
+        10.0 => '10',
+        100.0 => '100',
+        1000.0 => '1 thousand',
+        1500.0 => '1.5 thousand',
+        (1E36 + 1.0) => '1 undecillion'
+    }.each do |v,s|
+      assert_equal s, v.to_human
+    end
+  end
+
+  test 'rationals convert as expected' do
+    {
+        Rational('3/8') => '3/8',
+        Rational(1) => '1',
+        Rational('5/3') => '5/3',
+        Rational(10.0) => '10',
+        Rational(100) => '100',
+        Rational('100/1') => '100',
+        Rational(1000) => '1 thousand',
+        Rational(1500) => '1.5 thousand',
+        Rational('1'.ljust(34,'0')) => '1 decillion'
+    }.each do |v,s|
+      assert_equal s, v.to_human
+    end
+  end
+
+  test 'big_decimals convert as expected' do
+    {
+        BigDecimal(Rational('3/8'), 4) => '0.38',
+        BigDecimal(1) => '1',
+        BigDecimal(10) => '10',
+        BigDecimal(100) => '100',
+        BigDecimal(1000) => '1 thousand',
+        BigDecimal(1500) => '1.5 thousand',
+        BigDecimal('1'.ljust(31,'0')) => '1 nonillion'
+    }.each do |v,s|
+      assert_equal s, v.to_human
+    end
+  end
+
+end

data/test/extensions/object_extensions_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class ObjectExtensionsTest < ActiveSupport::TestCase
+
+  test 'all objects have object_pointer method' do
+    assert Object.respond_to?(:object_pointer)
+    assert Object.new.respond_to?(:object_pointer)
+    assert 'hello'.respond_to?(:object_pointer)
+    assert 12345.respond_to?(:object_pointer)
+    assert [1, 2, 3].respond_to?(:object_pointer)
+    assert Hash.new(hello: :world).respond_to?(:object_pointer)
+  end
+
+  test 'all objects have to_bool method' do
+    assert Object.respond_to?(:to_bool)
+    assert Object.new.respond_to?(:to_bool)
+    assert 'hello'.respond_to?(:to_bool)
+    assert 12345.respond_to?(:to_bool)
+    assert [1, 2, 3].respond_to?(:to_bool)
+    assert Hash.new(hello: :world).respond_to?(:to_bool)
+    assert true.respond_to?(:to_bool)
+    assert false.respond_to?(:to_bool)
+    assert nil.respond_to?(:to_bool)
+  end
+
+
+  test 'object_pointer_is_formatted_correctly' do
+    item = Object.new
+    expected = '0x' + item.object_id.to_s(16).rjust(12,'0').downcase
+    assert_equal expected, item.object_pointer
+  end
+
+
+  test 'to_bool works as expected' do
+    # normal true/false
+    assert true.to_bool
+    assert_not false.to_bool
+
+    # nil => false  (should not return nil!)
+    assert_not nil.to_bool
+    assert_not_nil nil.to_bool
+
+    # symbols
+    assert :true.to_bool
+    assert_not :false.to_bool
+    assert :yes.to_bool
+    assert_not :no.to_bool
+    assert :on.to_bool
+    assert_not :off.to_bool
+
+    # integers
+    assert_not 0.to_bool
+    assert 1.to_bool
+    assert (-1.to_bool)
+
+    # floats
+    assert_not 0.0.to_bool
+    assert 0.1.to_bool
+    assert 1.0.to_bool
+
+    # strings (expected true values)
+    assert 'true'.to_bool
+    assert 'True'.to_bool
+    assert 'TRUE'.to_bool
+    assert 't'.to_bool
+    assert 'T'.to_bool
+    assert 'yes'.to_bool
+    assert 'Yes'.to_bool
+    assert 'YES'.to_bool
+    assert 'y'.to_bool
+    assert 'Y'.to_bool
+    assert 'on'.to_bool
+    assert 'On'.to_bool
+    assert 'ON'.to_bool
+    assert '1'.to_bool
+
+    # strings (expected false values)
+    assert_not ''.to_bool
+    assert_not 'false'.to_bool
+    assert_not 'False'.to_bool
+    assert_not 'FALSE'.to_bool
+    assert_not 'f'.to_bool
+    assert_not 'F'.to_bool
+    assert_not 'no'.to_bool
+    assert_not 'No'.to_bool
+    assert_not 'NO'.to_bool
+    assert_not 'off'.to_bool
+    assert_not 'Off'.to_bool
+    assert_not 'OFF'.to_bool
+    assert_not '0'.to_bool
+
+    # strings (misc values are all false)
+    assert_not 'hello'.to_bool
+    assert_not 'maybe'.to_bool
+    assert_not 'true-ish'.to_bool
+    assert_not '123'.to_bool
+
+    # other values
+    assert_not Object.to_bool
+    assert_not Object.new.to_bool
+  end
+
+
+end