solidus_content 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e98fe492987ee0529a11e434b3d832a76ff4eeb07e44f3084d9eb1b79b18c87e
+  data.tar.gz: f73fd253f4f1ccbd4aca79833bcfc2ceb15aa5c27f2064cda84cf64dacea300d
+SHA512:
+  metadata.gz: 256fb4d66dfa430f90638cb31688ac951f3860f7951e8366253a1935628c99e7ba0197c1611d075adf7cc8200a786e241c9f0dc8d9a1d1f67d818f4c86f44b2c
+  data.tar.gz: da6e62c6b2fe8fe5e26c225df3fe511fecec3575213d44aa618cb29dfe36e8d01203a9e0984225359a530e97f4177191bccc13ec7fea862878e38ec7f49cc498

data/.circleci/config.yml

@@ -0,0 +1,72 @@
+version: 2.1
+
+orbs:
+  # Always take the latest version of the orb, this allows us to
+  # run specs against Solidus supported versions only without the need
+  # to change this configuration every time a Solidus version is released
+  # or goes EOL.
+  solidusio_extensions: solidusio/extensions@volatile
+
+jobs:
+  run-specs-with-postgres:
+    executor: solidusio_extensions/postgres
+    steps:
+      - solidusio_extensions/run-tests
+  run-specs-with-mysql:
+    executor: solidusio_extensions/mysql
+    steps:
+      - solidusio_extensions/run-tests
+  lint-code:
+    executor: solidusio_extensions/sqlite-memory
+    steps:
+      - checkout
+      - run:
+          name: 'Solidus master: Generate Gemfile.lock'
+          command: bundle lock
+          environment:
+            SOLIDUS_BRANCH: master
+          when: always
+      - restore_cache:
+          name: 'Solidus master: Restore Bundler cache'
+          keys:
+            - gems-v3-ruby-v2-5-6-solidus-master-{{ .Branch }}-{{ checksum "Gemfile.lock" }}
+            - gems-v3-ruby-v2-5-6-solidus-master-
+          when: always
+      - run:
+          name: 'Solidus master:  Install gems'
+          command: bundle install --path=vendor/bundle
+          environment:
+            SOLIDUS_BRANCH: master
+          when: always
+      - save_cache:
+          name: 'Solidus master: Save Bundler cache'
+          key: gems-v3-ruby-v2-5-6-solidus-master-{{ .Branch }}-{{ checksum "Gemfile.lock" }}
+          paths:
+            - vendor/bundle
+          when: always
+      - run:
+          name: 'Runs RuboCop on Solidus master'
+          command: bundle exec rubocop -ESP
+          environment:
+            SOLIDUS_BRANCH: master
+            TEST_RESULTS_PATH: test-results/gems-v3-ruby-v2-5-6-solidus-master/results.xml
+          when: always
+
+workflows:
+  "Run specs on supported Solidus versions":
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql
+      - lint-code
+
+  "Weekly run specs against master":
+    triggers:
+      - schedule:
+          cron: "0 0 * * 4" # every Thursday
+          filters:
+            branches:
+              only:
+                - master
+    jobs:
+      - run-specs-with-postgres
+      - run-specs-with-mysql

data/.gem_release.yml

@@ -0,0 +1,5 @@
+bump:
+  recurse: false
+  file: 'lib/solidus_content/version.rb'
+  message: Bump SolidusContent to %{version}
+  tag: true

data/.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy
+spec/examples.txt
+/sandbox
+.rvmrc
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,38 @@
+require:
+  - solidus_dev_support/rubocop
+
+AllCops:
+  Exclude:
+    - sandbox/**/*
+    - spec/dummy/**/*
+    - vendor/bundle/**/*
+
+RSpec/DescribeClass:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Rails/ApplicationRecord:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - spec/**/*
+    - db/migrate/**/*
+    - bin/**/*
+
+RSpec/NestedGroups:
+  Enabled: false
+
+RSpec/VerifiedDoubles:
+  IgnoreSymbolicNames: true

data/Gemfile

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+branch = ENV.fetch('SOLIDUS_BRANCH', 'master')
+gem 'solidus', github: 'solidusio/solidus', branch: branch
+
+# Needed to help Bundler figure out how to resolve dependencies,
+# otherwise it takes forever to resolve them.
+# See https://github.com/bundler/bundler/issues/6677
+gem 'rails', '>0.a'
+
+# Provides basic authentication functionality for testing parts of your engine
+gem 'solidus_auth_devise'
+
+case ENV['DB']
+when 'mysql'
+  gem 'mysql2'
+when 'postgresql'
+  gem 'pg'
+else
+  gem 'sqlite3'
+end
+
+# Supported content providers
+gem 'contentful'
+gem 'prismic.io', require: 'prismic'
+gem 'solidus_static_content', github: 'solidusio-contrib/solidus_static_content'
+
+gemspec
+
+# Use a local Gemfile to include development dependencies that might not be
+# relevant for the project or for other contributors, e.g. pry-byebug.
+#
+# We use `send` instead of calling `eval_gemfile` to work around an issue with
+# how Dependabot parses projects: https://github.com/dependabot/dependabot-core/issues/1658.
+send(:eval_gemfile, 'Gemfile-local') if File.exist? 'Gemfile-local'

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2020 Nebulab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Solidus nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,439 @@
+
+# SolidusContent
+
+[![nebulab](https://circleci.com/gh/nebulab/solidus_content.svg?style=shield)](https://app.circleci.com/pipelines/github/nebulab/solidus_content)
+
+Introduction goes here.
+
+## Installation
+
+Add solidus_content to your Gemfile:
+
+```ruby
+gem 'solidus_content'
+```
+
+Bundle your dependencies and run the installation generator:
+
+```shell
+bundle
+bin/rails generate solidus_content:install
+```
+
+## Usage
+
+Create an entry type for the home page:
+
+```rb
+home_entry_type = SolidusContent::EntryType.create!(
+  name: :home,
+  provider_name: :json,
+  options: { path: 'data/home' }
+)
+```
+
+Create a default entry for the home page:
+
+```rb
+home = SolidusContent::Entry.create!(
+  entry_type: home_entry_type,
+  slug: :default,
+)
+```
+
+And then write a file inside your app root under `data/home/default.json`:
+
+```json
+{"title":"Hello World!"}
+```
+
+### Within an existing view
+
+Use the content inside an existing view, e.g. `app/views/spree/home/index.html.erb`:
+
+```erb
+<% data = SolidusContent::Entry.data_for(:home, 'default') %>
+
+<h1><%= data[:title] %></h1>
+```
+
+### With the default route
+
+SolidusContent will add a default route that starts with `/c/`, by adding a view
+inside `app/views/spree/solidus_content/` with the name of the entry type you'll
+be able to render your content.
+
+E.g. `app/views/spree/solidus_content/home.html.erb`:
+```erb
+<h1><%= @entry.data[:title] %></h1>
+```
+
+Then, visit `/c/home/default` or even just `/c/home` (when the content slug is
+"default" it can be omitted).
+
+
+### With a custom route
+
+You can also define a custom route in your `Application` routes file and use
+the `SolidusContent` controller to render your content from a dedicated view:
+
+```rb
+# config/routes.rb
+Rails.application.routes.draw do
+  # Will render app/views/spree/solidus_content/home.html.erb
+  root to: 'spree/solidus_content#show', type: :home, id: :default
+
+  # Will render app/views/spree/solidus_content/info.html.erb
+  get "privacy", to: 'spree/solidus_content#show', type: :info, id: :privacy
+  get "legal", to: 'spree/solidus_content#show', type: :info, id: :legal
+
+  # Will render app/views/spree/solidus_content/post.html.erb
+  get "blog/:id", to: 'spree/solidus_content#show', type: :post
+
+  mount Spree::Core::Engine, at: '/'
+end
+```
+
+## Configuration
+
+Configure SolidusContent in an initializer:
+
+```rb
+# config/initializers/solidus_content.rb
+
+SolidusContent.configure do |config|
+  # Your configuration goes here, please refer to the examples provided in the
+  # initializer generated by `bin/rails g solidus_content:install`
+end
+```
+
+## Available Content Providers
+
+### RAW
+
+This is the most simple provider, its data will come directly from the entry
+options.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'raw',
+)
+entry = SolidusContent::Entry.create(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+  options: { title: "Hello World!", body: "My first post!" }
+)
+```
+
+### JSON
+
+Will fetch the data from a JSON file within the directory specified by the
+`path` entry-type option and with a basename corresponding to the entry `slug`.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'json',
+  options: { path: 'data/posts' }
+)
+entry = SolidusContent::Entry.create(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+)
+```
+
+```jsonc
+// [RAILS_ROOT]/data/posts/2020-03-27-hello-world.json
+{"title": "Hello World!", "body": "My first post!"}
+```
+
+_NOTE: Absolute paths are taken as they are and won't be joined to `Rails.root`._
+
+### YAML
+
+Will fetch the data from a YAML file within the directory specified by the
+`path` entry-type option and with a basename corresponding to the entry `slug`.
+
+If there isn't a file with the `yml` extension, the `yaml` extension will be tried.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'yaml',
+  options: { path: 'data/posts' }
+)
+entry = SolidusContent::Entry.create(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+)
+```
+
+```yaml
+# [RAILS_ROOT]/data/posts/2020-03-27-hello-world.yml
+
+title: Hello World!
+body: My first post!
+```
+
+_NOTE: Absolute paths are taken as they are and won't be joined to `Rails.root`._
+
+### Solidus static content
+
+To retrieve the page we have to pass the page `slug` to the entry options.
+If the page slug is the same of the entry one, we can avoid passing the options.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'solidus_static_content'
+)
+
+entry = SolidusContent::Entry.create!(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+  options: { slug: 'XXX' } # Can be omitted if the page slug is the same of the entry
+)
+```
+
+_Be sure to have added `gem "solidus_static_content"` to your Gemfile._
+
+### Contentful
+
+To fetch the data we have to create a connection with Contentful passing the
+`contentful_space_id` and the `contentful_access_token` to the entry-type options.
+
+Will fetch the data from Contentful passing the `entry_id` entry option.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'contentful',
+  options: {
+    contentful_space_id: 'XXX',
+    contentful_access_token: 'XXX'
+  }
+)
+
+entry = SolidusContent::Entry.create!(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+  options: { entry_id: 'XXX' }
+)
+```
+
+_Be sure to have added `gem "contentful"` to your Gemfile._
+
+### Prismic
+
+To fetch the data we have to create a connection with Prismic passing the
+`api_entry_point` to the entry-type options.
+
+If the repository is private, you have to also pass the `api_token` to the entry-type options.
+
+Will fetch the data from Prismic passing the `id` entry option.
+
+```rb
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'prismic',
+  options: {
+    api_entry_point: 'XXX',
+    api_token: 'XXX' # Only if the repository is private
+  }
+)
+
+entry = SolidusContent::Entry.create!(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+  options: { id: 'XXX' }
+)
+```
+
+_Be sure to have added `gem "prismic.io"` to your Gemfile._
+
+### Renderful
+
+The [Renderful](https://github.com/nebulab/renderful) provider works a bit differently from other
+providers because of how Renderful is configured.
+
+The provider is not registered by default, and you'll have to register it manually by passing your
+Renderful instance:
+
+```ruby
+# [RAILS_ROOT]/config/initializers/solidus_content.rb
+
+require 'solidus_content/providers/renderful'
+
+renderful = Renderful::Client.new(...)
+
+SolidusContent.config.register_provider(
+  :renderful_contentful,
+  SolidusContent::Providers::Renderful.new(renderful),
+)
+```
+
+Once configured, you'll be able to use it like all other providers:
+
+```ruby
+posts = SolidusContent::EntryType.create(
+  name: 'posts',
+  provider_name: 'renderful_contentful',
+)
+
+entry = SolidusContent::Entry.create!(
+  slug: '2020-03-27-hello-world',
+  entry_type: posts,
+  options: { id: 'XXX' }
+)
+```
+
+*Unlike other providers,* however, Renderful will not pass the raw entity fields to your view.
+Instead, you will get a `:render_in` proc that you should call with your view context. The call
+will be forwarded to Renderful, which will render your content:
+
+```erb
+<%= @entry.data[:render_in].(self) %>
+```
+
+### Registering a content provider
+
+To register a content-provider, add a callable to the configuration under the
+name you prefer. The
+
+```rb
+SolidusContent.config.register_provider :json, ->(input) {
+  dir = Rails.root.join(input.dig(:type_options, :path))
+  file = dir.join(input[:slug] + '.json')
+  data = JSON.parse(file.read, symbolize_names: true)
+
+  input.merge(data: data)
+}
+```
+
+The `input` passed to the content-provider will have the following keys:
+
+- `slug`: the slug of the content-entry
+- `type`: the name of the content-type
+- `provider`: the name of the content-provider
+- `options`: the entry options
+- `type_options`: the content-type options
+
+The `output` of the content-provider is the `input` hash augmented with the
+following keys:
+
+- `data`: the content itself
+- `provider_client`: (optional) the client of the external service
+- `provider_entry`: (optional) the object retrieved from the external service
+
+In both the input and output all keys should be symbolized.
+
+## Connecting Webhooks
+
+Many content providers such as Contentful or Prismic can send payloads via webhooks when content changes, those can be very useful in a number of ways.
+
+We suggest using the [`solidus_webhooks`](http://github.com/solidusio-contrib/solidus_webhooks#readme) extension to get the most out of `solidus_content`, let's see some examples.
+
+Add this to your Gemfile:
+
+```rb
+gem "solidus_webhooks"
+```
+
+### Using Webhooks to Auto-Create entries
+
+In this example we setup a webhook that will create or update Contentful entries whenever they're changed or created.
+
+```rb
+# config/initializers/webhooks.rb
+
+SolidusWebhooks.config.register_webhook_handler :contentful, -> payload {
+  next unless payload.dig(:sys, :Type) == "Entry"
+  entry_type = SolidusContent::EntryType.find_or_create_by(
+    name: payload.dig(:sys, :ContentType, :sys, :id),
+    provider_name: :raw
+  )
+  entry = entry_type.entries.find_or_initialize_by(slug: payload.dig(:sys, :id))
+  entry.options = payload.fetch(:fields)
+}
+```
+
+### Using Webhooks to expire caches
+
+When caching the content of `app/views/spree/home/index.html.erb` as in this example:
+
+```erb
+<% cache(@entry) do %>
+  <h1><%= @entry.data[:title] %></h1>
+<% end %>
+```
+
+You may want to setup a webhook that will touch the entry every time it's modified:
+
+```rb
+# config/initializers/webhooks.rb
+
+SolidusWebhooks.config.register_webhook_handler :prismic, -> payload {
+  prismic_entry_types = SolidusContent::EntryType.where(provider_name: :prismic)
+
+  # Prismic doesn't give much informations about which entries have been changed,
+  # so we're touching them all.
+  SolidusContent::Entry.where(entry_type: prismic_entry_types).touch_all
+}
+```
+
+*NOTE: `touch_all` was introduced in Rails 6, for earlier versions use `find_each(&:touch)`.*
+
+## Development
+
+### Testing the extension
+
+First bundle your dependencies, then run `bin/rake`. `bin/rake` will default to building the dummy
+app if it does not exist, then it will run specs. The dummy app can be regenerated by using
+`bin/rake extension:test_app`.
+
+```shell
+bundle
+bin/rake
+```
+
+To run [Rubocop](https://github.com/bbatsov/rubocop) static code analysis run
+
+```shell
+bundle exec rubocop
+```
+
+When testing your application's integration with this extension you may use its factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'solidus_content/factories'
+```
+
+### Running the sandbox
+
+To run this extension in a sandboxed Solidus application, you can run `bin/sandbox`. The path for
+the sandbox app is `./sandbox` and `bin/rails` will forward any Rails commands to
+`sandbox/bin/rails`.
+
+Here's an example:
+
+```shell
+$ bin/rails server
+=> Booting Puma
+=> Rails 6.0.2.1 application starting in development
+* Listening on tcp://127.0.0.1:3000
+Use Ctrl-C to stop
+```
+
+### Releasing new versions
+
+Your new extension version can be released using `gem-release` like this:
+
+```shell
+bundle exec gem bump -v VERSION --tag --push --remote upstream && gem release
+```
+
+## License
+
+Copyright (c) 2020 Nebulab, released under the New BSD License