inter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b72b65086332d83f591e0ace10b28c72d0b798eb
+  data.tar.gz: 9fd22162c416d7a85876a6b191e0fdeb8ba31965
+SHA512:
+  metadata.gz: b5119c156bdec468782df041b245d1e8c5d1115f12f955d706f26232be528ecf99cb782c6b245e441e1e8d01481247671d4e0364621579a5201416bbb45d506c
+  data.tar.gz: ff433a0f9b9ad5d38c5876053e9417c86ebd8517ca681dd4c61813402b69b464972f65d6e0677bbe9ef3ccf32c52fb35eeb7e426b526483c40c7fb3f5ecaa6c5

data/.gitignore

@@ -0,0 +1 @@
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+interactable

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    inter (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.0.1)
+      actionpack (= 4.0.1)
+      mail (~> 2.5.4)
+    actionpack (4.0.1)
+      activesupport (= 4.0.1)
+      builder (~> 3.1.0)
+      erubis (~> 2.7.0)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    activemodel (4.0.1)
+      activesupport (= 4.0.1)
+      builder (~> 3.1.0)
+    activerecord (4.0.1)
+      activemodel (= 4.0.1)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.1)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activesupport (4.0.1)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.1)
+    atomic (1.1.14)
+    builder (3.1.4)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.5)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.25)
+    minitest (4.7.5)
+    multi_json (1.8.2)
+    polyglot (0.3.3)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.0.1)
+      actionmailer (= 4.0.1)
+      actionpack (= 4.0.1)
+      activerecord (= 4.0.1)
+      activesupport (= 4.0.1)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.0.1)
+      sprockets-rails (~> 2.0.0)
+    railties (4.0.1)
+      actionpack (= 4.0.1)
+      activesupport (= 4.0.1)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.1.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    rspec-rails (2.14.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      railties (>= 3.0)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    sprockets (2.10.0)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.0.1)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (~> 2.8)
+    sqlite3 (1.3.8)
+    thor (0.18.1)
+    thread_safe (0.1.3)
+      atomic
+    tilt (1.4.1)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.38)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  inter!
+  rails
+  rake
+  rspec-rails
+  sqlite3

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Cristiano Betta <cbetta@gmail.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,176 @@
+# Inter
+
+Easily add arbitrary attributes to an ActiveRecord model on the fly, without the need of any extra new database columns or migrations.
+
+## Why?
+
+Ever added a 5th boolean to a model just so you could keep track if _something_ had happened to this user, article, etc? With __Inter__ you can add any arbitrary attributes to any ActiveRecord model on the fly without the need to add yet another database migration. Instead all __interactions__ are stored in a seperate table and hooked up using polymorphism. Using a simple DSL you can then quickly manipulate and query interactions.
+
+Benefits:
+
+* Cleaner models
+* Simple and powerful DSL
+* More lightweight than a full state machine
+* Can store any value
+
+## Usage
+
+## Dependencies
+
+* >= Ruby 2.0
+
+## Installation
+
+Add the gem to your Gemfile.
+
+```ruby
+gem "inter"
+```
+
+Then generate and run the database migrations.
+
+```shell
+rails generate inter:install
+rake db:migrate
+```
+
+And finally define an ActiveRecord model as an interactable.
+
+```ruby
+class Article < ActiveRecord::Base
+  include Inter::Actable
+end
+```
+
+## Basic usage
+
+### Instance methods
+
+Setting a value on an Article is now easy. Just pick a key name and set it to a desired value.
+
+```ruby
+# simple boolean setting and getting2
+article.is_published! # sets the published interaction to true
+article.isnt_published! # sets the published interaction to false
+article.is_published? #=> false
+
+# you can also combine keys
+article.is_published_and_not_promoted! #=> nil
+article.is_published_and_promoted? #=> false
+article.is_published_and_not_promoted? #=> true
+
+# more complex values
+article.set :tags, [:ruby, :rails, :gem] # or article.set "tags", [:ruby, :rails, :gem]
+article.get :tags #=> ["ruby", "rails", "gem"]
+article.has? :tags #=> true
+article.set :tags, nil
+article.has? :tags #=> false
+```
+
+### Class methods
+
+You can query interactable objects in a similar fasion.
+
+```ruby
+# similar to instance methods there are simple lookup methods
+Article.is_published #=> all articles for which published == true
+Article.isnt_published #=> all articles for which published != true
+
+# again you can combine interactions
+Article.is_published_and_promoted #=> all promoted and published articles
+```
+
+## Interaction history
+
+One of the advantages of Interactions is that they are kept as a permanent log. Thefefore you can easily look up if an interaction has ever happened in the past.
+
+```ruby
+# look up if an article has ever been published
+article.was_published? #=> false
+article.is_published! #=> nil
+article.isnt_published! #=> nil
+article.is_published? #=> false
+article.was_published? #=> true
+article.wasnt_published? #=> false
+
+# again you can combine keys
+article.was_published_and_promoted? #=> false
+
+# to fully inspect the log you need to dig a bit deeper
+# and access the interactions directly
+article.history :published #=> all interactions that match this key
+article.history "published"
+article.history :published, :promoted
+article.history ["published", "promoted"]
+```
+
+## Advanced usage
+
+A lot of the magic methods have underlying dumb methods that can be used too to further customize your needs.
+
+### Instance methods
+
+```ruby
+article.is "published" #=> nil
+article.is :published, :promoted #=> nil
+article.is [:published, :not_promoted] #=> nil
+article.is? :published, :promoted #=> false
+article.is? [:published, :not_promoted] #=> true
+article.get :promoted #=> true
+```
+
+### Class methods
+
+```ruby
+Article.inter(published: true) # loads all articles for which the current published state us true
+Article.inter(published: true).first # lazy loads the latest article
+# You can also get access to the raw interactions
+Article.interactions(published: true)
+```
+
+### Related lookup methods
+
+Finally if 2 related models are both interactable then you can query related models by interaction status.
+
+```ruby
+class Article < ActiveRecord::Base
+  include Inter::Actable
+  has_many :comments
+end
+
+class Comment < ActiveRecord::Base
+  include Inter::Actable
+  belongs_to :article
+end
+```
+
+```ruby
+article.comments.first.is_spam! #=> nil
+article.spam_comments #=> all comments with an interaction of "spam" set to true
+article.not_spam_comments #=> all comments with an interaction of "spam" != true
+article.spam_comments_ids #=> an array of IDs
+article.spam_comments_count #=> the length of all the comments that match the criteria
+
+# all of this maps down to the known pattern
+article.comments.inter(spam: true)
+```
+
+## Changelog
+
+* 0.0.2 Copied over implementation
+* 0.0.1 Gem skeleton
+
+## Contributors
+
+* [Cristiano Betta](http://github.com/cbetta) - Developer Evangelist - PayPal
+
+## Todos
+
+* Add a generator
+* Add tests
+* Add option to disable history
+
+## License
+
+See [LICENSE](/LICENSE)
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+desc "Set up and run tests"
+task :default => [:test]
+
+desc "Run tests"
+task :test do
+  sh "bundle exec rspec spec"
+end

data/inter.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "inter/version"
+
+Gem::Specification.new do |s|
+  s.name        = "inter"
+  s.version     = Inter::VERSION
+  s.authors     = ["Cristiano Betta"]
+  s.email       = ["cbetta@gmail.com"]
+  s.homepage    = "http://github.com/cbetta/inter"
+  s.summary     = "Smart interactions on any ActiveRecord model"
+  s.description = "An easy and simple way to keep track of interactions on an ActiveRecord model that would normally require a lot of boolean attributes to make possible."
+  s.license     = 'MIT License'
+
+  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"]
+
+  s.add_development_dependency "rails"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "sqlite3"
+end

data/lib/generators/inter/install_generator.rb

@@ -0,0 +1,15 @@
+module Inter
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+      desc "Installs Inter migrations"
+
+      def copy_migrations
+        time = Time.now.strftime("%Y%m%d%H%M%S")
+        template "create_interactions.rb", "db/migrate/#{time}_create_interactions.rb"
+
+        puts "Migrations completed. Please run `rake db:migrate` to finish the instalation"
+      end
+    end
+  end
+end

data/lib/generators/templates/create_interactions.rb

@@ -0,0 +1,13 @@
+class CreateInteractions < ActiveRecord::Migration
+  def change
+    create_table :interactions do |t|
+      t.integer  "interactable_id"
+      t.string   "interactable_type"
+      t.string   "key"
+      t.string   "value"
+      t.datetime "created_at",        null: false
+      t.datetime "updated_at",        null: false
+      t.boolean  "current",           default: true
+    end
+  end
+end

data/lib/inter.rb

@@ -0,0 +1,2 @@
+require "inter/actable"
+require "inter/action"

data/lib/inter/actable.rb

@@ -0,0 +1,172 @@
+module Inter
+  module Actable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.has_many :interactions, class_name: Inter::Action, as: :interactable
+    end
+
+    module ClassMethods
+      # def interaction key, value
+      #   interactions(key, value).first
+      # end
+
+      # def interactions key, value
+      #   Inter::Action.where(key: key, value: value.to_json, current: true, interactable_type: self.name)
+      # end
+
+      # def get *options
+      #   interaction(key, value).try(:interactable)
+      # end
+
+      # def get_all key, value
+      #   interactions(key, value).map{|int| int.interactable }
+      # end
+    end
+
+    def method_missing(meth, *args, &block)
+      case meth.to_s
+      when /^is_(.+)!$/
+        is *process($1)
+      when /^is(nt_.+)!$/
+        is *process($1)
+      when /^is_(.+)\?$/
+        is? *process($1)
+      when /^is(nt_.+)\?$/
+        is? *process($1)
+      when /^was_(.+)\?$/
+        was? *process($1)
+      when /^was(nt_.+)\?$/
+        was? *process($1)
+      else
+        super
+      end
+      # if meth.to_s =~ /^is_(.+)\?$/
+        # check_boolean_interactable($1)
+      # elsif meth.to_s =~ /^is_(.+)!$/
+        # is $1
+      # elsif meth.to_s =~ /^isnt_(.+)!$/
+        # isnt $1
+      # elsif meth.to_s =~ /^has_(.+)\?$/
+      #   check_length_interactable($1)
+      # elsif meth.to_s =~ /^all_([a-z]+)_counts$/
+      #   count_all_for $1
+      # elsif meth.to_s =~ /^([a-z_]+)_([a-z]+)_count$/
+      #   count_combined_interaction_relations $1, $2
+      # elsif meth.to_s =~ /^([a-z_]+)_([a-z]+)_ids$/
+      #   combined_interaction_relation_ids $1, $2
+      # elsif meth.to_s =~ /^([a-z_]+)_([a-z]+)$/
+      #   combined_interaction_relations $1, $2
+      # else
+        # super
+      # end
+    end
+
+    #
+    # Booleans
+    #
+    def is *names
+      [names].flatten.each do |name|
+        set key_for(name), value_for(name)
+      end
+    end
+
+    def is? *names
+      [names].flatten.each do |name|
+        value = value_for(name)
+        values = value == false ? [value, nil] : [value]
+        return false unless values.include?(get(key_for(name)))
+      end
+      true
+    end
+
+    #
+    # Complex values
+    #
+    def set key, value
+      interactions.create(key: key, value: value)
+    end
+
+    def get key
+      interactions.where(key: key, current: true).first.try(:value)
+    end
+
+    def has? key
+      get(key) != nil
+    end
+
+    #
+    # History
+    #
+    def was? *names
+      [names].flatten.each do |name|
+        if value_for(name)
+          return false if history(key_for(name)).count == 0
+        else
+          return false if history(key_for(name)).count > 0
+        end
+      end
+      true
+    end
+
+    def history *names
+      [names].flatten.map {|name| interactions.where(key: name)}.flatten
+    end
+
+    private
+
+    def process options
+      options.split("_and_")
+    end
+
+    def value_for name
+      name = name.to_s
+      !(name.starts_with?("not_") || name.starts_with?("is_not_") || name.starts_with?("isnt_") || name.starts_with?("was_not_") || name.starts_with?("wasnt_") || name.starts_with?("nt_"))
+    end
+
+    def key_for name
+      name = name.to_s
+      name.gsub(/^(is_not_)|(not_)|(isnt_)|(nt_)|(is_)|(was_not_)|(wasnt_)|(was_)/, "")
+    end
+
+
+    # private
+
+    # def check_boolean_interactable key
+    #   get(key) == true
+    # end
+
+    # def check_length_interactable key
+    #   interactions.where(key: key).count > 0
+    # end
+
+    # def count_all_for relation
+    #   relation_ids = send(relation).pluck(:id)
+    #   results = Inter::Action.where(interactable_id: relation_ids, current: true.to_s, value: true.to_s).pluck(:key)
+    #   results.inject(Hash.new(0)){|h,k| h[k] += 1; h}
+    # end
+
+    # def count_combined_interaction_relations interactions, relation
+    #   combined_interaction_relation_ids(interactions, relation).count
+    # end
+
+    # def combined_interaction_relations interactions, relation
+    #   ids = combined_interaction_relation_ids interactions, relation
+    #   klass = relation.singularize.capitalize.constantize
+    #   klass.find(ids)
+    # end
+
+    # def combined_interaction_relation_ids interactions, relation
+    #   interactions = interactions.split("_and_")
+    #   relation_ids = send(relation).pluck(:id)
+    #   interactions.each do |interaction|
+    #     value = true
+    #     if interaction.starts_with? "not_"
+    #       interaction = interaction.gsub("not_", "")
+    #       value = false
+    #     end
+    #     relation_ids &= Inter::Action.search(interaction, value, relation, relation_ids).pluck(:interactable_id).uniq
+    #   end
+    #   relation_ids
+    # end
+  end
+end