nexter 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74be5ca9400c99265d287af71bcaa55370a6135d
-  data.tar.gz: 0259777790818ed8426315b0f280e1b39ab18ff4
+  metadata.gz: 18207b8538b39dd309f1481c2b69fc8b50261cef
+  data.tar.gz: ee8714526f27d7653ff607833daf07070491feb4
 SHA512:
-  metadata.gz: d146b475e29d127b036f6b322791d354359483f1e23a8c7cb7270814f223d9a7ebb001f43e403b1130dcaf1f454d6bd5c993d95529e345085e65372d096bea70
-  data.tar.gz: e367f99e56ed4f79bff25a3b0aad121df2c10e578c2c6604b523870c234232a3744f69ce1b0453c82ea0c9314acdabafd9a8991ecd526b125ba01de50dd4ead5
+  metadata.gz: 58c0c99e1ef15ebc00c9c1534c09bf68ca7dfb51d8b491c53998ac167a054d35de0a3cefb2b3bcc34925260c33bcad683701ba814a0c418c2ad72538770b4bf3
+  data.tar.gz: 24c2d7d37d54e2f9d62e4eed0d7766ca5e64705a4c3f61ab544def97fddeaa125f36fa884d6f6f35180cc4f8d780b93b263f4fe3a47ecd9e4b78f07cb7a23118

data/.pryrc

@@ -0,0 +1,2 @@
+require "nexter"
+require "../spec/book"

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.ruby-version

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

data/README.md

@@ -1,6 +1,6 @@
 # Nexter
 
-What is Nexter ? A misspelled tv show or a killer feature ? Almost : it wraps your model with an ordered scope and cuts out the _next_ and _previous_ record. It also works with associations nested columns.
+What is Nexter ? A misspelled tv show or a killer feature ? Not sure but it wraps your ActiveRecord model with an ordered scope and consistently cuts out the _next_ and _previous_ records. It also works with associations & nested columns : `order("books.genre, authors.name, published_at desc")` 
 
 ## Installation
 
@@ -9,13 +9,59 @@ What is Nexter ? A misspelled tv show or a killer feature ? Almost : it wraps yo
 ## Usage
 
 ```ruby
-@bboks = Book.where("type" = "novel").includes(:author).order("type", "authors.name", "title")
-nexter = Nexter.wrap( @books.find(56), @books )
+@books = Book.includes(:author).bestsellers.
+              order("genre", "authors.name", "published_at desc")
 
-nexter.next
+nexter = Nexter.wrap( @books.find(56), @books )
 nexter.previous
+nexter.next
 ```
 
+## Use Case Full Stack
+
+It helps you cycle consistentely through each record of any filtered collection instead of helplessly hit the back button of your browser to find the next item of your search. It plays well with gem which keeps the state of an `ActiveRelation like [siphon](https://github.com/charly/siphon), [ransack](https://github.com/activerecord-hackery/ransack), [has_scope](https://github.com/plataformatec/has_scope) & others.
+
+```ruby
+class Book
+  def nexter=(relation)
+    @nexter = Nexter.wrap(relation, self)
+  end
+
+  def next
+    @nexter.next || self
+  end
+
+  def previous
+    @nexter.previous || self
+  end
+end
+```
+
+```ruby
+class BookController
+  before_filter :resource, except: :index
+
+  def resource
+    @book_search = BookSearch.new(params[:book_search])
+
+    @book ||= Book.includes([:author]).find(params[:id]).tap do |book|
+      book.nexter = siphon(Book.scoped).scope(@book_search)
+    end
+  end
+end
+```
+
+```erb
+<%= link_to "previous", book_path(@book.previous, book_search: params[:book_search]) %>
+<%= link_to "collection", book_path(book_search: params[:book_search]) %>
+<%= link_to "next", book_path(@book.next, book_search: params[:book_search])
+```
+
+## TODO
+
+- (docs) How it works
+- (feature) Joins ?
+- (docs) previous/next through ctrl (not preloaded)
 
 ## Contributing
 

data/lib/nexter/version.rb

@@ -1,3 +1,3 @@
 module Nexter
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/nexter/wrap.rb

@@ -0,0 +1,100 @@
+module Nexter
+  class Wrap
+
+    attr_reader :model, :relation
+
+    # extracted values from the relation
+    attr_reader :order_values, :associations
+
+    # list of build strings for finale SQL
+    attr_reader :wheres, :reorders
+
+    DIREC  = {asc: 1, desc: -1}
+    GOTO = {next: 1, previous: -1}
+
+    def initialize(relation, model)
+      @relation = relation
+      @model = model
+      @order_values = arrayize( relation.order_values )
+      @associations = relation.includes_values
+      # @cursor_column = extract_attr( @ranges.pop )
+      # @cursor = model.send( @cursor_column.to_sym, )
+    end
+
+    def next
+      after.first
+    end
+
+    def previous
+      before.first
+    end
+
+
+    def after
+      cut(:next)
+      relation.where( wheres.join(' OR ') )
+    end
+
+    def before
+      cut(:previous)
+      relation.where( wheres.join(' OR ') ).reorder( reorders.join(", ") )
+    end
+
+  private
+    # model.order(a, b,c) loop
+    # 1. ( (a and b and c > c.val)
+    # 2. (a and b > b.val)
+    # 3. (a > a.val))
+    def cut(goto = :next)
+      order_vals = @order_values.dup
+      @wheres = []
+      @reorders = []
+
+      while order_col = order_vals.pop do
+
+        inrange_of = order_vals.map {|col| "#{col[0]} = '#{value_of(col[0])}'"}.join(' AND ')
+        inrange_of = "#{inrange_of} AND" unless inrange_of.blank?
+
+        direction = order_col[1]
+        sign      = signature(direction, goto)
+
+        bigger_than  = "#{order_col[0]} #{get_bracket(sign)} '#{value_of(order_col[0])}'"
+
+        wheres << "( #{inrange_of} #{bigger_than} )"
+        reorders.unshift(" #{order_col[0]} #{get_direction(sign)}")
+      end
+    end
+
+    def signature(dir, goto)
+      sign = DIREC[dir.to_sym] * GOTO[goto]
+    end
+
+    def get_bracket(sign)
+      sign == -1 ? '<' : '>'
+    end
+
+    def get_direction(sign)
+      sign == -1 ? 'desc' : 'asc'
+    end
+
+    def value_of(cursor)
+      splits = cursor.split(".")
+      if splits.first == model.class.table_name || splits.size == 1
+        model.send(splits.last)
+      else
+        asso = model.reflections.keys.grep(/#{splits.first.singularize}/).first
+        model.send(asso).send(splits.last)
+      end
+    end
+
+    # helper to turn mixed order attributes to a consistant
+    def arrayize(array)
+      array.join(",").split(",").map(&:strip).map do |column|
+        splits = column.split(" ").map(&:strip).map(&:downcase)
+        splits << "asc" if splits.size == 1
+        splits
+      end
+    end
+
+  end
+end

data/nexter.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = Nexter::VERSION
   spec.authors       = ["Charles Sistovaris"]
   spec.email         = ["charlysisto@gmail.com"]
-  spec.description   = %q{What is Nexter ? A misspelled tv show or a killer feature ? Almost : it wraps your model with an ordered scope and cuts out the _next_ and _previous_ record. It also works with associations nested columns.}
+  spec.description   = %q{What is Nexter ? A misspelled tv show or a killer feature ? Almost : it wraps your model with an ordered scope and cuts out the next and previous record. It also works with associations & nested columns.}
   spec.summary       = %q{Wrap your model with an ordered scope and cut out the _next_ and _previous_ record.}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/charly/nexter"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/spec/book.rb

@@ -0,0 +1,37 @@
+Author = Struct.new(:b)
+
+Book = Struct.new(:a, :b, :c) do
+
+  def self.table_name
+    "books"
+  end
+
+  def reflections
+    {:author => "blurb"}
+  end
+
+  def author
+    Author.new("nabokov")
+  end
+end
+
+class Relation
+  attr_accessor :order_values, :includes_values
+
+  def order_values
+    @order_values ||= ["books.a", "authors.b", "books.c"]
+  end
+
+  def includes_values
+    [:author]
+  end
+
+  def where(args)
+    self
+  end
+
+  def reorder(args)
+    self
+  end
+
+end

data/spec/nexter/wrap_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Nexter::Wrap do
+
+  describe "#wheres" do
+    it "has the right SQL condition" do
+      relation = Relation.new.tap {|rel| rel.order_values=["authors.b", "c"]}
+      book = Book.new("novel", "nabokov", "ada")
+      nexter = Nexter::Wrap.new(relation, book)
+      nexter.after
+
+      expect(nexter.wheres[0]).to eq("( authors.b = 'nabokov' AND c > 'ada' )")
+      expect(nexter.wheres[1]).to eq("(  authors.b > 'nabokov' )")
+    end
+  end
+
+
+  describe "#reorders" do
+    it "has the right SQL condition" do
+      relation = Relation.new.tap {|rel| rel.order_values=["authors.b", "c"]}
+      book = Book.new("novel", "nabokov", "ada")
+      nexter = Nexter::Wrap.new(relation, book)
+      nexter.before
+
+      expect(nexter.wheres[0]).to eq("( authors.b = 'nabokov' AND c < 'ada' )")
+    end
+
+    it "has the right SQL order by" do
+      relation = Relation.new.tap {|rel| rel.order_values=["authors.b", "c"]}
+      book = Book.new("novel", "nabokov", "ada")
+      nexter = Nexter::Wrap.new(relation, book)
+      nexter.before
+
+      expect(nexter.reorders[0]).to eq(" authors.b desc")
+    end
+  end
+
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require "book"
+require "nexter"
+require "active_support"
+
+
+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
+
+  # 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
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Charles Sistovaris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-20 00:00:00.000000000 Z
+date: 2013-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -95,8 +95,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: 'What is Nexter ? A misspelled tv show or a killer feature ? Almost :
-  it wraps your model with an ordered scope and cuts out the _next_ and _previous_
-  record. It also works with associations nested columns.'
+  it wraps your model with an ordered scope and cuts out the next and previous record.
+  It also works with associations & nested columns.'
 email:
 - charlysisto@gmail.com
 executables: []
@@ -104,14 +104,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .pryrc
+- .rspec
+- .ruby-version
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/nexter.rb
 - lib/nexter/version.rb
+- lib/nexter/wrap.rb
 - nexter.gemspec
-homepage: ''
+- spec/book.rb
+- spec/nexter/wrap_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/charly/nexter
 licenses:
 - MIT
 metadata: {}
@@ -136,5 +143,8 @@ signing_key:
 specification_version: 4
 summary: Wrap your model with an ordered scope and cut out the _next_ and _previous_
   record.
-test_files: []
+test_files:
+- spec/book.rb
+- spec/nexter/wrap_spec.rb
+- spec/spec_helper.rb
 has_rdoc: