nexter 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc5b3a8f682a5e6c6190429e13c694c0e356d1d6
-  data.tar.gz: 16cd9f84c826b55a63dbd0c8559941ccf8ae171e
+  metadata.gz: 9fe3377bb4621f5dd4334001c71bfc251c1aab7a
+  data.tar.gz: b40d8a4a5dd7cfc932313cbceb18b538008e9bad
 SHA512:
-  metadata.gz: 0ae768b8cb07511b9e7889bb06c465445e1130aceb57550f3ea091a75a716702fadda4e6b159d8cef19e7114c0000e1c79bf8539a898f2a62f3ca4de688f6671
-  data.tar.gz: 66d07657f94d7f181b0d6966d3c82106dc52ef6815816d02e3615f9a89d4293bd7b202784c03d8c596866d178dbc8ad6ab429f5a26824104db1e38e157437165
+  metadata.gz: b19d7a48206c5276a18d6d6805c771d5d3f443047504d54b074a72ee1cfe9f77bf57743b5381f7a1738d276d72980f15f5df7af21168f7912edd13a8f33aa587
+  data.tar.gz: 7214177fefacbade18b798b5058a4b01979199fc4837ecfe5858af830fa3012a59e6fc184eddd0d13b0ce52e304589cd211bb07c0a9f4fbe867c2fd3d97121fc

data/.gitignore

@@ -16,3 +16,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+examples

data/lib/nexter.rb

@@ -1,11 +1,14 @@
 require "bundler/setup"
 
-require "active_support/core_ext"
-require "active_support/dependencies"
+require "active_support/all"
+# require "active_support/dependencies"
 
 require "nexter/version"
 require "nexter/wrap"
-require "nexter/derange"
+require "nexter/query"
+require "nexter/query/section"
+require "nexter/query/direction"
+
 require "nexter/compass"
 require "nexter/eyecontact"
 

data/lib/nexter/compass.rb

@@ -14,17 +14,15 @@ module Nexter
     end
 
     def bracket
-      signature == -1 ? '<' : '>'
+      sign == -1 ? '<' : '>'
     end
 
     def redirection
-      signature == -1 ? 'desc' : 'asc'
+      sign == -1 ? 'DESC' : 'ASC'
     end
 
-    private
-
-    def signature
-      DIREC[direction.to_sym] * GOTO[goto]
+    def sign
+      DIREC[direction.downcase.to_sym] * GOTO[goto]
     end
   end
 end

data/lib/nexter/query.rb

@@ -0,0 +1,37 @@
+module Nexter
+  class Query
+    attr_reader :columns, :compass, :wheres, :reorders
+
+    def initialize(columns, goto)
+      @columns = columns
+      @compass = Compass.new(goto)
+      @wheres = []
+      @reorders = []
+      iterate
+    end
+
+    def iterate
+      columns = @columns.dup
+
+      while column = columns.pop do
+        section   = Section.new(columns)
+        direction = Direction.new(column, compass)
+
+        reorders.unshift("#{column[:col]} #{direction.compass.redirection}")
+
+        next unless direction.slice
+
+        @wheres << "#{section.sql}#{section.blank? ? '' : ' AND '}#{direction.sql}"
+      end
+
+      # binding.pry
+      @wheres.compact!
+    end
+
+    alias sql iterate
+
+
+
+
+  end
+end

data/lib/nexter/query/direction.rb

@@ -0,0 +1,25 @@
+class Nexter::Query
+  class Direction
+    attr_reader :column, :compass
+    delegate :goto, :bracket, :redirection, to: :compass
+
+    def initialize(column, compass)
+      @column = column
+      @compass = compass
+      compass.direction = column[:dir]
+    end
+
+    def slice
+      if column[:val].present?
+        delimited = "#{column[:col]} #{bracket} '#{column[:val]}'"
+        delimited.concat(" OR #{column[:col]} IS NULL") if @compass.sign == 1
+        "(#{delimited})"
+      elsif @compass.sign == -1
+        "#{column[:col]} IS NOT NULL"
+      end
+    end
+    alias sql slice
+
+  end
+end
+

data/lib/nexter/query/section.rb

@@ -0,0 +1,38 @@
+class Nexter::Query
+
+  # Iterates over the columns, extracts their values
+  # and builds query part that says :
+  #
+  # > "col1 = value1"
+  # > "col2 = value2"
+  #
+  # then joins them with AND :
+  #
+  # > "col1 = value1 AND col2 = value2"
+  #
+  class Section
+    attr_reader :columns, :compass
+
+    # TODO : check if compass is needed (don't think so!)
+    def initialize(columns)
+      @columns = columns
+      @compass = compass
+    end
+
+    def iterate
+      @where ||= columns.map do |column|
+        if column[:val]
+          "#{column[:col]} = '#{column[:val]}'"
+        else
+          "#{column[:col]} IS NULL"
+        end
+      end.join(' AND ')
+    end
+    alias sql iterate
+
+    def blank?
+      iterate.blank?
+    end
+
+  end #section
+end

data/lib/nexter/version.rb

@@ -1,3 +1,3 @@
 module Nexter
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/nexter/wrap.rb

@@ -7,17 +7,11 @@ module Nexter
     # extracted values from the relation
     attr_reader :order_values, :associations
 
-    # list of build strings for finale SQL
-    attr_reader :wheres, :reorders
-
-
     def initialize(relation, model)
       @relation = relation
       @model = model
       @order_values = parse_order( relation.order_values )
       @associations = relation.includes_values
-      # @cursor_column = extract_attr( @ranges.pop )
-      # @cursor = model.send( @cursor_column.to_sym, )
     end
 
     # TODO : let user determine which strategy to choose:
@@ -31,37 +25,31 @@ module Nexter
     end
 
     def after
-      derange = cut(:next)
-      r = relation.where( wheres.join(' OR ') )
-      # r = r.order(:id) if derange.reorder
-      r
+      query = Query.new(map_column_values, :next)
+      relation.where( query.wheres.join(' OR ') )
     end
 
     def before
-      cut(:previous)
-      relation.where( wheres.join(' OR ') ).reorder( reorders.join(", ") )
+      query = Query.new(map_column_values, :previous)
+      relation.where( query.wheres.join(' OR ') ).
+              reorder( query.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 = []
-      derange = Nexter::Derange.new(model, goto)
-
-      while order_col = order_vals.pop do
-        derange.set_vals(order_vals, order_col)
-
-        # should be derange's result
-        wheres << derange.where
-        reorders.unshift(derange.reorder)
+    def map_column_values
+      @column_values ||= @order_values.map do |column|
+        {col: column[0], val: value_of(column[0]), dir: column[1]}
       end
+    end
 
-      derange
+  private
+    def value_of(cursor)
+      splits = cursor.split(".")
+      result = if splits.first == model.class.table_name || splits.size == 1
+        model.send(splits.last) if model.respond_to?(splits.last)
+      else
+        asso = model.class.reflections.keys.grep(/#{splits.first.singularize}/).first
+        asso = model.send(asso) and asso.send(splits.last)
+      end
     end
 
     # helper to turn mixed order attributes to a consistant

data/nexter.gemspec

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

data/spec/book.rb

@@ -1,13 +1,18 @@
 Book = Struct.new(:genre, :name, :title) do
 
+
   def id; 71; end
 
   def self.table_name
     "books"
   end
 
-  def reflections
-    {:author => "blurb"}
+  def self.sanitize(args)
+    "'#{args}'"
+  end
+
+  def self.reflections
+    {author: "blurb"}
   end
 
   def author

data/spec/nexter/compass_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Nexter::Compass do
+describe Nexter::Compass, focus: true do
 
   describe "#arrwo or #bracket" do
     context "when looking for *next*" do

data/spec/nexter/query/direction_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Nexter::Query::Direction do
+
+  let(:compass) {Nexter::Compass.new(:next)}
+  let(:columns) {[
+    {col: "authors.name",  val: "nabokov", dir: "asc"},
+    {col: "genre",         val: "novel",   dir: "asc"},
+    {col: "title",         val: "ada",     dir: "asc"}
+  ]}
+
+  describe "#slice", focus: true do
+
+    it "should be awesome" do
+      direction = Nexter::Query::Direction.new(columns.pop, compass)
+
+      expect(direction.slice).to eq("(title > 'ada' OR title IS NULL)")
+    end
+  end
+
+end

data/spec/nexter/query/section_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Nexter::Query::Section, focus: true do
+
+  # let(:compass) {Nexter::Compass.new(:next)}
+  let(:columns) {[
+    {col: "authors.name",  val: "nabokov", dir: "asc"},
+    {col: "genre",         val: "novel",   dir: "asc"},
+    {col: "title",         val: "ada",     dir: "asc"}
+  ]}
+
+  describe "#iterate" do
+
+    it "should iterate mother fucker" do
+      section = Nexter::Query::Section.new(columns)
+
+      expect(section.iterate).to eq(
+        "authors.name = 'nabokov' AND genre = 'novel' AND title = 'ada'")
+    end
+  end
+end

data/spec/nexter/query_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Nexter::Query, broken: true do
+
+  let(:columns) {[
+    {col: "authors.name",  val: "nabokov", dir: "asc"},
+    {col: "genre",         val: "novel",   dir: "asc"},
+    {col: "title",         val: "ada",     dir: "asc"}
+  ]}
+
+  describe "#where" do
+
+    it "builds the query from its ashes" do
+      query = Nexter::Query.new(columns, :next)
+
+      expect(query.wheres).to eq(
+        [ "authors.name = 'nabokov' AND genre = 'novel' AND title > 'ada'",
+          "authors.name = 'nabokov' AND genre > 'novel'",
+          "authors.name > 'nabokov'"])
+    end
+  end
+
+end

data/spec/nexter/wrap_spec.rb

@@ -1,8 +1,23 @@
 require "spec_helper"
 
 describe Nexter::Wrap do
+  let(:relation) {Relation.new.tap{|r| r.order_values=["authors.name","genre","title"]}}
+  let(:book)     {Book.new("novel", "nabokov", "ada")}
 
-  context "no missing values" do
+  describe "#map_column_values", focus: true do
+
+    it "should create hashes of attributes out of the order values" do
+      nexter = Nexter::Wrap.new(relation, book)
+
+      expect(nexter.map_column_values).to eq(
+        [ {col: "authors.name",  val: "nabokov", dir: "asc"},
+          {col: "genre",         val: "novel",   dir: "asc"},
+          {col: "title",         val: "ada",     dir: "asc"}
+        ])
+    end
+  end
+
+  context "no missing values", broken: true do
     let(:relation) { Relation.new.tap {|rel| rel.order_values=["authors.name", "title"]} }
     let(:book)     { Book.new("novel", "nabokov", "ada") }
 
@@ -27,36 +42,64 @@ describe Nexter::Wrap do
         nexter = Nexter::Wrap.new(relation, book)
         nexter.before
 
-        expect(nexter.reorders[0]).to eq(" authors.name desc")
+        expect(nexter.reorders[0]).to eq(" authors.name DESC")
       end
     end
   end
 
-  context "nil values" do
-    let(:relation) { Relation.new.tap {|rel| rel.order_values=["genre", "title"]} }
+  context "nil values", broken: true do
+    let(:relation) {Relation.new.tap {|r| r.order_values=["genre", "title", "id"]} }
 
-    describe "#wheres" do
+    describe "#wheres with Book#genre IS NULL" do
       let(:book) { Book.new(nil, "nabokov", "Ada") }
 
       it "has the right SQL condition" do
+        skip
         nexter = Nexter::Wrap.new(relation, book)
         nexter.after
 
-        expect(nexter.wheres[0]).to eq("(genre IS NULL AND title > 'Ada')")
+        expect(nexter.wheres).to eq("(genre IS NULL AND title > 'Ada')")
       end
     end
 
-    describe "#wheres" do
+    describe "#wheres with Book#title IS NULL" do
       let(:book) { Book.new("novel", "nabokov", nil) }
 
-      it "has the right SQL condition" do
+      it "has the right SQL condition for NEXT" do
         nexter = Nexter::Wrap.new(relation, book)
         nexter.after
 
-        expect(nexter.wheres[0]).to eq("(genre = 'novel' AND title IS NULL AND books.id > #{book.id})")
+        expect(nexter.wheres[0]).to \
+          eq("(genre = 'novel' AND title IS NULL AND id > '#{book.id}')")
+
+        expect(nexter.wheres[1]).to \
+          eq("(  genre > 'novel')")
+      end
+
+
+      it "has the right SQL condition for PREVIOUS" do
+        nexter = Nexter::Wrap.new(relation, book)
+        nexter.before
+
+        expect(nexter.wheres[0]).to \
+          eq("(genre = 'novel' AND title IS NULL AND id < '#{book.id}')")
+
+        expect(nexter.wheres[1]).to \
+          eq("(  genre > 'novel')")
       end
     end
 
+    describe "#after with Book#title IS NULL" do
+      let(:book) { Book.new("novel", "nabokov", nil) }
+
+      it "has the right SQL condition" do
+        nexter = Nexter::Wrap.new(relation, book)
+        nexter.after
+
+        expect(nexter.wheres[0]).to \
+          eq("(genre = 'novel' AND title IS NULL AND id > '#{book.id}')")
+      end
+    end
   end #contextr
 
 end

data/spec/spec_helper.rb

@@ -7,13 +7,14 @@
 require "book"
 require "nexter"
 require "active_support"
-# require "pry-rescue/rspec"
+require "pry"
 
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
-  config.filter_run :focus
+  config.filter_run focus: true
+  config.filter_run_excluding broken: true
 
   # 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: nexter
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Charles Sistovaris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-30 00:00:00.000000000 Z
+date: 2015-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,20 +94,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry-plus
-  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: '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.'
@@ -128,14 +114,18 @@ files:
 - Rakefile
 - lib/nexter.rb
 - lib/nexter/compass.rb
-- lib/nexter/derange.rb
 - lib/nexter/eyecontact.rb
+- lib/nexter/query.rb
+- lib/nexter/query/direction.rb
+- lib/nexter/query/section.rb
 - lib/nexter/version.rb
 - lib/nexter/wrap.rb
 - nexter.gemspec
 - spec/book.rb
 - spec/nexter/compass_spec.rb
-- spec/nexter/derange_spec.rb
+- spec/nexter/query/direction_spec.rb
+- spec/nexter/query/section_spec.rb
+- spec/nexter/query_spec.rb
 - spec/nexter/wrap_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/charly/nexter
@@ -158,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Wrap your model with an ordered scope and cut out the _next_ and _previous_
@@ -166,6 +156,8 @@ summary: Wrap your model with an ordered scope and cut out the _next_ and _previ
 test_files:
 - spec/book.rb
 - spec/nexter/compass_spec.rb
-- spec/nexter/derange_spec.rb
+- spec/nexter/query/direction_spec.rb
+- spec/nexter/query/section_spec.rb
+- spec/nexter/query_spec.rb
 - spec/nexter/wrap_spec.rb
 - spec/spec_helper.rb

data/lib/nexter/derange.rb

@@ -1,66 +0,0 @@
-module Nexter
-  class Derange
-
-    attr_reader :model, :compass, :table_name, :reorder
-
-    attr_accessor :delimiter, :columns, :trunks
-
-    delegate :goto, :bracket, :redirection, to: :compass
-
-
-    def initialize(model, goto)
-      @model = model
-      @table_name = model.class.table_name
-      @trunks = []
-      @reorder = false
-      @or_null = false
-      @compass = Nexter::Compass.new(goto)
-    end
-
-    def set_vals(order_vals, order_col)
-      @columns = order_vals
-      @delimiter = order_col[0]
-      compass.direction = order_col[1]
-    end
-
-    def where
-      "(#{range} #{range.blank? ? '' : 'AND'} #{slice})"
-    end
-
-    def reorder
-      " #{delimiter} #{redirection}"
-    end
-
-    def range
-      trunk = columns.map do |col|
-        if range_value = value_of(col[0])
-          # binding.pry
-          "#{col[0]} = #{model.class.sanitize range_value}"
-        else
-          "#{col[0]} IS NULL"
-        end
-      end.join(' AND ')
-    end
-
-    def slice
-      if val = value_of(delimiter)
-        d = model.class.sanitize val
-        delimited = "#{delimiter} #{bracket} #{d}"
-      else
-        # @reorder = true
-        "#{delimiter} IS NULL AND #{table_name}.id > #{model.id}"
-      end
-    end
-
-    def value_of(cursor)
-      splits = cursor.split(".")
-      result = if splits.first == table_name || splits.size == 1
-        model.send(splits.last)
-      else
-        # binding.pry
-        asso = model.class.reflections.keys.grep(/#{splits.first.singularize}/).first
-        asso = model.send(asso) and asso.send(splits.last)
-      end
-    end
-  end
-end

data/spec/nexter/derange_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Nexter::Derange do
-
-    let(:relation) { Relation.new }
-    let(:book)     { Book.new("novel", "nabokov", "Ada") }
-    let(:nexter)   { Nexter::Wrap.new(relation, book)}
-
-    describe "#range" do
-      it "returns a range of rows related to the current model (book)" do
-        derange = Nexter::Derange.new(book, :next)
-        derange.columns = nexter.order_values.tap(&:pop)
-
-        expect(derange.range).to eq("books.genre = 'novel' AND authors.name = 'nabokov'")
-      end
-
-      it "handles nil values" do
-        book.genre = nil
-        derange = Nexter::Derange.new(book, :next)
-        derange.columns = nexter.order_values.tap(&:pop)
-
-        expect(derange.range).to eq("books.genre IS NULL AND authors.name = 'nabokov'")
-      end
-
-      it "handles nil values (just for peace of mind)" do
-        book.name = nil
-        derange = Nexter::Derange.new(book, :next)
-        derange.columns = nexter.order_values.tap(&:pop)
-
-        expect(derange.range).to eq("books.genre = 'novel' AND authors.name IS NULL")
-      end
-    end
-
-    describe "#slice" do
-      it "returns a range of rows related to the current model (book)" do
-        derange = Nexter::Derange.new(book, :next)
-        order_col = nexter.order_values.pop
-        derange.set_vals(nexter.order_values, order_col)
-
-        expect(derange.slice).to eq("books.title > 'Ada'")
-      end
-
-      it "handles nil values" do
-        book.title = nil
-        derange = Nexter::Derange.new(book, :next)
-        order_col = nexter.order_values.pop
-        derange.set_vals(nexter.order_values, order_col)
-
-        expect(derange.slice).to eq("books.title IS NULL AND books.id > 71")
-      end
-    end
-
-end