one_touch 1.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+rails/*
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rbenv-version

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in one_touch.gemspec
+gemspec
+
+# gem 'cancan', '~> 1.6' # when add controller code in gem
+gem 'rake'
+gem 'rspec'
+gem 'rspec-rails'
+gem 'ruby-debug19'
+gem 'rails', '3.0.10'
+gem 'meta_where', '~> 1.0.0'
+# gem 'squeel' # add another version to support it and Rails3.1
+gem 'sqlite3', '~> 1.3.0', :group => :test

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+
+desc "Running Test"
+task :test do
+  system "bundle exec rspec spec/models/*.rb --debugger --backtrace --fail-fast"
+end

data/lib/one_touch/engine.rb

@@ -0,0 +1,4 @@
+module OneTouch
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/one_touch/models/active_record_extension.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__),'acts_as_favor')
+require File.join(File.dirname(__FILE__),'as_favor_host')
+require File.join(File.dirname(__FILE__),'as_favorable')
+require File.join(File.dirname(__FILE__),'relations')
+require File.join(File.dirname(__FILE__),'host_relation')
+
+module OneTouch
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+
+    included do
+
+    end
+
+    module ClassMethods
+
+      # Default is define two relations:
+      #   belongs_to :host, :class_name => "User"
+      #   belongs_to :favorable, :polymorphic => true
+      # Set acts_as_favor :host_class_name => nil to override default host relation by
+      #   belongs_to :host, :polymorphic => true
+      # User can define his own specific relations, but make sure two relations name must be host and favorable
+      #   and use acts_as_favor :no_default_relations => false after user defined relations
+      #   Ex: belongs_to :host, :class_name => "AnyOne", :primary_key => :any_key
+      #       belongs_to :tag
+      #       acts_as_favor :no_default_relations => true
+      def acts_as_favor(opt={})
+
+        opt.reverse_merge!({:include_host_relation_module => true, :host_class_name => "User", :no_default_relations => false})
+        class_attribute :host_relation_type, :favorable_relation_type, :instance_writer => false
+
+        method_name_of_host_klasses = "host_klasses_for_#{name.underscore}"
+
+        include ActsAsFavor
+
+        unless opt[:no_default_relations]
+          if opt[:host_class_name].nil?
+            belongs_to :host, :polymorphic => true
+            host_relation_type = :polymorphic
+            if respond_to? method_name_of_host_klasses
+              send(method_name_of_host_klasses).each do |k|
+                k.to_s.constantize.rewrite_join_favors  if k.to_s.constantize.respond_to? :rewrite_join_favors
+              end
+            end
+          else
+            belongs_to :host, :class_name => opt[:host_class_name]
+            host_relation_type = :single
+          end
+          if opt[:favorable_class_name].nil?
+            belongs_to :favorable, :polymorphic => true
+            favorable_relation_type = :polymorphic
+          else
+            belongs_to :favorable, :class_name => opt[:favorable_class_name]
+            favorable_relation_type = :single
+          end
+        end
+
+        if opt[:include_host_relation_module]
+          class_attribute :include_host_relation_module, :instance_writer => false
+          self.include_host_relation_module = true
+          add_host_relation_map(favorable_klasses, :be_favors, :host)
+        end
+
+        if respond_to? method_name_of_host_klasses
+          send(method_name_of_host_klasses).each do |k|
+            k.to_s.constantize.after_load_acts_as_favor if k.to_s.constantize.respond_to? :after_load_acts_as_favor
+          end
+        end
+      end
+
+      # Used in host class
+      # Ex:
+      #   as_favor_host :klass => "OtherClass"
+      #
+      def as_favor_host(opt={})
+        opt = { :klass => "Favor", :no_default_relations => false }.merge opt
+
+        assign_cattr_in_favor_class(:host_klasses,opt)
+        # The Name of has_many is stick to favors, to make it changable would cause some query problem
+        # :as => :host can not be configured too, cause in act_as_favor, the relation name was sticked
+        unless opt[:no_default_relations]
+          has_many :favors, :class_name => opt[:klass], :as => :host
+        end
+        include AsFavorHost
+      end
+
+      # Used in favorable class
+      def as_favorable(opt={})
+        opt = { :klass => "Favor", :no_default_relations => false }.merge opt
+
+        assign_cattr_in_favor_class(:favorable_klasses,opt)
+        unless opt[:no_default_relations]
+          has_many :be_favors, :class_name => opt[:klass], :as => :favorable
+        end
+        include AsFavorable
+        include HostRelation if favor_class.respond_to? :include_host_relation_module and favor_class.include_host_relation_module = true
+      end
+
+      private
+
+      def add_host_relation_map(favorable_klasses, *two_connection_name)
+        class_attribute :favorable_to_media, :media_to_host, :instance_writer => false
+        unless respond_to? :favorable_klasses
+          class_attribute :favorable_klasses
+          self.favorable_klasses = favorable_klasses
+        end
+        self.favorable_to_media = two_connection_name.first
+        self.media_to_host = two_connection_name[1]
+
+        include Relations
+        self.target_to_media = :be_favors
+        self.media_to_host = :host
+
+        favorable_klasses.each do |k|
+          klass = k.to_s.constantize
+          klass.send :include, HostRelation  # host_relation model is added to favorable klass
+        end
+      end
+
+      # Programmer Doc
+      #   To maintain the connection betwwen host, favorable and favor class,
+      #   I defined class_attribute in there super class AR::Base
+      #   I don't know if there is any good solution to not disturb AR::Base
+      def assign_cattr_in_favor_class(cattr_name,opt)
+        class_attribute :favor_klass, :favor_class, :instance_writer => false
+        self.favor_klass = opt[:klass]
+        self.favor_class = favor_klass.constantize
+
+        # favor_class.acts_as_favor :just_define_host_klasses => true unless favor_class.respond_to? :host_klasses
+        # favor.class.acts_as_favor
+        cattr_name = "#{cattr_name}_for_#{opt[:klass].underscore}".to_sym
+        unless ::ActiveRecord::Base.respond_to? cattr_name
+          ::ActiveRecord::Base.class_attribute cattr_name, :instance_writer => false
+          ::ActiveRecord::Base.send "#{cattr_name}=", []
+        end
+        (::ActiveRecord::Base.send cattr_name) << self.name.to_sym
+      end
+
+    end # End ClassMethods
+
+  end # ActiveRecordExtension
+end

data/lib/one_touch/models/acts_as_favor.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+module OneTouch
+  module ActsAsFavor
+    extend ActiveSupport::Concern
+
+    included  do
+
+      class_attribute :cons_context, :cons_context_match, :context_relation, :instance_writer => false
+      self.cons_context = self::CONTEXT
+      self.cons_context_match = self::CONTEXT_MATCH
+      self.context_relation = self::CONTEXT_RELATION if defined? CONTEXT_RELATION
+
+      # Seems there are many hook work to do, oppose hook, belongs hook ....
+      #   All needed hook should be just about relations between contexts
+      #   Other hooks should be write by user
+      after_save :context_relation_hook if context_relation.presence
+
+      validates_inclusion_of :context,:in => cons_context, :message => "%{value} not included in CONTEXT"
+
+      validate :context_should_match_favorable_type
+      validate :host_should_differ_favorable
+
+      scope :context_as, lambda { |context| where( { :context => context } ) if context.present? }
+
+      # Generate build or destroy methods like:
+      #   Favor.add_focus, Favor.del_focus
+      cons_context.each do |context|
+        generate_del_methods context
+        generate_add_methods context
+      end
+
+      # generate scope method like :
+      #   scope :context_as_follow , where(:context => follow)
+      cons_context.each do |cont|
+        method_name = "context_as_#{cont}".to_sym
+        scope method_name, where(:context => cont)
+      end
+
+      # Here add some dynamic scope query methods
+      #  the method name is context + favorable_type(transfer it to a valid method string)
+      #  for example,follow_investors retrive all record which context is follow and favorable type is investor
+      # sample output :
+      #   scope :focus_tags , where(:favorable_type => "Tag",:context => "focus")
+      # This function seems not useful in real life
+      #
+      # cons_context_match.each do |context,favorable|
+      #   favorable.each do |klass|
+      #     method_name = "#{context}_#{klass.to_s.tableize.tr('/','_')}".to_sym
+      #     scope method_name, where(:favorable_type => klass.to_s,:context => context.to_s)
+      #   end
+      # end
+
+      # just used in test
+      # But in production, I think it should be run once at init
+      # write how to use it in readme.md
+      def self.context_match_keys_should_belongs_to_context
+        cons_context_match.keys.all? { |key| cons_context.include? key.to_s }
+      end
+    end
+
+
+    module ClassMethods
+
+      # Generate dynamic class methods like add_focus, add_follow
+      # Favor.add_focus has at least two parameters as add_focus(operator,resource)
+      #  the operator is someone(maybe something) who has taken an action(context) on a resource
+      #  the resource is target
+      #  return an object with error when create favor failed
+      #
+      # Even method could receive a block to assign more attributes, but it is not recommended
+      # Favor is designed to handle simple data structure, mostly for simple relation data
+      #   just the user click one button or touch one link, then a favor was created
+      def generate_add_methods(name)
+        method_name = "add_#{name}".to_sym
+        define_singleton_method method_name do |operator,resource,other_field_option={}|
+          build_hash = other_field_option.merge(context: name)
+          favor = operator.favors.build build_hash
+          favor.favorable = resource
+          yield favor if block_given?
+          favor.save ? true : favor # check rails create method to make this ok
+        end
+      end
+
+      # Generate dynamic class methods like del_focus, del_follow
+      # Most like add_focus, but raise errors when delete favor failed
+      #   TODO: add exception object when raise errors or use the same raise of destroy
+      def generate_del_methods(name)
+        method_name = "del_#{name}".to_sym
+        define_singleton_method method_name do |ope,res,other_field_option={}|
+          query_hash = other_field_option.merge(context: name, favorable: res)
+          favor = ope.favors.where(query_hash)
+          if favor.present?
+            favor.first.destroy
+          else
+            false
+            # raise "delete favor failed,can not find favor object",caller
+          end
+        end
+      end
+
+      # seems just used for relations module
+      def host_klasses
+        attr = "host_klasses_for_#{name.underscore}".to_sym
+        respond_to?(attr) ? send(attr) : []
+      end
+
+      def favorable_klasses
+        attr = "favorable_klasses_for_#{name.underscore}".to_sym
+        respond_to?(attr) ? send(attr) : []
+      end
+
+      def favorable_to_media
+        :be_favors
+      end
+
+      def media_to_host
+        :host
+      end
+    end # end ClassMethods
+
+    private
+
+    def host_should_differ_favorable
+      if host_id == favorable_id and host_type == favorable_type
+        errors.add(:favorable_id," can not the same as the host_id when types of host and favorable are the same ")
+      end
+    end
+
+    def context_should_match_favorable_type
+      unless cons_context_match[context.to_sym].present? and
+          cons_context_match[context.to_sym].include? favorable_type.to_sym
+        errors.add(:context," and favorable type not included in context match")
+      end
+    end
+
+    # how to reslove two or more hook
+    def context_relation_hook
+      context_relation.each do |key,contexts|
+        if contexts.include? context.to_sym
+          other_context = contexts.select { |con| con != context.to_sym }.first
+          send("relation_#{key}_hook",other_context) if self.class.private_method_defined? "relation_#{key}_hook"
+        end
+      end
+    end
+
+    def relation_oppose_hook(other_context)
+      oppose_context = other_context
+      oppose_favor= Favor.where(:host => host, :context => oppose_context, :favorable => favorable)
+      oppose_favor.first.destroy if oppose_favor.presence
+    end
+
+  end
+end

data/lib/one_touch/models/array.rb

@@ -0,0 +1,12 @@
+class Array
+
+  # return a Hash
+  def each_relations_on(element,mark)
+    select {|e| e != element }.inject({}) do |memo,record|
+      memo.merge!({record => mark}) unless memo.keys.include? record
+      memo
+    end
+  end
+
+end
+

data/lib/one_touch/models/as_favor_host.rb

@@ -0,0 +1,68 @@
+module OneTouch
+  module AsFavorHost
+    extend ActiveSupport::Concern
+
+    included do
+
+      class_attribute :default_context_in_host, :instance_writer => false
+
+      if favor_class.respond_to? :host_relation_type and favor_class.host_relation_type == :polymorphic
+        scope :join_favors, joins(:favors.type(self))
+      else
+        scope :join_favors, joins(:favors)
+      end
+
+      scope :favorable_is, lambda { |sth| where(:favors => { :favorable => sth } ) }
+
+      # One module may not only host but also favorable, ex: User model
+      # when User as favorable, defined a method called context_as, so here define another method to distinct the former
+      scope :host_context_as, lambda { |context| where(:favors => { :context => context } ) }
+
+      if favor_class.respond_to? :host_relation_type # means favor class has load acts_as_favor
+        build_context_klass_methods
+      end
+    end
+
+    module ClassMethods
+
+      # if favor_class.host_relation_type == :polymorphic, then this will be automated executed
+      def rewrite_join_favors
+        scope :join_favors, joins(:favors.type(self))
+      end
+
+      def favor_to(favorable,context=default_context_in_host)
+        join_favors.host_context_as(context).
+          favorable_is(favorable)
+      end
+
+      def after_load_acts_as_favor
+        build_context_klass_methods
+      end
+
+      def build_context_klass_methods
+        favor_class.cons_context_match.each do |context, klasses|
+          klasses.each do |klass|
+            method_name = "#{context}_#{klass.to_s.underscore.pluralize}".to_sym
+            define_method method_name do
+              klass.to_s.constantize.favored_by(self,context)
+            end
+          end
+        end
+      end
+
+    end # End ClassMethods
+
+    # find the favor to target with specific context
+    # return ARelation object
+    def find_favor(target,context)
+      favors.where(context: context,favorable: target)
+    end
+
+    # check favor exist or not
+    # params is context and target
+    def favor?(target,context)
+      find_favor(target,context).present? ? true : false
+    end
+
+  end
+end

data/lib/one_touch/models/as_favorable.rb

@@ -0,0 +1,58 @@
+module OneTouch
+  module AsFavorable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_context_in_favorable, :instance_writer => false
+
+      scope :join_be_favors, joins(:be_favors.type(self))
+
+      scope :host_is, lambda { |someone|  where(:be_favors => { :host =>  someone } ) }
+      scope :context_as, lambda { |context| where(:be_favors => { :context => context } ) if context.present? }
+      scope :group_by_favorable, group("#{favor_klass.downcase.pluralize}.favorable_id")
+      # scope :includes_favors_and_hosts, includes(:be_favors => :host)
+
+    end # included
+
+    module ClassMethods
+
+      def allstars(context=default_context_in_favorable)
+        join_be_favors.context_as(context).group_by_favorable.
+          select("count(*) as counter, #{self.table_name}.*").order("counter desc")
+      end
+
+      def favored_by(user,context = default_context_in_favorable)
+        join_be_favors.context_as(context).
+          host_is(user)
+      end
+
+      def unfavored_by(user,context = default_context_in_favorable)
+        favored_by_ids = favored_by(user,context).map(&:id).presence || [0]
+        where(:id.not_in => favored_by_ids)
+      end
+
+    end # ClassMethods
+
+    def favors_count(cont=default_context_in_favorable)
+      be_favors.context_as(cont).count
+    end
+
+    # Return host list
+    #   same method to Host.favor_to, but different aspect
+    def favorers(host = default_host, context = default_context_in_favorable)
+      host.favor_to(self, context)
+    end
+
+    def favored_by?(ahost, context= default_context_in_favorable)
+      be_favors.where(:host => ahost, :context => context).present?
+    end
+
+    private
+
+    # Should be Overrided in favorable class
+    def default_host
+      ::User
+    end
+
+  end
+end

data/lib/one_touch/models/host_relation.rb

@@ -0,0 +1,31 @@
+module OneTouch
+  module HostRelation
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+
+      # results like
+      #   { [:focus, @tagA] => [ User1, User2, User3] , [:dislike, @tagB] => [ User2, User5 ] ... }
+      #   or { [ nil, @tagA] => [ Article1, Post2, User3] , [:nil, @tagB] => [ User2, User5 ] ... }
+      #   or { [[:Tag, 1], :focus] => [ [:User, 1], [:User, 2] ... ] } or
+      #   simply is { [:Tag, :focus] => [ [:User, 1], [:User, 2] ... ] } or
+      #   just as { 1 => [ [:User, 1], [:User, 2] ... ] }, 1 is the relation point
+      #   { TagA => [ :focus, User1, User2, User3] , TagB => [ :like, User2, User5 ] }
+      def host_relations(to_media, media_to_host)
+        includes(to_media.to_sym => media_to_host.to_sym).inject({}) do |memo,favorable|
+          favorable.send(to_media).each do |favor|
+            favor.respond_to?(:context) ? (context = favor.context) : (context = nil)
+            combine_key = [context, favorable]
+
+            host = favor.send media_to_host
+            memo.keys.include?(combine_key) ? memo[combine_key] << host : memo[combine_key] = [host]
+          end
+          memo
+        end
+      end
+    end # End ClassMethods
+  end
+end

data/lib/one_touch/models/relations.rb

@@ -0,0 +1,62 @@
+module OneTouch
+  module Relations
+    extend ActiveSupport::Concern
+
+    included do
+      # should add be_favors and host as a class attributes
+      class_attribute :favorable_klasses unless respond_to? :favorable_klasses
+      class_attribute :target_to_media, :media_to_host, :instance_writer => false
+    end
+
+    module ClassMethods
+
+      # build all favorable_to_host_relation
+      # results should be like Tag.host_relations
+      def build_relations
+        favorable_klasses.inject({}) do |memo,klass|
+          memo.merge(klass.to_s.constantize.host_relations(target_to_media, media_to_host))
+        end
+      end
+
+      # match relation and relation_rules, if relation did not match any rule, return 0 point
+      # This methods can be override by user
+      def matching_mark(relation_key)
+        @rule ||= relation_rules
+        transfer_key = relation_key.map { |ele| ele.is_a?(ActiveRecord::Base) ? ele.class.name.to_sym : ele.to_sym }
+        @rule[transfer_key].presence || 0
+      end
+
+      # Transfer ([User1, User2, User3], mark 5) to { User1 => { User2 => 5, User3 => 5 } ...}
+      #   and combine the origin relation
+      # the code is a little ugly
+      def array_hosts_to_hash(origin_relation,hosts,mark)
+        hosts.inject(origin_relation) do |memo,host|
+          each_relations= hosts.each_relations_on(host,mark)
+          # the old_relation and new_relation both are Hash
+          memo.merge!(host => each_relations) do |key,old_r,new_r|
+            old_r.merge!(new_r) do |key,old_mark,new_mark|
+              old_mark + new_mark
+            end
+          end
+        end
+      end
+
+      # Transfer favorable_to_host_relation to host_to_host_relations
+      # TODO: use fiber to improve performance
+      # TODO: No test for it
+      def host_relations
+        h_relation = {}
+        build_relations.each do |key, hosts|
+          h_relation = array_hosts_to_hash h_relation, hosts, matching_mark(key)
+        end
+        h_relation
+      end
+
+      # TODO: add this function
+      def favorable_relations
+      end
+
+    end # end ClassMethods
+
+  end
+end

data/lib/one_touch/railtie.rb

@@ -0,0 +1,14 @@
+require 'rails'
+require File.join(File.dirname(__FILE__), 'models/array') # maybe move it outside models folder
+
+module OneTouch
+
+  class Railtie < ::Rails::Railtie
+    initializer 'one_touch' do |app|
+      ActiveSupport.on_load(:active_record) do
+        require File.join(File.dirname(__FILE__), 'models/active_record_extension')
+        ::ActiveRecord::Base.send :include, OneTouch::ActiveRecordExtension
+      end
+    end
+  end # end Railtie
+end

data/lib/one_touch/version.rb

@@ -0,0 +1,3 @@
+module OneTouch
+  VERSION = "1.0.0"
+end

data/lib/one_touch.rb

@@ -0,0 +1,3 @@
+require "one_touch/version"
+require File.join(File.dirname(__FILE__), 'one_touch/railtie')
+require File.join(File.dirname(__FILE__), 'one_touch/engine')

data/one_touch.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "one_touch/version"
+
+Gem::Specification.new do |s|
+  s.name        = "one_touch"
+  s.version     = OneTouch::VERSION
+  s.authors     = ["raykin"]
+  s.email       = ["raykincoldxiao@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{ One Touch is used for recording relation between resources }
+  s.description = %q{ One Touch makes one click operation simple }
+
+  s.rubyforge_project = "one_touch"
+
+  s.add_runtime_dependency 'rails', '~> 3.0'
+  #s.add_development_dependency 'rails', '~> 3.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

data/readme.md

@@ -0,0 +1,122 @@
+### Intro
+In webapp, many data is generated by just one click like focus someone, dislike some post.This gem make it easy.
+
+These one click data most are relation data and managed in one single model in this gem. So we can analyze the relation data easily.
+
+## Dependency
+version ~> 1 support Rails3.0 and need meta_where
+version ~> 2 will support Rails3.1 and need squeel
+
+## Usage
+    gem install one_touch
+
+Suppose we have User, Post and Tag model.We also has a Favor model which record the relations between users or between user and post.Favor model could be anyother model.
+
+Then we define:
+```ruby
+    class User; as_favor_host; as_favorable; end;
+
+    class Post; as_favorable; end;
+
+    class Tag; as_favorable; end;
+
+    # Make sure Favor has defined constants CONTEXT and CONTEXT_MATCH before acts_as_favor
+    # The Favor column depend on the relations you defined
+    # In this case, it would be id, user_id, favorable_id, favorable_type, context
+    # Don't forget context column
+    class Favor
+      CONTEXT = Set.new(%w[focus favorite follow agree oppose buy subscribe])
+      CONTEXT_MATCH = { :focus => [:Tag, :Post], :follow => [:User] }
+
+      acts_as_favor
+    end
+    # The real relations between them are:
+    #   User has_many :favors, :class_name => "Favor", :as => :host
+    #   Post has_many :be_favors, :class_name => "Favor", :as => :favorable
+    #   Favor belongs_to :host, :class_name => "User"; belongs_to :favorable, :polymorphic => true
+    # This is default setting
+```ruby
+You can define the relation by yourself.
+```ruby
+    class Favor
+      belongs_to :host, :polymorphic => true
+      belongs_to :favorable, :polymorphic => true
+      acts_as_favor :no_default_relations => true
+    end
+    # make sure the relation name are host and favorable, they can not be changed
+```ruby
+Or you want Favor model to be another name, Bridge.
+```ruby
+    class User
+       as_favor_host :klass => "Bridge"
+    end
+```ruby
+In short, there are four relation names can not be configured, favors, be_favors, host and favorable.
+And if you change the Favor model name, make sure it consists in all applications.
+
+## Features
+    Favor.add_context and Favor.del_context can add or del favors. Ex:
+```ruby
+    # @host focus on @favorable
+    Favor.add_focus(@host, @favorable)
+    #=> success return true, fail return error @favor object
+    #=> could also
+
+    # @host remove focus on @favorable
+    Favor.del_focus(@host, @favorable)
+
+```ruby
+
+### Query Methods
+The most useful methods would be: favor_to, favored_by, allstars. They are all class methods.
+```ruby
+    User.favor_to(@user1, :follow) #=> return guys(an ActiveRelation object) who follows @user1, so you can define fans
+    def fans
+      User.favor_to(self, :follow)
+    end
+    @user1.fans # => the same results
+
+    Tag.favored_by(@user1, :focus) #=> return tag that @use1 focused
+
+    Tag.allstars(:focus) #=> return tags with a count attribute which returns how many focus on it
+
+    # Dynamic methods context_favorable_pluralize_klass, Ex:
+    @user1.focus_tags
+    # => return the tags which was focused by @user1
+    @user1.favor?(@tag1, :focus) #=> return true if @user1 focus on @tag1
+```ruby
+Actually the favor_to and favored_by are fundmental methods which many other methods based on
+
+#### Analyze Relation Data
+
+Use Favor.host_relations to get the relations of Users.
+But first you should define the relation mark rule.
+```ruby
+    class Favor
+      def self.relation_rules
+        { [:agree, :Answer] => 3, [:follow, :User] => 2, [:focus, :Tag] => 1 }
+      end
+    end
+```ruby
+
+The results like:
+```ruby
+    Favor.host_relations
+    # It a Hash, the first element is
+    # => @user1 => { @user2 => 100, @user3 => 50, .... }
+```ruby
+This means @user1 is more close to @user2 than @user3.Maybe the answers that @user1 and @user2 both agree are more than the answers that @user1 and @user2 both agree.Actually it depends on your mark rule, but it really shows there must be more common betweens @user1 and @user2.
+##### Becare running host_relations is really time consumer, so run it in backend job and keep the results.
+
+### Why call it one touch
+  Because We create or delete data in one click. No Form Needed.
+
+### TODO
+  Change the dependency meta_where to squeel and make it support Rails3.1
+  Add cache to favored_by, favor_to
+  Add a generator to make install faster.
+  Add another gem to supply view and controller template
+
+### Abstract Requirement
+  Connect any two resource in one model.
+  I really want to implement this gem as more abstract requirement.That means four relation names can be configured,  But's not easy.

data/spec/fake_app.rb

@@ -0,0 +1,76 @@
+require 'active_record'
+require 'action_controller/railtie'
+require 'action_view/railtie'
+
+# database
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('test')
+
+# config
+app = Class.new(Rails::Application)
+#app.config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+#app.config.session_store :cookie_store, :key => "_myapp_session"
+app.config.active_support.deprecation = :log
+app.initialize!
+#
+## routes
+#app.routes.draw do
+#  resources :users
+#end
+
+class Favor < ActiveRecord::Base
+
+  # CONTEXT is an array of string and do not change the string to symbol
+  #   CONTEXT_MATCH is all symbols, do not change it
+  CONTEXT = Set.new(%w[dig focus favorite follow dislike])
+  CONTEXT_MATCH = { :focus => [:Tag],:favorite => [:Tag],
+    :follow => [:User,:Investor], :dislike => [:User] }
+  CONTEXT_RELATION = { :oppose => [:follow, :dislike], :contain => [:favorite, :focus] }
+
+  # acts_as_favor # should run it after table has create
+
+  # belongs_to :host, :polymorphic => true
+  # belongs_to :favorable, :polymorphic => true
+
+  def self.relation_rules
+    { [:follow, :User] => 2, [:dislike, :User] => 2, [:focus, :Tag] => 1 }
+  end
+
+end
+
+class TestingFoo < ActiveRecord::Base
+  CONTEXT = Set.new(%w[follow dislike])
+  CONTEXT_MATCH = { :dislike => [:User] }
+  CONTEXT_RELATION = { :oppose => [:follow, :dislike] }
+end
+
+class Ask < ActiveRecord::Base
+end
+class User < ActiveRecord::Base
+end
+class Tag < ActiveRecord::Base
+end
+class Tagging < ActiveRecord::Base
+end
+
+#migrations
+class CreateAllTables < ActiveRecord::Migration
+  def self.up
+    create_table(:favors)  do |t|
+      t.references :host,:polymorphic => true # if user just need t.string user_id
+      t.references :favorable,:polymorphic => true
+      t.string :context
+    end
+    create_table(:users) {|t| t.string :email;t.string :name}
+    create_table(:tags) {|t| t.string :name}
+    #create_table(:readerships) {|t| t.integer :user_id; t.integer :book_id }
+    #create_table(:authorships) {|t| t.integer :user_id; t.integer :book_id }
+  end
+
+  def self.down
+    drop_table :favors
+    drop_table :users
+    drop_table :tags
+  end
+
+end

data/spec/models/acts_as_favor_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe OneTouch::ActsAsFavor do
+
+  include OneTouch::LoadTestData
+
+  context ActiveRecord::Base do
+    [:acts_as_favor,:as_favor_host,:as_favorable].each do |method_name|
+      it "should respond to #{method_name}" do
+        ActiveRecord::Base.should respond_to method_name
+      end
+    end
+  end
+
+  it "favorable class should has two elements: user and tag" do
+    Favor.favorable_klasses.count.should eq(2)
+    Favor.favorable_klasses.should include(:User,:Tag)
+  end
+
+  it "should check context against entity type when the context is invalid" do
+    afavor.update_attributes context: "error_context"
+    afavor.valid?.should be_false
+  end
+
+  it "should check context against entity type when the context is valid" do
+    afavor.update_attributes context: "follow"
+    afavor.valid?.should be_false
+  end
+
+  it "should save ok when context is favorite and essay is target resource" do
+    afavor.update_attributes context: "favorite"
+    afavor.valid?.should be_true
+  end
+
+  [:add_focus, :del_focus, :context_as_follow].each do |method_name|
+    it "should has an class method #{method_name}" do
+      Favor.should respond_to method_name
+    end
+  end
+
+  it "should add a focus to a tag " do
+    fly_favor = Favor.add_focus foo,fly_tag
+    fly_favor.should be_true
+    foo.favors.where(context: 'focus',favorable_id: fly_tag.id,favorable_type: 'Tag').first.should be_true
+  end
+
+  it " foo can not follow him self ,return an instance of Favor" do
+    Favor.add_follow(foo,foo).class.should eq(Favor)
+    # lambda {Favor.add_follow(foo,foo)}.should raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  it " keys of context_match should belongs to context " do
+    Favor.context_match_keys_should_belongs_to_context.should be_true
+  end
+
+  context TestingFoo do
+    it "should not contain method host_relations" do
+      TestingFoo.should_not respond_to 'host_relations'
+    end
+  end
+
+  describe "all stars" do
+
+    before :each do
+      Favor.add_follow(tom,foo)
+      Favor.add_follow(bar,foo)
+      Favor.add_follow(ray,foo)
+      Favor.add_follow(ray,bar)
+      Favor.add_follow(tom,bar)
+      Favor.add_follow(foo,ray)
+      Favor.add_follow(foo,tom)
+    end
+
+    it "keys of #build_relations should contains ['follow',foo]" do
+      Favor.build_relations.keys.should include(['follow',foo])
+    end
+
+    it "relation ['follow',foo] get 2 mark " do
+      first_build_relation = Favor.build_relations.select { |k,v| k.last == foo && k.first == 'follow' }
+      first_build_relation.keys.should include(['follow',foo])
+      Favor.matching_mark(first_build_relation.keys.first).should eq(2)
+    end
+
+    it "host relations should be a complex nested hash" do
+      h_relations = Favor.host_relations
+      h_relations.is_a? Hash
+      h_relations.values.first.is_a? Hash
+      foo_relations = h_relations.select {|k,v| k == foo}
+      foo_relations.values.should eq([{}])
+      bar_relations = h_relations.select {|k,v| k == bar}
+      bar_relations.values.should eq([{ tom => 2, ray => 2}])
+      bar_to_tom = bar_relations.values.select {|k,v| k== tom}
+      tom_relations = h_relations.select {|k,v| k == tom}
+      tom_to_bar = tom_relations.values.select {|k,v| k== bar}
+      bar_to_tom.should eq(tom_to_bar)
+    end
+
+  end
+
+end

data/spec/models/array_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Array do
+
+  it "#each_relations_on should return a relation hash" do
+    a=%w[foo bar tom]
+    a.each_relations_on("tom",5).should eq({"foo" => 5, "bar" => 5})
+  end
+
+end

data/spec/models/as_favor_host_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe OneTouch::AsFavorHost do
+
+  include OneTouch::LoadTestData
+  context "foo" do
+
+    [:focus_tags,:favor_klass].each do |method_name|
+      it "should response #{method_name}, and ActiveRecord::Base not response to it" do
+        foo.should respond_to method_name
+        ActiveRecord::Base.should_not respond_to method_name
+      end
+    end
+
+    it "should find a favor on afavor" do
+      foo.favor?(tag,"favorite").should be_true
+    end
+
+  end
+
+end

data/spec/models/as_favorable_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe OneTouch::AsFavorable do
+
+  include OneTouch::LoadTestData
+
+  context Tag do
+    it " should contain classmethod allstars" do
+      Tag.should respond_to(:allstars)
+    end
+
+    it "when context is nil, return all" do
+      all_tags = Tag.all
+      Tag.context_as(nil).should eq(all_tags)
+    end
+
+    it "first tag favors count should be 1" do
+      Tag.first.favors_count.should eq(1)
+    end
+
+  end
+
+  context "first tag" do
+    it " favored_by? foo is true " do
+      Tag.first.favored_by?(foo, :favorite).should be_true
+    end
+  end
+
+  context "User" do
+
+    before :each do
+      Favor.add_follow(tom,foo)
+      Favor.add_follow(bar,foo)
+      Favor.add_follow(ray,foo)
+      Favor.add_follow(ray,bar)
+      Favor.add_follow(tom,bar)
+      Favor.add_follow(foo,ray)
+      Favor.add_follow(foo,tom)
+    end
+
+    let(:foo_follows) { User.favored_by(foo, "follow") }
+
+    context Favor do
+      it "build relations should return a hash of relation between favorable and host" do
+        Favor.build_relations.instance_of?(Hash).should be_true
+        Favor.build_relations.first.first.should eq(["favorite", Tag.first]) # means first key
+      end
+
+    end
+
+    it "host relations should has key [foo,'follow'] " do
+      User.host_relations(:be_favors, :host).keys.should include(['follow', foo])
+    end
+
+    it "host relations of foo follow should be  tom, bar, ray" do
+      User.host_relations(:be_favors, :host)[['follow',foo]].should eq([tom,bar,ray])
+    end
+
+    it "allstars of be followed should has four guy,first one is foo,second is bar" do
+      allstars = User.allstars(:follow)
+      # allstars.count.should == 4 # it failed cause allstars.to_sql has a count(*)
+      allstars.all.count.should == 4
+      allstars.first.should eq(foo)
+      allstars.second.should eq(bar)
+      allstars.first.counter.should eq(3)
+    end
+
+    it "favored by foo should be ray and tom" do
+      foo_follows.first.should eq(ray)
+      foo_follows.second.should eq(tom)
+    end
+
+    # favor_to is defined in as_favor_host.rb
+    it "foo's fans should contains three guys that are tom,bar,ray" do
+      fans= User.favor_to(foo, "follow")
+      fans.all.count.should eq(3)
+      fans.should include(tom,ray,bar)
+    end
+
+    it "favorers of foo should be three guys  " do
+      favorers = foo.favorers(User,:follow)
+      favorers.count.should eq(3)
+      favorers.should include(tom,ray,bar)
+    end
+
+    # follow_users is defined in as_favor_host.rb
+    it "foo's follow_users should contains two guys as ray,tom" do
+      follows= foo.follow_users
+      follows.count.should eq(2)
+      follows.should include(ray,tom)
+    end
+
+    it " when foo dislike ray, foo's followings did not include ray " do
+      Favor.add_dislike(foo,ray)
+      foo_follows = User.favored_by(foo, "follow")
+      foo_follows.count.should eq(1)
+      foo_follows.should include(tom)
+      no_foo_follows = User.unfavored_by(foo, "follow")
+      no_foo_follows.count.should eq(User.count - 1)
+    end
+
+    it " unfollow singleone is all peoples " do
+      single_one = User.create(email: "singleone@test.com")
+      User.unfavored_by(single_one, 'follow').count.should eq(User.count)
+    end
+
+  end
+
+end

data/spec/models/load_test_data.rb

@@ -0,0 +1,17 @@
+module OneTouch
+  module LoadTestData
+
+    def self.included(base)
+      base.class_eval do
+        let!(:foo) { User.create(email: "foo@test.com",name: "iamfoo") }
+        let!(:bar) { User.create(email: "bar@test.com") }
+        let!(:ray) { User.create(email: "ray@test.com") }
+        let!(:tom) { User.create(email: "tom@test.com") }
+        let!(:tag) { Tag.create :name => "money" }
+        let!(:fly_tag) { Tag.create :name => "fly" }
+        let!(:afavor) { Favor.create :host_id => foo.id, :host_type => "User", :favorable_id => tag.id,:favorable_type => "Tag" , :context => "favorite" }
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rails'
+require 'one_touch'
+require File.join(File.dirname(__FILE__), 'fake_app')
+require 'meta_where'
+#require 'squeel'
+require 'rspec/rails'
+require 'models/load_test_data'
+
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+
+  config.before :all do
+    #CreateAllTables.down if ActiveRecord::Base.connection.table_exists? 'favors'
+    CreateAllTables.up unless ActiveRecord::Base.connection.table_exists? 'favors'
+
+    # Squeel.configure do |config|
+    #   config.load_core_extensions :hash, :symbol
+    # end
+
+    Tag.as_favorable
+
+    User.as_favor_host
+
+    User.as_favorable
+    Favor.acts_as_favor :host_class_name => nil
+    # TestingFoo.acts_as_favor
+    # Tag.as_favorable :be_tagging_favors, :klass => "Tagging"
+    # Ask.as_favor_host :tagging_favors, :klass => "Tagging"
+    # Tagging.acts_as_favor :host_class_name => nil, :favorable_klass_name => :Tag, :include_favor_relations_module => true
+    # relation should be in another module
+  end
+end
+

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: one_touch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- raykin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-11 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &25065280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *25065280
+description: ! ' One Touch makes one click operation simple '
+email:
+- raykincoldxiao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/one_touch.rb
+- lib/one_touch/engine.rb
+- lib/one_touch/models/active_record_extension.rb
+- lib/one_touch/models/acts_as_favor.rb
+- lib/one_touch/models/array.rb
+- lib/one_touch/models/as_favor_host.rb
+- lib/one_touch/models/as_favorable.rb
+- lib/one_touch/models/host_relation.rb
+- lib/one_touch/models/relations.rb
+- lib/one_touch/railtie.rb
+- lib/one_touch/version.rb
+- log/development.log
+- one_touch.gemspec
+- readme.md
+- spec/fake_app.rb
+- spec/models/acts_as_favor_spec.rb
+- spec/models/array_spec.rb
+- spec/models/as_favor_host_spec.rb
+- spec/models/as_favorable_spec.rb
+- spec/models/load_test_data.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: one_touch
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: One Touch is used for recording relation between resources
+test_files: []
+has_rdoc: