arspy 0.0.2 → 0.0.3

data/lib/arspy/class_extensions.rb

@@ -2,8 +2,8 @@ module Arspy
   module ClassExtensions
     module ActiveRecord
       module Base
-        def la; Arspy::Operators.la(self); end
-        def lf; Arspy::Operators.lf(self); end
+        def la; Arspy::Operators.list_associations(self); end
+        def lf; Arspy::Operators.list_fields(self); end
       end
     end
   end

data/lib/arspy/delegators/active_record_extensions.rb

@@ -2,8 +2,8 @@ module Arspy
   module Delegators
     module ActiveRecordExtensions
       def pr(*args); Arspy::Operators.print_object(self, *args); end
-      def la; Arspy::Operators.la(self.class); end
-      def lf; Arspy::Operators.lf(self.class); end
+      def la; Arspy::Operators.list_associations(self.class); end
+      def lf; Arspy::Operators.list_fields(self.class); end
     end
   end
 end

data/lib/arspy/delegators/array_extensions.rb

@@ -14,10 +14,10 @@ module Arspy
       end
 
       def la
-        Arspy::Operators.la(self.first.class) unless (self.emtpy? || !(self.first.is_a?(ActiveRecord::Base)))
+        Arspy::Operators.list_associations(self.first.class) unless (self.emtpy? || !(self.first.is_a?(ActiveRecord::Base)))
       end
       def lf
-        Arspy::Operators.lf(self.first.class) unless (self.empty? || !(self.first.is_a?(ActiveRecord::Base)))
+        Arspy::Operators.list_fields(self.first.class) unless (self.empty? || !(self.first.is_a?(ActiveRecord::Base)))
       end
       def pr(*args)
         Arspy::Operators.print_array(self, *args)

data/lib/arspy/delegators/association_collection_extensions.rb

@@ -15,11 +15,11 @@ module Arspy
       end
       def la
         load_target unless loaded?
-        Arspy::Operators.la(@target.first.class) unless (@target.emtpy? || !(@target.first.is_a?(ActiveRecord::Base)))
+        Arspy::Operators.list_associations(@target.first.class) unless (@target.emtpy? || !(@target.first.is_a?(ActiveRecord::Base)))
       end
       def lf
         load_target unless loaded?
-        Arspy::Operators.lf(@target.first.class) unless (@target.empty? || !(@target.first.is_a?(ActiveRecord::Base)))
+        Arspy::Operators.list_fields(@target.first.class) unless (@target.empty? || !(@target.first.is_a?(ActiveRecord::Base)))
       end
       def wi(*args)
         load_target unless loaded?

data/lib/arspy/operators.rb

@@ -1,6 +1,6 @@
 module Arspy
   module Operators
-    def self.la(active_record_klass)
+    def self.list_associations(active_record_klass)
       counts = {}
       rows = active_record_klass.reflect_on_all_associations.map do |a|
         counts[a.macro] ||= 0
@@ -12,7 +12,7 @@ module Arspy
       "Total: #{counts.inject(0){|sum, c| sum+c.last}} (" + counts.map{|c| "#{c.last} #{c.first}" }.join(', ') + ")"
     end
 
-    def self.lf(active_record_klass)
+    def self.list_fields(active_record_klass)
       rows = active_record_klass.columns.map do |c|
         self.format_column_field(c)
       end
@@ -70,20 +70,96 @@ module Arspy
       return array if (args.empty? || array.nil? || array.empty?)
       array.select{|o| o && !self.test_object(o, args)}
     end
-    def self.interpret(array, symbol, *args)
-      return nil unless (array && symbol)
+    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 == symbol}
-        array.map(&symbol).flatten
-      elsif (array.first.attribute_names.include?(symbol.to_s) || array.first.respond_to?(symbol))
-        return array.map(&symbol) if args.empty?
-        raise 'Hash not allowed as attribute conditionals' if args.any?{|a| a.is_a?(Hash)}
-        array.select{|o| o && self.test_attribute(o, symbol, args)}
-      else
-        nil
+      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{|d| [d[:abbr], d] }.flatten])
+    end
+    def self.remove_ambiguities(descriptors)
+      list={}
+      ambiguities = {}
+      descriptors.each do |d|
+        if list.include?(d[:abbr])
+          if ambiguities[d[:abbr]]
+            ambiguities[d[:abbr]][:methods] << d[:method_name]
+          else            
+           ambiguities[d[:abbr]] = {:abbr=>d[:abbr], :methods=>[d[:method_name]]}
+           ambiguities[d[:abbr]][:methods] << list[d[:abbr]][:method_name]
+          end
+        else
+          list[d[:abbr]] = d
+        end
+      end
+      descriptors.reject!{|d| ambiguities.map{|h| h.first}.include?(d[:abbr])}
+      ambiguities
+    end
+    def self.abbreviate_method_name(method_name)
+      splits = method_name.to_s.split('_')
+      abbr=[]
+      if splits.first == ''
+        abbr << '_'
+      end
+      splits.reject!{|s| s == ''}
+      abbr += splits.map do |s| 
+        chars = s.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?{|a| a.is_a?(Hash)}
+      array.select{|o| o && self.test_attribute(o, method_name, args)}
+    end
+    public
 
     def self.test_attribute(obj, attr_sym, args)
       return false if (obj.nil? || attr_sym.nil? || args.empty?)
@@ -101,11 +177,6 @@ module Arspy
       end
     end
 
-    def self.prepare_arguments(symbol, *args)
-      return nil if args.empty?
-      Hash[*args.map{|a| a.is_a?(Hash) ? a.map{|k,v| [k, v]} : [symbol, a]}.flatten]
-    end
-
     @@column_padding = 2
     def self.print_matrix(matrix_array)
       return nil if matrix_array.empty?

data/spec/database.rb

@@ -1,63 +1,80 @@
 require 'rubygems'
 
-gem 'activerecord', ENV['AR_VERSION'] ? "=#{ENV['AR_VERSION']}" : '>=2.1.0'
+gem 'activerecord', ENV['AR_VERSION'] ? "=#{ENV['AR_VERSION']}" : '>=2.3.2'
 require 'active_record'
 
 ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
 ActiveRecord::Base.logger = Logger.new("#{File.dirname(__FILE__)}/active_record.log")
 cx = ActiveRecord::Base.connection
 
-cx.create_table(:things, :force=>true) do |t|
-
+cx.create_table(:people, :force=>true) do |t|
+  t.string :first_name
+  t.string :last_name
+  t.integer :age
+  t.boolean :active
 end
-cx.create_table(:one_manies, :force=>true) do |t|
 
+class Person < ActiveRecord::Base
+  has_many :friendships
+  has_many :friends, :through=>:friendships
+  has_many :blogs
+  has_many :comments
+  
+  def full_name; "#{first_name} #{last_name}"; end
 end
-cx.create_table(:many_manies, :force=>true) do |t|
 
+cx.create_table(:friendships, :force=>true) do |t|
+  t.references :person
+  t.references :friend
+  t.integer :years_known
 end
-cx.create_table(:many_manies_things, :force=>true) do |t|
 
+class Friendship < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :friend, :class=>'Person'
 end
-cx.create_table(:manies_one, :force=>true) do |t|
 
+cx.create_table(:blogs, :force=>true) do |t|
+  t.references :person
+  t.string :title
+  t.datetime :published_at
+  t.references :asset, :polymorphic=>true
 end
 
-#basic_associations
-connection.create_table(:companies, :force=>true) do |t|
-  t.string :name
-  t.string :status
-end
-connection.create_table(:contract_workers, :force=>true) do |t|
-  t.references :company
-  t.references :contractor
-  t.string :status
+class Blog < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :asset, :polymorphic=>true
+  has_many :comments
 end
-connection.create_table(:licenses, :force=>true) do |t|
-  t.references :company
-  t.string :status
+
+cx.create_table(:comments, :force=>true) do |t|
+  t.references :person
+  t.references :blog
+  t.string :content
 end
-connection.create_table(:contractors, :force=>true) do |t|
-  t.string :name
-  t.string :status
+
+class Comment < ActiveRecord::Base
+  belongs_to :person
+  belongs_to :blog
 end
-connection.create_table(:employees, :force=>true) do |t|
-  t.references :company
-  t.string :name
-  t.string :status
+
+cx.create_table(:images, :force=>true) do |t|
+  t.string :caption
+  t.integer :size
 end
 
-#polymorphic_associations
-connection.create_table(:comments, :force=>true) do |t|
-  t.references :document, :polymorphic=>true
-  t.text :comment
-  t.string :status
+class Image < ActiveRecord::Base
+  has_one :blog, :as=>:asset
 end
-connection.create_table(:articles, :force=>true) do |t|
-  t.string :name
-  t.string :status
+
+cx.create_table(:recordings, :force=>true) do |t|
+  t.string :title
+  t.integer :duration
 end
-connection.create_table(:images, :force=>true) do |t|
-  t.string :name
-  t.string :status
+
+class Recording < ActiveRecord::Base
+  has_one :blog, :as=>:asset
 end
+
+
+

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Jeff Patmon
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-03 00:00:00 -07:00
+date: 2010-04-04 00:00:00 -07:00
 default_executable: 
 dependencies: []