set_builder 2.0.0.beta2 → 2.0.0.beta3

data/spec/lib/jspec.nodejs.js

@@ -4,9 +4,9 @@
 JSpec
 .include({
   name: 'node',
-  
+
   // --- Matchers
-  
+
   matchers : {
     have_enumerable_property: 'actual.propertyIsEnumerable(expected)',
     have_writable_property: 'Object.getOwnPropertyDescriptor(actual, expected).writable === true',

data/spec/lib/jspec.shell.js

@@ -2,29 +2,29 @@
 // JSpec - Shell - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
 
 ;(function(){
-  
+
   var _quit = quit
-  
+
   Shell = {
-    
+
     // --- Global
-    
+
     main: this,
-    
+
     // --- Commands
-    
+
     commands: {
       quit: ['Terminate the shell', function(){ _quit() }],
       exit: ['Terminate the shell', function(){ _quit() }],
       p: ['Inspect an object', function(o){ return o.toSource() }]
     },
-    
+
     /**
      * Start the interactive shell.
      *
      * @api public
      */
-    
+
     start : function() {
       for (var name in this.commands)
         if (this.commands.hasOwnProperty(name))
@@ -33,7 +33,7 @@
               this.main.__defineGetter__(name, this.commands[name][1])
     }
   }
-  
+
   Shell.start()
-  
-})()
+
+})()

data/spec/lib/jspec.timers.js

@@ -2,67 +2,67 @@
 // Mock Timers - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
 
 ;(function(){
-  
+
   /**
    * Localized timer stack.
    */
   var timers = [];
-  
+
   // nodejs, rhino don't have a window object
   var global = this;
-  
+
   // if they where mocked before this library is loaded - bad luck
   var savedGlobals = {
     setTimeout: global.setTimeout,
     setInterval: global.setInterval,
     clearInterval: global.clearInterval,
     clearTimeout: global.clearTimeout,
-    
+
     // those should not be globals, but are mocked none the less, so we save them
     resetTimers: global.resetTimers,
     tick: global.tick
   };
   var hadResetTimers = 'resetTimers' in global;
   var hadTick = 'tick' in global;
-  
+
   function forEachProperty(anObject, aClosure) {
     for (var key in anObject) {
       if ( ! anObject.hasOwnProperty(key))
         continue;
-      
+
       aClosure(key, anObject[key]);
     }
   }
-  
+
   global.MockTimers = {
-    
+
     mockTimersVersion: '2.0.0',
-    
+
     mockGlobalTimerFunctions: function() {
       forEachProperty(this.mocks, function(aName, aFunction) {
         global[aName] = aFunction;
       });
     },
-    
+
     unmockGlobalTimerFunctions: function() {
       forEachProperty(this.savedGlobals, function(aName, aFunction) {
         global[aName] = aFunction;
       });
-      
+
       if ( ! hadResetTimers)
         delete global['resetTimers'];
       if ( ! hadTick)
         delete global['tick'];
-      
+
     }
   };
-  
+
   function clearTimer(id) {
     return delete timers[--id];
   }
-  
+
   var mocks = {
-    
+
     /**
      * Set mock timeout with _callback_ and timeout of _ms_.
      *
@@ -95,7 +95,7 @@
       timers[timers.length] = callback;
       return timers.length;
     },
-    
+
     /**
      * Destroy timer with _id_.
      *
@@ -106,7 +106,7 @@
     clearInterval: clearTimer,
     clearTimeout: clearTimer
   };
-  
+
   // additional functions that are not originally in the global namespace
   /**
    * Reset timers.
@@ -117,7 +117,7 @@
   mocks.resetTimers = function() {
     return timers = [];
   };
-  
+
   /**
    * Increment each timers internal clock by _ms_.
    *
@@ -128,10 +128,10 @@
     for (var i = 0, len = timers.length; i < len; ++i) {
       if ( ! timers[i] || ! (timers[i].current += ms))
         continue;
-      
+
       if (timers[i].current - timers[i].last < timers[i].step)
         continue;
-      
+
       var times = Math.floor((timers[i].current - timers[i].last) / timers[i].step);
       var remainder = (timers[i].current - timers[i].last) % timers[i].step;
       timers[i].last = timers[i].current - remainder;
@@ -139,10 +139,10 @@
         timers[i]();
     }
   };
-  
+
   // make them available publicly
   MockTimers.mocks = mocks;
-  
+
   JSpec.include({
     beforeSpec: function(){
       MockTimers.mockGlobalTimerFunctions();
@@ -151,4 +151,4 @@
       MockTimers.unmockGlobalTimerFunctions();
     }
   });
-})();
+})();

data/spec/rhino.js

@@ -7,4 +7,4 @@ load('spec/unit/spec.helper.js')
 JSpec
 .exec('spec/unit/spec.js')
 .run({ reporter: JSpec.reporters.Terminal, fixturePath: 'spec/fixtures' })
-.report()
+.report()

data/spec/server.rb

@@ -1,4 +1,4 @@
 
 get '/lib/*' do |path|
   send_file File.dirname(__FILE__) + '/../lib/' + path
-end
+end

data/spec/unit/array.spec.js

@@ -4,20 +4,20 @@ describe 'Array'
     it 'should return an empty string if you pass a 0-length array'
       expect([].toSentence()).to(be, '');
     end
-    
+
     it 'should return the lone value if you pass a 1-length array'
       expect(['banana'].toSentence()).to(be, 'banana');
     end
-    
+
     it 'should concatenate only using "and" if you pass a 2-length array'
       expect(['apple', 'banana'].toSentence()).to(be, 'apple and banana');
     end
-    
+
     it 'should use different concatenators for a 3+-length array'
       expect(['apple', 'banana', 'chocolate'].toSentence()).to(be, 'apple, banana, and chocolate');
     end
   end
-  
+
   describe '.dup'
     it 'should create an independently modifiable array'
       var a = [1, 2, 3];
@@ -27,7 +27,7 @@ describe 'Array'
       expect(b.length).to(be, 3);
     end
   end
-  
+
   describe '.each'
     it 'should correctly work through this array of arrays'
       var i = 0;
@@ -42,7 +42,7 @@ describe 'Array'
       expect(i).to(be, 4);
     end
   end
-  
+
   describe '.inject'
     it 'should count 4 objects in [12,32,12,11]'
       expect([12,32,12,11].inject(0, function(i, item) {
@@ -58,7 +58,7 @@ describe 'Array'
       })).to(eql, ["big", "angry", "words"]);
     end
   end
-  
+
   describe '.find'
     it 'should return the first word with an "a" in it'
       expect(["not", "me", "what?", "me"].find(function(word) {
@@ -66,7 +66,7 @@ describe 'Array'
       })).to(be, "what?")
     end
   end
-      
+
   describe '.select'
       it 'should return all members of the array where fn(member) is true'
         expect(["this", "nope", "that", "this"].select(function(word){
@@ -74,7 +74,7 @@ describe 'Array'
         })).to(eql, ["this", "this"]);
       end
   end
-  
+
 end
 
 

data/spec/unit/set_builder.spec.js

@@ -2,25 +2,32 @@ describe 'SetBuilder'
   before_each
 
     SetBuilder.registerTraits([
-      [['string','who are'],
-        ['negative','not'],
-        ['name','awesome']],
-       [['string','who'],
-        ['negative','have not'],
-        ['name','died']],
-       [['string','who were'],
-        ['name','born'],
-        ['modifier','date']],
-       [['string','whose'],
-        ['name','age'],
-        ['modifier','number']],
-       [['string','who have'],
-        ['negative','not'],
-        ['name','attended'],
-        ['direct_object_type','school']],
-       [['string','whose'],
-        ['name','name'],
-        ['modifier','string']]
+      [["string","who "],
+       ["enum",["are","are not"]],
+       ["string", " "],
+       ["name","awesome"]],
+      [["string","who "],
+       ["enum",["have","have not"]],
+       ["string", " "],
+       ["name","died"]],
+      [["string","who were "],
+       ["name","born"],
+       ["string", " "],
+       ["modifier","date"]],
+      [["string","whose "],
+       ["name","age"],
+       ["string", " "],
+       ["modifier","number"]],
+      [["string","who "],
+       ["enum",["have","have not"]],
+       ["string", " "],
+       ["name","attended"],
+       ["string", " "],
+       ["direct_object_type","school"]],
+      [["string","whose "],
+       ["name","name"],
+       ["string", " "],
+       ["modifier","string"]]
     ]);
 
     SetBuilder.registerModifiers({
@@ -31,103 +38,86 @@ describe 'SetBuilder'
         is: ['string']
       }
     });
-    
+
     SetBuilder.registerValueMap('school', [['1','Concordia'], ['2','McKendree']]);
-    
+
     set_data = [
-      ['awesome'],
-      ['attended', 2],
-      ['died'],
-      ['name', {'is': "Jerome"}]
+      { trait: 'awesome', enums: ['are'] },
+      { trait: 'attended', enums: ['have'], school: 2 },
+      { trait: 'died', enums: ['have'] },
+      { trait: 'name', modifiers: [
+        { operator: 'is', values: ['Jerome'] }] }
     ];
-    
+
     set_data_hash = {
-      '0': {
-        trait: 'awesome'
-      },
-      '1': {
-        trait: 'attended',
-        direct_object: 2
-      },
-      '2': {
-        trait: 'died'
-      },
-      '3': {
-        trait: 'name',
-        modifiers: {
-          '0': {
-            operator: 'is',
-            values: {
-              '0': 'Jerome'
-            }
-          }
-        }
-      }
+      '0': { trait: 'awesome', enums: {'0': 'are'} },
+      '1': { trait: 'attended', enums: {'0': 'have'}, school: 2 },
+      '2': { trait: 'died', enums: {'0': 'have'} },
+      '3': { trait: 'name', modifiers: {
+        '0': { operator: 'is', values: {'0': 'Jerome'} } } }
     };
   end
-  
-  
-  
-  
+
+
+
+
   describe '.getValueMap'
     it 'should return an array of arrays'
       expect(SetBuilder.getValueMap('school')).to(eql, [['1','Concordia'], ['2','McKendree']]);
     end
   end
-  
+
   describe '.getValue'
     it 'should return a value based on the key and name'
       expect(SetBuilder.getValue('school', 1)).to(be, 'Concordia')
       expect(SetBuilder.getValue('school', '1')).to(be, 'Concordia')
     end
-    
+
     it 'should return what it was passed if there is no value map for the key'
       expect(SetBuilder.getValue('band', 1)).to(be, 1)
     end
   end
-  
+
   describe '.getValueMaps'
     it 'should return the names of the value maps registered'
       expect(SetBuilder.getValueMaps()).to(eql, ['school']);
     end
   end
-  
-  
-  
+
+
+
   describe '.Trait'
-  
     describe '.constructor'
       it 'should correctly parse the name of the trait'
         var trait = new SetBuilder.Trait([['string', 'who are'], ['name', 'awesome']]);
         expect(trait.name()).to(be, 'awesome');
       end
-    
+
       it 'should correctly identify when it expects a direct objects'
         var trait = new SetBuilder.Trait([['string', 'who have'], ['name', 'attended'], ['direct_object_type', 'string']]);
         expect(trait.requiresDirectObject()).to(be, true);
       end
-    
+
       it 'should correctly parse paramters with modifiers'
         var trait = new SetBuilder.Trait([['string', 'who were'], ['name', 'born'], ['modifier', 'date']]);
         expect(trait.modifiers().length).to(be, 1);
       end
     end
-    
   end
-  
-  
-  
+
+
+
   describe '.Traits'
     before_each
       traits = SetBuilder.traits();
     end
-  
+
     describe '.length'
       it 'should have parsed the data structure correctly'
         expect(traits.length()).to(be, 6);
       end
     end
-  
+
     describe '.find'
       it 'should get a SetBuilder.Trait object by name'
         expect(traits.__find('awesome').name()).to(eql, 'awesome');
@@ -137,7 +127,7 @@ describe 'SetBuilder'
         expect(traits.__find('name').name()).to(eql,    'name');
       end
     end
-    
+
   end
 
 
@@ -159,22 +149,22 @@ describe 'SetBuilder'
         expect(modifiers.operators_for('string')).to(eql, expected_modifiers);
       end
     end
-
   end
-  
+
+
+
   describe '.Set'
-    
     describe '.constraints'
       it 'should have parsed the correct number of objects'
         var set = new SetBuilder.Set(set_data);
         expect(set.constraints().length).to(be, 4);
       end
-        
+
       it 'should parse hash-style objects as well as arrays'
         var set = new SetBuilder.Set(set_data_hash);
         expect(set.constraints().length).to(be, 4);
       end
-        
+
       it 'should consider two sets with identical constraints equal'
         var set1 = new SetBuilder.Set(set_data);
         var set2 = new SetBuilder.Set(set_data_hash);
@@ -182,31 +172,30 @@ describe 'SetBuilder'
         expect(set2.isEqualTo(set1)).to(be, true);
       end
     end
-  
+
     describe '.toString'
       it 'should generate the natural language description of a simple set'
-        var simple_set = new SetBuilder.Set([['awesome']]);
+        var simple_set = new SetBuilder.Set([{ trait: 'awesome', enums: {'0': 'are'} }]);
         expect(simple_set.toString()).to(eql, 'who are awesome');
       end
-      
+
       it 'should generate the natural language description of a complex set'
         var set = new SetBuilder.Set(set_data);
-        var expected_string = 'who are awesome, who have attended McKendree, who died, and whose name is Jerome'
+        var expected_string = 'who are awesome, who have attended McKendree, who have died, and whose name is Jerome'
         expect(set.toString()).to(be, expected_string);
       end
 
       it 'should generate the natural language description of a complex set with negation (NB: nouns are not negated)'
         var set = new SetBuilder.Set([
-          ['!awesome'],
-          ['!attended', 1],
-          ['!died'],
-          ['!name', {'is': "Jerome"}]
+          { trait: 'awesome', enums: ['are not'] },
+          { trait: 'attended', enums: ['have not'], school: 1 },
+          { trait: 'died', enums: ['have not'] },
+          { trait: 'name', modifiers: [{ operator: 'is', values: ['Jerome'] }] }
         ]);
         var expected_string = 'who are not awesome, who have not attended Concordia, who have not died, and whose name is Jerome'
         expect(set.toString()).to(eql, expected_string);
       end
     end
-    
+
   end
 end
-

data/spec/unit/spec.helper.js

@@ -0,0 +1 @@
+

data/test/constraint_test.rb

@@ -0,0 +1,84 @@
+require "test_helper"
+
+class ConstraintTest < ActiveSupport::TestCase
+  include SetBuilder
+
+
+  test "constraints find correct modifiers" do
+    trait = $friend_traits[:name]
+    assert_equal 1, trait.modifiers.length
+
+    constraint = trait.apply({modifiers: [{ operator: :is, values: ["Jerome"] }]})
+    assert_equal 1, constraint.modifiers.length
+    assert_kind_of Modifiers::StringPreposition, constraint.modifiers.first
+  end
+
+  test "modifiers should find correct values" do
+    trait = $friend_traits[:name]
+    constraint = trait.apply({modifiers: [{ operator: :is, values: ["Jerome"] }]})
+    modifier = constraint.modifiers.first
+    assert_equal :is, modifier.operator
+    assert_equal ["Jerome"], modifier.values
+  end
+
+  test "constraint should be valid" do
+    trait = $friend_traits[:name]
+    constraint = trait.apply({modifiers: [{ operator: :is, values: ["Jerome"] }]})
+    assert constraint.valid?
+  end
+
+
+
+  context "A constraint" do
+    should "be invalid if it is missing a direct object" do
+      trait = Trait.new('who "attended" :school')
+      constraint = trait.apply({})
+      assert_match /school is blank/, constraint.errors.join
+    end
+
+    should "be invalid if it is missing an enumeration" do
+      trait = Trait.new('who [is|is not] "awesome"')
+      constraint = trait.apply({})
+      assert_match /should have values for 1 enums/, constraint.errors.join
+    end
+
+    should "be invalid if it supplies an unexpected value for an enumeration" do
+      trait = Trait.new('who [is|is not] "awesome"')
+      constraint = trait.apply(enums: ["is totally"])
+      assert_match /should be 'is' or 'is not'/, constraint.errors.join
+    end
+
+    should "be invalid if it supplies an unexpected value for a modifier's operator" do
+      trait = Trait.new('whose "name" <string>')
+      constraint = trait.apply(modifiers: [{ operator: "starts_with", values: ["Jer"] }])
+      assert_match /should be :contains, :does_not_contain, :begins_with, :does_not_begin_with, :ends_with, :does_not_end_with, :is, or :is_not/, constraint.errors.join
+    end
+  end
+
+
+
+  context "#to_s" do
+    should "carry over arbitrary text in the trait definition" do
+      trait = Trait.new('who "died", tragically')
+      assert_equal "who died, tragically", trait.apply({}).to_s
+    end
+
+    should "interpolate direct objects" do
+      trait = Trait.new('who "attended" :school')
+      assert_equal "who attended Concordia", trait.apply({school: 1}).to_s
+    end
+
+    should "interpolate modifiers" do
+      trait = Trait.new('who was "born" <date>')
+      assert_equal "who was born on 2016-01-01", trait.apply({
+        modifiers: [{ operator: "on", values: ["2016-01-01"] }] }).to_s
+    end
+
+    should "interpolate enums" do
+      trait = Trait.new('who [was|was not] "born" in [Russia|Ukraine]')
+      assert_equal "who was born in Ukraine", trait.apply({enums: ["was", "Ukraine"] }).to_s
+    end
+  end
+
+
+end

data/test/date_preposition_test.rb

@@ -1,13 +1,23 @@
-require 'test_helper'
+require "test_helper"
 
 class DatePrepositionTest < ActiveSupport::TestCase
   include SetBuilder::Modifiers
-  
-  
+
+  attr_reader :table
+
+  setup do
+    @table = Arel::Table.new(:people)
+  end
+
+
   test "should constrain our date queries to A.D." do
-    modifier = DatePreposition.new({:in_the_last => [Date.today.year, "years"]})
-    assert_equal "x>='0001-01-01'", modifier.build_conditions_for("x")
+    Timecop.freeze do
+      time = 5.years.ago
+      modifier = DatePreposition.new(operator: :in_the_last, values: [5, "years"])
+      assert_equal "\"people\".\"birthday\" >= '#{time}'",
+        modifier.build_arel_for(table[:birthday]).to_sql
+    end
   end
-  
-  
+
+
 end