middleman-dato 0.5.16.3 → 0.5.17

data/lib/middleman_dato/items_repo.rb

@@ -1,107 +0,0 @@
-require 'active_support/core_ext/string'
-require 'middleman_dato/item'
-
-module MiddlemanDato
-  class ItemsRepo
-    attr_reader :entities_repo, :collections_by_type
-
-    def initialize(entities_repo)
-      @entities_repo = entities_repo
-      @collections_by_type = {}
-      @items_by_id = {}
-
-      build_cache!
-    end
-
-    def find(id)
-      @items_by_id[id]
-    end
-
-    def respond_to?(method, include_private = false)
-      if collections_by_type.key?(method)
-        true
-      else
-        super
-      end
-    end
-
-    private
-
-    def item_type_key(item_type)
-      api_key = item_type.api_key
-      if item_type.singleton
-        [api_key.to_sym, true]
-      else
-        [api_key.pluralize.to_sym, false]
-      end
-    end
-
-    def build_cache!
-      item_type_entities.each do |item_type|
-        key, singleton = item_type_key(item_type)
-        @collections_by_type[key] = if singleton
-                                      nil
-                                    else
-                                      ItemCollection.new
-                                    end
-      end
-
-      item_entities.each do |item_entity|
-        item = Item.new(item_entity, self)
-
-        key, singleton = item_type_key(item_entity.item_type)
-        if singleton
-          @collections_by_type[key] = item
-        else
-          @collections_by_type[key].push item
-        end
-
-        @items_by_id[item.id] = item
-      end
-    end
-
-    def item_type_entities
-      entities_repo.find_entities_of_type('item_type')
-    end
-
-    def item_entities
-      entities_repo.find_entities_of_type('item')
-    end
-
-    def method_missing(method, *arguments, &block)
-      if collections_by_type.key?(method) && arguments.empty?
-        collections_by_type[method]
-      else
-        super
-      end
-    end
-
-    class ItemCollection < Array
-      def each(&block)
-        if block && block.arity == 2
-          each_with_object({}) do |item, acc|
-            acc[item.id] = item
-          end.each(&block)
-        else
-          super(&block)
-        end
-      end
-
-      def [](id)
-        if id.is_a? String
-          find { |item| item.id == id }
-        else
-          super(id)
-        end
-      end
-
-      def keys
-        map(&:id)
-      end
-
-      def values
-        to_a
-      end
-    end
-  end
-end

data/lib/middleman_dato/json_api_entity.rb

@@ -1,75 +0,0 @@
-module MiddlemanDato
-  class JsonApiEntity
-    attr_reader :payload, :data_source
-
-    def initialize(payload, data_source)
-      @payload = payload
-      @data_source = data_source
-    end
-
-    def id
-      @payload[:id]
-    end
-
-    def type
-      @payload[:type]
-    end
-
-    def ==(other)
-      if other.is_a? JsonApiEntity
-        id == other.id && type == other.type
-      else
-        false
-      end
-    end
-
-    def to_s
-      "#<JsonApiEntity id=#{id} type=#{type} payload=#{payload}>"
-    end
-    alias inspect to_s
-
-    def [](key)
-      attributes[key]
-    end
-
-    def respond_to?(method, include_private = false)
-      if attributes.key?(method) || relationships.key?(method)
-        true
-      else
-        super
-      end
-    end
-
-    private
-
-    def attributes
-      @payload.fetch(:attributes, {})
-    end
-
-    def relationships
-      @payload.fetch(:relationships, {})
-    end
-
-    def dereference_linkage(linkage)
-      if linkage.is_a? Array
-        linkage.map do |item|
-          data_source.find_entity(item[:type], item[:id])
-        end
-      else
-        data_source.find_entity(linkage[:type], linkage[:id])
-      end
-    end
-
-    def method_missing(method, *arguments, &block)
-      return super unless arguments.empty?
-
-      if attributes.key?(method)
-        attributes[method]
-      elsif relationships.key?(method)
-        dereference_linkage(relationships[method][:data])
-      else
-        super
-      end
-    end
-  end
-end

data/lib/middleman_dato/site.rb

@@ -1,36 +0,0 @@
-# coding: utf-8
-require 'middleman_dato/client'
-require 'middleman_dato/entities_repo'
-require 'middleman_dato/items_repo'
-
-module MiddlemanDato
-  class Site
-    attr_reader :options
-    attr_reader :entities_repo
-    attr_reader :items_repo
-
-    def initialize(options)
-      @options = options
-      @entities_repo = EntitiesRepo.new
-      @items_repo = ItemsRepo.new(@entities_repo)
-    end
-
-    def refresh!
-      @entities_repo = EntitiesRepo.new(client.site, client.items)
-      @items_repo = ItemsRepo.new(@entities_repo)
-    end
-
-    def entity
-      @entities_repo.find_entities_of_type('site').first
-    end
-
-    private
-
-    def client
-      @client ||= Client.new(
-        options[:api_host],
-        options[:token]
-      )
-    end
-  end
-end

data/spec/middleman_dato/entities_repo_spec.rb

@@ -1,41 +0,0 @@
-require 'middleman_dato/json_api_entity'
-
-module MiddlemanDato
-  RSpec.describe EntitiesRepo do
-    subject(:source) { described_class.new(payload) }
-
-    describe '#entities' do
-      context 'a payload with a data key' do
-        context 'object' do
-          let(:payload) do
-            { data: { id: 'bar', type: 'item' } }
-          end
-
-          it 'inserts the object into entities' do
-            expect(source.entities['item']['bar']).to be_a JsonApiEntity
-          end
-        end
-
-        context 'array' do
-          let(:payload) do
-            { data: [{ id: 'bar', type: 'item' }] }
-          end
-
-          it 'inserts the objects into entities' do
-            expect(source.entities['item']['bar']).to be_a JsonApiEntity
-          end
-        end
-      end
-
-      context 'a payload with an included key' do
-        let(:payload) do
-          { included: [{ id: 'bar', type: 'item' }] }
-        end
-
-        it 'inserts the objects into entities' do
-          expect(source.entities['item']['bar']).to be_a JsonApiEntity
-        end
-      end
-    end
-  end
-end

data/spec/middleman_dato/field_type/file_spec.rb

@@ -1,20 +0,0 @@
-module MiddlemanDato
-  module FieldType
-    RSpec.describe MiddlemanDato::FieldType::File do
-      subject(:file) { described_class.parse(attributes, nil) }
-      let(:attributes) do
-        {
-          path: '/foo.png',
-          format: 'jpg',
-          size: 4000
-        }
-      end
-
-      it 'responds to path, format and size methods' do
-        expect(file.path).to eq '/foo.png'
-        expect(file.format).to eq 'jpg'
-        expect(file.size).to eq 4000
-      end
-    end
-  end
-end

data/spec/middleman_dato/field_type/image_spec.rb

@@ -1,24 +0,0 @@
-module MiddlemanDato
-  module FieldType
-    RSpec.describe Image do
-      subject(:image) { described_class.parse(attributes, nil) }
-      let(:attributes) do
-        {
-          path: '/foo.png',
-          format: 'jpg',
-          size: 4000,
-          width: 20,
-          height: 20
-        }
-      end
-
-      it 'responds to path, format, size, width and height' do
-        expect(image.path).to eq '/foo.png'
-        expect(image.format).to eq 'jpg'
-        expect(image.size).to eq 4000
-        expect(image.width).to eq 20
-        expect(image.height).to eq 20
-      end
-    end
-  end
-end

data/spec/middleman_dato/field_type/lat_lon_spec.rb

@@ -1,18 +0,0 @@
-module MiddlemanDato
-  module FieldType
-    RSpec.describe LatLon do
-      subject(:latlon) { described_class.parse(attributes, nil) }
-      let(:attributes) do
-        {
-          latitude: 12,
-          longitude: 10
-        }
-      end
-
-      it 'responds to latitude and longitude methods' do
-        expect(latlon.latitude).to eq 12
-        expect(latlon.longitude).to eq 10
-      end
-    end
-  end
-end

data/spec/middleman_dato/field_type/seo_spec.rb

@@ -1,31 +0,0 @@
-module MiddlemanDato
-  module FieldType
-    RSpec.describe Seo do
-      subject(:seo) { described_class.parse(attributes, nil) }
-      let(:attributes) do
-        {
-          title: 'title',
-          description: 'description',
-          image: {
-            path: '/foo.png',
-            format: 'jpg',
-            size: 4000,
-            width: 20,
-            height: 20
-          }
-        }
-      end
-
-      it 'responds to title, description and image methods' do
-        expect(seo.title).to eq 'title'
-        expect(seo.description).to eq 'description'
-        expect(seo.image).to be_a MiddlemanDato::FieldType::Image
-        expect(seo.image.path).to eq '/foo.png'
-        expect(seo.image.format).to eq 'jpg'
-        expect(seo.image.size).to eq 4000
-        expect(seo.image.width).to eq 20
-        expect(seo.image.height).to eq 20
-      end
-    end
-  end
-end

data/spec/middleman_dato/field_type/video_spec.rb

@@ -1,32 +0,0 @@
-module MiddlemanDato
-  module FieldType
-    RSpec.describe Video do
-      subject(:video) { described_class.parse(attributes, nil) }
-      let(:attributes) do
-        {
-          url: 'https://www.youtube.com/watch?v=oHg5SJYRHA0',
-          provider_uid: '123123',
-          thumbnail_url: 'http://i3.ytimg.com/vi/oHg5SJYRHA0/hqdefault.jpg',
-          title: "RickRoll'D",
-          width: 640,
-          height: 480
-        }
-      end
-
-      it 'responds to path, format, size, width and height' do
-        expect(video.url).to eq 'https://www.youtube.com/watch?v=oHg5SJYRHA0'
-        expect(video.provider_uid).to eq '123123'
-        expect(video.thumbnail_url).to eq 'http://i3.ytimg.com/vi/oHg5SJYRHA0/hqdefault.jpg'
-        expect(video.title).to eq "RickRoll'D"
-        expect(video.width).to eq 640
-        expect(video.height).to eq 480
-      end
-
-      describe 'iframe_embed' do
-        it 'returns a iframe embed HTML fragment' do
-          expect(video.iframe_embed).to eq '<iframe width="560" height="315" src="http://www.youtube.com/embed/oHg5SJYRHA0?rel=0" frameborder="0" allowfullscreen></iframe>'
-        end
-      end
-    end
-  end
-end

data/spec/middleman_dato/item_spec.rb

@@ -1,188 +0,0 @@
-module MiddlemanDato
-  RSpec.describe Item do
-    subject(:item) { described_class.new(entity, repo) }
-    let(:entity) do
-      double(
-        'MiddlemanDato::JsonApiEntity(Item)',
-        id: '14',
-        item_type: item_type,
-        title: "My titlè with àccents",
-        body: 'Hi there',
-        position: 2,
-        updated_at: '2010-01-01T00:00'
-      )
-    end
-    let(:repo) do
-      instance_double('MiddlemanDato::ItemsRepo')
-    end
-    let(:item_type) do
-      double(
-        'MiddlemanDato::JsonApiEntity(Content Type)',
-        singleton: is_singleton,
-        api_key: 'work_item',
-        fields: fields
-      )
-    end
-    let(:is_singleton) { false }
-    let(:fields) do
-      [
-        double(
-          'MiddlemanDato::JsonApiEntity(Field)',
-          position: 1,
-          api_key: 'title',
-          localized: false,
-          field_type: 'string',
-          appeareance: { type: 'title' }
-        ),
-        double(
-          'MiddlemanDato::JsonApiEntity(Field)',
-          position: 1,
-          api_key: 'body',
-          localized: false,
-          field_type: 'text',
-          appeareance: { type: 'plain' }
-        )
-      ]
-    end
-
-    describe '#slug' do
-      context 'singleton' do
-        let(:is_singleton) { true }
-
-        it 'returns the parameterized content type api key' do
-          expect(item.slug).to eq 'work-item'
-        end
-      end
-
-      context 'non singleton, no title field' do
-        let(:fields) { [] }
-
-        it 'returns the ID' do
-          expect(item.slug).to eq '14'
-        end
-      end
-
-      context 'non singleton, title field' do
-        it 'returns the ID + title' do
-          expect(item.slug).to eq '14-my-title-with-accents'
-        end
-      end
-    end
-
-    describe '#attributes' do
-      it 'returns an hash of the field values' do
-        expected_attributes = {
-          'title' => "My titlè with àccents",
-          'body' => 'Hi there'
-        }
-        expect(item.attributes).to eq expected_attributes
-      end
-    end
-
-    describe 'position' do
-      it 'returns the entity position field' do
-        expect(item.position).to eq 2
-      end
-    end
-
-    describe 'updated_at' do
-      it 'returns the entity updated_at field' do
-        expect(item.updated_at).to be_a Time
-      end
-    end
-
-    describe 'dynamic methods' do
-      context 'existing field' do
-        it 'returns the field value' do
-          expect(item.respond_to?(:body)).to be_truthy
-          expect(item.body).to eq 'Hi there'
-        end
-
-        context 'localized field' do
-          let(:entity) do
-            double(
-              'MiddlemanDato::JsonApiEntity(Item)',
-              id: '14',
-              item_type: item_type,
-              title: { it: 'Foo', en: 'Bar' }
-            )
-          end
-
-          let(:fields) do
-            [
-              double(
-                'MiddlemanDato::JsonApiEntity(Field)',
-                position: 1,
-                api_key: 'title',
-                localized: true,
-                field_type: 'string',
-                appeareance: { type: 'plain' }
-              )
-            ]
-          end
-
-          it 'returns the value for the current locale' do
-            I18n.with_locale(:it) do
-              expect(item.title).to eq 'Foo'
-            end
-          end
-
-          context 'non existing value' do
-            it 'raises nil' do
-              I18n.with_locale(:ru) do
-                expect(item.title).to eq nil
-              end
-            end
-          end
-        end
-      end
-
-      context 'non existing field' do
-        it 'raises NoMethodError' do
-          expect(item.respond_to?(:qux)).to be_falsy
-          expect { item.qux }.to raise_error NoMethodError
-        end
-      end
-
-      context 'non existing field type' do
-        let(:fields) do
-          [
-            double(
-              'MiddlemanDato::JsonApiEntity(Field)',
-              position: 1,
-              api_key: 'title',
-              localized: true,
-              field_type: 'rotfl'
-            )
-          ]
-        end
-
-        it 'raises RuntimeError' do
-          expect { item.title }.to raise_error RuntimeError
-        end
-      end
-    end
-
-    context 'equality' do
-      subject(:same_item) { described_class.new(entity, repo) }
-
-      subject(:another_item) { described_class.new(another_entity, repo) }
-      let(:another_entity) do
-        double(
-          'MiddlemanDato::JsonApiEntity(Item)',
-          id: '15'
-        )
-      end
-
-
-      it 'two items are equal if their id is the same' do
-        expect(item).to eq same_item
-      end
-
-      it 'else they\'re not' do
-        expect(item).not_to eq another_item
-        expect(item).not_to eq "foobar"
-      end
-    end
-  end
-end