middleman-dato 0.0.1.rc4 → 0.0.1.rc5

data/lib/dato/middleman_extension.rb

@@ -1,18 +1,18 @@
-require 'middleman-core'
-require 'dato/repo'
-require 'dato/meta_tags_builder'
-require 'ostruct'
+require "middleman-core"
+require "dato/repo"
+require "dato/meta_tags_builder"
+require "ostruct"
 
 module Dato
   class MiddlemanExtension < ::Middleman::Extension
-    option :domain, nil, 'Space domain'
-    option :token, nil, 'Space API token'
-    option :api_host, 'http://dato-api.herokuapp.com', 'Space API token'
-    option :base_url, nil, 'Website base URL'
+    option :domain, nil, "Space domain"
+    option :token, nil, "Space API token"
+    option :api_host, "http://dato-api.herokuapp.com", "Space API token"
+    option :base_url, nil, "Website base URL"
 
     attr_reader :records
 
-    def initialize(app, options_hash={}, &block)
+    def initialize(app, options_hash = {}, &block)
       super
 
       Repo.instance.connection_options = options
@@ -42,18 +42,16 @@ module Dato
       end
 
       def dato_meta_tags(record)
-        begin
-          builder = MetaTagsBuilder.new(
-            self,
-            Repo.instance.connection_options[:base_url],
-            Repo.instance.space,
-            record
-          )
-          builder.meta_tags
-        rescue Exception => e
-          puts e.message
-          puts e.backtrace.join("\n")
-        end
+        builder = MetaTagsBuilder.new(
+          self,
+          Repo.instance.connection_options[:base_url],
+          Repo.instance.space,
+          record
+        )
+        builder.meta_tags
+      rescue Exception => e
+        puts e.message
+        puts e.backtrace.join("\n")
       end
     end
   end

data/lib/dato/record.rb

@@ -1,15 +1,24 @@
-require "dato/file"
-require "dato/seo"
-require "time"
+require "active_support/core_ext/hash/indifferent_access"
+require "dato/field"
+
+module Slugify
+  refine String do
+    def to_slug
+      downcase.strip.gsub(" ", "-").gsub(/[^\w-]/, "")
+    end
+  end
+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 = {}
     end
 
     def singleton?
@@ -24,28 +33,6 @@ module Dato
       end
     end
 
-    def read_attribute(name)
-      attribute = @attributes[name]
-
-      attribute = if fields[name][:localized]
-        attribute[I18n.locale]
-      else
-        attribute
-      end
-
-      return nil if !attribute
-
-      if %w(image file).include? fields[name][:field_type]
-        Dato::File.new(attribute)
-      elsif fields[name][:field_type] == "date"
-        Date.parse(attribute)
-      elsif fields[name][:field_type] == "seo"
-        Dato::Seo.new(attribute)
-      else
-        attribute
-      end
-    end
-
     def id
       @attributes[:id]
     end
@@ -61,5 +48,29 @@ module Dato
         super
       end
     end
+
+    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
+    end
+
+    def ==(other)
+      id == other.id
+    end
+
+    private
+
+    def read_attribute(name)
+      unless @values.has_key?(name)
+        @values[name] = Field.value(attributes[name], fields[name])
+      end
+      @values[name]
+    end
   end
 end

data/lib/dato/repo.rb

@@ -1,14 +1,14 @@
-require 'singleton'
-require 'active_support/inflector/methods'
-require 'dato/client'
-require 'dato/record'
+require "singleton"
+require "active_support/inflector/methods"
+require "dato/client"
+require "dato/record"
 
 module Dato
   class Repo
     include Singleton
 
     attr_reader :client, :space, :content_types, :records_per_content_type,
-      :connection_options
+      :connection_options, :records
 
     def connection_options=(options)
       @connection_options = options
@@ -23,43 +23,40 @@ module Dato
       space_response = client.space.with_indifferent_access
       @space = space_response[:data]
       @content_types = prepare_content_types(space_response)
-      @records_per_content_type = group_by_content_type(client.records)
+      @records = client.records.with_indifferent_access
+      @records_per_content_type = group_by_content_type(@records)
     end
 
     def prepare_content_types(data)
       data = data.with_indifferent_access
 
-      content_types = Hash[
-        data[:data][:links][:content_types][:linkage]
-          .map do |content_type|
-            [
-              content_type[:id],
-              content_type_data(content_type[:id], data[:included])
-            ]
-          end
+      Hash[
+        data[:data][:links][:content_types][:linkage].map do |content_type|
+          [
+            content_type[:id],
+            content_type_data(content_type[:id], data[:included])
+          ]
+        end
       ]
     end
 
     def content_type_data(content_type, data)
-      content_type = data
-        .find do |item|
-          item[:type] == "content_type" && item[:id] == content_type
-        end
+      content_type = data.
+                     detect do |item|
+        item[:type] == "content_type" && item[:id] == content_type
+      end
 
-      field_ids = content_type[:links][:fields][:linkage]
-        .map { |field| field[:id] }
+      field_ids = content_type[:links][:fields][:linkage].
+                  map { |field| field[:id] }
 
       fields = Hash[
-        data
-          .select do |item|
-            item[:type] == "field" && field_ids.include?(item[:id])
-          end
-          .map do |field|
-            [
-              field[:attributes][:api_key],
-              field[:attributes]
-            ]
-          end
+        data.
+        select do |item|
+          item[:type] == "field" && field_ids.include?(item[:id])
+        end.
+        map do |field|
+          [field[:attributes][:api_key], field[:attributes]]
+        end
       ]
 
       {
@@ -68,19 +65,27 @@ module Dato
       }
     end
 
+    def find(id)
+      record = records[:data].detect { |r| r[:id] == id }
+      normalize_record(record) unless record.nil?
+    end
+
+    def find_all(ids)
+      ids.map { |id| find(id) }
+    end
+
     def group_by_content_type(data)
       Hash[
         content_types.map do |id, content_type|
-          records = data
-            .with_indifferent_access[:data]
-            .select do |record|
-              record[:links][:content_type][:linkage][:id] == id
-            end
+          records = data[:data].
+                    select do |record|
+            record[:links][:content_type][:linkage][:id] == id
+          end
 
           if content_type[:singleton]
-            [ id, records.any? ? normalize_record(records.first) : nil ]
+            [id, records.any? ? normalize_record(records.first) : nil]
           else
-            [ id.pluralize, group_by_id(records) ]
+            [id.pluralize, group_by_id(records)]
           end
         end
       ]
@@ -88,17 +93,14 @@ module Dato
 
     def group_by_id(records)
       Hash[
-        records
-          .group_by { |record| record[:id] }
-          .map do |id, records|
-            [ id, normalize_record(records.first) ]
-          end
+        records.
+          group_by { |record| record[:id] }.
+          map { |id, r| [id, normalize_record(r.first)] }
       ]
     end
 
     def normalize_record(record)
       content_type = record[:links][:content_type][:linkage][:id]
-
       Record.new(
         record[:attributes].merge(id: record[:id]),
         content_types[content_type]

data/lib/middleman_extension.rb

@@ -1 +1 @@
-require 'middleman-dato'
+require "middleman-dato"

data/middleman-dato.gemspec

@@ -2,18 +2,20 @@
 $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "middleman-dato"
-  s.version     = "0.0.1.rc4"
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Stefano Verna"]
-  s.email       = ["s.verna@cantierecreativo.net"]
-  s.homepage    = "http://cantierecreativo.net"
-  s.summary     = %q{Fetches data from a Dato space}
-  s.description = %q{Fetches data from a Dato space}
+  s.name = "middleman-dato"
+  s.version = "0.0.1.rc5"
+  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.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{ |f| File.basename(f) }
+  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.add_runtime_dependency("middleman-core", [">= 3.3.12"])

data/spec/dato/field_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+RSpec.describe Dato::Field do
+  describe ".value" do
+    let(:attribute) { "bar" }
+    let(:field) { { field_type: "text" } }
+
+    it "returns the field value" do
+      expect(described_class.value(attribute, field)).to eq("bar")
+    end
+
+    context "if the field is marked to be localizable" do
+      let(:field) { { field_type: "text", localized: true } }
+
+      before do
+        allow(I18n).to receive(:locale).and_return("en")
+      end
+
+      context "if it has a translation for the current locale" do
+        let(:attribute) { { en: "baz" } }
+
+        it "returns the field value translation" do
+          expect(described_class.value(attribute, field)).to eq("baz")
+        end
+      end
+
+      context "else" do
+        let(:attribute) { { fr: "baz" } }
+
+        it "returns nil" do
+          expect(described_class.value(attribute, field)).to be_nil
+        end
+      end
+    end
+
+    describe "field types" do
+      let(:client) { double("Client") }
+
+      before do
+        allow(Dato::Client).to receive(:new).and_return(client)
+        allow(client).to receive(:records).and_return(data: [
+          {
+            id: 1,
+            attributes: {},
+            links: {
+              content_type: {
+                linkage: {
+                  id: "foo",
+                  type: "content_type"
+                }
+              }
+            }
+          }
+        ])
+        allow(client).to receive(:space).and_return(
+          data: {
+            links: {
+              content_types: {
+                linkage: [
+                  {
+                    id: "foo",
+                    type: "content_type"
+                  }
+                ]
+              }
+            }
+          },
+          included: [
+            {
+              attributes: {
+                name: "foo",
+                singleton: false
+              },
+              id: "foo",
+              links: {
+                fields: {
+                  linkage: []
+                },
+                singleton_record: {
+                  linkage: nil
+                }
+              },
+              type: "content_type"
+            }
+          ]
+        )
+
+        Dato::Repo.instance.connection_options = {}
+        Dato::Repo.instance.sync!
+      end
+
+      [
+        { type: "image", value: {}, result: Dato::Fields::File.new({}) },
+        { type: "file", value: {}, result: Dato::Fields::File.new({}) },
+        { type: "date", value: "2015-06-09", result: Date.new(2015, 6, 9) },
+        { type: "seo", value: {}, result: Dato::Fields::Seo.new({}) },
+        { type: "belongs_to", value: 1, result: Dato::Record.new({ id: 1 }, fields: {}) }
+      ].each do |data|
+        context "if the field has '#{data[:type]}' type" do
+          let(:attribute) { data[:value] }
+          let(:field) { { field_type: data[:type] } }
+
+          it "converts the value to the specific type" do
+            expect(described_class.value(attribute, field)).to eq(data[:result])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dato/meta_tags/article_modified_time_spec.rb

@@ -1,21 +1,21 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Dato::MetaTags
   RSpec.describe ArticleModifiedTime do
-    subject(:meta_tag) { described_class.new(builder, space, record) }
+    subject(:meta_tag) { described_class.new(builder, base_url, space, record) }
     let(:builder) { MockBuilder.new }
+    let(:base_url) { nil }
     let(:space) { nil }
     let(:record) do
       double("Record", updated_at: Time.now, singleton?: false)
     end
 
-    describe '.value' do
-      context 'if record is not singleton' do
-        it 'returns an ISO 8601 time representation' do
+    describe ".value" do
+      context "if record is not singleton" do
+        it "returns an ISO 8601 time representation" do
           expect(meta_tag.value).not_to be_nil
         end
       end
     end
   end
 end
-