nano-pure-mod 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 68c5329af7cd7822e1648758a4ca2e005d76dfa59d7d07d5ab455ccffdc44f0b
+  data.tar.gz: 7423284fdcba7f453174a6c873f3383947581073163d382c3c466a3535b385cd
+SHA512:
+  metadata.gz: 34673a6f1b8fd25a57ca12cc5e78690ff7c0645c290ecb217e1cab4a3922a17e515cd411a3c1f4450e59127cbb3135cf5c37b0c749cd30f49ded38e538106d39
+  data.tar.gz: 68963f77bf04144db5e61ad9e48107f146a5546a446ce4a1d87e5fdb451b8839018d861e2f30ff1500b5d2d8df0bcb8bcb0df12759deedf3afe98602e60188a2

data/nano-pure-mod.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "nano-pure-mod"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on will_paginate"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/nano-pure-mod" }
+end

data/will_paginate-4.0.1/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+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/will_paginate-4.0.1/README.md

@@ -0,0 +1,58 @@
+# will_paginate
+
+will_paginate is a pagination library that integrates with Ruby on Rails, Sinatra, Hanami::View, and Sequel.
+
+``` ruby
+gem 'will_paginate', '~> 4.0'
+```
+
+See [installation instructions][install] on the wiki for more info.
+
+ℹ️ will_paginate is now in _maintenance mode_ and it will not be receiving new features. [See alternatives](https://www.ruby-toolbox.com/categories/pagination)
+
+## Basic will_paginate use
+
+``` ruby
+## perform a paginated query:
+@posts = Post.paginate(page: params[:page])
+
+# or, use an explicit "per page" limit:
+Post.paginate(page: params[:page], per_page: 30)
+
+## render page links in the view:
+<%= will_paginate @posts %>
+```
+
+And that's it! You're done. You just need to add some CSS styles to [make those pagination links prettier][css].
+
+You can customize the default "per_page" value:
+
+``` ruby
+# for the Post model
+class Post
+  self.per_page = 10
+end
+
+# set per_page globally
+WillPaginate.per_page = 10
+```
+
+New in Active Record 3:
+
+``` ruby
+# paginate in Active Record now returns a Relation
+Post.where(published: true).paginate(page: params[:page]).order(id: :desc)
+
+# the new, shorter page() method
+Post.page(params[:page]).order(created_at: :desc)
+```
+
+See [the wiki][wiki] for more documentation. [Report bugs][issues] on GitHub.
+
+Happy paginating.
+
+
+[wiki]: https://github.com/mislav/will_paginate/wiki
+[install]: https://github.com/mislav/will_paginate/wiki/Installation "will_paginate installation"
+[issues]: https://github.com/mislav/will_paginate/issues
+[css]: http://mislav.github.io/will_paginate/

data/will_paginate-4.0.1/lib/will_paginate/active_record.rb

@@ -0,0 +1,248 @@
+require 'will_paginate/per_page'
+require 'will_paginate/page_number'
+require 'will_paginate/collection'
+require 'active_record'
+
+module WillPaginate
+  # = Paginating finders for ActiveRecord models
+  # 
+  # WillPaginate adds +paginate+, +per_page+ and other methods to
+  # ActiveRecord::Base class methods and associations.
+  # 
+  # In short, paginating finders are equivalent to ActiveRecord finders; the
+  # only difference is that we start with "paginate" instead of "find" and
+  # that <tt>:page</tt> is required parameter:
+  #
+  #   @posts = Post.paginate :all, :page => params[:page], :order => 'created_at DESC'
+  #
+  module ActiveRecord
+    # makes a Relation look like WillPaginate::Collection
+    module RelationMethods
+      include WillPaginate::CollectionMethods
+
+      attr_accessor :current_page
+      attr_writer :total_entries
+
+      def per_page(value = nil)
+        if value.nil? then limit_value
+        else limit(value)
+        end
+      end
+
+      # TODO: solve with less relation clones and code dups
+      def limit(num)
+        rel = super
+        if rel.current_page
+          rel.offset rel.current_page.to_offset(rel.limit_value).to_i
+        else
+          rel
+        end
+      end
+
+      # dirty hack to enable `first` after `limit` behavior above
+      def first(*args)
+        if current_page
+          rel = clone
+          rel.current_page = nil
+          rel.first(*args)
+        else
+          super
+        end
+      end
+
+      # fix for Rails 3.0
+      def find_last(*args)
+        if !loaded? && args.empty? && (offset_value || limit_value)
+          @last ||= to_a.last
+        else
+          super
+        end
+      end
+
+      def offset(value = nil)
+        if value.nil? then offset_value
+        else super(value)
+        end
+      end
+
+      def total_entries
+        @total_entries ||= begin
+          if loaded? and size < limit_value and (current_page == 1 or size > 0)
+            offset_value + size
+          else
+            @total_entries_queried = true
+            result = count
+            result = result.size if result.respond_to?(:size) and !result.is_a?(Integer)
+            result
+          end
+        end
+      end
+
+      def count(*args)
+        if limit_value
+          excluded = [:order, :limit, :offset, :reorder]
+          excluded << :includes unless eager_loading?
+          rel = self.except(*excluded)
+          column_name = if rel.select_values.present?
+            select = rel.select_values.join(", ")
+            select if select !~ /[,*]/
+          end || :all
+          rel.count(column_name)
+        else
+          super(*args)
+        end
+      end
+
+      # workaround for Active Record 3.0
+      def size
+        if !loaded? and limit_value and group_values.empty?
+          [super, limit_value].min
+        else
+          super
+        end
+      end
+
+      # overloaded to be pagination-aware
+      def empty?
+        if !loaded? and offset_value
+          total_entries <= offset_value
+        else
+          super
+        end
+      end
+
+      def clone
+        copy_will_paginate_data super
+      end
+
+      # workaround for Active Record 3.0
+      def scoped(options = nil)
+        copy_will_paginate_data super
+      end
+
+      def to_a
+        if current_page.nil? then super # workaround for Active Record 3.0
+        else
+          ::WillPaginate::Collection.create(current_page, limit_value) do |col|
+            col.replace super
+            col.total_entries ||= total_entries
+          end
+        end
+      end
+
+      private
+
+      def copy_will_paginate_data(other)
+        other.current_page = current_page unless other.current_page
+        other.total_entries = nil if defined? @total_entries_queried
+        other
+      end
+    end
+
+    module Pagination
+      def paginate(options)
+        options  = options.dup
+        pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
+        options.delete(:page)
+        per_page = options.delete(:per_page) || self.per_page
+        total    = options.delete(:total_entries)
+
+        if options.any?
+          raise ArgumentError, "unsupported parameters: %p" % options.keys
+        end
+
+        rel = limit(per_page.to_i).page(pagenum)
+        rel.total_entries = total.to_i          unless total.blank?
+        rel
+      end
+
+      def page(num)
+        rel = if ::ActiveRecord::Relation === self
+          self
+        elsif !defined?(::ActiveRecord::Scoping) or ::ActiveRecord::Scoping::ClassMethods.method_defined? :with_scope
+          # Active Record 3
+          scoped
+        else
+          # Active Record 4
+          all
+        end
+
+        rel = rel.extending(RelationMethods)
+        pagenum = ::WillPaginate::PageNumber(num.nil? ? 1 : num)
+        per_page = rel.limit_value || self.per_page
+        rel = rel.offset(pagenum.to_offset(per_page).to_i)
+        rel = rel.limit(per_page) unless rel.limit_value
+        rel.current_page = pagenum
+        rel
+      end
+    end
+
+    module BaseMethods
+      # Wraps +find_by_sql+ by simply adding LIMIT and OFFSET to your SQL string
+      # based on the params otherwise used by paginating finds: +page+ and
+      # +per_page+.
+      #
+      # Example:
+      # 
+      #   @developers = Developer.paginate_by_sql ['select * from developers where salary > ?', 80000],
+      #                          :page => params[:page], :per_page => 3
+      #
+      # A query for counting rows will automatically be generated if you don't
+      # supply <tt>:total_entries</tt>. If you experience problems with this
+      # generated SQL, you might want to perform the count manually in your
+      # application.
+      # 
+      def paginate_by_sql(sql, options)
+        pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" } || 1
+        per_page = options[:per_page] || self.per_page
+        total    = options[:total_entries]
+
+        WillPaginate::Collection.create(pagenum, per_page, total) do |pager|
+          query = sanitize_sql(sql.dup)
+          original_query = query.dup
+          oracle = self.connection.adapter_name =~ /^(oracle|oci$)/i
+
+          # add limit, offset
+          if oracle
+            query = <<-SQL
+              SELECT * FROM (
+                SELECT rownum rnum, a.* FROM (#{query}) a
+                WHERE rownum <= #{pager.offset + pager.per_page}
+              ) WHERE rnum >= #{pager.offset}
+            SQL
+          elsif (self.connection.adapter_name =~ /^sqlserver/i)
+            query << " OFFSET #{pager.offset} ROWS FETCH NEXT #{pager.per_page} ROWS ONLY"
+          else
+            query << " LIMIT #{pager.per_page} OFFSET #{pager.offset}"
+          end
+
+          # perfom the find
+          pager.replace find_by_sql(query)
+
+          unless pager.total_entries
+            count_query = original_query.sub /\bORDER\s+BY\s+[\w`,\s.]+$/mi, ''
+            count_query = "SELECT COUNT(*) FROM (#{count_query})"
+            count_query << ' AS count_table' unless oracle
+            # perform the count query
+            pager.total_entries = count_by_sql(count_query)
+          end
+        end
+      end
+    end
+
+    # mix everything into Active Record
+    ::ActiveRecord::Base.extend PerPage
+    ::ActiveRecord::Base.extend Pagination
+    ::ActiveRecord::Base.extend BaseMethods
+
+    klasses = [::ActiveRecord::Relation]
+    if defined? ::ActiveRecord::Associations::CollectionProxy
+      klasses << ::ActiveRecord::Associations::CollectionProxy
+    else
+      klasses << ::ActiveRecord::Associations::AssociationCollection
+    end
+
+    # support pagination on associations and scopes
+    klasses.each { |klass| klass.send(:include, Pagination) }
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/array.rb

@@ -0,0 +1,33 @@
+require 'will_paginate/collection'
+
+class Array
+  # Paginates a static array (extracting a subset of it). The result is a
+  # WillPaginate::Collection instance, which is an array with a few more
+  # properties about its paginated state.
+  #
+  # Parameters:
+  # * <tt>:page</tt> - current page, defaults to 1
+  # * <tt>:per_page</tt> - limit of items per page, defaults to 30
+  # * <tt>:total_entries</tt> - total number of items in the array, defaults to
+  #   <tt>array.length</tt> (obviously)
+  #
+  # Example:
+  #   arr = ['a', 'b', 'c', 'd', 'e']
+  #   paged = arr.paginate(:per_page => 2)      #->  ['a', 'b']
+  #   paged.total_entries                       #->  5
+  #   arr.paginate(:page => 2, :per_page => 2)  #->  ['c', 'd']
+  #   arr.paginate(:page => 3, :per_page => 2)  #->  ['e']
+  #
+  # This method was originally {suggested by Desi
+  # McAdam}[http://www.desimcadam.com/archives/8] and later proved to be the
+  # most useful method of will_paginate library.
+  def paginate(options = {})
+    page     = options[:page] || 1
+    per_page = options[:per_page] || WillPaginate.per_page
+    total    = options[:total_entries] || self.length
+
+    WillPaginate::Collection.create(page, per_page, total) do |pager|
+      pager.replace self[pager.offset, pager.per_page].to_a
+    end
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/collection.rb

@@ -0,0 +1,136 @@
+require 'will_paginate/per_page'
+require 'will_paginate/page_number'
+
+module WillPaginate
+  # Any will_paginate-compatible collection should have these methods:
+  #
+  #   current_page, per_page, offset, total_entries, total_pages
+  #
+  # It can also define some of these optional methods:
+  #
+  #   out_of_bounds?, previous_page, next_page
+  #
+  # This module provides few of these methods.
+  module CollectionMethods
+    def total_pages
+      total_entries.zero? ? 1 : (total_entries / per_page.to_f).ceil
+    end
+
+    # current_page - 1 or nil if there is no previous page
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    # current_page + 1 or nil if there is no next page
+    def next_page
+      current_page < total_pages ? (current_page + 1) : nil
+    end
+
+    # Helper method that is true when someone tries to fetch a page with a
+    # larger number than the last page. Can be used in combination with flashes
+    # and redirecting.
+    def out_of_bounds?
+      current_page > total_pages
+    end
+  end
+
+  # = The key to pagination
+  # Arrays returned from paginating finds are, in fact, instances of this little
+  # class. You may think of WillPaginate::Collection as an ordinary array with
+  # some extra properties. Those properties are used by view helpers to generate
+  # correct page links.
+  #
+  # WillPaginate::Collection also assists in rolling out your own pagination
+  # solutions: see +create+.
+  # 
+  # If you are writing a library that provides a collection which you would like
+  # to conform to this API, you don't have to copy these methods over; simply
+  # make your plugin/gem dependant on this library and do:
+  #
+  #   require 'will_paginate/collection'
+  #   # WillPaginate::Collection is now available for use
+  class Collection < Array
+    include CollectionMethods
+
+    attr_reader :current_page, :per_page, :total_entries
+
+    # Arguments to the constructor are the current page number, per-page limit
+    # and the total number of entries. The last argument is optional because it
+    # is best to do lazy counting; in other words, count *conditionally* after
+    # populating the collection using the +replace+ method.
+    def initialize(page, per_page = WillPaginate.per_page, total = nil)
+      @current_page = WillPaginate::PageNumber(page)
+      @per_page = per_page.to_i
+      self.total_entries = total if total
+    end
+
+    # Just like +new+, but yields the object after instantiation and returns it
+    # afterwards. This is very useful for manual pagination:
+    #
+    #   @entries = WillPaginate::Collection.create(1, 10) do |pager|
+    #     result = Post.find(:all, :limit => pager.per_page, :offset => pager.offset)
+    #     # inject the result array into the paginated collection:
+    #     pager.replace(result)
+    #
+    #     unless pager.total_entries
+    #       # the pager didn't manage to guess the total count, do it manually
+    #       pager.total_entries = Post.count
+    #     end
+    #   end
+    #
+    # The possibilities with this are endless. For another example, here is how
+    # WillPaginate used to define pagination for Array instances:
+    #
+    #   Array.class_eval do
+    #     def paginate(page = 1, per_page = 15)
+    #       WillPaginate::Collection.create(page, per_page, size) do |pager|
+    #         pager.replace self[pager.offset, pager.per_page].to_a
+    #       end
+    #     end
+    #   end
+    #
+    # The Array#paginate API has since then changed, but this still serves as a
+    # fine example of WillPaginate::Collection usage.
+    def self.create(page, per_page, total = nil)
+      pager = new(page, per_page, total)
+      yield pager
+      pager
+    end
+
+    # Current offset of the paginated collection. If we're on the first page,
+    # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+    # the offset is 30. This property is useful if you want to render ordinals
+    # side by side with records in the view: simply start with offset + 1.
+    def offset
+      current_page.to_offset(per_page).to_i
+    end
+
+    def total_entries=(number)
+      @total_entries = number.to_i
+    end
+
+    # This is a magic wrapper for the original Array#replace method. It serves
+    # for populating the paginated collection after initialization.
+    #
+    # Why magic? Because it tries to guess the total number of entries judging
+    # by the size of given array. If it is shorter than +per_page+ limit, then we
+    # know we're on the last page. This trick is very useful for avoiding
+    # unnecessary hits to the database to do the counting after we fetched the
+    # data for the current page.
+    #
+    # However, after using +replace+ you should always test the value of
+    # +total_entries+ and set it to a proper value if it's +nil+. See the example
+    # in +create+.
+    def replace(array)
+      result = super
+      
+      # The collection is shorter then page limit? Rejoice, because
+      # then we know that we are on the last page!
+      if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+        self.total_entries = offset + length
+      end
+
+      result
+    end
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/core_ext.rb

@@ -0,0 +1,30 @@
+require 'set'
+
+# copied from ActiveSupport so we don't depend on it
+
+unless Hash.method_defined? :except
+  Hash.class_eval do
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+  end
+end
+
+unless String.method_defined? :underscore
+  String.class_eval do
+    def underscore
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/deprecation.rb

@@ -0,0 +1,55 @@
+module WillPaginate::Deprecation
+  class << self
+    def warn(message, stack = caller)
+      offending_line = origin_of_call(stack)
+      full_message = "DEPRECATION WARNING: #{message} (called from #{offending_line})"
+      logger = rails_logger || Kernel
+      logger.warn full_message
+    end
+
+    private
+
+    def rails_logger
+      defined?(Rails.logger) && Rails.logger
+    end
+
+    def origin_of_call(stack)
+      lib_root = File.expand_path('../../..', __FILE__)
+      stack.find { |line| line.index(lib_root) != 0 } || stack.first
+    end
+  end
+
+  class Hash < ::Hash
+    def initialize(values = {})
+      super()
+      update values
+      @deprecated = {}
+    end
+
+    def []=(key, value)
+      check_deprecated(key, value)
+      super
+    end
+
+    def deprecate_key(*keys, &block)
+      message = block_given? ? block : keys.pop
+      Array(keys).each { |key| @deprecated[key] = message }
+    end
+
+    def merge(another)
+      to_hash.update(another)
+    end
+
+    def to_hash
+      ::Hash.new.update(self)
+    end
+
+    private
+
+    def check_deprecated(key, value)
+      if msg = @deprecated[key] and (!msg.respond_to?(:call) or (msg = msg.call(key, value)))
+        WillPaginate::Deprecation.warn(msg)
+      end
+    end
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/i18n.rb

@@ -0,0 +1,22 @@
+module WillPaginate
+  module I18n
+    def self.locale_dir
+      File.expand_path('../locale', __FILE__)
+    end
+
+    def self.load_path
+      Dir["#{locale_dir}/*.{rb,yml}"]
+    end
+
+    def will_paginate_translate(keys, options = {}, &block)
+      if defined? ::I18n
+        defaults = Array(keys).dup
+        defaults << block if block_given?
+        ::I18n.translate(defaults.shift, **options.merge(:default => defaults, :scope => :will_paginate))
+      else
+        key = Array === keys ? keys.first : keys
+        yield key, options
+      end
+    end
+  end
+end

data/will_paginate-4.0.1/lib/will_paginate/locale/en.yml

@@ -0,0 +1,37 @@
+en:
+  will_paginate:
+    previous_label: "← Previous"
+    previous_aria_label: "Previous page"
+    next_label: "Next →"
+    next_aria_label: "Next page"
+    page_gap: "…"
+    container_aria_label: "Pagination"
+    page_aria_label: "Page %{page}"
+
+    page_entries_info:
+      single_page:
+        zero:  "No %{model} found"
+        one:   "Displaying 1 %{model}"
+        other: "Displaying all %{count} %{model}"
+      single_page_html:
+        zero:  "No %{model} found"
+        one:   "Displaying <b>1</b> %{model}"
+        other: "Displaying <b>all&nbsp;%{count}</b> %{model}"
+
+      multi_page: "Displaying %{model} %{from} - %{to} of %{count} in total"
+      multi_page_html: "Displaying %{model} <b>%{from}&nbsp;-&nbsp;%{to}</b> of <b>%{count}</b> in total"
+
+    # models:
+    #   entry:
+    #     zero:  entries
+    #     one:   entry
+    #     few:   entries
+    #     other: entries
+
+    # line_item:
+    #   page_entries_info:
+    #     single_page:
+    #       zero:  "Your shopping cart is empty"
+    #       one:   "Displaying one item in your cart"
+    #       other: "Displaying all %{count} items"
+    #     multi_page: "Displaying items %{from} - %{to} of %{count} in total"