arspy 0.0.5 → 0.0.7

data/lib/arspy/operators/selector.rb

@@ -0,0 +1,28 @@
+require 'arspy/operators/selector/base'
+require 'arspy/operators/selector/attribute_selector'
+require 'arspy/operators/selector/range_selector'
+require 'arspy/operators/selector/integer_selector'
+require 'arspy/operators/selector/string_selector'
+require 'arspy/operators/selector/unsupported_selector'
+require 'arspy/operators/selector/hash_selector'
+
+module Arspy
+  module Operators
+
+   module Selector
+      @@selector_classes = [
+        IntegerSelector,
+        RangeSelector,
+        StringSelector,
+        HashSelector,
+        UnsupportedSelector
+      ]
+
+      def self.for(arg)
+        @@selector_classes.detect{|klass| klass.applies?(arg)}.new(arg)
+      end
+
+
+    end
+  end
+end

data/lib/arspy/operators.rb

@@ -1,7 +1,11 @@
+require 'arspy/operators/attribute_test'
+require 'arspy/operators/selector'
+require 'arspy/operators/interpreter'
+
 module Arspy
   module Operators
 
-    def self.list_associations(klass_or_object)
+    def self.list_associations(klass_or_object, *args)
       active_record_klass = klass_or_object.is_a?(Class) ? klass_or_object : klass_or_object.class
       return unless active_record_klass.ancestors.include?(ActiveRecord::Base)
       counts = {}
@@ -11,23 +15,26 @@ module Arspy
         self.format_column_association(assoc)
       end
       rows.sort!{|row1,row2| row1.first <=> row2.first}
+      return rows if args.include?(:data)
       self.print_matrix(rows)
       "Total: #{counts.inject(0){|sum, count| sum+count.last}} (" + counts.map{|count| "#{count.last} #{count.first}" }.join(', ') + ")"
     end
 
-    def self.list_fields(klass_or_object)
+    def self.list_fields(klass_or_object, *args)
       active_record_klass = klass_or_object.is_a?(Class) ? klass_or_object : klass_or_object.class
       return unless active_record_klass.ancestors.include?(ActiveRecord::Base)
       rows = active_record_klass.columns.map do |column|
         self.format_column_field(column)
       end
       rows.sort!{|row1,row2| row1.first <=> row2.first}
+      return rows if args.include?(:data)
       self.print_matrix(rows)
       "Total #{active_record_klass.columns.size} field#{active_record_klass.columns.size == 1 ? '' : 's'}"
     end
 
     def self.awesome_print(klass_object_or_array, options={})
-      AwesomePrint.new(options).puts klass_object_or_array
+      #AwesomePrint.new(options).puts(klass_object_or_array)
+      ap(klass_object_or_array)
       nil
     end
 
@@ -36,13 +43,25 @@ module Arspy
       [assoc.name.to_s, assoc.macro.to_s, "(#{assoc.options[:class_name] || assoc.name.to_s.singularize.camelize})", select_options.empty? ? '' : Hash[*select_options.flatten].inspect]
     end
     def self.format_column_field(field)
-      [field.name.to_s, ":#{field.type}", "(#{field.sql_type})"]
+      [field.name.to_s, ":#{field.type}", format_db_type(field), format_db_type_modifiers(field)]
+    end
+    def self.format_db_type(field)
+      prec_scale = field.precision && field.scale ? "#{field.precision}:#{field.scale}" : ""
+      default = field.default ? " (#{field.default})" : ""
+      "#{field.sql_type}#{prec_scale}#{default}"
+    end
+    def self.format_db_type_modifiers(field)
+      modifiers = []
+      modifiers << 'PRIMARY' if field.primary
+      modifiers << 'NOT NULL' unless field.null
+      #modifiers << "LIMIT(#{field.limit})" if field.limit
+      modifiers.join(',')
     end
 
     def self.print_array(array, *args)
       if args.empty?
         case array.first
-        when ActiveRecord::Base then AwesomePrint.new.puts(array)
+        when ActiveRecord::Base then ap(array)
         else
           array.each{|element| puts element}
         end
@@ -64,7 +83,8 @@ module Arspy
 
     def self.print_object(object, *args)
       print_matrix([args.map{|arg| object[arg]}]) unless args.empty?
-      AwesomePrint.new.puts(object) if args.empty?
+      #AwesomePrint.new.puts(object) if args.empty?
+      ap(object) if args.empty?
       nil
     end
     def self.test_object(obj, args)
@@ -79,121 +99,30 @@ module Arspy
         end
       end
     end
+    # t.people.with(20..30)
+    # t.people.with(2,3,4)
+    # t.people.with(:name=>[/Ed/, /Jen/, 'Joe'])
+    # t.people.with(:age=>10..20)
+    # t.people.with('statistics.statistic_type.abbrevation'=>%w(GP SV% GAA))
     def self.with(array, *args)
       return array if (args.empty? || array.nil? || array.empty?)
-      array.select{|obj| obj && self.test_object(obj, args)}
+      array.select{|obj| 
+        obj && args.any?{|arg|
+          Selector.for(arg).select?(obj) }}
     end
     def self.without(array, *args)
       return array if (args.empty? || array.nil? || array.empty?)
-      array.select{|obj| obj && !self.test_object(obj, args)}
+      array.select{|obj| obj && !args.any?{|arg| Selector.for(arg).select?(obj) }}
     end
-    def self.enable_abbreviations; @@abbreviations_enabled = true; end
-    def self.disable_abbreviations; @@abbreviations_enabled = false; end
-    @@abbreviations_enabled = true
-    def self.interpret(array, method_name, *args)
-      return nil unless (array && method_name)
-      return nil unless (array.is_a?(Array) && !array.empty? && array.first.is_a?(ActiveRecord::Base))
 
-      if array.first.class.reflect_on_all_associations.detect{|a| a.name == method_name}
-        return interpret_association(array, method_name, *args)
-      elsif (array.first.attribute_names.include?(method_name.to_s) || array.first.respond_to?(method_name))
-        return interpret_attribute_or_method(array, method_name, *args)
-      end
-      return @@abbreviations_enabled ? interpret_abbreviation(array, method_name, *args) : nil
-    end
-    private
-    def self.interpret_abbreviation(array, symbol, *args)
-      if (descriptor = resolve_abbreviation_for_attributes_and_associations(array.first, symbol))
-        if descriptor[:type] == :association
-          return interpret_association(array, descriptor[:method_name], *args)
-        else
-          return interpret_attribute_or_method(array, descriptor[:method_name], *args)
-        end
-      end
-      nil
-    end
-    def self.resolve_abbreviation_for_attributes_and_associations(object, method_name)
-      klass = object.class
-      setup_abbreviations(object) unless object.instance_variable_defined?('@arspy_abbreviations')
-      if (ambiguity = klass.instance_variable_get('@arspy_ambiguous_abbreviations')[method_name])
-        raise "Ambiguous abbreviation '#{ambiguity[:abbr]}' could be #{quote_and_join(ambiguity[:methods])}"
-      end
-      klass.instance_variable_get('@arspy_abbreviations')[method_name]
-    end
-    def self.setup_abbreviations(object)
-      associations = object.class.reflect_on_all_associations.map(&:name).map(&:to_sym)
-      attributes = object.attribute_names.map(&:to_sym)
-      assoc_descriptors = associations.map{|method_name| {:method_name=>method_name, :type=>:association, :abbr=>abbreviate_method_name(method_name)}}
-      attrib_descriptors = attributes.map{|method_name| {:method_name=>method_name, :type=>:attribute, :abbr=>abbreviate_method_name(method_name)}}
-      all_descriptors = assoc_descriptors + attrib_descriptors
-      object.class.instance_variable_set('@arspy_ambiguous_abbreviations', remove_ambiguities(all_descriptors))
-      object.class.instance_variable_set('@arspy_abbreviations', Hash[*all_descriptors.map{|desc| [desc[:abbr], desc] }.flatten])
-    end
-    def self.remove_ambiguities(descriptors)
-      list={}
-      ambiguities = {}
-      descriptors.each do |desc|
-        if list.include?(desc[:abbr])
-          if ambiguities[desc[:abbr]]
-            ambiguities[desc[:abbr]][:methods] << desc[:method_name]
-          else            
-           ambiguities[desc[:abbr]] = {:abbr=>desc[:abbr], :methods=>[desc[:method_name]]}
-           ambiguities[desc[:abbr]][:methods] << list[desc[:abbr]][:method_name]
-          end
-        else
-          list[desc[:abbr]] = desc
-        end
-      end
-      descriptors.reject!{|desc| ambiguities.map{|hash| hash.first}.include?(desc[:abbr])}
-      ambiguities
-    end
-    def self.abbreviate_method_name(method_name)
-      words = method_name.to_s.split('_')
-      abbr=[]
-      if words.first == ''
-        abbr << '_'
-      end
-      words.reject!{|word| word == ''}
-      abbr += words.map do |word|
-        chars = word.split(//)
-        first = chars.shift
-        [first, chars.map{|ch| ch =~ /[0-9]/ ? ch : nil}].compact.flatten.join('')
-      end
-      
-      abbr << '_' if (method_name.to_s =~ /_$/)
-      abbr.join('').to_sym
-    end
-    def self.quote_and_join(array)
-      return "'#{array.first}'" if array.size == 1
-      last = array.pop
-      "'#{array.join("', '")}' or '#{last}'"
-    end
-    def self.interpret_association(array, method_name, *args)
-      array.map(&method_name).flatten
-    end
-    def self.interpret_attribute_or_method(array, method_name, *args)
-      return array.map(&method_name) if args.empty?
-      raise 'Hash not allowed as attribute conditionals' if args.any?{|arg| arg.is_a?(Hash)}
-      array.select{|obj| obj && self.test_attribute(obj, method_name, args)}
-    end
-    public
+    def self.enable_abbreviations; Interpreter.enable_abbreviations(true); end
+    def self.disable_abbreviations; Interpreter.enable_abbreviations(false); end
 
-    def self.test_attribute(obj, attr_sym, args)
-      return false if (obj.nil? || attr_sym.nil? || args.empty?)
-      value = obj.__send__(attr_sym)
-      args.any? do |arg|
-        case arg
-        when String then (arg == value || (obj.instance_eval("#{attr_sym} #{arg}") rescue false))
-        when Regexp then arg.match(value)
-        when Range then arg.include?(value)
-        when Integer then (value.is_a?(ActiveRecord::Base) ? arg == value.id : arg == value)  #TODO: what about value is association collection
-        when Float then arg == value
-        else
-          false
-        end
-      end
+    def self.interpret(array, method_name, *args)
+      Interpreter.for(array, method_name).interpret(*args)
     end
 
+
     @@column_padding = 2
     def self.print_matrix(matrix_array)
       return nil if matrix_array.empty?

data/lib/meta_programming/object.rb

@@ -2,10 +2,10 @@ module MetaProgramming
   module Object
     def self.included(base)
       raise 'This module may only be included in class Object' unless base.name == 'Object'
-      base.extend(ClassExtensions)
+      base.extend(ClassMethods)
     end
 
-    module ClassExtensions
+    module ClassMethods
       def metaclass
         class << self; self; end
       end