arspy 0.0.5 → 0.0.7

data/README.rdoc

@@ -113,6 +113,15 @@ Expressions using associations
   Jenny     Westmeyers  213  2
   Maria     Stone       8    88
 
+=== Printing objects and classes
+
+ARSpy integrates 'awesome print' to print lists of objects and classes.  Print objects or
+classes with the 'pr' command, or explicitly print with the 'ap' command.
+
+  User.ap  # => prints the object attributes and columns with awesome print
+  User.find(2).blogs.title.pr  #=> prints the titles of all blogs
+  User.find(2).blogs.pr  # => prints the object fields and data usign awesome print
+
 
 == Iterating Associations and Data
 
@@ -203,3 +212,4 @@ results that do not meet the conditions passed in the parameters.
 
 * ActiveRecord
 * ActiveSupport
+* Awesome Print

data/Rakefile

@@ -12,7 +12,7 @@ spec = Gem::Specification.new do |s|
   s.description = 'Active Record Spy'
   s.summary = 'Rails console command line tool for browsing and inspecting the structure, associations and data of an ActiveRecord data model.'
 
-  s.add_dependency('awesome_print', '>= 0.1.1')
+  s.add_dependency('awesome_print', '>= 0.1.4')
   
   exclude_folders = '' # 'spec/rails/{doc,lib,log,nbproject,tmp,vendor,test}'
   exclude_files = [] # FileList['**/*.log'] + FileList[exclude_folders+'/**/*'] + FileList[exclude_folders]

data/lib/arspy/class_extensions.rb

@@ -2,8 +2,8 @@ module Arspy
   module ClassExtensions
     module ActiveRecord
       module Base
-        def la; Arspy::Operators.list_associations(self); end
-        def lf; Arspy::Operators.list_fields(self); end
+        def la(*args); Arspy::Operators.list_associations(self, *args); end
+        def lf(*args); Arspy::Operators.list_fields(self, *args); end
         def pr; Arspy::Operators.awesome_print(self); end
         def ap(opts={}); Arspy::Operators.awesome_print(self, opts); end
       end

data/lib/arspy/delegators/active_record_extensions.rb

@@ -1,8 +1,8 @@
 module Arspy
   module Delegators
     module ActiveRecordExtensions
-      def la; Arspy::Operators.list_associations(self.class); end
-      def lf; Arspy::Operators.list_fields(self.class); end
+      def la(*args); Arspy::Operators.list_associations(self.class, *args); end
+      def lf(*args); Arspy::Operators.list_fields(self.class, *args); end
       def pr(*args); Arspy::Operators.print_object(self, *args); end
       def ap(opts={}); Arspy::Operators.awesome_print(self, opts); end
     end

data/lib/arspy/delegators/array_extensions.rb

@@ -13,11 +13,11 @@ module Arspy
         end
       end
 
-      def la
-        Arspy::Operators.list_associations(self.first) unless self.emtpy?
+      def la(*args)
+        Arspy::Operators.list_associations(self.first, *args) unless self.emtpy?
       end
-      def lf
-        Arspy::Operators.list_fields(self.first) unless self.empty?
+      def lf(*args)
+        Arspy::Operators.list_fields(self.first, *args) unless self.empty?
       end
       def ap(opts={})
         Arspy::Operators.awesome_print(self, opts={}) unless self.empty?

data/lib/arspy/delegators/association_collection_extensions.rb

@@ -9,13 +9,13 @@ module Arspy
           result
         end
       end
-      def la
+      def la(*args)
         load_target unless loaded?
-        Arspy::Operators.list_associations(@target.first) unless @target.emtpy?
+        Arspy::Operators.list_associations(@target.first, *args) unless @target.emtpy?
       end
-      def lf
+      def lf(*args)
         load_target unless loaded?
-        Arspy::Operators.list_fields(@target.first) unless @target.empty?
+        Arspy::Operators.list_fields(@target.first, *args) unless @target.empty?
       end
       def pr(*args)
         load_target unless loaded?

data/lib/arspy/delegators/null_extensions.rb

@@ -1,8 +1,8 @@
 module Arspy
   module Delegators
     module NullExtensions
-      def la; end
-      def lf; end
+      def la(*args); end
+      def lf(*args); end
       def pr(*args); end
       def ap(opts={}); end
     end

data/lib/arspy/operators/abbreviations.rb

@@ -0,0 +1,68 @@
+module Abbreviations
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def resolve_abbreviation_for_attributes_and_associations!(object, method_name)
+    self.class.resolve_abbreviation_for_attributes_and_associations!(object, method_name)
+  end
+  module ClassMethods
+    def 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 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 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 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 quote_and_join(array)
+      return "'#{array.first}'" if array.size == 1
+      last = array.pop
+      "'#{array.join("', '")}' or '#{last}'"
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/base.rb

@@ -0,0 +1,11 @@
+module Arspy
+  module Operators
+    module AttributeTest
+      class Base
+        def initialize(param)
+          @param = param
+        end
+      end
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/float_test.rb

@@ -0,0 +1,24 @@
+module Arspy
+  module Operators
+    module AttributeTest
+
+
+      class FloatTest < Base
+
+        def self.applies?(param)
+          param.is_a? Float
+        end
+
+        def match?(value_or_object)
+          case value_or_object
+          when ActiveRecord::Base
+            false
+          else
+            value_or_object.to_f == @param rescue nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/integer_test.rb

@@ -0,0 +1,24 @@
+module Arspy
+  module Operators
+    module AttributeTest
+
+
+      class IntegerTest < Base
+
+        def self.applies?(param)
+          param.is_a? Integer
+        end
+
+        def match?(value_or_object)
+          case value_or_object
+          when ActiveRecord::Base
+            value_or_object.id == @param
+          else
+            value_or_object.to_i == @param rescue nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/range_test.rb

@@ -0,0 +1,24 @@
+module Arspy
+  module Operators
+    module AttributeTest
+
+
+      class RangeTest < Base
+
+        def self.applies?(param)
+          param.is_a? Range
+        end
+
+        def match?(value_or_object)
+          case value_or_object
+          when ActiveRecord::Base
+            @param.include?(value_or_object.id)
+          else
+            @param.include?(value_or_object.to_i)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/regexp_test.rb

@@ -0,0 +1,23 @@
+module Arspy
+  module Operators
+    module AttributeTest
+
+      class RegexpTest < Base
+        def self.applies?(param)
+          param.is_a? Regexp
+        end
+
+        def match?(value_or_object)
+          case value_or_object
+          when ActiveRecord::Base
+            raise "Test for '#{@param}' on object '#{value_or_object.class.name}' not supported."
+          else
+            value_or_object =~ @param
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/string_test.rb

@@ -0,0 +1,23 @@
+module Arspy
+  module Operators
+    module AttributeTest
+
+      class StringTest < Base
+
+        def self.applies?(param)
+          param.is_a? String
+        end
+
+        def match?(value_or_object)
+          case value_or_object
+          when ActiveRecord::Base
+            value_or_object.instance_eval{ value_or_object }
+          else
+            value_or_object.to_s == @param rescue nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/attribute_test/unsupported_test.rb

@@ -0,0 +1,17 @@
+module Arspy
+  module Operators
+    module AttributeTest
+      class UnsupportedTest < Base
+
+        def self.applies?(param)
+          true
+        end
+  
+        def match?(object)
+          raise "#{@param.class.name} '#{@param.inspect}' not supported."
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/attribute_test.rb

@@ -0,0 +1,20 @@
+require 'arspy/operators/attribute_test/base'
+require 'arspy/operators/attribute_test/integer_test'
+require 'arspy/operators/attribute_test/range_test'
+require 'arspy/operators/attribute_test/regexp_test'
+require 'arspy/operators/attribute_test/string_test'
+require 'arspy/operators/attribute_test/unsupported_test'
+
+module Arspy
+  module Operators
+    module AttributeTest
+      @@attribute_test_classes = [
+        IntegerTest, RangeTest, StringTest, RegexpTest, UnsupportedTest
+      ]
+
+      def self.for(param)
+        @@attribute_test_classes.detect{|klass| klass.applies?(param)}.new(param)
+      end
+
+    end  end
+end

data/lib/arspy/operators/interpreter/abbreviated_association_interpreter.rb

@@ -0,0 +1,22 @@
+require 'arspy/operators/abbreviations'
+module Arspy
+  module Operators
+    module Interpreter
+      class AbbreviatedAssociationInterpreter < AssociationInterpreter
+        include Abbreviations
+
+        def self.applies?(array, method_name)
+          descriptor = resolve_abbreviation_for_attributes_and_associations!(array.first, method_name)
+          descriptor && descriptor[:type] == :association
+        end
+
+        def initialize(array, method_name)
+          descriptor = resolve_abbreviation_for_attributes_and_associations!(array.first, method_name)
+          super(array, descriptor[:method_name])
+        end
+
+      end
+    end
+  end
+end
+

data/lib/arspy/operators/interpreter/abbreviated_attribute_interpreter.rb

@@ -0,0 +1,22 @@
+require 'arspy/operators/abbreviations'
+
+module Arspy
+  module Operators
+    module Interpreter
+      class AbbreviatedAttributeInterpreter < AttributeInterpreter
+        include Abbreviations
+
+        def self.applies?(array, method_name)
+          descriptor = resolve_abbreviation_for_attributes_and_associations!(array.first, method_name)
+          descriptor && descriptor[:type] == :attribute
+        end
+
+        def initialize(array, method_name)
+          descriptor = resolve_abbreviation_for_attributes_and_associations!(array.first, method_name)
+          super(array, descriptor[:method_name])
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/interpreter/association_interpreter.rb

@@ -0,0 +1,18 @@
+module Arspy
+  module Operators
+    module Interpreter
+
+      class AssociationInterpreter < Base
+
+        def self.applies?(array, method_name)
+          array.first.class.reflect_on_all_associations.detect{|a| a.name == method_name}
+        end
+
+        def interpret(*args)
+          @array.map(&@method_name).flatten
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/interpreter/attribute_interpreter.rb

@@ -0,0 +1,21 @@
+module Arspy
+  module Operators
+    module Interpreter
+      class AttributeInterpreter < Base
+
+        def self.applies?(array, method_name)
+          array.first.attribute_names.include?(method_name.to_s)
+        end
+
+        def interpret(*args)
+          return @array.map(&@method_name) if args.empty?
+          raise 'Hash not supported as attribute conditionals' if args.any?{|arg| arg.is_a?(Hash)}
+          selector = Selector.for({@method_name => args})
+          @array.select{|obj| obj && selector.select?(obj)}
+        end
+
+      end
+      
+    end
+  end
+end

data/lib/arspy/operators/interpreter/base.rb

@@ -0,0 +1,11 @@
+module Arspy
+  module Operators
+    module Interpreter
+      class Base
+        def initialize(array, method_name)
+          @array, @method_name = array, method_name
+        end
+      end
+    end
+  end
+end

data/lib/arspy/operators/interpreter/method_interpreter.rb

@@ -0,0 +1,14 @@
+module Arspy
+  module Operators
+    module Interpreter
+
+      class MethodInterpreter < AttributeInterpreter
+        def self.applies?(array, method_name)
+          array.first.respond_to?(method_name) && array.first.method(method_name).arity == 0
+        end
+
+      end
+    end
+  end
+end
+

data/lib/arspy/operators/interpreter/null_interpreter.rb

@@ -0,0 +1,12 @@
+module Arspy
+  module Operators
+    module Interpreter
+      class NullInterpreter < Base
+        def self.applies?(array, method_name)
+          true
+        end
+        def interpret(*args); nil; end
+      end
+    end
+  end
+end

data/lib/arspy/operators/interpreter.rb

@@ -0,0 +1,29 @@
+
+require 'arspy/operators/interpreter/base'
+require 'arspy/operators/interpreter/association_interpreter'
+require 'arspy/operators/interpreter/attribute_interpreter'
+require 'arspy/operators/interpreter/method_interpreter'
+require 'arspy/operators/interpreter/abbreviated_association_interpreter'
+require 'arspy/operators/interpreter/abbreviated_attribute_interpreter'
+require 'arspy/operators/interpreter/null_interpreter'
+
+module Arspy
+  module Operators
+    module Interpreter
+      @@interpreter_classes = [
+        AssociationInterpreter, AttributeInterpreter,
+        MethodInterpreter, AbbreviatedAssociationInterpreter,
+        AbbreviatedAttributeInterpreter,
+        NullInterpreter
+      ]
+
+      def self.for(array, method_name)
+        return NullInterpreter.new(array, method_name) unless (array && method_name && array.is_a?(Array) && !array.empty? && array.first.is_a?(ActiveRecord::Base))
+        @@interpreter_classes.detect{|klass| klass.applies?(array, method_name)}.new(array, method_name)
+      end
+
+      @@abbreviations_enabled = true
+
+    end
+  end
+end

data/lib/arspy/operators/selector/attribute_selector.rb

@@ -0,0 +1,33 @@
+module Arspy
+  module Operators
+    module Selector
+
+      class AttributeSelector < Base
+        def self.applies?(key_value)
+          key_value.first.is_a? Symbol
+        end
+        def initialize(key_value)
+          super
+          @attribute = key_value.first.to_sym
+          @test_values = key_value.last.is_a?(Array) ? key_value.last : [key_value.last]
+        end
+
+        def select?(obj)
+          raise "Attribute '#{@attribute}' not found for #{obj.class.name}" unless obj.attribute_names.include?(@attribute.to_s)
+          response = obj.__send__ @attribute
+          return nil unless response
+          raise "Attributes resulting in arrays not supported" if response.is_a?(Array)
+          response = [response] unless response.is_a?(Array)
+          response.any?{|value_or_object| attribute_tests.any?{|test| test.match?(value_or_object)}}
+        end
+
+        def attribute_tests
+          @attribute_tests ||= @test_values.map do |param|
+            AttributeTest.for(param)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/selector/base.rb

@@ -0,0 +1,12 @@
+module Arspy
+  module Operators
+    module Selector
+      class Base
+        def initialize(arg)
+          @argument = arg
+        end
+      end
+
+    end
+  end
+end

data/lib/arspy/operators/selector/hash_selector.rb

@@ -0,0 +1,30 @@
+module Arspy
+  module Operators
+    module Selector
+
+      class HashSelector < Base
+        @@hash_selector_classes = [
+          Selector::AttributeSelector,
+          Selector::UnsupportedSelector
+        ]
+        def self.applies?(arg)
+          arg.is_a? Hash
+        end
+
+        def select?(obj)
+          selectors.any?{|selector| selector.select?(obj) }
+        end
+
+        def selectors
+          @selectors ||= @argument.map do |key_value|
+            hash_selector_class_for(key_value).new(key_value)
+          end
+        end
+        def hash_selector_class_for(key_value)
+          @@hash_selector_classes.detect{|klass| klass.applies?(key_value) }
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/selector/integer_selector.rb

@@ -0,0 +1,17 @@
+module Arspy
+  module Operators
+    module Selector
+      class IntegerSelector < Base
+
+        def self.applies?(arg)
+          arg.is_a? Integer
+        end
+
+        def select?(obj)
+          obj.id == @argument
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/selector/range_selector.rb

@@ -0,0 +1,17 @@
+module Arspy
+  module Operators
+    module Selector
+      class RangeSelector < Base
+
+        def self.applies?(arg)
+          arg.is_a? Range
+        end
+
+        def select?(obj)
+          @argument.include?(obj.id)
+        end
+
+      end
+    end
+  end
+end

data/lib/arspy/operators/selector/string_selector.rb

@@ -0,0 +1,14 @@
+module Arspy
+  module Operators
+    module Selector
+      class StringSelector < Base
+        def self.applies?(arg)
+          arg.is_a? String
+        end
+        def select?(obj)
+          obj.instance_eval { @argument }
+        end
+      end
+    end
+  end
+end

data/lib/arspy/operators/selector/unsupported_selector.rb

@@ -0,0 +1,17 @@
+module Arspy
+  module Operators
+    module Selector
+      class UnsupportedSelector < Base
+        def self.applies?(arg)
+          true
+        end
+        def initialize(arg)
+          raise "#{arg.inspect} not supported."
+        end
+        def select?(obj)
+          nil
+        end
+      end
+    end
+  end
+end