flog 1.2.0 → 2.0.0

data/spec_fixtures/collection/bigger_example/association_extensions/date_ranged.rb

@@ -0,0 +1,11 @@
+module Centerstone #:nodoc:
+  module AssociationExtensions
+    module DateRanged
+      
+      def current
+        containing(Time.now)
+      end
+      
+    end
+  end
+end

data/spec_fixtures/collection/bigger_example/association_extensions/ranged.rb

@@ -0,0 +1,13 @@
+module Centerstone #:nodoc:
+  module AssociationExtensions
+    module Ranged
+    
+      %w{before after containing contained_by overlapping}.each do |comparison|
+        define_method comparison do |target|
+          self.select { |x|  x.send((comparison + '?').to_sym,  target) }
+        end
+      end
+      
+    end
+  end
+end

data/spec_fixtures/collection/bigger_example/reflection_extensions/ranged.rb

@@ -0,0 +1,50 @@
+module Centerstone #:nodoc:
+  module ReflectionExtensions
+    module Ranged
+      
+      def self.included(base)
+        puts 'hello'
+        base.send(:include,  InstanceMethods)
+        
+        base.instance_eval do
+          alias_method_chain :initialize, :has_many_range_extension
+        end
+      end
+      
+      module InstanceMethods
+        def initialize_with_has_many_range_extension(*args)
+          puts 'yo'
+          returning initialize_without_has_many_range_extension(*args) do
+            puts 'returning stuff'
+            if macro.to_s == 'has_many'
+              puts 'adding the extension'
+              add_has_many_range_extension
+            end
+            puts 'blah'
+          end
+        end
+        
+        private
+        
+        def add_has_many_range_extension
+          puts 'extension adding, hey'
+          puts 'bbbbb'
+          puts "target class [#{klass}]"
+          if klass.acts_as_range?
+            puts 'target acts as range'
+            extension = Centerstone::AssociationExtensions::Ranged
+            opts = options
+            
+            opts[:extend] ||= []
+            opts[:extend] = [opts[:extend]].flatten
+            
+            opts[:extend].push(extension) unless opts[:extend].include?(extension)
+            
+            @options = opts
+          end
+        end
+      end
+      
+    end
+  end
+end

data/spec_fixtures/directory/bot_filter.rb

@@ -0,0 +1,70 @@
+class BotFilter
+  attr_reader :options
+  
+  def initialize(options = {})
+    @options = options
+  end
+  
+  @@kinds = []
+  @@filters_registered = false
+  
+  class << self
+    def new(options = {})
+      locate_filters(options) unless @@filters_registered
+      obj = allocate
+      obj.send :initialize, options
+      obj
+    end
+    
+    def kinds
+      @@kinds
+    end
+    
+    def register(name)
+      @@kinds << name
+    end
+    
+    def clear_kinds
+      @@kinds = []
+      @@filters_registered = false
+    end
+    
+    def get(ident)
+      name = ident.to_s.gsub(/(?:^|_)([a-z])/) { $1.upcase }.to_sym
+      const_get(name)
+    end
+    
+    def locate_filters(options)
+      if options and options[:active_filters]
+        options[:active_filters].each do |filter|
+          register_filter(filter)
+        end
+      end
+      @@filters_registered = true
+    end
+    
+    def filter_path(name)
+      File.expand_path(File.dirname(__FILE__)+"/../lib/filters/#{name}.rb")
+    end
+    
+    def register_filter(name)
+      path = filter_path(name)
+      raise ArgumentError, "Could not find source code for filter [#{name}] in [#{path}]" unless File.exists? path
+      load(path)
+      register(name)
+    end
+  end
+  
+  def process(data)
+    result = data
+    self.class.kinds.each do |k|
+      if result
+        result = BotFilter.get(k).new(options).process(result)
+      else
+        result = nil
+        break
+      end
+    end
+    result
+  end
+end

data/spec_fixtures/directory/bot_parser.rb

@@ -0,0 +1,79 @@
+require 'bot_parser_format'
+
+class BotParser
+  @formats = []
+  
+  class << self
+    attr_reader :formats
+    
+    def register_format(*args, &block)
+      formats << BotParserFormat.new(*args, &block)
+    end
+    
+    def clear_formats
+      @formats = []
+    end
+  end
+  
+  def formats()  self.class.formats;  end
+  
+  register_format :image, /^\s*(?:(.*?)\s+)?(http:\S+\.(?:jpe?g|png|gif))(?:\s+(\S.*))?$/i,
+  %q['http://www.citizenx.cx/img/best_picture_ever.jpg'],
+  %q['http://www.citizenx.cx/img/best_picture_never.jpg this poster hangs over my bed'],
+  %q['Best. Picture. Ever. http://www.citizenx.cx/img/best_picture_ever.jpg'] do |md, _|
+    { :title => md[1], :source => md[2], :caption => md[3] }
+  end
+  
+  register_format :video, %r{^\s*(?:(.*?)\s+)?(http://(?:www\.)?youtube\.com/\S+\?\S+)(?:\s+(.*))?$}i,
+  %q['http://www.youtube.com/watch?v=E2Fjilze0eI'],
+  %q['http://www.youtube.com/watch?v=E2Fjilze0eI the bunny gets it'],
+  %q['A waste of chocolate http://www.youtube.com/watch?v=E2Fjilze0eI'] do |md, _|
+    { :title => md[1], :embed => md[2], :caption => md[3] }
+  end
+  
+  register_format :quote, /^\s*"([^"]+)"\s+--\s*(.*?)(?:\s+\((https?:.*)\))?$/i,
+  %q['"adios, turd nuggets" --J.P.'],
+  %q['"adios, turd nuggets" --J.P. (http://imdb.com/title/tt0456554/)'] do |md, _|
+    { :quote => md[1], :source => md[2], :url => md[3] }
+  end
+  
+  register_format :link, %r{^\s*(?:(.*?)\s+)?(https?://\S+)\s*(?:\s+(\S.*))?$}i,
+  %q['http://news.yahoo.com/s/ap/20071203/ap_on_sc/dinosaur_mummy'],
+  %q['http://news.yahoo.com/s/ap/20071203/ap_on_sc/dinosaur_mummy shows just how fast a mummified dinosaur can be'],
+  %q['Fossilized Hadrosaur http://news.yahoo.com/s/ap/20071203/ap_on_sc/dinosaur_mummy'] do |md, _|
+      { :name => md[1], :url => md[2], :description => md[3] }
+  end
+  
+  register_format :fact, %r{^\s*fact:\s+(.*)}i,
+  %q['FACT: Zed Shaw doesn't do pushups, he pushes the earth down'] do |md, _|
+    { :title => "FACT: #{md[1]}" }
+  end
+  
+  register_format :true_or_false, %r{^\s*(?:(?:true\s+or\s+false)|(?:t\s+or\s+f))\s*[:\?]\s+(.*)}i,
+  %q['T or F: the human body has more than one sphincter'],
+  %q['true or false: the human body has more than one sphincter'],
+  %q['true or false? the human body has more than one sphincter'] do |md, _|
+    { :title => "True or False?  #{md[1]}" }
+  end
+  
+  register_format :definition, %r{^\s*defin(?:e|ition):?\s+(.*?)\s*(?:[:=]|as)\s*(.*)}i,
+  %q['Definition: tardulism: the ideology of the tard culture'],
+  %q['Definition: tardulism = the ideology of the tard culture'],
+  %q["define tardulism as the ideology of the tard culture"] do |md, _|
+    { :title => "DEFINITION: #{md[1]}: #{md[2]}" }
+  end
+  
+  def parse(sender, channel, mesg)
+    return nil if mesg.empty?
+    
+    common = { :poster => sender, :channel => channel }
+    
+    result = nil
+    formats.detect { |f|  result = f.process(mesg) }
+        
+    return nil unless result
+    
+    result = common.merge(result)
+    result
+  end
+end

data/spec_fixtures/directory/bot_parser_format.rb

@@ -0,0 +1,23 @@
+class BotParserFormat
+  attr_reader :name, :format, :block
+  
+  def initialize(name, format, *description, &block)
+    raise ArgumentError, 'Block needed' if block.nil?
+    
+    @name   = name
+    @format = format
+    @block  = block
+    @description = description
+  end
+  
+  def description
+    @description.empty? ? nil : @description.join("\n")
+  end
+  
+  def process(text)
+    md = format.match(text)
+    return nil unless md
+    
+    block.call(md, text).merge(:type => name)
+  end
+end

data/spec_fixtures/directory/bot_sender.rb

@@ -0,0 +1,46 @@
+class BotSender
+  attr_reader :kind
+  
+  @@kinds = {  }
+  
+  def self.kinds
+    @@kinds.keys.sort_by {|k| k.to_s }
+  end
+  
+  def self.register(args = {})
+    args.each_pair {|k,v| @@kinds[k] = v }
+  end
+
+  def self.new(args = {})
+    raise ArgumentError unless self.kinds.include?(args[:destination])
+    obj = @@kinds[args[:destination]].allocate
+    obj.send :initialize, args  
+    obj
+  end
+
+  def initialize(args = {})
+    validate(args)
+    @kind = args[:destination]
+  end
+
+  def deliver(message)
+    return nil unless message and message[:type]
+    meth = "do_#{message[:type]}".to_sym
+    raise ArgumentError, "unknown message type [#{message[:type]}]" unless self.respond_to?(meth)
+    begin
+      self.send(meth, message)
+    rescue Exception => e
+      return e.to_s
+    end
+  end
+  
+  # validate arguments when creating a specific BotSender type instance
+  def validate(args = {})
+  end
+end
+
+require 'senders/tumblr'
+
+class BotSender
+  @@kinds[:tumblr] = BotSender::Tumblr
+end

data/spec_fixtures/simple/simple.rb

@@ -0,0 +1,191 @@
+module ObjectDaddy
+
+  def self.included(klass)
+    klass.extend ClassMethods
+    if defined? ActiveRecord and klass < ActiveRecord::Base
+      klass.extend RailsClassMethods    
+      
+      class << klass
+        alias_method :validates_presence_of_without_object_daddy, :validates_presence_of
+        alias_method :validates_presence_of, :validates_presence_of_with_object_daddy
+      end   
+    end
+  end
+    
+  module ClassMethods
+    attr_accessor :exemplars_generated, :exemplar_path, :generators
+    attr_reader :presence_validated_attributes
+    protected :exemplars_generated=
+    
+    # create a valid instance of this class, using any known generators
+    def spawn(args = {})
+      gather_exemplars
+      (generators || {}).each_pair do |handle, gen_data|
+        next if args[handle]
+        generator = gen_data[:generator]
+        if generator[:block]
+          if generator[:start]
+            generator[:prev] = args[handle] = generator[:start]
+            generator.delete(:start)
+          else
+            generator[:prev] = args[handle] = generator[:block].call(generator[:prev])
+          end
+        elsif generator[:method]
+          args[handle] = send(generator[:method])
+        elsif generator[:class]
+          args[handle] = generator[:class].next
+        end
+      end
+      if presence_validated_attributes and !presence_validated_attributes.empty?
+        req = {}
+        (presence_validated_attributes.keys - args.keys).each {|a| req[a.to_s] = true } # find attributes required by validates_presence_of not already set
+        
+        belongs_to_associations = reflect_on_all_associations(:belongs_to).to_a
+        missing = belongs_to_associations.select { |a|  req[a.name.to_s] or req[a.primary_key_name.to_s] }
+        if create_scope = scope(:create)
+          missing.reject! { |a|   create_scope.include?(a.primary_key_name) }
+        end
+        missing.each {|a| args[a.name] = a.class_name.constantize.generate }
+      end
+      new(args)
+    end
+
+    # register a generator for an attribute of this class
+    # generator_for :foo do |prev| ... end
+    # generator_for :foo do ... end
+    # generator_for :foo, value
+    # generator_for :foo => value
+    # generator_for :foo, :class => GeneratorClass
+    # generator_for :foo, :method => :method_name
+    def generator_for(handle, args = {}, &block)
+      if handle.is_a?(Hash)
+        raise ArgumentError, "only specify one attr => value pair at a time" unless handle.keys.length == 1
+        gen_data = handle
+        handle = gen_data.keys.first
+        args = gen_data[handle]
+      end
+      
+      raise ArgumentError, "an attribute name must be specified" unless handle = handle.to_sym
+      
+      unless args.is_a?(Hash)
+        unless block
+          retval = args
+          block = lambda { retval }  # lambda { args } results in returning the empty hash that args gets changed to
+        end
+        args = {}  # args is assumed to be a hash for the rest of the method
+      end
+      
+      if args[:method]
+        record_generator_for(handle, :method => args[:method].to_sym)
+      elsif args[:class]
+        raise ArgumentError, "generator class [#{args[:class].name}] does not have a :next method" unless args[:class].respond_to?(:next)
+        record_generator_for(handle, :class => args[:class])
+      elsif block
+        raise ArgumentError, "generator block must take an optional single argument" unless (-1..1).include?(block.arity)  # NOTE: lambda {} has an arity of -1, while lambda {||} has an arity of 0
+        h = { :block => block }
+        h[:start] = args[:start] if args[:start]
+        record_generator_for(handle, h)
+      else
+        raise ArgumentError, "a block, :class generator, :method generator, or value must be specified to generator_for"
+      end
+    end
+    
+    def gather_exemplars
+      return if exemplars_generated
+      if superclass.respond_to?(:gather_exemplars)
+        superclass.gather_exemplars
+        self.generators = (superclass.generators || {}).dup
+      end
+      
+      path = File.join(exemplar_path, "#{underscore(name)}_exemplar.rb")
+      load(path) if File.exists?(path)
+      self.exemplars_generated = true
+    end
+    
+    def presence_validated_attributes
+      @presence_validated_attributes ||= {}
+      attrs = @presence_validated_attributes
+      if superclass.respond_to?(:presence_validated_attributes)
+        attrs = superclass.presence_validated_attributes.merge(attrs)
+      end
+      attrs
+    end
+    
+  protected
+  
+    # we define an underscore helper ourselves since the ActiveSupport isn't available if we're not using Rails
+    def underscore(string)
+      string.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+    end
+    
+    def record_generator_for(handle, generator)
+      self.generators ||= {}
+      raise ArgumentError, "a generator for attribute [:#{handle}] has already been specified" if (generators[handle] || {})[:source] == self
+      generators[handle] = { :generator => generator, :source => self }
+    end
+  end
+  
+  module RailsClassMethods
+    def exemplar_path
+      File.join(RAILS_ROOT, 'test', 'exemplars')
+    end
+    
+    def validates_presence_of_with_object_daddy(*attr_names)
+      @presence_validated_attributes ||= {}
+      new_attr = attr_names.dup
+      new_attr.pop if new_attr.last.is_a?(Hash)
+      new_attr.each {|a| @presence_validated_attributes[a] = true }
+      validates_presence_of_without_object_daddy(*attr_names)
+    end
+    
+    def generate(args = {})
+      obj = spawn(args)
+      obj.save
+      obj
+    end
+    
+    def generate!(args = {})
+      obj = spawn(args)
+      obj.save!
+      obj
+    end
+  end
+end
+
+
+# these additional routines are just to give us coverage for flog opcodes that we hadn't yet covered in an integration test
+alias puts print
+attr_writer :foo
+
+foo = 2
+
+case 'foo'
+when :foo
+  true
+else
+  false
+end
+
+class Foo
+  def initialize
+    super(:foo)
+  end
+end
+
+until true
+  true
+end
+
+while false
+  true
+end
+
+begin
+  true
+rescue Exception
+  false
+else
+  true
+end
+
+puts(/foo/)