set_builder 2.0.0.beta2 → 2.0.0.beta3

data/test/modifier_test.rb

@@ -1,9 +1,34 @@
-require 'test_helper'
+require "test_helper"
 
 class ModifierTest < ActiveSupport::TestCase
   include SetBuilder::Modifiers
 
 
+
+  test "should be valid if `values` is omitted for an operator that expects no arguments" do
+    preposition = SetBuilder::Modifiers::DatePreposition.new(operator: "ever", values: [])
+    assert_equal [], preposition.values
+    assert preposition.valid?
+
+    preposition = SetBuilder::Modifiers::DatePreposition.new(operator: "ever")
+    assert_equal [], preposition.values
+    assert preposition.valid?
+  end
+
+  test "should not flatten double-wrapped `values`" do
+    preposition = SetBuilder::Modifiers::DatePreposition.new(operator: "on", values: [["2015-01-01"]])
+    assert_equal [["2015-01-01"]], preposition.values
+    assert preposition.valid?
+  end
+
+  test "should be valid if `values` is not wrapped in an array" do
+    preposition = SetBuilder::Modifiers::DatePreposition.new(operator: "on", values: "2015-01-01")
+    assert_equal ["2015-01-01"], preposition.values
+    assert preposition.valid?
+  end
+
+
+
   test "get type with string" do
     assert_equal StringPreposition, SetBuilder::Modifier["StringPreposition"]
   end

data/test/set_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class SetTest < ActiveSupport::TestCase
 
@@ -6,49 +6,79 @@ class SetTest < ActiveSupport::TestCase
 
   test "set data struture" do
     set = to_set [
-      [: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"] }] }]
     assert set.valid?
-    assert_equal "who are awesome, who have attended McKendree, who died, and whose name is Jerome", set.to_s
+    assert_equal "who are awesome, who have attended McKendree, who have died, and whose name is Jerome", set.to_s
+  end
+
+  test "parsing sets that come from HTML" do
+    set = to_set({
+      "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"} }} } })
+    assert set.valid?
+    assert_equal "who are awesome, who have attended McKendree, who have died, and whose name is Jerome", set.to_s
+  end
+
+  test "normalizing sets" do
+    expected_constraints = [
+      { trait: "awesome", enums: ["are"] },
+      { trait: "attended", enums: ["have"], school: 2 },
+      { trait: "died", enums: ["have"] },
+      { trait: "name", modifiers: [{ operator: "is", values: ["Jerome"] }] }]
+    set = to_set({
+      "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"} }} } })
+    assert_equal expected_constraints, set.to_a
+  end
+
+  test "normalize should handle nil" do
+    assert_equal [], SetBuilder::Set.normalize(nil)
   end
 
   test "sets with invalid modifiers should be invalid" do
-    set = to_set [[:born, {:after => ["wrong"]}]]
+    set = to_set [{ trait: :born, modifiers: [{ operator: :after, values: ["wrong"] }] }]
     assert_equal false, set.valid?
   end
 
   test "sets should not allow non-numbers in a number modifiers" do
-    set = to_set [[:age, {:is => ["12a"]}]]
+    set = to_set [{ trait: :age, modifiers: [{ operator: :is, values: ["12a"] }] }]
     refute set.valid?
+    assert_match /"12a" is not a valid number/, set.errors.values.join(", ")
   end
 
   test "sets should not allow empty string in a number modifiers" do
-    set = to_set [[:age, {:is => [""]}]]
+    set = to_set [{ trait: :age, modifiers: [{ operator: :is, values: [""] }] }]
     refute set.valid?
+    assert_match /number is blank/, set.errors.values.join(", ")
   end
 
   test "sets lacking expected modifiers should be invalid" do
-    set = to_set [[:born, {:ever => []}]]
+    set = to_set [{ trait: :born, modifiers: [{ operator: :ever, values: [] }] }]
     assert_equal true, set.valid?
 
-    set = to_set [[:born]]
+    set = to_set [{ trait: :born }]
     assert_equal false, set.valid?
   end
 
   test "set structure with negations (nouns are ignored)" do
     set = to_set [
-      ["!awesome"],
-      ["!attended", 2],
-      ["!died"],
-      ["!name", {:is => "Jerome"}]]
+      { trait: "awesome", enums: ["are not"] },
+      { trait: "attended", enums: ["have not"], school: 2 },
+      { trait: "died", enums: ["have not"] },
+      { trait: "name", modifiers: [{ operator: :is, values: ["Jerome"] }] }]
     assert set.valid?
     assert_equal "who are not awesome, who have not attended McKendree, who have not died, and whose name is Jerome", set.to_s
   end
 
   test "simple perform" do
-    set = to_set [[:awesome]]
+    set = to_set [{ trait: "awesome", enums: ["are"] }]
 
     expected_results = [{:conditions => {:awesome => true}}]
     assert_equal expected_results, set.perform
@@ -56,27 +86,20 @@ class SetTest < ActiveSupport::TestCase
 
   test "complex perform" do
     set = to_set [
-      [:awesome],
-      [:attended, 1],
-      [:died],
-      [:name, {:begins_with => "Jerome"}]]
+      { trait: "awesome", enums: ["are"] },
+      { trait: "attended", enums: ["have"], school: 1 },
+      { trait: "died", enums: ["have"] },
+      { trait: "name", modifiers: [{ operator: :begins_with, values: ["Jer"] }] }]
 
     expected_results = [
       {:conditions => {:awesome => true}},
       {:joins => "INNER JOIN schools ON friends.school_id=schools.id", :conditions => {"schools.id" => 1}},
       {:conditions => {:alive => false}},
-      {:conditions => ["friends.name LIKE ?", "Jerome%"]}
+      {:conditions => "\"friends\".\"name\" LIKE 'Jer%'"}
     ]
     assert_equal expected_results, set.perform
   end
 
-  test "invalid set" do
-    set = to_set [[:name, {:starts_with => "Jerome"}]]  # starts_with is not a valid operator
-
-    # !todo: what to do?
-    skip "TODO: test invalid sets"
-  end
-
 
 private
 

data/test/string_preposition_test.rb

@@ -1,19 +1,20 @@
-require 'test_helper'
+require "test_helper"
 
 class StringPrepositionTest < ActiveSupport::TestCase
   include SetBuilder::Modifiers
-  
+
   attr_reader :table
-  
+
   setup do
     @table = Arel::Table.new(:fruits)
   end
-  
-  
+
+
   test "#build_arel_for should generate the correct SQL" do
-    modifier = StringPreposition.new({:does_not_contain => ["banana"]})
-    assert_equal "\"fruits\".\"name\" NOT LIKE '%banana%'", modifier.build_arel_for(table[:name]).to_sql
+    modifier = StringPreposition.new(operator: :does_not_contain, values: ["banana"])
+    assert_equal "(\"fruits\".\"name\" IS NULL OR \"fruits\".\"name\" NOT LIKE '%banana%')",
+      modifier.build_arel_for(table[:name]).to_sql
   end
-  
-  
+
+
 end

data/test/test_helper.rb

@@ -3,8 +3,10 @@ require "rails"
 require "rails/test_help"
 require "active_support/core_ext"
 require "set_builder"
+require "shoulda/context"
 require "pry"
 require "support/fake_connection"
+require "timecop"
 
 require "minitest/reporters"
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
@@ -13,25 +15,27 @@ Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 
 SetBuilder::ValueMap.register(:school, [[1, "Concordia"], [2, "McKendree"]])
 
+friends = Arel::Table.new(:friends)
+
 $friend_traits = SetBuilder::Traits.new do
 
-  trait('who are [not] "awesome"') do |query, scope|
+  trait('who [are|are not] "awesome"') do |query, scope|
     scope << {:conditions => {:awesome => true}}
   end
 
-  trait('who [have not] "died"') do |query, scope|
+  trait('who [have|have not] "died"') do |query, scope|
     scope << {:conditions => {:alive => false}}
   end
 
   trait('who were "born" <date>') do |query, scope|
-    scope << {:conditions => query.modifiers[0].build_conditions_for("friends.birthday")}
+    scope << {:conditions => query.modifiers[0].build_arel_for(friends[:birthday]).to_sql}
   end
 
   trait('whose "age" <number>') do |query, scope|
-    scope << {:conditions => query.modifiers[0].build_conditions_for("friends.age")}
+    scope << {:conditions => query.modifiers[0].build_arel_for(friends[:age]).to_sql}
   end
 
-  trait('who have [not] "attended" :school') do |query, scope|
+  trait('who [have|have not] "attended" :school') do |query, scope|
     scope << {
       :joins => "INNER JOIN schools ON friends.school_id=schools.id",
       :conditions => {"schools.id" => query.direct_object}
@@ -39,7 +43,7 @@ $friend_traits = SetBuilder::Traits.new do
   end
 
   trait('whose "name" <string>') do |query, scope|
-    scope << {:conditions => query.modifiers[0].build_conditions_for("friends.name")}
+    scope << {:conditions => query.modifiers[0].build_arel_for(friends[:name]).to_sql}
   end
 end
 
@@ -53,17 +57,15 @@ class Friend
 
 
   # Stubs so that Arel can SQL
+  class << self
+    attr_accessor :connection_pool
 
-  attr_accessor :connection_pool
-
-  def initialize
-    @connection_pool = Fake::ConnectionPool.new
-  end
-
-  def connection
-    connection_pool.connection
+    def connection
+      connection_pool.connection
+    end
   end
+  @connection_pool = Fake::ConnectionPool.new
 
 end
 
-Arel::Table.engine = Arel::Sql::Engine.new(Friend.new)
+Arel::Table.engine = Friend

data/test/trait_test.rb

@@ -1,42 +1,61 @@
-require 'test_helper'
+require "test_helper"
 
 class TraitTest < ActiveSupport::TestCase
-  include SetBuilder::Modifiers
+  include SetBuilder
 
 
-  test "constraints find correct modifiers" do
-    trait = $friend_traits[:name]
-    assert_equal 1, trait.modifiers.length
+  context "When defining a trait, it" do
+    should "strip any leading or trailing whitespace" do
+      assert_equal 'who "died"', Trait.new(' who "died" ').to_s
+    end
 
-    constraint = trait.apply({:is => "Jerome"})
-    assert_equal 1, constraint.modifiers.length
-    assert_kind_of StringPreposition, constraint.modifiers.first
-  end
+    should "take the quoted part of the string as the trait name" do
+      assert_equal "died", Trait.new('who "died"').name
+    end
 
-  test "modifiers should find correct values" do
-    trait = $friend_traits[:name]
-    modifier = trait.apply({:is => "Jerome"}).modifiers.first
-    assert_equal :is, modifier.operator
-    assert_equal ["Jerome"], modifier.values
-  end
+    should "not allow you to define more than one trait name" do
+      assert_raise(ArgumentError) { Trait.new('who "died" "allegedly"') }
+    end
 
-  test "traits correctly expect direct objects" do
-    trait_requires_direct_object = {
-      :awesome => false,
-      :born => false,
-      :attended => true,
-      :died => false,
-      :name => false
-    }
-    trait_requires_direct_object.each do |trait, expected_value|
-      assert_equal expected_value, $friend_traits[trait].requires_direct_object?
+    should "not required you to define a trait name" do
+      assert_raise(ArgumentError) { Trait.new('who died') }
     end
-  end
 
-  test "constraint should be valid" do
-    trait = $friend_traits[:name]
-    constraint = trait.apply({:is => "Jerome"})
-    assert constraint.valid?
+    should "assume that it doesn't expect a direct object" do
+      refute Trait.new('who "attended"').requires_direct_object?
+    end
+
+    should "take a word prefixed with ':' as the type of the direct object" do
+      trait = Trait.new('who "attended" :school')
+      assert_equal :school, trait.direct_object_type
+      assert trait.requires_direct_object?
+    end
+
+    should "not allow you to define more than one direct object" do
+      assert_raise(ArgumentError) { Trait.new('who "attended" :school :university') }
+    end
+
+    should "have no enums unless defined" do
+      assert_equal 0, Trait.new('who "died"').enums.length
+    end
+
+    should "take bracketed text as a built-in set of alternatives" do
+      trait = Trait.new('who [have|have not] "died"')
+      assert_equal [["have", "have not"]], trait.enums
+    end
+
+    should "require you to define at least two alternatives" do
+      assert_raise(ArgumentError) { Trait.new('who [have not] "died"') }
+    end
+
+    should "take words wrapped in angle brackets as modifiers" do
+      trait = Trait.new('who were "born" <date>')
+      assert_equal [Modifiers::DatePreposition], trait.modifiers
+    end
+
+    should "raise an exception if a modifier isn't defined" do
+      assert_raise(ArgumentError) { Trait.new('who were "born" <nope>') }
+    end
   end
 
 

data/test/traits_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class TraitsTest < ActiveSupport::TestCase
   include SetBuilder::Modifiers
@@ -27,53 +27,58 @@ class TraitsTest < ActiveSupport::TestCase
     assert_equal expected_modifiers, $friend_traits.modifiers.collect(&:name).sort
   end
 
-  test "two collections of traits can be concatenated with `+`" do
-    traits1 = SetBuilder::Traits.new do
-      trait('who are [not] "awesome"') { |query, scope| }
-    end
-
-    traits2 = SetBuilder::Traits.new do
-      trait('who are [not] "living"') { |query, scope| }
-    end
 
-    combined_traits = traits1 + traits2
-    assert_kind_of SetBuilder::Traits, combined_traits
-    assert_equal %w{awesome living}, combined_traits.map(&:name)
-  end
+  context "two collections of traits" do
+    setup do
+      @traits1 = SetBuilder::Traits.new do
+        trait('who are "awesome"') { |query, scope| }
+      end
 
-  test "two collections of traits can be concatenated with `concat`" do
-    traits1 = SetBuilder::Traits.new do
-      trait('who are [not] "awesome"') { |query, scope| }
+      @traits2 = SetBuilder::Traits.new do
+        trait('who are "living"') { |query, scope| }
+      end
     end
 
-    traits2 = SetBuilder::Traits.new do
-      trait('who are [not] "living"') { |query, scope| }
+    should "be concatenatable with `+`" do
+      combined_traits = @traits1 + @traits2
+      assert_kind_of SetBuilder::Traits, combined_traits
+      assert_equal %w{awesome living}, combined_traits.map(&:name)
     end
 
-    combined_traits = traits1.concat traits2
-    assert_kind_of SetBuilder::Traits, combined_traits
-    assert_equal %w{awesome living}, combined_traits.map(&:name)
+    should "be concatenatable with `concat`" do
+      combined_traits = @traits1.concat @traits2
+      assert_kind_of SetBuilder::Traits, combined_traits
+      assert_equal %w{awesome living}, combined_traits.map(&:name)
+    end
   end
 
+
   test "to_json" do
-    expected_json = [[["string","who are"],
-      ["negative","not"],
+    expected_json = [[["string","who "],
+      ["enum",["are","are not"]],
+      ["string", " "],
       ["name","awesome"]],
-     [["string","who"],
-      ["negative","have not"],
+     [["string","who "],
+      ["enum",["have","have not"]],
+      ["string", " "],
       ["name","died"]],
-     [["string","who were"],
+     [["string","who were "],
       ["name","born"],
+      ["string", " "],
       ["modifier","date"]],
-     [["string","whose"],
+     [["string","whose "],
       ["name","age"],
+      ["string", " "],
       ["modifier","number"]],
-     [["string","who have"],
-      ["negative","not"],
+     [["string","who "],
+      ["enum",["have","have not"]],
+      ["string", " "],
       ["name","attended"],
+      ["string", " "],
       ["direct_object_type","school"]],
-     [["string","whose"],
+     [["string","whose "],
       ["name","name"],
+      ["string", " "],
       ["modifier","string"]]].to_json
     assert_equal expected_json, $friend_traits.to_json
   end

data/test/value_map_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class ValueMapTest < ActiveSupport::TestCase
 

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: set_builder
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.beta3
 platform: ruby
 authors:
 - Bob Lail
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-25 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.1'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.1'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -100,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
@@ -114,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem for describing constraints on data sets
 email:
 - bob.lailfamily@gmail.com
@@ -133,6 +155,7 @@ files:
 - lib/set_builder.rb
 - lib/set_builder/constraint.rb
 - lib/set_builder/engine.rb
+- lib/set_builder/errors/trait_not_found.rb
 - lib/set_builder/modifier.rb
 - lib/set_builder/modifier/adverb.rb
 - lib/set_builder/modifier/base.rb
@@ -142,7 +165,6 @@ files:
 - lib/set_builder/modifiers/date_preposition.rb
 - lib/set_builder/modifiers/number_preposition.rb
 - lib/set_builder/modifiers/string_preposition.rb
-- lib/set_builder/query_builders/string.rb
 - lib/set_builder/set.rb
 - lib/set_builder/trait.rb
 - lib/set_builder/trait_builder.rb
@@ -173,8 +195,8 @@ files:
 - spec/unit/array.spec.js
 - spec/unit/set_builder.spec.js
 - spec/unit/spec.helper.js
+- test/constraint_test.rb
 - test/date_preposition_test.rb
-- test/inflector_test.rb
 - test/modifier_test.rb
 - test/set_test.rb
 - test/string_preposition_test.rb
@@ -233,8 +255,8 @@ test_files:
 - spec/unit/array.spec.js
 - spec/unit/set_builder.spec.js
 - spec/unit/spec.helper.js
+- test/constraint_test.rb
 - test/date_preposition_test.rb
-- test/inflector_test.rb
 - test/modifier_test.rb
 - test/set_test.rb
 - test/string_preposition_test.rb

data/test/inflector_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-class InflectorTest < ActiveSupport::TestCase
-
-
-  test "active" do
-    assert_equal "who died", SetBuilder::Trait.new('who "died"').to_s
-  end
-    
-  test "perfect" do
-    assert_equal "who have attended", SetBuilder::Trait.new('who have "attended"').to_s
-  end
-    
-  test "passive" do
-    assert_equal "who were born", SetBuilder::Trait.new('who were "born"').to_s
-  end
-    
-  test "reflexive" do
-    assert_equal "who are awesome", SetBuilder::Trait.new('who are "awesome"').to_s
-  end
-    
-  test "noun" do
-    assert_equal "whose name", SetBuilder::Trait.new('whose "name"').to_s
-  end
-    
-
-end