middleman-dato 0.0.1.rc12 → 0.5.0

data/lib/dato/record.rb

@@ -1,77 +1,108 @@
-require "active_support/core_ext/hash/indifferent_access"
-require "dato/field"
+require 'forwardable'
+require 'active_support/inflector/transliterate'
 
-module Slugify
-  refine String do
-    def to_slug
-      downcase.strip.gsub(" ", "-").gsub(/[^\w-]/, "")
-    end
-  end
+Dir[File.dirname(__FILE__) + '/field_type/*.rb'].each do |file|
+  require file
 end
 
 module Dato
   class Record
-    using Slugify
-    attr_reader :attributes, :fields, :content_type
-
-    def initialize(attributes, content_type)
-      @attributes = attributes.with_indifferent_access
-      @content_type = content_type
-      @fields = content_type[:fields].with_indifferent_access
-      @values = {}
+    extend Forwardable
+
+    attr_reader :entity
+    def_delegators :entity, :id, :type
+
+    def initialize(entity, records_repo)
+      @entity = entity
+      @records_repo = records_repo
+    end
+
+    def slug
+      if singleton?
+        content_type.api_key.humanize.parameterize
+      elsif title_attribute
+        "#{id}-#{send(title_attribute).parameterize}"
+      else
+        id.to_s
+      end
     end
 
     def singleton?
-      @singleton = content_type[:singleton]
+      content_type.singleton
     end
 
-    def respond_to?(method, include_private = false)
-      if @attributes.has_key?(method)
-        true
-      else
-        super
+    def content_type
+      entity.content_type
+    end
+
+    def fields
+      content_type.fields.sort_by(&:position)
+    end
+
+    def attributes
+      fields.each_with_object({}) do |field, acc|
+        acc[field.api_key.to_sym] = send(field.api_key)
       end
     end
 
-    def id
-      @attributes[:id]
+    def position
+      entity.position
     end
 
     def updated_at
-      Time.parse(@attributes[:updated_at])
+      Time.parse(entity.updated_at)
     end
 
-    def method_missing(method, *arguments, &block)
-      if @attributes.has_key?(method) && arguments.size == 0
-        read_attribute(method.to_sym)
-      else
-        super
-      end
+    def to_s
+      api_key = content_type.api_key
+      "#<Record id=#{id} content_type=#{api_key} attributes=#{attributes}>"
     end
+    alias inspect to_s
 
-    def slug
-      field_name = content_type[:fields].select do |_name, data|
-        data[:field_type] == "title"
-      end.shift.first
-
-      "#{id}-#{send(field_name).to_slug}"
-    rescue NoMethodError
-      # there is no title
-      return nil
+    def title_attribute
+      title_field = fields.find do |field|
+        field.field_type == 'string' &&
+          field.appeareance[:type] == 'title'
+      end
+      title_field && title_field.api_key
     end
 
-    def ==(other)
-      if other.is_a? Record
-        id == other.id
+    def respond_to?(method, include_private = false)
+      field = fields.find { |f| f.api_key.to_sym == method }
+      if field
+        true
       else
-        false
+        super
       end
     end
 
     private
 
-    def read_attribute(name)
-      Field.value(attributes[name], fields[name])
+    def read_attribute(method, field)
+      field_type = field.field_type
+      type_klass_name = "::Dato::FieldType::#{field_type.camelize}"
+      type_klass = type_klass_name.safe_constantize
+
+      if type_klass
+        value = if field.localized
+                  (entity.send(method) || {})[I18n.locale]
+                else
+                  entity.send(method)
+                end
+
+        value && type_klass.parse(value, @records_repo)
+      else
+        raise "Cannot convert field `#{method}` of type `#{field_type}`"
+      end
+    end
+
+    def method_missing(method, *arguments, &block)
+      field = fields.find { |f| f.api_key.to_sym == method }
+      if field && arguments.empty?
+        read_attribute(method, field)
+      else
+        super
+      end
     end
   end
 end

data/lib/dato/records_repo.rb

@@ -0,0 +1,106 @@
+require 'active_support/core_ext/string'
+require 'dato/record'
+
+module Dato
+  class RecordsRepo
+    attr_reader :entities_repo, :collections_by_type
+
+    def initialize(entities_repo)
+      @entities_repo = entities_repo
+      @collections_by_type = {}
+
+      build_collections_by_type!
+    end
+
+    def find(id)
+      collections_by_type.values.flatten.find do |record|
+        record && record.id == id
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      if collections_by_type.key?(method)
+        true
+      else
+        super
+      end
+    end
+
+    private
+
+    def content_type_key(content_type)
+      api_key = content_type.api_key
+      if content_type.singleton
+        [api_key.to_sym, true]
+      else
+        [api_key.pluralize.to_sym, false]
+      end
+    end
+
+    def build_collections_by_type!
+      content_type_entities.each do |content_type|
+        key, singleton = content_type_key(content_type)
+        @collections_by_type[key] = if singleton
+                                      nil
+                                    else
+                                      RecordCollection.new
+                                    end
+      end
+
+      record_entities.each do |record_entity|
+        record = Record.new(record_entity, self)
+
+        key, singleton = content_type_key(record_entity.content_type)
+        if singleton
+          @collections_by_type[key] = record
+        else
+          @collections_by_type[key].push record
+        end
+      end
+    end
+
+    def content_type_entities
+      entities_repo.find_entities_of_type('content_type')
+    end
+
+    def record_entities
+      entities_repo.find_entities_of_type('record')
+    end
+
+    def method_missing(method, *arguments, &block)
+      if collections_by_type.key?(method) && arguments.empty?
+        collections_by_type[method]
+      else
+        super
+      end
+    end
+
+    class RecordCollection < Array
+      def each(&block)
+        if block && block.arity == 2
+          each_with_object({}) do |record, acc|
+            acc[record.id] = record
+          end.each(&block)
+        else
+          super(&block)
+        end
+      end
+
+      def [](id)
+        if id.is_a? String
+          find { |record| record.id == id }
+        else
+          super(id)
+        end
+      end
+
+      def keys
+        map(&:id)
+      end
+
+      def values
+        to_a
+      end
+    end
+  end
+end

data/lib/dato/space.rb

@@ -0,0 +1,36 @@
+require 'dato/client'
+require 'dato/entities_repo'
+require 'dato/records_repo'
+
+module Dato
+  class Space
+    attr_reader :options
+    attr_reader :entities_repo
+    attr_reader :records_repo
+
+    def initialize(options)
+      @options = options
+      @entities_repo = EntitiesRepo.new
+      @records_repo = RecordsRepo.new(@entities_repo)
+    end
+
+    def refresh!
+      @entities_repo = EntitiesRepo.new(client.space, client.records)
+      @records_repo = RecordsRepo.new(@entities_repo)
+    end
+
+    def entity
+      @entities_repo.find_entities_of_type('space').first
+    end
+
+    private
+
+    def client
+      @client ||= Client.new(
+        options[:api_host],
+        options[:domain],
+        options[:token]
+      )
+    end
+  end
+end

data/lib/middleman-dato.rb

@@ -1,3 +1,6 @@
-require "dato/middleman_extension"
+require "middleman-core"
 
-Dato::MiddlemanExtension.register(:dato)
+Middleman::Extensions.register(:dato) do
+  require "dato/middleman_extension"
+  Dato::MiddlemanExtension
+end

data/middleman-dato.gemspec

@@ -1,25 +1,26 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name = "middleman-dato"
-  s.version = "0.0.1.rc12"
+  s.name = 'middleman-dato'
+  s.version = '0.5.0'
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Stefano Verna"]
-  s.email = ["s.verna@cantierecreativo.net"]
-  s.homepage = "http://cantierecreativo.net"
-  s.summary = "Fetches data from a Dato space"
-  s.description = "Fetches data from a Dato space"
+  s.authors = ['Stefano Verna']
+  s.email = ['s.verna@cantierecreativo.net']
+  s.homepage = 'http://cantierecreativo.net'
+  s.summary = 'Fetches data from a Dato space'
+  s.description = 'Fetches data from a Dato space'
 
   s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map do |f|
     File.basename(f)
   end
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 
-  s.add_runtime_dependency("middleman-core", [">= 3.3.12"])
-  s.add_runtime_dependency("faraday", [">= 0.9.0"])
-  s.add_runtime_dependency("faraday_middleware", [">= 0.9.0"])
-  s.add_runtime_dependency("imgix", [">= 0.3.1"])
+  s.add_runtime_dependency('middleman-core', ['>= 3.3.12'])
+  s.add_runtime_dependency('faraday', ['>= 0.9.0'])
+  s.add_runtime_dependency('faraday_middleware', ['>= 0.9.0'])
+  s.add_runtime_dependency('imgix', ['>= 0.3.1'])
+  s.add_runtime_dependency('video_embed')
 end

data/spec/dato/entities_repo_spec.rb

@@ -0,0 +1,41 @@
+require 'dato/json_api_entity'
+
+module Dato
+  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: 'record' } }
+          end
+
+          it 'inserts the object into entities' do
+            expect(source.entities['record']['bar']).to be_a JsonApiEntity
+          end
+        end
+
+        context 'array' do
+          let(:payload) do
+            { data: [{ id: 'bar', type: 'record' }] }
+          end
+
+          it 'inserts the objects into entities' do
+            expect(source.entities['record']['bar']).to be_a JsonApiEntity
+          end
+        end
+      end
+
+      context 'a payload with an included key' do
+        let(:payload) do
+          { included: [{ id: 'bar', type: 'record' }] }
+        end
+
+        it 'inserts the objects into entities' do
+          expect(source.entities['record']['bar']).to be_a JsonApiEntity
+        end
+      end
+    end
+  end
+end

data/spec/dato/field_type/file_spec.rb

@@ -0,0 +1,20 @@
+module Dato
+  module FieldType
+    RSpec.describe Dato::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/dato/field_type/image_spec.rb

@@ -0,0 +1,24 @@
+module Dato
+  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/dato/field_type/lat_lon_spec.rb

@@ -0,0 +1,18 @@
+module Dato
+  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