buttercms-ruby-zwg 2.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54ecb3cd54e93defe79a22aca4f2e3a82c4f507cb6e3c1c57382f7690f0c3837
+  data.tar.gz: 9cd1b5498b7752d50cd560463fe99ed1866d9c9864bb85cce0dad8d50d1d64aa
+SHA512:
+  metadata.gz: 1416c28751442d8e03235efef34aa742f0cec6eeed5d93b14fff5d519283e700c9d790e7e4e7e1c58b0ab6217cd40274a54bb944cb46c3a8a6c480ae51b6a7f8
+  data.tar.gz: 219c0bc189f17ecc58ac4cc7d33cde89c516d394f087af6365cb215d2787df63221bd4a281680d94d46fb65cfd6ecf660e4a1364b41aac364cf61d1421dc8ea6

data/.github/workflows/rubygems-publish.yml

@@ -0,0 +1,25 @@
+# This workflow will publish a gem to rubygems.org when a release is created
+# For more information see: # https://github.com/discourse/publish-rubygems-action
+
+name: Publish Gem
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+ publish:
+    if: github.ref == 'refs/heads/master' && github.event_name == 'push' && contains(github.event.head_commit.message, 'chore(release)')
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Release Gem
+        uses: discourse/publish-rubygems-action@v2
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          RELEASE_COMMAND: rake release
+          GIT_EMAIL: 41898282+github-actions[bot]@users.noreply.github.com
+          GIT_NAME: github-actions[bot]

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+.ruby-version
+.rvmrc
+*.rdb
+*.store
+test.rb

data/.rspec

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

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+
+group :development, :test do
+  gem 'rspec-rails'
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Butter
+https://buttercms.com/
+
+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,148 @@
+# ButterCMS API Ruby Client
+
+## Documentation
+
+For a comprehensive list of examples, check out the [API documentation](https://buttercms.com/docs/api/).
+
+## Setup
+
+To setup your project, follow these steps:
+
+1. Install using `gem install buttercms-ruby` or by adding to your `Gemfile`:
+
+  ```ruby
+  gem 'buttercms-ruby'
+  ```
+
+2. Set your API token.
+
+  ```ruby
+  require 'buttercms-ruby'
+
+  ButterCMS::api_token = "YourToken"
+
+  # Fetch content from test mode (eg. for your staging website)
+  # ButterCMS::test_mode = true
+
+  # Set read timeout (Default is 5.0)
+  # ButterCMS::read_timeout = 5.0
+
+  # Set open timeout (Default is 2.0)
+  # ButterCMS::open_timeout = 2.0
+  ```
+
+## Pages
+
+https://buttercms.com/docs/api/?ruby#pages
+
+
+```ruby
+params = {page: 1, page_size: 10, locale: 'en', preview: 1, 'fields.headline': 'foo bar', levels: 2} # optional
+pages = ButterCMS::Page.list('news', params)
+
+page = ButterCMS::Page.get('news', 'hello-world', params)
+
+pages = ButterCMS::Page.search('query', params)
+```
+
+## Collections
+
+https://buttercms.com/docs/api/?ruby#retrieve-a-collection
+
+```ruby
+# list each instance of a given collection with meta data for fetching the next page.
+params = { page: 1, page_size: 10, locale: 'en', preview: 1, 'fields.headline': 'foo bar', levels: 2 } # optional
+ButterCMS::Content.list('collection1', params)
+
+# list instances for multiple collections, this will not return meta data for pagination control.
+ButterCMS::Content.fetch(['collection1', 'collection2'], params)
+
+# Test mode can be used to setup a staging website for previewing Collections or for testing content during local development. To fetch content from test mode add the following configuration:
+ButterCMS::test_mode = true
+```
+
+## Blog Engine
+
+https://buttercms.com/docs/api/?ruby#blog-engine
+
+```ruby
+posts = ButterCMS::Post.all({:page => 1, :page_size => 10})
+puts posts.first.title
+puts posts.meta.next_page
+
+posts = ButterCMS::Post.search("my favorite post", {page: 1, page_size: 10})
+puts posts.first.title
+
+post = ButterCMS::Post.find("post-slug")
+puts post.title
+
+# Create a Post.
+ButterCMS::write_api_token = "YourWriteToken"
+ButterCMS::Post.create({
+  slug: 'blog-slug',
+  title: 'blog-title'
+})
+
+# Update a Post
+ButterCMS::Post.update('blog-slug', {
+  title: 'blog-title-v2'
+})
+
+# Create a page
+ButterCMS::Page.create({
+  slug: 'page-slug',
+  title: 'page-title',
+  status: 'published',
+  "page-type": 'page_type',
+  fields: {
+    meta_title: 'test meta title'
+  }
+})
+
+# update a Page
+ButterCMS::Page.update('page-slug-2', {
+  status: 'published',
+  fields: {
+    meta_title: 'test meta title'
+  }
+})
+
+
+
+author = ButterCMS::Author.find("author-slug")
+puts author.first_name
+
+category = ButterCMS::Category.find("category-slug")
+puts category.name
+
+tags = ButterCMS::Tag.all
+p tags
+
+rss_feed = ButterCMS::Feed.find(:rss)
+puts rss_feed.data
+```
+
+
+## Fallback Data Store
+
+This client supports automatic fallback to a data store when API requests fail. When a data store is set, on every successful API request the response is written to the data store. When a subsequent API request fails, the client attempts to fallback to the value in the data store. Currently, Redis and YAML Store are supported.
+
+```ruby
+# Use YAMLstore
+ButterCMS::data_store = :yaml, "/File/Path/For/buttercms.store"
+
+# Use Redis
+ButterCMS::data_store = :redis, ENV['REDIS_URL']
+
+# Use Redis over ssl store
+ButterCMS.data_store = :redis_ssl, ENV["REDIS_URL"], { ca_file: "/path/to/ca.crt" }
+
+# Set logger (optional)
+ButterCMS::logger = MyLogger.new
+```
+
+### Other
+
+View Ruby [Blog engine](https://buttercms.com/ruby-blog-engine/) and [Full CMS](https://buttercms.com/ruby-cms/) for other examples of using ButterCMS with Ruby.
+
+### Development

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rspec/core/rake_task'
+
+# Gem Tasks is required to run the `rake release` command
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/buttercms-ruby.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'buttercms/version'
+
+Gem::Specification.new do |s|
+  s.name = "buttercms-ruby-zwg"
+  s.version = ButterCMS::VERSION
+  s.require_paths = ["lib"]
+  s.summary = 'Ruby API client for ButterCMS'
+  s.description = 'Butter is the #1 developer rated headless CMS. See https://buttercms.com for details.'
+  s.authors = ["ButterCMS"]
+  s.email= ["support@buttercms.com"]
+  s.homepage = "https://buttercms.com/docs"
+  s.license = 'MIT'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'webmock'
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+end

data/lib/buttercms/author.rb

@@ -0,0 +1,7 @@
+module ButterCMS
+  class Author < ButterResource
+    def self.resource_path
+      "/authors/"
+    end
+  end
+end

data/lib/buttercms/butter_collection.rb

@@ -0,0 +1,22 @@
+module ButterCMS
+  class ButterCollection
+    include Enumerable
+
+    attr_reader :items
+    attr_reader :meta
+
+    def initialize(klass, json)
+      data = json["data"]
+      meta = json["meta"]
+
+      @meta = HashToObject.convert(meta) if meta
+      @items = data.map {|o| klass.new("data" => o) }
+    end
+
+    def each(&block)
+      @items.each do |member|
+        block.call(member)
+      end
+    end
+  end
+end

data/lib/buttercms/butter_resource.rb

@@ -0,0 +1,96 @@
+module ButterCMS
+  class ButterResource
+    attr_reader :meta, :data
+
+    def initialize(json)
+      @json = json
+      @data = HashToObject.convert(json["data"])
+      @meta = HashToObject.convert(json["meta"]) if json["meta"]
+
+      define_attribute_methods(@data)
+    end
+
+    def marshal_dump
+      { json: @json, data: @data, meta: @meta }
+    end
+
+    def marshal_load(dump)
+      @json = dump[:json]
+      @data = dump[:data]
+      @meta = dump[:meta]
+
+      define_attribute_methods(@data)
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@json)
+    end
+
+    def self.endpoint(id = nil)
+      # Append trailing slash when id is added to path because
+      # API expects all endpoints to include trailing slashes
+      resource_path + (id ? "#{id}/" : '')
+    end
+
+    def self.patch_endpoint(id)
+      # Append trailing slash when id is added to path because
+      # API expects all endpoints to include trailing slashes
+      resource_path + "*/#{id}/"
+    end
+
+    def self.resource_path
+      raise "resource_path must be set"
+    end
+
+    def self.all(options = {})
+      response = ButterCMS.request(self.endpoint, options)
+
+      self.create_collection(response)
+    end
+
+    def self.find(id, options = {})
+      response = ButterCMS.request(self.endpoint(id), options)
+
+      self.create_object(response)
+    end
+
+    def self.create(options = {})
+      options[:method] = 'Post'
+      response = ButterCMS.write_request(self.endpoint, options)
+
+      self.create_object(response)
+    end
+
+    def self.update(id, options = {})
+      options[:method] = 'Patch'
+      _endpoint = if resource_path.include?("/pages/")
+        self.patch_endpoint(id)
+      else
+        self.endpoint(id)
+      end
+      response = ButterCMS.write_request(_endpoint, options)
+
+      self.create_object(response)
+    end
+
+    private
+
+    def self.create_collection(response)
+      ButterCollection.new(self, response)
+    end
+
+    def self.create_object(response)
+      self.new(response)
+    end
+
+    def define_attribute_methods(methods)
+      return unless methods.respond_to?(:each_pair)
+
+      methods.each_pair do |key, value|
+        instance_variable_set("@#{key}", value)
+        self.class.send(:attr_reader, key)
+      end
+    end
+  end
+end

data/lib/buttercms/category.rb

@@ -0,0 +1,7 @@
+module ButterCMS
+  class Category < ButterResource
+    def self.resource_path
+      "/categories/"
+    end
+  end
+end

data/lib/buttercms/content.rb

@@ -0,0 +1,20 @@
+module ButterCMS
+  class Content < ButterResource
+    def self.resource_path
+      "/content/"
+    end
+
+    def self.list(collection_slug, options = {})
+      response = ButterCMS.request(self.endpoint(collection_slug), options)
+
+      self.create_collection(response)
+    end
+    
+    def self.fetch(collection_slugs, options = {})
+      params = { keys: collection_slugs.join(',') }.merge(options)
+      response = ButterCMS.request(self.resource_path, params)
+      
+      self.new(response)
+    end
+  end
+end

data/lib/buttercms/data_store_adapters/redis.rb

@@ -0,0 +1,26 @@
+begin
+  require 'redis'
+rescue LoadError
+  puts "WARNING: redis >= 3.0.0 is required to use the redis data store."
+  raise
+end
+
+module ButterCMS
+  module DataStoreAdapters
+    class Redis
+      def initialize(options)
+        redis_url = options.first
+
+        @redis = ::Redis.new(url: redis_url)
+      end
+
+      def set(key, value)
+        @redis.set(key, value)
+      end
+
+      def get(key)
+        @redis.get(key)
+      end
+    end
+  end
+end

data/lib/buttercms/data_store_adapters/redis_ssl.rb

@@ -0,0 +1,27 @@
+begin
+  require 'redis'
+rescue LoadError
+  puts "WARNING: redis >= 3.0.0 is required to use the redis data store."
+  raise
+end
+
+module ButterCMS
+  module DataStoreAdapters
+    class RedisSSL
+      def initialize(options)
+        redis_url = options.first
+        ssl_params = options.second && Hash[options.second]
+
+        @redis = ::Redis.new(url: redis_url, ssl_params:)
+      end
+
+      def set(key, value)
+        @redis.set(key, value)
+      end
+
+      def get(key)
+        @redis.get(key)
+      end
+    end
+  end
+end

data/lib/buttercms/data_store_adapters/yaml.rb

@@ -0,0 +1,25 @@
+require 'yaml/store'
+
+module ButterCMS
+  module DataStoreAdapters
+    class Yaml
+      def initialize(options)
+        file_path = options.first
+
+        @store = YAML::Store.new file_path
+      end
+
+      def set(key, value)
+        @store.transaction do
+          @store[key] = value
+        end
+      end
+
+      def get(key)
+        @store.transaction do
+          @store[key]
+        end
+      end
+    end
+  end
+end

data/lib/buttercms/errors.rb

@@ -0,0 +1,15 @@
+module ButterCMS
+  # Error is the top level error raised by ButterCMS
+  class Error < StandardError
+  end
+
+  # NotFound is raised when a resource cannot be found
+  class NotFound < Error
+  end
+
+  class Unauthorized < Error
+  end
+  
+  class BadRequest < Error
+  end
+end

data/lib/buttercms/feed.rb

@@ -0,0 +1,7 @@
+module ButterCMS
+  class Feed < ButterResource
+    def self.resource_path
+      "/feeds/"
+    end
+  end
+end

data/lib/buttercms/hash_to_object.rb

@@ -0,0 +1,7 @@
+module ButterCMS
+  class HashToObject
+    def self.convert(hash)
+      JSON.parse(hash.to_json, object_class: OpenStruct, quirks_mode: true)
+    end
+  end
+end

data/lib/buttercms/page.rb

@@ -0,0 +1,25 @@
+module ButterCMS
+  class Page < ButterResource
+    def self.resource_path
+      "/pages/"
+    end
+
+    def self.list(page_type, options = {})
+      response = ButterCMS.request(self.endpoint(page_type), options)
+
+      self.create_collection(response)
+    end
+
+    def self.get(page_type, slug, options = {})
+      response = ButterCMS.request(self.endpoint("#{page_type}/#{slug}"), options)
+
+      self.create_object(response)
+    end
+
+    def self.search(query = '', options = {})
+      response = ButterCMS.request('/pages/search/', {query: query}.merge(options))
+      
+      self.create_collection(response)
+    end
+  end
+end

data/lib/buttercms/post.rb

@@ -0,0 +1,13 @@
+module ButterCMS
+  class Post < ButterResource
+    def self.resource_path
+      "/posts/"
+    end
+
+    def self.search(query = '', options = {})
+      response = ButterCMS.request('/search/', {query: query}.merge(options))
+
+      self.create_collection(response)
+    end
+  end
+end

data/lib/buttercms/tag.rb

@@ -0,0 +1,7 @@
+module ButterCMS
+  class Tag < ButterResource
+    def self.resource_path
+      "/tags/"
+    end
+  end
+end

data/lib/buttercms/version.rb

@@ -0,0 +1,3 @@
+module ButterCMS
+  VERSION = '2.4.1'
+end

data/lib/buttercms-ruby.rb

@@ -0,0 +1,194 @@
+require 'json'
+require 'ostruct'
+require 'logger'
+require 'uri'
+require 'net/http'
+require 'pathname'
+
+require "buttercms/errors"
+require 'buttercms/version'
+require 'buttercms/hash_to_object'
+require 'buttercms/butter_collection'
+require 'buttercms/butter_resource'
+require 'buttercms/author'
+require 'buttercms/category'
+require 'buttercms/tag'
+require 'buttercms/post'
+require 'buttercms/feed'
+require 'buttercms/content'
+require 'buttercms/page'
+
+# See https://github.com/jruby/jruby/issues/3113
+if RUBY_VERSION < '2.0.0'
+  require_relative 'core_ext/ostruct'
+end
+
+module ButterCMS
+  @api_url = URI.parse('https://api.buttercms.com/v2')
+
+  class << self
+    attr_accessor :api_token
+    attr_accessor :write_api_token
+    attr_accessor :test_mode
+    attr_accessor :read_timeout
+    attr_accessor :open_timeout
+    attr_reader :data_store
+    attr_writer :logger
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout).tap do |log|
+      log.progname = "ButterCMS"
+    end
+  end
+
+  def self.data_store=(*args)
+    args.flatten!
+
+    if args.count < 2
+      raise ArgumentError.new "Wrong number of arguments"
+    end
+
+    strategy = args.first
+    options = args.drop(1)
+
+    case strategy
+    when :yaml
+      require_relative 'buttercms/data_store_adapters/yaml'
+      @data_store = ButterCMS::DataStoreAdapters::Yaml.new(options)
+    when :redis
+      require_relative 'buttercms/data_store_adapters/redis'
+      @data_store = ButterCMS::DataStoreAdapters::Redis.new(options)
+    when :redis_ssl
+      require_relative 'buttercms/data_store_adapters/redis_ssl'
+      @data_store = ButterCMS::DataStoreAdapters::RedisSSL.new(options)
+    else
+      raise ArgumentError.new "Invalid ButterCMS data store #{strategy}"
+    end
+  end
+
+  def self.api_request(path, options = {})
+    query = options.dup
+    query[:auth_token] ||= api_token
+
+    if test_mode
+      query[:test] = 1
+    end
+
+    # If the user has passed in a "/" leading path, don't interpret that
+    # as wanting to get rid of the API prefix
+    if path.start_with?("/")
+      path = path[1..-1]
+    end
+
+    path = Pathname.new(@api_url.path).join(path).to_s + "?#{URI.encode_www_form(query)}"
+
+    response =
+      Net::HTTP.start(@api_url.host, @api_url.port, http_options) do |http|
+        request = Net::HTTP::Get.new(path)
+        request["User-Agent"] = "ButterCMS/Ruby #{ButterCMS::VERSION}"
+        request["Accept"]     = "application/json"
+
+        http.request(request)
+      end
+
+    case response
+    when Net::HTTPNotFound
+      raise ::ButterCMS::NotFound, JSON.parse(response.body)["detail"]
+    when Net::HTTPUnauthorized
+      raise ::ButterCMS::Unauthorized, JSON.parse(response.body)['detail']
+    end
+
+    response.body
+  end
+
+  def self.request(path, options = {})
+    raise ArgumentError.new "Please set your API token" unless api_token
+
+    key = "buttercms:#{path}:#{options}"
+
+    begin
+      result = api_request(path, options)
+
+      if data_store
+        data_store.set(key, result)
+        logger.info "Set key #{key}"
+      end
+
+    # TODO - more selective exception handling (SocketError)
+    rescue Exception => e
+
+      if data_store
+        if result = data_store.get(key)
+          logger.info "Fetched key #{key}"
+
+          # Log request error
+          logger.error e
+        else
+          logger.info "No data for key #{key}"
+        end
+      end
+
+      # Raise request exception if there's no data store or value returned
+      raise e unless data_store && result
+    end
+
+    return JSON.parse(result)
+  end
+
+  def self.write_request(path, options = {})
+    raise ArgumentError.new "Please set your write API token" unless write_api_token
+    result = write_api_request(path, options)
+
+    return JSON.parse(result)
+  end
+
+  def self.write_api_request(path, options = {})
+    query = options.dup
+    token_for_request = query.delete(:auth_token) || write_api_token
+
+    path = "#{@api_url.path}#{URI.encode(path)}"
+
+    response =
+      Net::HTTP.start(@api_url.host, @api_url.port, http_options) do |http|
+        write_type = query.delete(:method) || "Post"
+        request_type = "Net::HTTP::#{write_type}".constantize
+        request = request_type.new(path)
+        request["User-Agent"] = "ButterCMS/Ruby #{ButterCMS::VERSION}"
+        request["Accept"]     = "application/json"
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Token #{token_for_request}"
+        request.body = query.except(:auth_token).to_json
+
+        http.request(request)
+      end
+
+    case response
+    when Net::HTTPNotFound
+      raise ::ButterCMS::NotFound, JSON.parse(response.body)["detail"]
+    when Net::HTTPBadRequest
+      parsed_body = JSON.parse(response.body)
+      errors = if parsed_body.is_a?(Array)
+        parsed_body.join(' ')
+      else
+        parsed_body.map do |k, v|
+          "#{k}: #{v}"
+        end.join(" ")
+      end
+      raise ::ButterCMS::BadRequest, errors
+    end
+
+    response.body
+  end
+
+  private
+
+  def self.http_options
+    {
+      open_timeout: open_timeout || 2.0,
+      read_timeout: read_timeout || 5.0,
+      ssl_timeout:  2.0,
+      use_ssl:      @api_url.scheme == "https",
+    }
+  end
+end

data/lib/console.rb

@@ -0,0 +1,10 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'buttercms-ruby', :path => '../buttercms-ruby'
+end
+
+# start a REPL session
+ButterCMS::api_token = "" # add your dev token here
+binding.irb

data/lib/core_ext/ostruct.rb

@@ -0,0 +1,9 @@
+class OpenStruct
+  def [] key
+    send key
+  end unless respond_to? :[]
+
+  def []= key, val
+    send %(#{key}=), val
+  end unless respond_to? :[]=
+end

data/spec/lib/butter-ruby_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ButterCMS do
+  describe '.request' do
+    context 'with an api token' do
+      before do
+        allow(ButterCMS).to receive(:api_token).and_return('test123')
+      end
+
+      it 'should make an api request' do
+        request = stub_request(:get, "https://api.buttercms.com/v2?auth_token=test123")
+          .to_return(body: JSON.generate({data: {test: 'test'}}))
+
+        ButterCMS.request('')
+        expect(request).to have_been_made
+      end
+
+      it "should properly escape paths" do
+        request = stub_request(
+          :get,
+          "https://api.buttercms.com/v2/pages/*/homepage%20en?auth_token=test123"
+        ).to_return(body: JSON.generate({data: {test: 'test'}}))
+
+        # support leading slashes
+        ButterCMS.request('/pages/*/homepage en')
+
+        # and no leading slashes
+        ButterCMS.request('pages/*/homepage en')
+
+
+        expect(request).to have_been_made.twice
+      end
+    end
+
+    context 'without an api token' do
+      it 'should throw an argument error' do
+        expect{ ButterCMS.request() }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "raises NotFound on 404" do
+      allow(ButterCMS).to receive(:api_token).and_return("test123")
+
+      request = stub_request(:get, %r{/posts/slug/})
+        .with(query: { auth_token: "test123" })
+        .to_return(status: 404, body: '{"detail":"Not found."}')
+
+      expect { ButterCMS.request("/posts/slug/") }
+        .to raise_error(ButterCMS::NotFound)
+
+      expect(request).to have_been_made
+    end
+
+    it "raises Unauthorized on 401" do
+      allow(ButterCMS).to receive(:api_token).and_return("test")
+
+      request = stub_request(:get, %r{/posts/slug/})
+        .with(query: { auth_token: "test" })
+        .to_return(status: 401, body: '{"detail":"Invalid token."}')
+
+      expect { ButterCMS.request("/posts/slug/") }
+        .to raise_error(ButterCMS::Unauthorized)
+
+      expect(request).to have_been_made
+    end
+  end
+end

data/spec/lib/buttercms/butter_collection_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ButterCMS::ButterCollection do
+  let(:json) { {"data" => ["foo"], "meta" => {}} }
+  let(:klass) { double('klass', :new => 'bar') }
+
+  it 'implements #items' do
+    collection = ButterCMS::ButterCollection.new(klass, json)
+
+    expect(collection.items).to match_array(["bar"])
+  end
+
+  it 'implements #meta' do
+    collection = ButterCMS::ButterCollection.new(klass, json)
+
+    expect(collection.meta).to be_a(OpenStruct)
+  end
+
+  it 'implements #count' do
+    collection = ButterCMS::ButterCollection.new(klass, json)
+
+    expect(collection.count).to eq 1
+  end
+
+  # Marshal.load (used by Rails for caching) was not restoring the ButterResource's dynamic methods
+  # See https://github.com/ButterCMS/buttercms-ruby/issues/13
+  describe 'marshal load' do
+    subject { described_class.new(ButterCMS::ButterResource, 'data' => [{ 'name' => 'Test Name', 'description' => 'Test Description' }]) }
+
+    it 'restores the ButterResource dynamic methods' do
+      collection = Marshal.load(Marshal.dump(subject))
+      resource = collection.first
+
+      aggregate_failures do
+        expect(resource.name).to eq('Test Name')
+        expect(resource.description).to eq('Test Description')
+      end
+    end
+  end
+end

data/spec/lib/buttercms/butter_resource_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe ButterCMS::ButterResource do
+  before do
+    allow(ButterCMS).to receive(:token).and_return('test123')
+    allow(ButterCMS).to receive(:request).and_return({"data" => [{"attribute" => 'test'}]})
+
+    allow(ButterCMS::ButterResource).to receive(:resource_path).and_return('')
+  end
+
+  describe 'auto-generated methods' do
+    let(:resource) { described_class.new('data' => { 'name' => 'Test Name', 'description' => 'Test Description' }) }
+
+    it 'creates attribute reader methods for data pairs' do
+      aggregate_failures do
+        expect(resource.name).to eq('Test Name')
+        expect(resource.description).to eq('Test Description')
+      end
+    end
+  end
+
+  describe '.all' do
+
+    it 'should make a request with the correct endpoint' do
+      expect(ButterCMS).to receive(:request).with('', {})
+      ButterCMS::ButterResource.all()
+    end
+
+    it 'should return a collection' do
+      objects = ButterCMS::ButterResource.all
+      expect(objects).to be_a(ButterCMS::ButterCollection)
+      expect(objects.first).to be_a(ButterCMS::ButterResource)
+    end
+  end
+
+  describe '.find' do
+    it 'should make a request with the correct endpoint' do
+      expect(ButterCMS).to receive(:request).with('1/', {})
+      ButterCMS::ButterResource.find(1)
+    end
+
+    it 'should return one object' do
+      expect(ButterCMS::ButterResource.find(1)).to be_a(ButterCMS::ButterResource)
+    end
+  end
+end

data/spec/lib/buttercms/content_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ButterCMS::Content do
+  before do
+    allow(ButterCMS).to receive(:token).and_return('test123')
+    allow(ButterCMS).to receive(:request).and_return({
+      "meta"=>{
+        "next_page"=>2, 
+        "previous_page"=>nil, 
+        "count"=>2
+        }, 
+      "data"=>{
+        "author"=>[
+          { "name"=>"Charles Dickens"},
+          { "name"=>"J.K. Rowling"}
+        ]
+      }
+    })
+    
+    @response = ButterCMS::Content.list('slug', {
+      page: 1,
+      page_size: 2
+    })
+  end
+  
+  it "has meta and collection info" do
+    expect(@response.meta.next_page).to eq(2)
+    expect(@response.to_a.first.data.first).to eq('author')
+    expect(@response.to_a.first.data.last.first).to have_attributes(
+      name: "Charles Dickens"
+    )
+  end
+end

data/spec/lib/buttercms/hash_to_object_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ButterCMS::HashToObject do
+  describe '.convert' do
+    it 'converts hash to object' do
+      hash = {
+        "key1" => "value",
+        "key2" => {
+          "nested_key" => "nested value"
+        }
+      }
+
+      obj = ButterCMS::HashToObject.convert(hash)
+
+      expect(obj.key1).to eq 'value'
+      expect(obj.key2.nested_key).to eq "nested value"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+require 'webmock/rspec'
+require 'buttercms-ruby'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: buttercms-ruby-zwg
+version: !ruby/object:Gem::Version
+  version: 2.4.1
+platform: ruby
+authors:
+- ButterCMS
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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: 'Butter is the #1 developer rated headless CMS. See https://buttercms.com
+  for details.'
+email:
+- support@buttercms.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/rubygems-publish.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- buttercms-ruby.gemspec
+- lib/buttercms-ruby.rb
+- lib/buttercms/author.rb
+- lib/buttercms/butter_collection.rb
+- lib/buttercms/butter_resource.rb
+- lib/buttercms/category.rb
+- lib/buttercms/content.rb
+- lib/buttercms/data_store_adapters/redis.rb
+- lib/buttercms/data_store_adapters/redis_ssl.rb
+- lib/buttercms/data_store_adapters/yaml.rb
+- lib/buttercms/errors.rb
+- lib/buttercms/feed.rb
+- lib/buttercms/hash_to_object.rb
+- lib/buttercms/page.rb
+- lib/buttercms/post.rb
+- lib/buttercms/tag.rb
+- lib/buttercms/version.rb
+- lib/console.rb
+- lib/core_ext/ostruct.rb
+- spec/lib/butter-ruby_spec.rb
+- spec/lib/buttercms/butter_collection_spec.rb
+- spec/lib/buttercms/butter_resource_spec.rb
+- spec/lib/buttercms/content_spec.rb
+- spec/lib/buttercms/hash_to_object_spec.rb
+- spec/spec_helper.rb
+homepage: https://buttercms.com/docs
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Ruby API client for ButterCMS
+test_files: []