motion-support 0.1.0 → 0.2.0

data/spec/motion-support/_helpers/inflector_test_cases.rb

@@ -0,0 +1,313 @@
+module InflectorTestCases
+  SingularToPlural = {
+    "search"      => "searches",
+    "switch"      => "switches",
+    "fix"         => "fixes",
+    "box"         => "boxes",
+    "process"     => "processes",
+    "address"     => "addresses",
+    "case"        => "cases",
+    "stack"       => "stacks",
+    "wish"        => "wishes",
+    "fish"        => "fish",
+    "jeans"       => "jeans",
+    "funky jeans" => "funky jeans",
+    "my money"    => "my money",
+
+    "category"    => "categories",
+    "query"       => "queries",
+    "ability"     => "abilities",
+    "agency"      => "agencies",
+    "movie"       => "movies",
+
+    "archive"     => "archives",
+
+    "index"       => "indices",
+
+    "wife"        => "wives",
+    "safe"        => "saves",
+    "half"        => "halves",
+
+    "move"        => "moves",
+
+    "salesperson" => "salespeople",
+    "person"      => "people",
+
+    "spokesman"   => "spokesmen",
+    "man"         => "men",
+    "woman"       => "women",
+
+    "basis"       => "bases",
+    "diagnosis"   => "diagnoses",
+    "diagnosis_a" => "diagnosis_as",
+
+    "datum"       => "data",
+    "medium"      => "media",
+    "stadium"     => "stadia",
+    "analysis"    => "analyses",
+    "my_analysis" => "my_analyses",
+
+    "node_child"  => "node_children",
+    "child"       => "children",
+
+    "experience"  => "experiences",
+    "day"         => "days",
+
+    "comment"     => "comments",
+    "foobar"      => "foobars",
+    "newsletter"  => "newsletters",
+
+    "old_news"    => "old_news",
+    "news"        => "news",
+
+    "series"      => "series",
+    "species"     => "species",
+
+    "quiz"        => "quizzes",
+
+    "perspective" => "perspectives",
+
+    "ox"          => "oxen",
+    "photo"       => "photos",
+    "buffalo"     => "buffaloes",
+    "tomato"      => "tomatoes",
+    "dwarf"       => "dwarves",
+    "elf"         => "elves",
+    "information" => "information",
+    "equipment"   => "equipment",
+    "bus"         => "buses",
+    "status"      => "statuses",
+    "status_code" => "status_codes",
+    "mouse"       => "mice",
+
+    "louse"       => "lice",
+    "house"       => "houses",
+    "octopus"     => "octopi",
+    "virus"       => "viri",
+    "alias"       => "aliases",
+    "portfolio"   => "portfolios",
+
+    "vertex"      => "vertices",
+    "matrix"      => "matrices",
+    "matrix_fu"   => "matrix_fus",
+
+    "axis"        => "axes",
+    "taxi"        => "taxis", # prevents regression
+    "testis"      => "testes",
+    "crisis"      => "crises",
+
+    "rice"        => "rice",
+    "shoe"        => "shoes",
+
+    "horse"       => "horses",
+    "prize"       => "prizes",
+    "edge"        => "edges",
+
+    "cow"         => "kine",
+    "database"    => "databases",
+
+    # regression tests against improper inflection regexes
+    "|ice"        => "|ices",
+    "|ouse"       => "|ouses",
+    "slice"       => "slices",
+    "police"      => "police"
+  }
+
+  CamelToUnderscore = {
+    "Product"               => "product",
+    "SpecialGuest"          => "special_guest",
+    "ApplicationController" => "application_controller",
+    "Area51Controller"      => "area51_controller"
+  }
+
+  UnderscoreToLowerCamel = {
+    "product"                => "product",
+    "special_guest"          => "specialGuest",
+    "application_controller" => "applicationController",
+    "area51_controller"      => "area51Controller"
+  }
+
+  SymbolToLowerCamel = {
+    :product                => 'product',
+    :special_guest          => 'specialGuest',
+    :application_controller => 'applicationController',
+    :area51_controller      => 'area51Controller'
+  }
+
+  CamelToUnderscoreWithoutReverse = {
+    "HTMLTidy"              => "html_tidy",
+    "HTMLTidyGenerator"     => "html_tidy_generator",
+    "FreeBSD"               => "free_bsd",
+    "HTML"                  => "html",
+  }
+
+  CamelWithModuleToUnderscoreWithSlash = {
+    "Admin::Product" => "admin/product",
+    "Users::Commission::Department" => "users/commission/department",
+    "UsersSection::CommissionDepartment" => "users_section/commission_department",
+  }
+
+  ClassNameToForeignKeyWithUnderscore = {
+    "Person" => "person_id",
+    "MyApplication::Billing::Account" => "account_id"
+  }
+
+  ClassNameToForeignKeyWithoutUnderscore = {
+    "Person" => "personid",
+    "MyApplication::Billing::Account" => "accountid"
+  }
+
+  ClassNameToTableName = {
+    "PrimarySpokesman" => "primary_spokesmen",
+    "NodeChild"        => "node_children"
+  }
+
+  StringToParameterized = {
+    "Donald E. Knuth"                     => "donald-e-knuth",
+    "Random text with *(bad)* characters" => "random-text-with-bad-characters",
+    "Allow_Under_Scores"                  => "allow_under_scores",
+    "Trailing bad characters!@#"          => "trailing-bad-characters",
+    "!@#Leading bad characters"           => "leading-bad-characters",
+    "Squeeze   separators"                => "squeeze-separators",
+    "Test with + sign"                    => "test-with-sign",
+    "Test with malformed utf8 \251"       => "test-with-malformed-utf8"
+  }
+
+  StringToParameterizeWithNoSeparator = {
+    "Donald E. Knuth"                     => "donaldeknuth",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Random text with *(bad)* characters" => "randomtextwithbadcharacters",
+    "Trailing bad characters!@#"          => "trailingbadcharacters",
+    "!@#Leading bad characters"           => "leadingbadcharacters",
+    "Squeeze   separators"                => "squeezeseparators",
+    "Test with + sign"                    => "testwithsign",
+    "Test with malformed utf8 \251"       => "testwithmalformedutf8"
+  }
+
+  StringToParameterizeWithUnderscore = {
+    "Donald E. Knuth"                     => "donald_e_knuth",
+    "Random text with *(bad)* characters" => "random_text_with_bad_characters",
+    "With-some-dashes"                    => "with-some-dashes",
+    "Retain_underscore"                   => "retain_underscore",
+    "Trailing bad characters!@#"          => "trailing_bad_characters",
+    "!@#Leading bad characters"           => "leading_bad_characters",
+    "Squeeze   separators"                => "squeeze_separators",
+    "Test with + sign"                    => "test_with_sign",
+    "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
+  }
+
+  StringToParameterizedAndNormalized = {
+    "Malmö"                               => "malmo",
+    "Garçons"                             => "garcons",
+    "Ops\331"                             => "opsu",
+    "Ærøskøbing"                          => "aeroskobing",
+    "Aßlar"                               => "asslar",
+    "Japanese: 日本語"                    => "japanese"
+  }
+
+  UnderscoreToHuman = {
+    "employee_salary" => "Employee salary",
+    "employee_id"     => "Employee",
+    "underground"     => "Underground"
+  }
+
+  MixtureToTitleCase = {
+    'active_record'         => 'Active Record',
+    'ActiveRecord'          => 'Active Record',
+    'action web service'    => 'Action Web Service',
+    'Action Web Service'    => 'Action Web Service',
+    'Action web service'    => 'Action Web Service',
+    'actionwebservice'      => 'Actionwebservice',
+    'Actionwebservice'      => 'Actionwebservice',
+    "david's code"          => "David's Code",
+    "David's code"          => "David's Code",
+    "david's Code"          => "David's Code",
+    "sgt. pepper's"         => "Sgt. Pepper's",
+    "i've just seen a face" => "I've Just Seen A Face",
+    "maybe you'll be there" => "Maybe You'll Be There",
+    "¿por qué?"             => '¿Por Qué?',
+    "Fred’s"                => "Fred’s",
+    "Fred`s"                => "Fred`s"
+  }
+
+  OrdinalNumbers = {
+    "-1" => "-1st",
+    "-2" => "-2nd",
+    "-3" => "-3rd",
+    "-4" => "-4th",
+    "-5" => "-5th",
+    "-6" => "-6th",
+    "-7" => "-7th",
+    "-8" => "-8th",
+    "-9" => "-9th",
+    "-10" => "-10th",
+    "-11" => "-11th",
+    "-12" => "-12th",
+    "-13" => "-13th",
+    "-14" => "-14th",
+    "-20" => "-20th",
+    "-21" => "-21st",
+    "-22" => "-22nd",
+    "-23" => "-23rd",
+    "-24" => "-24th",
+    "-100" => "-100th",
+    "-101" => "-101st",
+    "-102" => "-102nd",
+    "-103" => "-103rd",
+    "-104" => "-104th",
+    "-110" => "-110th",
+    "-111" => "-111th",
+    "-112" => "-112th",
+    "-113" => "-113th",
+    "-1000" => "-1000th",
+    "-1001" => "-1001st",
+    "0" => "0th",
+    "1" => "1st",
+    "2" => "2nd",
+    "3" => "3rd",
+    "4" => "4th",
+    "5" => "5th",
+    "6" => "6th",
+    "7" => "7th",
+    "8" => "8th",
+    "9" => "9th",
+    "10" => "10th",
+    "11" => "11th",
+    "12" => "12th",
+    "13" => "13th",
+    "14" => "14th",
+    "20" => "20th",
+    "21" => "21st",
+    "22" => "22nd",
+    "23" => "23rd",
+    "24" => "24th",
+    "100" => "100th",
+    "101" => "101st",
+    "102" => "102nd",
+    "103" => "103rd",
+    "104" => "104th",
+    "110" => "110th",
+    "111" => "111th",
+    "112" => "112th",
+    "113" => "113th",
+    "1000" => "1000th",
+    "1001" => "1001st"
+  }
+
+  UnderscoresToDashes = {
+    "street"                => "street",
+    "street_address"        => "street-address",
+    "person_street_address" => "person-street-address"
+  }
+
+  Irregularities = {
+    'person' => 'people',
+    'man'    => 'men',
+    'child'  => 'children',
+    'sex'    => 'sexes',
+    'move'   => 'moves',
+    'cow'    => 'kine',
+    'zombie' => 'zombies',
+    'genus'  => 'genera'
+  }
+end

data/spec/motion-support/core_ext/array/access_spec.rb

@@ -0,0 +1,29 @@
+describe 'array access' do
+  describe "from" do
+    it "should return the tail of an array from position" do
+      ['a', 'b', 'c', 'd'].from(0).should == ["a", "b", "c", "d"]
+      ['a', 'b', 'c', 'd'].from(2).should == ["c", "d"]
+      ['a', 'b', 'c', 'd'].from(10).should == []
+      [].from(0).should == []
+    end
+  end
+  
+  describe "to" do
+    it "should return the head of an array up to position" do
+      ['a', 'b', 'c', 'd'].to(0).should == ["a"]
+      ['a', 'b', 'c', 'd'].to(2).should == ["a", "b", "c"]
+      ['a', 'b', 'c', 'd'].to(10).should == ["a", "b", "c", "d"]
+      [].to(0).should == []
+    end
+  end
+  
+  describe "second" do
+    it "should return the second element in an array" do
+      ['a', 'b', 'c', 'd'].second.should == 'b'
+    end
+    
+    it "should return nil if there is no second element" do
+      [].second.should == nil
+    end
+  end
+end

data/spec/motion-support/core_ext/array/conversion_spec.rb

@@ -0,0 +1,60 @@
+describe 'array' do
+  describe "to_sentence" do
+    it "should convert plain array" do
+      [].to_sentence.should == ""
+      ['one'].to_sentence.should == "one"
+      ['one', 'two'].to_sentence.should == "one and two"
+      ['one', 'two', 'three'].to_sentence.should == "one, two, and three"
+    end
+    
+    it "should convert sentence with words connector" do
+      ['one', 'two', 'three'].to_sentence(:words_connector => ' ').should == "one two, and three"
+      ['one', 'two', 'three'].to_sentence(:words_connector => ' & ').should == "one & two, and three"
+      ['one', 'two', 'three'].to_sentence(:words_connector => nil).should == "onetwo, and three"
+    end
+    
+    it "should convert sentence with last word connector" do
+      ['one', 'two', 'three'].to_sentence(:last_word_connector => ', and also ').should == "one, two, and also three"
+      ['one', 'two', 'three'].to_sentence(:last_word_connector => nil).should == "one, twothree"
+      ['one', 'two', 'three'].to_sentence(:last_word_connector => ' ').should == "one, two three"
+      ['one', 'two', 'three'].to_sentence(:last_word_connector => ' and ').should == "one, two and three"
+    end
+    
+    it "should convert two-element array" do
+      ['one', 'two'].to_sentence.should == "one and two"
+      ['one', 'two'].to_sentence(:two_words_connector => ' ').should == "one two"
+    end
+    
+    it "should convert one-element array" do
+      ['one'].to_sentence.should == "one"
+    end
+    
+    it "should create new object" do
+      elements = ["one"]
+      elements.to_sentence.object_id.should.not == elements[0].object_id
+    end
+    
+    it "should convert non-string element" do
+      [1].to_sentence.should == '1'
+    end
+    
+    it "should not modify given hash" do
+      options = { words_connector: ' ' }
+      ['one', 'two', 'three'].to_sentence(options).should == "one two, and three"
+      options.should == { words_connector: ' ' }
+    end
+  end
+  
+  describe "to_s" do
+    it "should convert to database format" do
+      collection = [
+        Class.new { def id() 1 end }.new,
+        Class.new { def id() 2 end }.new,
+        Class.new { def id() 3 end }.new
+      ]
+
+      [].to_s(:db).should == "null"
+      collection.to_s(:db).should == "1,2,3"
+    end
+  end
+end

data/spec/motion-support/core_ext/array/extract_options_spec.rb

@@ -0,0 +1,15 @@
+describe 'array options' do
+  describe "extract_options!" do
+    it "should extract an options hash from an array" do
+      [1, 2, :a => :b].extract_options!.should == { :a => :b }
+    end
+    
+    it "should return an empty hash if the last element is not a hash" do
+      [1, 2].extract_options!.should == {}
+    end
+    
+    it "should return an empty hash on an empty array" do
+      [].extract_options!.should == {}
+    end
+  end
+end

data/spec/motion-support/core_ext/array/grouping_spec.rb

@@ -0,0 +1,85 @@
+describe 'array grouping' do
+  describe "in_groups_of" do
+    it "should group array and fill rest with nil" do
+      %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3).should == [
+        ["1", "2", "3"],
+        ["4", "5", "6"],
+        ["7", "8", "9"],
+        ["10", nil, nil]
+      ]
+    end
+    
+    it "should group array and fill with specified filler" do
+      %w(1 2 3 4 5).in_groups_of(2, 'empty').should == [
+        ["1", "2"],
+        ["3", "4"],
+        ["5", "empty"]
+      ]
+    end
+    
+    it "should not fill the last group if turned off" do
+      %w(1 2 3 4 5).in_groups_of(2, false).should == [
+        ["1", "2"],
+        ["3", "4"],
+        ["5"]
+      ]
+    end
+    
+    it "should yield each slice to a block if given" do
+      result = []
+      %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) { |group| result << ['foo'] + group + ['bar'] }
+      result.should == [
+        ["foo", "1", "2", "3", "bar"],
+        ["foo", "4", "5", "6", "bar"],
+        ["foo", "7", "8", "9", "bar"],
+        ["foo", "10", nil, nil, "bar"]
+      ]
+    end
+  end
+  
+  describe "in_groups" do
+    it "should group array and fill the rest with nil" do
+      %w(1 2 3 4 5 6 7 8 9 10).in_groups(3).should == [
+        ["1", "2", "3", "4"],
+        ["5", "6", "7", nil],
+        ["8", "9", "10", nil]
+      ]
+    end
+    
+    it "should group array and fill the result with specified filler" do
+      %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, 'empty').should == [
+        ["1", "2", "3", "4"],
+        ["5", "6", "7", "empty"],
+        ["8", "9", "10", "empty"]
+      ]
+    end
+    
+    it "should not fill the last group if turned off" do
+      %w(1 2 3 4 5 6 7).in_groups(3, false).should == [
+        ["1", "2", "3"],
+        ["4", "5"],
+        ["6", "7"]
+      ]
+    end
+    
+    it "should yield each slice to a block if given" do
+      result = []
+      %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) { |group| result << ['foo'] + group + ['bar'] }
+      result.should == [
+        ["foo", "1", "2", "3", "4", "bar"],
+        ["foo", "5", "6", "7", nil, "bar"],
+        ["foo", "8", "9", "10", nil, "bar"]
+      ]
+    end
+  end
+  
+  describe "split" do
+    it "should split array based on delimiting value" do
+      [1, 2, 3, 4, 5].split(3).should == [[1, 2], [4, 5]]
+    end
+    
+    it "should split array based on block result" do
+      (1..10).to_a.split { |i| i % 3 == 0 }.should == [[1, 2], [4, 5], [7, 8], [10]]
+    end
+  end
+end

data/spec/motion-support/core_ext/array/prepend_and_append_spec.rb

@@ -0,0 +1,25 @@
+describe 'array' do
+  describe "prepend" do
+    it "should add an element to the front of the array" do
+      [1, 2, 3].prepend(0).should == [0, 1, 2, 3]
+    end
+    
+    it "should change the array" do
+      array = [1, 2, 3]
+      array.prepend(0)
+      array.should == [0, 1, 2, 3]
+    end
+  end
+  
+  describe "append" do
+    it "should add an element to the back of the array" do
+      [1, 2, 3].append(4).should == [1, 2, 3, 4]
+    end
+    
+    it "should change the array" do
+      array = [1, 2, 3]
+      array.append(4)
+      array.should == [1, 2, 3, 4]
+    end
+  end
+end

data/spec/motion-support/core_ext/array/wrap_spec.rb

@@ -0,0 +1,19 @@
+describe 'array' do
+  describe "wrap" do
+    it "should return empty array for nil" do
+      Array.wrap(nil).should == []
+    end
+    
+    it "should return unchanged array for array" do
+      Array.wrap([1, 2, 3]).should == [1, 2, 3]
+    end
+    
+    it "should not flatten multidimensional array" do
+      Array.wrap([[1], [2], [3]]).should == [[1], [2], [3]]
+    end
+    
+    it "should turn simple object into array" do
+      Array.wrap(0).should == [0]
+    end
+  end
+end

data/spec/motion-support/{array_spec.rb → core_ext/array_spec.rb}

@@ -1,9 +1,4 @@
 describe 'array' do
-  it 'determines when an array is empty' do
-    [1, 2, 3].should.not.be.empty
-    [].should.be.empty
-  end
-
   it 'finds hash values' do
     array_of_hashes = [
       {

data/spec/motion-support/core_ext/class/attribute_accessor_spec.rb

@@ -0,0 +1,127 @@
+class CAttrAccessorBase
+  cattr_accessor :empty_accessor
+  cattr_accessor :base_accessor, :derived_accessor
+end
+
+class CAttrAccessorDerived < CAttrAccessorBase
+end
+
+describe "class" do
+  describe "attribute accessors" do
+    before do
+      @class = Class.new
+      @class.instance_eval do
+        cattr_accessor :foo
+        cattr_accessor :bar, :instance_writer => false
+        cattr_reader   :shaq, :instance_reader => false
+        cattr_accessor :camp, :instance_accessor => false
+      end
+      @object = @class.new
+    end
+    
+    describe "reader" do
+      it "should return nil by default" do
+        @class.foo.should.be.nil
+      end
+    end
+    
+    describe "writer" do
+      it "should set value" do
+        @class.foo = :test
+        @class.foo.should == :test
+      end
+      
+      it "should set value through instance writer" do
+        @object.foo = :bar
+        @object.foo.should == :bar
+      end
+      
+      it "should set instance reader's value through module's writer" do
+        @class.foo = :test
+        @object.foo.should == :test
+      end
+      
+      it "should set module reader's value through instances's writer" do
+        @object.foo = :bar
+        @class.foo.should == :bar
+      end
+    end
+    
+    describe "instance_writer => false" do
+      it "should not create instance writer" do
+        @class.should.respond_to :foo
+        @class.should.respond_to :foo=
+        @object.should.respond_to :bar
+        @object.should.not.respond_to :bar=
+      end
+    end
+    
+    describe "instance_reader => false" do
+      it "should not create instance reader" do
+        @class.should.respond_to :shaq
+        @object.should.not.respond_to :shaq
+      end
+    end
+  
+    describe "instance_accessor => false" do
+      it "should not create reader or writer" do
+        @class.should.respond_to :camp
+        @object.should.not.respond_to :camp
+        @object.should.not.respond_to :camp=
+      end
+    end
+  end
+  
+  describe "invalid attribute accessors" do
+    it "should raise NameError when creating an invalid reader" do
+      lambda do
+        Class.new do
+          cattr_reader "invalid attribute name"
+        end
+      end.should.raise NameError
+    end
+    
+    it "should raise NameError when creating an invalid writer" do
+      lambda do
+        Class.new do
+          cattr_writer "invalid attribute name"
+        end
+      end.should.raise NameError
+    end
+  end
+  
+  describe "inheritance" do
+    it "should be accessible in the base class and the derived class" do
+      CAttrAccessorBase.respond_to?(:empty_accessor).should == true
+      CAttrAccessorDerived.respond_to?(:empty_accessor).should == true
+    end
+  
+    it "should return nil for an unset accessor in the base class" do
+      CAttrAccessorBase.empty_accessor.should == nil
+    end
+  
+    it "should return nil for an unset accessor in the derived class" do
+      CAttrAccessorDerived.empty_accessor.should == nil
+    end
+  
+    it "should return a value for an accessor set in the base class in the base class" do
+      CAttrAccessorBase.base_accessor = 10
+      CAttrAccessorBase.base_accessor.should == 10
+    end
+  
+    it "should return a value for an accessor set in the base class in the derived class" do
+      CAttrAccessorBase.base_accessor = 10
+      CAttrAccessorDerived.base_accessor.should == 10
+    end
+  
+    it "should return a value for the base class if set for the derived class" do
+      CAttrAccessorDerived.derived_accessor = 20
+      CAttrAccessorBase.derived_accessor.should == 20
+    end
+  
+    it "should return a value for an accessor set in the derived class in the derived class" do
+      CAttrAccessorDerived.derived_accessor = 20
+      CAttrAccessorDerived.derived_accessor.should == 20
+    end
+  end
+end