set_builder 1.0.2

data/lib/set_builder/modifiers.rb

@@ -0,0 +1,3 @@
+require 'set_builder/modifiers/string_modifier'
+require 'set_builder/modifiers/date_modifier'
+require 'set_builder/modifiers/number_modifier'

data/lib/set_builder/modifiers/date_modifier.rb

@@ -0,0 +1,83 @@
+require 'set_builder/modifier/adverb'
+
+
+module SetBuilder
+  module Modifiers
+    class DateModifier < Modifier::Adverb
+      
+      
+      
+      def self.operators
+        {
+          :ever => [],
+          :before => [:date],
+          :after => [:date],
+          :on => [:date],
+          :during_month => [:month],
+          :during_year => [:year],
+          :in_the_last => [:number, :period],
+          :between => [:date, :date]
+        }
+      end
+      
+      
+      
+      def build_conditions_for(selector)
+        case operator
+        when :ever
+          "#{selector} IS NOT NULL"
+        when :before
+          "#{selector}<'#{format_value(get_date)}'"
+        when :after
+          "#{selector}>'#{format_value(get_date)}'"
+        when :on
+          "#{selector}='#{format_value(get_date)}'"
+        when :during_month
+          "extract(month from #{selector})=#{values[0].to_i}"
+        when :during_year
+          year = values[0].to_i
+          return "TRUE" if year <= 0
+          "#{selector} BETWEEN '#{year}-01-01' AND '#{year}-12-31'"
+        when :in_the_last
+          "#{selector}>='#{format_value(get_date)}'"
+        when :between
+          "#{selector} BETWEEN '#{format_value(Date.parse values[0])}' AND '#{format_value(Date.parse values[1])}'"
+        end
+      end
+      
+      
+      
+    protected
+      
+      
+      
+      def get_date
+        case operator
+        when :in_the_last
+          case values[1]
+          when "years", "year"
+            values[0].to_i.years.ago
+          when "months", "month"
+            values[0].to_i.months.ago
+          when "weeks", "week"
+            values[0].to_i.weeks.ago
+          when "days", "day"
+            values[0].to_i.days.ago
+          end
+        else
+          Date.parse values[0]
+        end
+      end
+      
+      
+      
+      def format_value(date)
+        date = [Date.new(1,1,1), date].max # constrain dates to A.D.
+        date.strftime('%Y-%m-%d')
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/set_builder/modifiers/number_modifier.rb

@@ -0,0 +1,48 @@
+require 'set_builder/modifier/verb'
+
+
+module SetBuilder
+  module Modifiers
+    class NumberModifier < Modifier::Verb
+      
+      
+      
+      def self.operators
+        {
+          :is => [:number],
+          :is_less_than => [:number],
+          :is_greater_than => [:number],
+          :is_between => [:number, :number]
+        }
+      end
+      
+      
+      
+      def build_conditions_for(selector)
+        case operator
+        when :is
+          ["#{selector}=?", format_value]
+        when :is_less_than
+          ["#{selector}<?", format_value]
+        when :is_greater_than
+          ["#{selector}>?", format_value]
+        when :is_between
+          ["#{selector}>=? AND #{selector}<=?", values[0], values[1]]
+        end
+      end
+      
+      
+      
+    private
+      
+      
+      
+      def format_value
+        values[0]
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/set_builder/modifiers/string_modifier.rb

@@ -0,0 +1,81 @@
+require 'set_builder/modifier/verb'
+
+
+module SetBuilder
+  module Modifiers
+    class StringModifier < Modifier::Verb
+      
+      
+      
+      def self.operators
+        {
+          :contains => [:string],
+          :does_not_contain => [:string],
+          :begins_with => [:string],
+          :does_not_begin_with => [:string],
+          :ends_with => [:string],
+          :does_not_end_with => [:string],
+          :is => [:string],
+          :is_not => [:string]
+        }
+      end
+      
+      
+      
+      def self.negate(operator)
+        case operator
+        when :contains
+          "does not contain"
+        when :begins_with
+          "does not begin with"
+        when :ends_with
+          "does not end with"
+        when :is
+          "is not"
+        end
+      end
+      
+      
+      
+      def build_conditions_for(selector, operator=nil)
+        operator ||= self.operator
+        case operator
+        
+        when :does_not_contain
+          negate(selector, :contains)
+        when :does_not_begin_with
+          negate(selector, :begins_with)
+        when :does_not_end_with
+          negate(selector, :ends_with)
+        when :is_not
+          negate(selector, :is)
+        
+        when :is
+          ["#{selector}=?", values[0]]
+        else
+          ["#{selector} LIKE ?", get_like_value_for_operator]
+        end
+      end
+      
+      
+      
+    private
+      
+      
+      
+      def get_like_value_for_operator
+        case operator
+        when :contains
+          "%#{values[0]}%"
+        when :begins_with
+          "#{values[0]}%"
+        when :ends_with
+          "%#{values[0]}"
+        end
+      end
+      
+      
+      
+    end
+  end
+end

data/lib/set_builder/set.rb

@@ -0,0 +1,81 @@
+module SetBuilder
+  class Set
+    
+    
+    
+    def initialize(model_or_scope, raw_data)
+      @model, @scope = get_model_and_scope(model_or_scope)
+      @set = raw_data
+    end
+    
+    
+    
+    attr_reader :model
+    
+    
+    
+    def constraints
+      @constraints ||= get_constraints
+    end
+    
+    
+    
+    #
+    # Returns true if all of the constraints in this set are valid
+    #
+    def valid?
+      constraints.all?(&:valid?)
+    end
+    
+    
+    
+    #
+    # Describes this set in natural language
+    #
+    def to_s
+      constraints.to_sentence
+    end
+    
+    
+    
+    #
+    # Returns an instance of ActiveRecord::NamedScope::Scope
+    # which can fetch the objects which belong to this set
+    #    
+    def perform
+      constraints.inject(@scope) {|scope, constraint| constraint.perform(scope)}
+    end
+    
+    
+    
+  private
+    
+    
+    
+    def get_constraints
+      @set.inject([]) do |constraints, line|
+        negate, trait_name, args = false, line.first.to_s, line[1..-1]
+        trait_name, negate = trait_name[1..-1], true if (trait_name[0..0] == "!")
+        trait = model.traits[trait_name]
+        raise("\"#{trait_name}\" is not a trait for #{model}") unless trait
+        constraints << trait.apply(*args).negate(negate)
+      end
+    end
+    
+    
+    
+    # !todo: this can be overriden or factored out to allow SetBuilder 
+    #   to be used with other ORMs like DataMapper
+    def get_model_and_scope(model_or_scope)
+      if defined?(ActiveRecord::NamedScope::Scope) && model_or_scope.is_a?(ActiveRecord::NamedScope::Scope)
+        [model_or_scope.proxy_scope, model_or_scope]
+      else
+        # [model_or_scope, model_or_scope.scoped({})]
+        [model_or_scope, model_or_scope.scoped]
+      end
+    end
+    
+    
+    
+  end
+end

data/lib/set_builder/trait.rb

@@ -0,0 +1,74 @@
+require 'set_builder/constraint'
+require 'set_builder/modifier'
+
+
+module SetBuilder
+  class Trait
+    
+    
+    
+    def initialize(name, part_of_speech, *args, &block)
+      case name
+      when Hash
+        @name, @direct_object_type = name.first[0].to_s, name.first[1]
+      else
+        @name = name.to_s
+      end
+      @part_of_speech, @block = part_of_speech, block
+      @modifiers = (args||[]).collect {|modifier| Modifier[modifier]}
+    end
+    
+    
+    
+    attr_reader :name, :part_of_speech, :modifiers, :direct_object_type
+    
+    
+    
+    def requires_direct_object?
+      !@direct_object_type.nil?
+    end
+    alias :direct_object_required? :requires_direct_object?
+    
+    
+    
+    def noun?
+      (self.part_of_speech == :noun)
+    end
+    
+    
+    
+    def to_s(negative=false)
+      case part_of_speech
+      when :active
+        negative ? "who have not #{name}" : "who #{name}"
+      when :perfect
+        negative ? "who have not #{name}" : "who have #{name}"
+      when :passive
+        negative ? "who were not #{name}" : "who were #{name}"
+      when :reflexive
+        negative ? "who are not #{name}" : "who are #{name}"
+      when :noun
+        "whose #{name}"
+      end
+    end
+    
+    
+    
+    def to_json
+      array = []
+      array << (requires_direct_object? ? [name, @direct_object_type] : name)
+      array << part_of_speech
+      array << modifiers.collect{|klass| Modifier.name(klass)} unless modifiers.empty?
+      array.to_json
+    end
+    
+    
+    
+    def apply(*args)
+      SetBuilder::Constraint.new(self, *args, &@block)
+    end
+    
+    
+    
+  end
+end

data/lib/set_builder/traits.rb

@@ -0,0 +1,42 @@
+require 'set_builder/trait'
+require 'set_builder/modifier_collection'
+
+
+module SetBuilder
+  class Traits < Array
+    
+    
+    
+    def [](index)
+      case index
+      when Symbol, String
+        index = index.to_s
+        self.find {|trait| trait.name == index}
+      else
+        super
+      end
+    end
+    
+    
+    
+    def to_json
+      "[#{collect(&:to_json).join(",")}]"
+    end
+    
+    
+    
+    def modifiers
+      # !nb: not sure why inject was failing but it was modifying trait.modifiers!
+      @modifiers = ModifierCollection.new
+      each do |trait|
+        trait.modifiers.each do |modifier|
+          @modifiers << modifier unless @modifiers.member?(modifier)
+        end
+      end
+      @modifiers
+    end
+    
+    
+    
+  end
+end

data/lib/set_builder/value_map.rb

@@ -0,0 +1,62 @@
+module SetBuilder
+  module ValueMap
+    
+    
+    
+    @registered_value_maps = {}
+    
+    
+    
+    def self.registered?(name)
+      name = name.to_sym
+      @registered_value_maps.key?(name)
+    end
+    
+    
+    
+    def self.to_s(name, value)
+      name = name.to_sym
+      map = @registered_value_maps[name]
+      if map
+        pair = map.find {|pair| pair[0] == value}
+        pair ? pair[1].to_s : "(unknown)"
+      else
+        value.to_s
+      end
+    end
+    
+    
+    
+    def self.for(name)
+      name = name.to_sym
+      @registered_value_maps[name] || raise(ArgumentError, "A value map has not been registered for #{value}")
+    end
+    
+    
+    
+    def self.register_collection(name, collection, name_method = :name, id_method = :id)
+      map = collection.map {|i| [i.send(id_method).to_s, i.send(name_method)]}
+      register(name, map)
+    end
+    
+    
+    
+    def self.register(name, map)
+      raise "map is expected to be an array of pairs" unless map.is_a?(Array)
+      name = name.to_sym
+      @registered_value_maps[name] = map
+    end
+    
+    
+    
+    def self.to_json
+      @registered_value_maps.to_json
+    end
+    
+    
+    
+  end
+  
+  
+  
+end