set_builder 1.0.2

data/init.rb

@@ -0,0 +1 @@
+require 'set_builder'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/set_builder.rb

@@ -0,0 +1,58 @@
+require 'active_record'
+require 'active_support/core_ext'
+require 'set_builder/traits'
+require 'set_builder/modifiers'
+require 'set_builder/value_map'
+require 'set_builder/set'
+
+
+module SetBuilder
+  
+  
+  def self.extended(base)
+    base.instance_variable_set("@traits", SetBuilder::Traits.new)
+    base.send(:include, SetBuilder::Modifiers)
+  end
+  
+  
+  attr_reader :traits
+  
+  
+  def modifiers
+    traits.modifiers
+  end
+  
+  
+  def that_belong_to(set)
+    SetBuilder::Set.new(self, set)
+  end
+  
+  
+protected
+  
+  
+  
+  def trait(*args, &block)
+    part_of_speech = get_part_of_speech(args.shift)
+    name = args.shift
+    traits << Trait.new(name, part_of_speech, *args, &block)
+  end
+  
+  
+  def get_part_of_speech(arg)
+    case arg
+    when :is, :are, :reflexive
+      :reflexive
+    when nil, :active
+      :active
+    when :was, :were, :passive
+      :passive
+    when :has, :have, :perfect
+      :perfect
+    when :whose, :noun
+      :noun
+    end
+  end
+  
+  
+end

data/lib/set_builder/constraint.rb

@@ -0,0 +1,67 @@
+require 'set_builder/modifier'
+
+
+module SetBuilder
+  class Constraint
+    
+    
+    #
+    # Sample constraints:
+    # 
+    #     [:awesome],
+    #     [:attended, "school"],
+    #     [:died],
+    #     [:name, {:is => "Jerome"}]]
+    # 
+    def initialize(trait, *args, &block)
+      @trait, @block = trait, block
+      @direct_object = args.shift if trait.requires_direct_object?
+      @modifiers = trait.modifiers.collect {|modifier_type| modifier_type.new(args.shift)}
+    end
+    
+    
+    
+    attr_reader :trait, :direct_object, :modifiers, :negative
+    
+    
+    
+    delegate :direct_object_required?,
+             :direct_object_type,
+             :to => :trait
+    
+    
+    
+    def valid?
+      (!direct_object_required? or !direct_object.nil?) and modifiers.all?(&:valid?)
+    end
+    
+    
+    
+    def to_s
+      # p "ValueMap.to_s(#{direct_object_type} (#{direct_object_type.class}), #{direct_object} (#{direct_object.class}))"
+      @description ||= begin
+        description = trait.to_s(@negative)
+        description << " #{ValueMap.to_s(direct_object_type, direct_object)}" if direct_object_required?
+        description << " #{modifiers.collect{|m| m.to_s(@negative)}.join(" ")}" unless modifiers.empty?
+        description
+      end
+    end
+    
+    
+    
+    def negate(value)
+      @negative = value
+      @negative = false if trait.noun?
+      self
+    end
+    
+    
+    
+    def perform(scope)
+      scope.scoped(@block.call(self, scope))
+    end
+    
+    
+    
+  end
+end

data/lib/set_builder/modifier.rb

@@ -0,0 +1,134 @@
+require 'set_builder/modifiers'
+require 'set_builder/modifier/adverb'
+require 'set_builder/modifier/verb'
+
+module SetBuilder
+  module Modifier
+    
+    
+    
+    @registered_modifiers = {}
+    
+    
+    
+    def self.registered?(klass)
+      @registered_modifiers.values.member?(klass)
+    end
+    
+    
+    
+    def self.name(klass)
+      @registered_modifiers.each do |key, value|
+        return key if (value == klass)
+      end
+      klass.name
+    end
+    
+    
+    
+    def self.for(type)
+      type = get_type(type)
+      @registered_modifiers[type] || raise(ArgumentError, "A modifier has not been registered for #{type}")
+    end
+    
+    
+    
+    def self.[](klass_or_symbol)
+      klass_or_symbol.is_a?(Class) ? SetBuilder::Modifier.valid_modifier!(klass_or_symbol) : SetBuilder::Modifier.for(klass_or_symbol)
+    end
+    
+    
+    
+    # 
+    # Usage
+    #   register(type, modifier)
+    #   register([type, modifier], [type, modifier])
+    #   register(type, modifier, type, modifier)
+    #
+    def self.register(*args)
+      args, i = args.flatten, 0
+      while args[i+1]
+        type, modifier_klass = get_type(args[i]), args[i+1]
+        valid_modifier!(modifier_klass) # || raise(ArgumentError, "#{modifier_klass} is not a valid modifier")
+        @registered_modifiers[type] = modifier_klass
+        i += 2
+      end
+    end
+    
+    
+    
+    def self.valid_modifier!(klass)
+      raise(ArgumentError, "#{klass} must inherit from either `SetBuilder::Modifier::Verb` or `SetBuilder::Modifier::Adverb`") unless (is_subclass_of?(klass, SetBuilder::Modifier::Adverb) or is_subclass_of?(klass, SetBuilder::Modifier::Verb))
+      raise(ArgumentError, "#{klass} must respond to `operators`") unless klass.respond_to?(:operators)
+      raise(ArgumentError, "#{klass}.operators must not be empty") if klass.operators.empty?
+      klass
+    end
+    
+    
+    
+  private
+    
+    
+    
+    def self.get_type(type)
+      if type.is_a?(Symbol)
+        type
+      else
+        type.to_s.downcase.to_sym
+      end
+    end
+    
+    
+    
+    def self.is_subclass_of?(klass, superklass)
+      sc = klass
+      while (sc = sc.superclass)
+        return true if (sc == superklass)
+      end
+      false
+    end
+    
+    
+    
+  end
+  
+  
+  
+  #
+  # Force predefined modifiers to pass `valid_modifier?`
+  #
+  Modifier.register(
+    [:date,     Modifiers::DateModifier],
+    [:number,   Modifiers::NumberModifier],
+    [:string,   Modifiers::StringModifier]
+  )
+  
+  
+  
+end
+
+
+
+
+
+
+
+#
+# Why is the below not working?
+#
+
+# class Class
+#   
+#   
+#   
+#   def is_subclass_of?(klass)
+#     sc = self
+#     while (sc = sc.superclass)
+#       return true if (sc == klass)
+#     end
+#     false
+#   end
+#   
+#   
+#   
+# end

data/lib/set_builder/modifier/adverb.rb

@@ -0,0 +1,11 @@
+require 'set_builder/modifier/base'
+
+
+module SetBuilder
+  module Modifier
+    class Adverb < Base
+      
+      
+    end
+  end
+end

data/lib/set_builder/modifier/base.rb

@@ -0,0 +1,105 @@
+module SetBuilder
+  module Modifier
+    class Base
+      
+      
+      
+      def initialize(hash)
+        @operator, @values = (hash.is_a?(Hash) ? [hash.first[0].to_sym, hash.first[1]] : [nil, nil])
+        @values ||= []
+        @values = [@values] unless @values.is_a?(Array)
+      end
+      
+      
+      
+      attr_reader :operator, :values
+      
+      
+      
+      def valid?
+        valid_operator?(self.operator) && valid_arguments?(self.values)
+      end
+      
+      
+      
+      def valid_operator?(operator)
+        !operator.nil? && self.class.operators.key?(operator)
+      end
+      
+      
+      
+      def valid_arguments?(values)
+        argument_types = self.class.operators[operator] || []
+        return false unless (values.length == argument_types.length)
+        values.each_with_index do |value, i|
+          return false unless valid_argument_of_type?(value, argument_types[i])
+        end
+        true
+      end
+      
+      
+      
+      def valid_argument_of_type?(argument, type)
+        validator = "valid_#{type}_argument?"
+        if respond_to?(validator)
+          send(validator, argument)
+        else
+          true
+        end
+      end
+      
+      
+      
+      def valid_date_argument?(string)
+        begin
+          Date.parse(string)
+          true
+        rescue
+          false
+        end
+      end
+
+
+      def valid_number_argument?(number)
+        !(number.to_s =~ /\A\d+\Z/).nil?
+      end
+      
+      
+      
+      def to_s(negative=false)
+        words = negative ? [self.class.negate(operator).to_s.gsub(/_/, " ")] : [operator.to_s.gsub(/_/, " ")]
+        arguments = self.class.operators[operator] || []
+        (0...arguments.length).each do |i|
+          # p "ValueMap.to_s(#{arguments[i]} (#{arguments[i].class}), #{values[i]} (#{values[i].class})): #{ValueMap.to_s(arguments[i], values[i])}"
+          words << ValueMap.to_s(arguments[i], values[i])
+        end
+        words.join(" ")
+      end
+      
+      
+      
+      def self.negate(operator)
+        operator
+      end
+      
+      
+      
+      def self.to_hash
+        hash = {}
+        operators.each do |operator, array|
+          hash[operator.to_s] = array.map {|type| type.to_s }
+        end
+        hash
+      end
+      
+      
+      
+      def self.to_json
+        to_hash.to_json
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/set_builder/modifier/verb.rb

@@ -0,0 +1,24 @@
+require 'set_builder/modifier/base'
+
+
+module SetBuilder
+  module Modifier
+    class Verb < Base
+      
+      
+      
+    protected
+      
+      
+      
+      def negate(selector, operator)
+        conditions = build_conditions_for(selector, operator)
+        conditions[0] = "NOT(#{conditions[0]})"
+        conditions        
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/set_builder/modifier_collection.rb

@@ -0,0 +1,41 @@
+module SetBuilder
+  class ModifierCollection < Array
+    
+    
+    
+    # def [](index)
+    #   case index
+    #   when Symbol, String
+    #     index = index.to_s
+    #     self.find {|trait| trait.name == index}
+    #   else
+    #     super
+    #   end
+    # end
+    
+    
+    
+    def to_hash
+      hash = {}
+      each do |modifier|
+        hash[Modifier.name(modifier).to_s] = modifier.to_hash
+      end
+      hash
+    end
+    
+    
+    
+    def to_json
+      to_hash.to_json
+    end
+    
+    
+    
+    # def modifiers
+    #   inject([]) {|modifiers, trait| modifiers.concat(trait.modifiers)}.uniq
+    # end
+    
+    
+    
+  end
+end