test_fish0 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3dd996ed9f7ffef651e15e2e1ccd9c308aabd0e05b488c5c3e706616b4c2656a
+  data.tar.gz: 799b77b1d84372b044b5cd6f338babc3a0e0140e5fb8252e855084a9a18c8db1
+SHA512:
+  metadata.gz: 9a97c20d84d27cb4192397852df15fe60d73fdba2727314e5a99e3a008c316467cec5b2b24e94d72b5338e1e94665ed8c61f430302234dbf660c8aacf3ec45cb
+  data.tar.gz: 607dc072a84459d44a8c7e4acae0294856e5dfc4ce7174ca7ad5757d673a3e58456c022c750427fe402edf5ddada91a4d9c05bc07c61ec56ec4fde107affec23

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Dmitry Zuev
+
+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,174 @@
+# Fish0
+
+[![Build Status](https://api.travis-ci.org/rambler-digital-solutions/fish0.svg)](https://travis-ci.org/rambler-digital-solutions/fish0)
+[![Code Climate](https://codeclimate.com/github/rambler-digital-solutions/fish0/badges/gpa.svg)](https://codeclimate.com/github/rambler-digital-solutions/fish0)
+[![Gem Version](https://badge.fury.io/rb/fish0.svg)](https://badge.fury.io/rb/fish0)
+
+> The fish doesn't think because the fish knows everything.
+
+Fish0 is the plugin for read-only content websites with MongoDB storage. Works perfect with Rambler&Co CQRS architecture.
+
+## Installation
+
+Simply add gem to your `Gemfile`
+
+````
+gem 'fish0'
+````
+
+## Configuration
+
+```ruby
+# config/initializers/fish0.rb
+
+Fish0::Configuration.configure do |config|
+  config.mongo_uri = 'mongodb://user:password@host_1:27017,replica_host_2:27017/project_db?auth_source=admin'
+  config.mongo_params = { read: { mode: :secondary } }
+end
+```
+
+## Models
+
+Inherit your model class from `Fish0::Model` and feel the power of the Fish!
+
+With `attribute` define your attributes and with `primary_key` set your main primary key, e.g. `id`, `slug`, etc.
+
+```ruby
+# app/models/article.rb
+class Article < Fish0::Model
+  # Define some attributes
+  attribute :headline, String
+  attribute :slug, String
+  attribute :content, Array[Hash]
+  attribute :published_at, DateTime
+
+  primary_key :slug
+
+  # ...
+end
+
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  # ...
+
+  def show
+    @article = Article.where(slug: params[:slug]).first
+  end
+
+  # ...
+end
+```
+
+## Repository
+
+### Basic repository usage
+
+This code will get first article with `slug: 'content123'` from `articles` MongoDB collection, and return content with class `Article`.
+
+```ruby
+Fish0::Repository.new(:articles)
+                 .where(slug: 'content123')
+                 .first!
+```
+
+By default Fish0::Repository will coerce `:entity_class` from `:collection`, so you can skip this parameter.
+
+### Writing your own repository
+
+```ruby
+# app/services/article_repository.rb
+class ArticleRepository < Fish0::Repository
+  def initialize
+    super(:articles)
+  end
+
+  def published
+    where(visible: true, published_at: { '$lt': DateTime.now })
+  end
+end
+
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  # ...
+
+  def show
+    @article = Article.where(slug: params[:slug]).published.first!
+  end
+
+  # ...
+end
+```
+
+## Pagination
+
+```ruby
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  include Fish0::Concerns::Paginatable
+
+  def index
+    @articles = paginate(Article.published)
+  end
+
+  # ...
+
+  protected
+
+  def per_page
+    31
+  end
+
+  # ...
+end
+```
+
+## ViewModel
+
+ViewModel concern wraps Virtus around your models. It also adds `#to_partial_path` and `#type` methods. Method `#to_partial_path` helps render your models via `render` helper.
+
+
+```ruby
+# app/models/article.rb
+class Article
+  include Fish0::Concerns::ViewModel
+
+  attribute :headline, String
+  attribute :slug, String
+  attribute :content, Array[Hash]
+  attribute :published_at, DateTime
+
+  # ...
+end
+```
+
+## Cacheable
+
+If you want your models to support `#cache_key` method and use Rails caching, you should include Fish0::Concerns::Cacheable to such models.
+
+Your model should respond to `:updated_at` with DateTime object.
+
+```ruby
+# app/models/article.rb
+class Article
+  # ...
+  cacheable
+
+  # ...
+end
+
+# app/controllers/articles_controller.rb
+class ArticlesController < ApplicationController
+  # ...
+
+  def show
+    @article = Article.where(slug: params[:slug]).first!
+    if stale?(@article)
+      respond_to do |format|
+        format.html
+      end
+    end
+  end
+
+  # ...
+end
+```

data/Rakefile

@@ -0,0 +1,22 @@
+#!/usr/bin/env rake
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each { |f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc 'Run all specs in spec directory (excluding plugin specs)'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/fish0/collection.rb

@@ -0,0 +1,21 @@
+module Fish0
+  class Collection < Array
+    def cache_key
+      most_recent = select(&:updated_at).sort_by(&:updated_at).last
+
+      timestamp = time_to_string(most_recent ? most_recent.updated_at : Time.zone.now)
+
+      "#{objects_key}-#{timestamp}"
+    end
+
+    protected
+
+    def objects_key
+      Digest::MD5.hexdigest(map(&:primary_key_value).join)
+    end
+
+    def time_to_string(timestamp)
+      timestamp.strftime('%Y%m%d%H%M%S%9N')
+    end
+  end
+end

data/lib/fish0/concerns/base.rb

@@ -0,0 +1,90 @@
+module Fish0
+  module Concerns
+    module Base
+      extend ActiveSupport::Concern
+
+      def primary_key
+        self.class.primary_key
+      end
+
+      def primary_key_value
+        send(primary_key)
+      end
+
+      included do
+        class << self
+          def primary_key(val = @primary_key)
+            @primary_key = val
+            return default_primary_key unless @primary_key
+            @primary_key
+          end
+
+          def cacheable
+            include Concerns::Cacheable
+          end
+
+          def disable_coercion
+            include Virtus.model(coerce: false)
+          end
+          alias_method :skip_coercion, :disable_coercion # DEPRECATED
+
+          def enable_coercion
+            include Virtus.model(coerce: true)
+          end
+
+          def scope(name, body)
+            scopes << [name, body]
+          end
+
+          def scopes
+            @scopes ||= []
+          end
+
+          # rubocop:disable Style/TrivialAccessors
+          def default_scope(body)
+            @default_scope = body
+          end
+          # rubocop:enable Style/TrivialAccessors
+
+          def method_missing(method_name, *arguments, &block)
+            if repository.respond_to?(method_name)
+              repository.send(method_name, *arguments, &block)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, include_private = false)
+            repository.respond_to?(method_name) || super
+          end
+
+          protected
+
+          def default_primary_key
+            :slug
+          end
+
+          def entity
+            self
+          end
+
+          def collection
+            model_name.collection
+          end
+
+          def repository
+            rep = repository_class.new(collection: collection, entity_class: entity)
+            rep.instance_exec(&@default_scope) if @default_scope
+            scopes.each { |s| rep.scope(*s) }
+            rep
+          end
+
+          def repository_class
+            return "#{entity}Repository".constantize if "#{entity}Repository".safe_constantize
+            Fish0::Repository
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fish0/concerns/cacheable.rb

@@ -0,0 +1,37 @@
+module Fish0
+  module Concerns
+    module Cacheable
+      extend ActiveSupport::Concern
+
+      included do
+        def cache_key(*timestamp_names)
+          if timestamp_names.any?
+            cache_key_string(max_updated_column_timestamp(timestamp_names))
+          elsif (timestamp = max_updated_column_timestamp)
+            cache_key_string(timestamp)
+          else
+            "#{self.class.to_s.tableize}/#{primary_key_value}"
+          end
+        end
+
+        private
+
+        def timestamp_attributes_for_update
+          [:updated_at]
+        end
+
+        def max_updated_column_timestamp(timestamp_names = timestamp_attributes_for_update)
+          timestamp_names
+            .map { |attr| self[attr] }
+            .compact
+            .map(&:to_time)
+            .max
+        end
+
+        def cache_key_string(timestamp)
+          "#{self.class.to_s.tableize}/#{primary_key_value}-#{timestamp.utc.to_s(:nsec)}"
+        end
+      end
+    end
+  end
+end

data/lib/fish0/concerns/equalable.rb

@@ -0,0 +1,10 @@
+module Fish0
+  module Concerns
+    module Equalable
+      def ==(other)
+        other.class == self.class && other.attributes == attributes
+      end
+      alias eql? ==
+    end
+  end
+end

data/lib/fish0/concerns/paginatable.rb

@@ -0,0 +1,25 @@
+module Fish0
+  module Concerns
+    module Paginatable
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :page
+
+        protected
+
+        def page
+          @page ||= (params[:page].to_i || 1)
+        end
+
+        def paginate(collection)
+          Fish0::Paginator.new(collection, page_number: page, per_page: per_page).to_collection
+        end
+
+        def per_page
+          22
+        end
+      end
+    end
+  end
+end

data/lib/fish0/concerns/view_model.rb

@@ -0,0 +1,20 @@
+module Fish0
+  module Concerns
+    module ViewModel
+      extend ActiveSupport::Concern
+
+      included do
+        include Virtus.model
+        attribute :type, String
+
+        def type
+          (super || '').demodulize.underscore
+        end
+
+        def to_partial_path
+          type.to_s
+        end
+      end
+    end
+  end
+end

data/lib/fish0/configuration.rb

@@ -0,0 +1,30 @@
+module Fish0
+  ##
+  # Fish0::Configuration
+  #
+  # Usage:
+  #   # config/initializers/fish0.rb
+  #   Fish0::Configuration.configure do |config|
+  #     config.mongo_uri = 'mongodb://user:password@host_1:27017,replica_host_2:27017/'\
+  #       'fish0_development?auth_source=admin'
+  #     config.mongo_params = { read: { mode: :secondary } }
+  #   end
+  #
+
+  class Configuration
+    include ActiveSupport::Configurable
+
+    # Usage:
+    # Enter your full mongo_uri (can include username, password, multiple hosts, ports, db name,
+    # and additional options as get-parameters
+    config_accessor :mongo_uri do
+      'mongodb://localhost:27017/fish0_development'
+    end
+
+    # Usage:
+    # Enter your as second argument to MongoClient::New
+    config_accessor :mongo_params do
+      { read: { mode: :secondary } }
+    end
+  end
+end

data/lib/fish0/engine.rb

@@ -0,0 +1,12 @@
+module Fish0
+  class Engine < ::Rails::Engine
+    isolate_namespace Fish0
+
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.fixture_replacement :factory_girl, dir: 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/fish0/exceptions.rb

@@ -0,0 +1,3 @@
+module Fish0
+  class RecordNotFound < StandardError; end
+end

data/lib/fish0/model.rb

@@ -0,0 +1,10 @@
+module Fish0
+  class Model
+    extend ActiveModel::Naming
+    include Fish0::Concerns::Base
+    include Fish0::Concerns::ViewModel
+    include Fish0::Concerns::Equalable
+
+    skip_coercion
+  end
+end

data/lib/fish0/paginator.rb

@@ -0,0 +1,55 @@
+module Fish0
+  class Paginator
+    include Enumerable
+    delegate :each, :to_collection, :skip, :limit, :padding, :fetch, to: :collection
+
+    attr_reader :collection
+
+    def initialize(collection, page_number: 1, per_page: 22, padding: 0)
+      raise ArgumentError,
+            'you can paginate only Fish0::Repository' unless collection.is_a?(Fish0::Repository)
+      @collection = collection
+      @per = per_page
+      @page = page_number
+      @padding = padding
+      per(per_page)
+      page(page_number)
+    end
+
+    def page(value = @page)
+      @page = value
+      skip((@page - 1) * @per + @padding)
+      self
+    end
+
+    def per(value = @per)
+      @per = value
+      skip((@page - 1) * @per + @padding)
+      limit(@per)
+      self
+    end
+
+    def padding(value)
+      @padding = value
+      page
+      skip
+      self
+    end
+
+    def total
+      collection.count
+    end
+
+    def current_page
+      @page
+    end
+
+    def pages
+      (total.to_f / @per).ceil
+    end
+
+    def last_page?
+      current_page >= pages
+    end
+  end
+end

data/lib/fish0/repository.rb

@@ -0,0 +1,125 @@
+module Fish0
+  class Repository
+    attr_reader :source,
+                :collection,
+                :conditions,
+                :order,
+                :skip_quantity,
+                :limit_quantity,
+                :entity_class
+
+    include Enumerable
+
+    delegate :aggregate, to: :source
+    delegate :each, to: :to_collection
+
+    def initialize(collection:, entity_class: nil, source: nil)
+      raise ArgumentError, 'you should provide collection name' unless collection
+      @collection = collection
+      @source = source ? source[collection] : Fish0.mongo_reader[collection]
+      @conditions = default_conditions
+      @order = {}
+      @limit_quantity = 0
+      @skip_quantity = 0
+      @entity_class = entity_class || String(collection).singularize.camelize.constantize
+    end
+
+    def find_one(query)
+      where(query).first
+    end
+
+    def find_one!(query)
+      find_one(query) || raise(RecordNotFound, "can't find in #{collection} with #{conditions}")
+    end
+
+    def to_collection
+      Fish0::Collection.new(fetch.map(&to_entity))
+    end
+
+    def find(filter = nil, options = {})
+      @source.find filter.dup, options
+    end
+
+    def all
+      self
+    end
+
+    def projection(values)
+      @projection = values
+      self
+    end
+
+    def distinct(field)
+      @source.distinct field, @conditions
+    end
+
+    def first
+      element = fetch.limit(1).first
+      to_entity.call(element) if element
+    end
+
+    def first!
+      first || raise(RecordNotFound, "can't find in #{collection} with #{conditions}")
+    end
+
+    def where(query)
+      conditions.merge!(query)
+      self
+    end
+
+    def search(string)
+      where('$text' => { '$search' => string })
+      self
+    end
+
+    def order_by(query)
+      order.merge!(query)
+      self
+    end
+
+    def limit(value)
+      @limit_quantity = value
+      self
+    end
+
+    def skip(value)
+      @skip_quantity = value
+      self
+    end
+
+    def scope(name, body)
+      return if respond_to?(name)
+
+      unless body.respond_to?(:call)
+        raise ArgumentError, 'The scope body needs to be callable.'
+      end
+
+      define_singleton_method(name) do |*args|
+        instance_exec(*args, &body)
+        self
+      end
+    end
+
+    def fetch
+      scoped = find(conditions, sort: order)
+      scoped = scoped.projection(@projection) if @projection
+      scoped = scoped.skip(skip_quantity) if skip_quantity.positive?
+      scoped = scoped.limit(limit_quantity) if limit_quantity.positive?
+      scoped
+    end
+
+    def count
+      find(conditions).count
+    end
+
+    protected
+
+    def default_conditions
+      {}
+    end
+
+    def to_entity
+      -> (attrs) { entity_class.new(attrs) }
+    end
+  end
+end

data/lib/fish0/version.rb

@@ -0,0 +1,3 @@
+module Fish0
+  VERSION = '0.2.0'.freeze
+end