siphon 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e74e06bdcf94fdf9c64373f47e7e477098ccbbb7
-  data.tar.gz: 953a9d7dbb2adda4570775a3d4cabd488b855ba7
+  metadata.gz: c9cbec06f2449680deffd25cef9db8e0d217e522
+  data.tar.gz: c0fe656444c3e47bd1423ab40ee80afa76c58b91
 SHA512:
-  metadata.gz: 23ec3db1cc57a2387396f75933ef705157c3fc48355da20306e8e59f033b45dad2b7566ef6a77149154ad3f0861102716a631da336493c7391ef5577d7aacb2a
-  data.tar.gz: e02a1597243a1a7647e2fde9c2465eece79d789c656e9177ca1565facea45d3f1682ca73cb92d986371663f09deb3f529b68e316729ec2aa6cf2b262f12f6fa8
+  metadata.gz: 96c32edf06fe03b7fdb89f2056a11da27856410cd2750800ac5c5a1978387b605f00d44024a2b88f5f281aff3fb95aa377996047bb2da0fc1d5fb21568b1b8f1
+  data.tar.gz: 697a795ec9c66240c83fc70135e855aeae7c631af6c2dd751d70ca74a2ed797c443c0a271f036182a458322a283af345d8ece047b053e48f576cc58af2a5503c

data/.gitignore

@@ -8,8 +8,10 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
+bin/
 doc/
 lib/bundler/man
+lib/siphon/trials/
 pkg
 rdoc
 spec/reports

data/README.md

@@ -1,6 +1,7 @@
 # Siphon
 
-Siphon's a minimalistic gem which enables you to easily apply/combine/exclude your ActiveRecord scopes with params.
+Siphon's a minimalistic gem which enables you to easily and conditionnaly apply your ActiveRecord scopes with parameteres sent through the web.
+
 
 ## Installation
 
@@ -8,81 +9,83 @@ Add this line to your application's Gemfile:
 
     gem 'siphon'
 
+
 ## Usage
 
-Siphon is super simple and can be easily overidden. However for basic usage it has a couple of helpers.
+So Siphon's just a tiny convienience gem which is still quit experimental but it does its job of applying scopes to an activerecord model thanks to a formobject (using the great [virtus][1] here) containing the coerced values. 
+Here's how it works :
 
-### Basic Usage
+### The Scopes :
 
-    ```ruby
-    #books_controller.rb
-    
-    def collection
-      @books ||= Siphon.new(Book.includes(:auhtor)).
-        has_scopes({year: integer, author_name: :string}).filter(params)
+    # order.rb
+    class Order < ActiveRecord::Base
+      scope :stale, ->(duration) { where(["state='onhold' OR (state != 'done' AND updated_at < ?)", duration.ago]) }
+      scope :unpaid -> { where(paid: false) }
     end
 
-### Advanced Usage
-TODO: More examples
-
-    # books_siphon.rb
-    BookSiphon < Siphon
-      
-      def initialize
-        super
-        has_scopes({some: :integer, default: :boolean, scopes: nil})
-      end
-    
-      # def default
-      #   relation.paginate(:page => params[:page])
-      # end
+### The Form :
+
+    = form_for @order_form do |f|
+      = f.label :stale, "Stale since more than"
+      = f.select :stale, [["1 week", 1.week], ["3 weeks", 3.weeks], ["3 months", 3.months]], include_blank: true
+      = f.label :unpaid
+      = f.check_box :unpaid
+
+### The Form Object:
+
+    # order_form.rb
+    class OrderForm
+      include Virtus.model
+      include ActiveModel::Model
+      #
+      # attribute are the named scopes and their value are : 
+      # - either the value you pass a scope which takes arguments
+      # - either a Siphon::Nil value to apply (or not) a scope which has no argument
+      #
+      attribute :stale, Integer
+      attribute :unpaid, Siphon::Nil
     end
 
-## Why Siphon ?
 
-Thanks to Arel & ActiveRelation, Rails has an extraordinary, super powerful API to create scopes. You can chain them, merge them, pass them around, in what ever order you want, they'll just build the SQL you expect and only fire when necessary. 
+### Aaaaand... TADA siphon :
 
-However once you're in the controller all this beauty is lost if you want to start applying scopes conditionally - e.g : depending on params in the url.
+    # orders_controller.rb
+    def search 
+      @order_form = OrderForm.new(params[:order_form])
+      @orders = siphon(Order.all).scope(@order_form)
+    end
 
-One way of doing it is like that :
+Here's how it works : it takes an initial ActiveRelation (Order.all) and then from a FormObject (@order_form) it will apply or not a set of scopes with typecasted arguments.
 
-    def index
-      @results = Results.scoped
-      @results = @results.gender(params[:gender]) if params[:gender]
-      @results = @results.career(params[:career]) if params[:career]
-    end
 
-It's ugly, it doesn't scale and each time I see an `if` I hear the squeeking sound of a tree falling in the rain forest to build another Mc Donalds.
+## Advanced Usage
 
-## Why not Has_Scope ?
+You may want to check [how to combine siphon with ransack][2]
 
-So what about has_scope ?
 
-    # books_controller.rb
-    has_scope :gender
-    has_scope :career
-    
-    def index
-      @results = apply_scopes(Results).all
-    end
+## Some Insights
 
-and yee it was build by the awesome José Valim. But in my taste it suffers from the same problem Paperclip and all gem which rely on configuration with hashes have : Hashitis. 
+Siphon stands on the giant shoulder of Virtus which takes care of coercing the string values a form sends to the controller. But coercing is only solving one part of the problem. This is where siphon comes into play :
 
-    # tree_controller.rb
-    has_scope :color, :unless => :show_all_colors?
-    has_scope :only_tall, :type => :boolean, :only => :index, :if => :restrict_to_only_tall_trees?
-    has_scope :shadown_range, :default => 10, :except => [ :index, :show, :new ]
-    has_scope :root_type, :as => :root, :allow_blank => true
-    has_scope :calculate_height, :default => proc {|c| c.session[:height] || 20 }, :only => :new
+As you saw in the example a scope either takes an argument(s) or it doesn't so the idea is :
 
-As soon as you reach a certain level of complexity it looks as bad as if nested ifs were crawling all over your code. That's why most of us go for CarrierWave today : because well if you need behaviour why try to invent another DSL when you already have the best at hands : RUBY !
+1. either the field holds a value which is meant to be passed to the scope (like a date, a name, a duration, etc).
+2. either the scopes takes no argument and the boolean field (like a check box) only indicates if you want it applied or not.
 
-* You unclutter your controllers - which I like anorexic.
-* You're not limited by the set of configuration the gem gives you.
-* you can apply as much logic as you whish 
-* It's encapsultated, unit-testable & respects SRP
+So the values have two distinctive roles .
 
-Actually Siphon shouln't even be a gem but just a set of guidelines. But hey it has a cool name...
+In the case of `stale` which takes a duration :
+
+    = form_for @order_form do |f|
+      = f.label :stale, "Stale since more than"
+      = f.select :stale, [["1 week", 1], ["3 weeks", 3], ["9 weeks", 9]], include_blank: true
+
+If you select a duration the scope will be called and the argument will be turned into an integer and passed as an arg.
+But if you select the blank option the value of params[:stale] will be an empty string. Siphon knows it should be an integer thanks to the formobject and concludes this means no values are passed to the scope and therefore shouldn't be called.
+
+In the case of `unpaid` siphon knows it doesn't take any argument (Siphon::Nil) and therefore only calls the scope of the field when it's not falsy ("0", "f", "false" etc).
+
+That's all!
 
 ## Contributing
 
@@ -91,3 +94,6 @@ Actually Siphon shouln't even be a gem but just a set of guidelines. But hey it
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+[1]: https://github.com/solnic/virtus
+[2]: http:://www.coderwall.com/charly

data/TODO.md

@@ -0,0 +1,17 @@
+## TODO
+* [] default param values e.g : has_scopes({ state: "pending" })
+* [] play well with ransack
+* [] more complex examples
+
+## Investigate Crazy Idea
+
+A new dsl
+url: bla?published&after=1950author_lang="english"
+
+    @books = siphon(Book.includes :author)
+
+    # applies scope only if the corresponding params are present
+    @books.with(params).published.after(1900).author_lang("french")
+    # applies scope event if the params are absent but overrides argument ???
+    # may not be necessary : siphon(Book.order(params[:order] || "authors.birth"))
+    @books.ensure.instore(true).order("authors.birth")

data/lib/siphon/adapter.rb

@@ -0,0 +1,49 @@
+module Siphon
+  # ==========
+  #   Adapter
+  # ==========
+  #
+  # use : determine which scope will be called &
+  #       set relevant args to nil for
+  #
+  #
+  class Adapter
+
+    def initialize(formobj)
+      @formobj = formobj
+
+      @scopes_hash = @formobj.scopes
+      @argless = argless_list(formobj)
+    end
+
+    def call
+      filterout_empty_string_and_nil
+      apply_nil_on_argless_scopes
+    end
+
+  private
+    # if scope is present in form but with no value (aka 'empty string')
+    # or if present in formobj but not in form  (aka : value is nil)
+    # don't apply the scope && reject from scopes_hash
+    def filterout_empty_string_and_nil
+      @scopes_hash.delete_if { |scope, arg| ["", nil].include? @formobj[scope] }
+    end
+
+    # scope with no args are listed in @argless
+    # we loop & set their arg to nil (aka: no arg with splat)
+    # must be called AFTER filterout_empty_string_and_nil
+    def apply_nil_on_argless_scopes
+      @argless.each {|scope, v| @scopes_hash[scope]= nil if @scopes_hash[scope] }
+      @scopes_hash
+    end
+
+    # list of virtus attributes with Siphon::Nil type
+    def argless_list(formobj)
+      formobj.class.
+        attribute_set.
+        select {|a| a.class == Siphon::Nil}.
+        map(&:name)
+    end
+
+  end
+end

data/lib/siphon/base.rb

@@ -1,66 +1,30 @@
-#
-#
-#
 module Siphon
+  # ========
+  #   Base
+  # ========
+  #
+  # use : Handles the ActiveRelation on which
+  #       scopes from a **FormObject** will be applied
+  #
+  # e.g : Siphon::Base.new(Book.published).scope(BookForm.new(params[:q]))
+  #
   class Base
-    attr_accessor :relation, :scopes, :scope_datatypes
-
+    attr_accessor :relation
 
     # Siphon.new(Book.scoped)
     def initialize(relation)
       @relation = relation
     end
 
-    def filter(params)
-      @scopes = map_scope_datatypes( params, scope_datatypes )
+    def scope(formobject)
+      scopes_hash = Siphon::Adapter.new(formobject).call
 
-      scopes.each do |key, value|
-        self.relation= relation.send(key, *value)
+      scopes_hash.each do |meth, arg|
+        self.relation = relation.send(meth, *arg)
       end
 
       relation
     end
 
-    # Possible Datatype
-    # -----------------
-    # admin: nil
-    # category_name: String
-    # published: Boolean,
-    # age_gt:    Integer
-    # before:    Date
-    #
-    def has_scopes(scope_datatypes = {})
-      @scope_datatypes = scope_datatypes.symbolize_keys
-      self
-    end
-
-  private
-    # TODO : for now we're assuming scope_datatypes is a Hash, K ?
-    def map_scope_datatypes( params, scope_datatypes )
-      scope_hash = {}
-
-      params.symbolize_keys.each do |scope, value|
-        next unless scope_datatypes.has_key?(scope)
-        scope_hash[scope] = convert_type( value, scope_datatypes[scope] )
-      end
-
-      return scope_hash
-    end
-
-    def convert_type(value, type)
-      v = case type
-          when :integer
-            Integer(value)
-          when :boolean
-            value != "false"
-          when :string
-            value
-          when :none
-            nil
-          else
-            value == "nil" ? nil : value
-          end
-    end
-
-  end
+  end # Base
 end

data/lib/siphon/nil.rb

@@ -0,0 +1,12 @@
+require "virtus"
+
+module Siphon
+  class Nil < ::Virtus::Attribute
+
+    # if the value is false
+    def coerce(value)
+      [nil, "", "0", "false", "f", "F"].include?(value) ? nil : 1
+    end
+
+  end
+end

data/lib/siphon/version.rb

@@ -1,3 +1,3 @@
 module Siphon
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/siphon.rb

@@ -2,9 +2,10 @@ require "bundler/setup"
 
 require "active_support/core_ext"
 
-
 require "siphon/version"
 require "siphon/base"
+require "siphon/adapter"
+require "siphon/nil"
 
 module Siphon
   # Your code goes here...
@@ -13,14 +14,8 @@ module Siphon
     @siphon = Siphon::Base.new(args)
   end
 
-  def siphon_scopes
-    @siphon and Hash[ @siphon.scopes.map {|k, v| v||= "nil"; [k, v]} ]
-  end
-
-
 end
 
 ActiveSupport.on_load :action_controller do
   include Siphon
-  helper_method :siphon_scopes
 end

data/siphon.gemspec

@@ -26,4 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "pry"
+
+  spec.add_development_dependency "activemodel"
+  spec.add_development_dependency "virtus"
 end

data/spec/class/formobj.rb

@@ -0,0 +1,31 @@
+class Formobj
+
+  include Virtus.model
+
+  attribute :name,  String
+  attribute :after, Integer
+  attribute :admin, Boolean
+  attribute :order, String
+  attribute :stale, Siphon::Nil
+
+  attr_accessor :sinfull
+
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+
+
+  # def initialize(params = {})
+  #   params.each do |attr, value|
+  #     self.public_send("#{attr}=", value)
+  #   end if params
+
+  #   super()
+  # end
+
+  def scopes
+    attributes
+  end
+
+
+end

data/spec/siphon/adapter_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+
+describe Siphon::Adapter, focus: true do
+
+  describe "scope ->() {...}" do
+    context "when Formobject#attributes is coerced to Siphon::Nil" do
+      it "will not return the scope if the argument is false" do
+        formobj     = Formobj.new(stale: "0")
+
+        scopes_hash = Siphon::Adapter.new(formobj).call
+        expect(scopes_hash).to eq({})
+      end
+
+      it "will return the scope with nil if the argument's true" do
+        formobj     = Formobj.new(stale: "1")
+
+        scopes_hash = Siphon::Adapter.new(formobj).call
+        expect(scopes_hash).to eq({stale: nil})
+      end
+    end
+  end
+
+  describe "scope ->(args) {...}" do
+    context "when Formobject takes string values" do
+      it "will return Formobject typecasted values"  do
+        formobj = Formobj.new(after: "1950")
+
+        scopes_hash = Siphon::Adapter.new(formobj).call
+        expect(scopes_hash).to eq(after: 1950)
+      end
+    end
+
+    context "when Formobject#attributes returns empty strings" do
+      it "return hash withtout empty strings"  do
+        formobj     = Formobj.new(admin: "")
+
+        scopes_hash = Siphon::Adapter.new(formobj).call
+        expect(scopes_hash.keys).to_not include(:admin)
+      end
+    end
+  end
+end

data/spec/siphon/base_spec.rb

@@ -1,7 +1,5 @@
 require "spec_helper"
 
-class Tree
-end
 
 describe Siphon::Base do
 
@@ -19,79 +17,55 @@ describe Siphon::Base do
     end
   end
 
-  describe "#has_scopes" do
+  describe "#with", broken: true do
 
-    it "returns self" do
+    it "returns proxy" do
       siphon = Siphon::Base.new("")
 
-      expect(siphon.has_scopes({published: nil})).to  eq(siphon)
+      expect(siphon.with({published: nil})).to be_kind_of(Siphon::Proxy)
     end
 
-    it "sets scope_datatypes" do
-      siphon = Siphon::Base.new("").has_scopes(published: :integer)
+    it "sets params" do
+      siphon = Siphon::Base.new("").with(published: :integer)
 
-      expect(siphon.scope_datatypes).to eq(published: :integer)
+      expect(siphon.params).to eq(published: :integer)
     end
   end
 
-  describe "#filter" do
-
-    it "triggers a scope with string arg (default)" do
+  describe "#proxy", broken: true do
+    it "handles the scope calls" do
       relation = double
-      siphon = Siphon::Base.new(relation).has_scopes(name: nil)
-
-      expect(relation).to receive(:name).with("jack")
-
-      siphon.filter(name: "jack")
-    end
-
-    it "triggers a scope with an integer arg" do
-      relation = double
-      siphon = Siphon::Base.new(relation).has_scopes(age_gt: :integer)
-
-      expect(relation).to receive(:age_gt).with(18)
-
-      siphon.filter(age_gt: "18")
-    end
+      siphon = Siphon::Base.new(relation)
 
-    it "triggers a scope with a boolean arg" do
-      relation = double
-      siphon = Siphon::Base.new(relation).has_scopes(admin: :boolean)
 
-      expect(relation).to receive(:admin).with(false)
+      expect(relation).to receive(:admin).with("yes").and_return(relation)
+      expect(relation).to receive(:published).with("yes").and_return(relation)
 
-      siphon.filter(admin: "false")
+      siphon.with(admin: "yes", published: "yes").admin("no").published
     end
+  end
 
-    it "chains multiple scopes" do
+  describe "#recall", broken: true do
+    it "exposes a proxy whose method_missing will record calls to be recalled conditionally" do
       relation = double
-      siphon = Siphon::Base.new(relation).has_scopes(age_gt: :integer, admin: :boolean)
+      expect(relation).to receive(:admin).with("yes").and_return(relation)
+      expect(relation).to receive(:published).with("yes").and_return(relation)
 
-      expect(relation).to receive(:admin).with(false).and_return(relation)
-      expect(relation).to receive(:age_gt).with(18).and_return(relation)
-
-      siphon.filter(age_gt: "18", admin: "false")
+      Siphon::Base.new(relation).recall.admin("no").published.when({admin: "yes", published: "yes"})
     end
+  end
 
-    it "chains **only** scopes defined by has_scopes" do
+  describe "functional testing", broken: true  do
+    it "kinda works" do
       relation = double
-      siphon = Siphon::Base.new(relation).has_scopes(age_gt: :integer)
+      formobj = Formobj.new(admin: true, after: 1950, name: "")
 
-      expect(relation).to receive(:age_gt)
-      expect(relation).to_not receive(:controller)
+      expect(relation).to receive(:admin).with(true).and_return(relation)
+      expect(relation).to receive(:after).with(1950).and_return(relation)
 
-      siphon.filter(age_gt: "18", controller: "books_controller")
+      Siphon::Base.new(relation).admin(false).after(1).scope(formobj)
     end
   end
 
-  # TESTING PRIVATE METHOD !
-  describe "PRIVATE !! : #map_scope_datatypes" do
-
-    it "maps datatype date" do
-      pending "IGNORE & DELETE if not working"
-      siphon = Siphon::Base.new("")
-      siphon.map_scope_datatypes({age_gt: "18"}, {age_gt: :integer}).should == {age_gt: 18}
-    end
-  end
 
 end

data/spec/siphon/formobj_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+
+describe Formobj, idle: false do
+  describe "#attributes", idle: true do
+    it "returns a hash" do
+      formobj = Formobj.new(name: "proust", admin: "true", after: "1800")
+
+      expect(formobj.attributes).to be_a(Hash)
+    end
+
+    it "includes attributes not passed in initializer" do
+      formobj = Formobj.new(name: "proust")
+
+      expect(formobj.attributes.keys).to include(:admin, :order, :after)
+      # expect(formobj.attributes).to eq("blza")
+    end
+
+    it "does not include PORO attributes (attr_accessor)" do
+      formobj = Formobj.new(name: "proust")
+
+      expect(formobj.attributes.keys).to_not include(:sinfull)
+    end
+
+    context "when params.value's empty strings" do
+      it "returns empty string"  do
+        formobj = Formobj.new(name: "", admin: "", after: "")
+
+        expect(formobj.name).to eq ""
+        expect(formobj.after).to eq ""
+        expect(formobj.admin).to eq ""
+      end
+    end
+
+    context "when params.value's nil" do
+      it "returns nil"  do
+        formobj = Formobj.new(name: nil, admin: nil, after: nil)
+
+        expect(formobj.name).to eq nil
+        expect(formobj.after).to eq nil
+        expect(formobj.admin).to eq nil
+      end
+    end
+
+    context "when param is not present" do
+      it "returns default values"  do
+        formobj = Formobj.new()
+
+        expect(formobj.name).to eq "nabokov"
+        expect(formobj.after).to eq 1950
+        expect(formobj.admin).to eq false
+      end
+    end
+
+    context "when params.value has string values" do
+      it "returns typecasted values"  do
+        formobj = Formobj.new(name: "proust", admin: "true", after: "1800")
+
+        expect(formobj.name).to eq "proust"
+        expect(formobj.after).to eq 1800
+        expect(formobj.admin).to eq true
+      end
+
+      it "returns true with '1' " do
+        formobj = Formobj.new(admin: "1")
+        expect(formobj.admin).to eq true
+      end
+
+      it "DOES NOT RETURN TRUE with 'random' " do
+        formobj = Formobj.new(admin: "random")
+        expect(formobj.admin).to_not eq true
+      end
+
+      it "returns false with 'false' " do
+        formobj = Formobj.new(admin: "false")
+        expect(formobj.admin).to eq false
+      end
+
+      it "returns false with '0' " do
+        formobj = Formobj.new(admin: "0")
+        expect(formobj.admin).to eq false
+      end
+    end
+  end
+
+  describe "#attributes with nil arg" do
+    it "will do something ???? " do
+      pending "Put this in the siphon::nil tests...."
+      formobj = Formobj.new(stale: "0")
+
+      expect(formobj.stale).to eq("")
+    end
+  end
+end

data/spec/siphon/mapper_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+
+describe "Siphon::Mapper", broken: true do
+
+
+  describe "#yo" do
+
+    it "does awesome stuff" do
+
+      mapper = Siphon::Mapper.new([:active, name: "jfk", age: 18, published: true], [{name: "clinton"}, {age: "12"}, :published])
+
+
+      expect(mapper.types).to eq( "" )
+
+
+    end
+  end
+end

data/spec/siphon_spec.rb

@@ -1,11 +1,15 @@
+require "spec_helper"
 
+class Controller
+  include Siphon
+end
 
 describe Siphon do
+  let(:ctrl) {Controller.new}
 
   describe "#new" do
-
     it "shoot a Siphon::Base instance" do
-      expect(Siphon.apply_scope).to be_an_instance_of(Siphon::Base)
+      expect(ctrl.siphon("")).to be_an_instance_of(Siphon::Base)
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,18 +4,20 @@
 # loaded once.
 #
 require "siphon"
+require "pry"
 
+require "virtus"
+require "active_support"
+require "active_model"
+require "class/formobj"
 
-class ActiveRelation
-  def self.title_with
-  end
-end
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
-  config.filter_run :focus
+  config.filter_run_excluding( broken: true, idle: true )
+  # config.filter_run :focus
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: siphon
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Charles Sistovaris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-06 00:00:00.000000000 Z
+date: 2013-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,6 +80,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Siphon enables you to easily apply/combine/exclude your ActiveRecord
   scopes with params
 email:
@@ -96,12 +124,19 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- TODO.md
 - lib/siphon.rb
+- lib/siphon/adapter.rb
 - lib/siphon/base.rb
+- lib/siphon/nil.rb
 - lib/siphon/version.rb
 - siphon.gemspec
 - spec/class/active_relation.rb
+- spec/class/formobj.rb
+- spec/siphon/adapter_spec.rb
 - spec/siphon/base_spec.rb
+- spec/siphon/formobj_spec.rb
+- spec/siphon/mapper_spec.rb
 - spec/siphon_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/charly/siphon
@@ -131,6 +166,10 @@ summary: Siphon enables you to easily apply/combine/exclude your ActiveRecord sc
   with params
 test_files:
 - spec/class/active_relation.rb
+- spec/class/formobj.rb
+- spec/siphon/adapter_spec.rb
 - spec/siphon/base_spec.rb
+- spec/siphon/formobj_spec.rb
+- spec/siphon/mapper_spec.rb
 - spec/siphon_spec.rb
 - spec/spec_helper.rb