contentful_middleman 0.0.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccfe1bc9ea0a8cfa76de3d65aa382141e3d81da0
-  data.tar.gz: 5929f5f756b15d636a17e575a40c81bf3f0b1230
+  metadata.gz: e5976bd4bf0b3954a33f737d13b8d9e2b928a9f8
+  data.tar.gz: 27378bfcc1245e25474fa1ccb26ccdbee82ba203
 SHA512:
-  metadata.gz: ece6120ab1f940ce2bd6dac04a5ef093d322caf057e4f17a247362445b7a61b6eac19f35da0eef2e9c3f00b56f9417a19ebc1fab5fc8440c2e2a0dd16ea5bcc8
-  data.tar.gz: d20282b168ad58b84b9d77400dbaa01d9527d776119dd2510263f8de3b32cd824bb330ade6045ad17e77221185032938d94d51b93a8d71213e77e2d6e975d1ff
+  metadata.gz: 687bf3399611ae1cabf559862d375914afc69fdb93df7bcad0258875b5b42c46cb6f8a3e7540639f464ec71d892df862ea6d9f0dd246c41cab0a46f79d65d04c
+  data.tar.gz: 007f63c5d2fb64088ef48590e17eb5f1539afcb6ff1eeaf85d6f7fcb758a0ab470216ba61211046943cac18aa24ad25c22c6f992c4281a94a6467782fa568d94

data/CHANGELOG.md

@@ -1,15 +1,28 @@
-0.0.4
-===
+# Change Log
 
+## 1.0.
+### Other
+This release brings breaking changes that are not compatible with extension configurations in
+previous versions. For more information about the supported configuration please read the
+README file.
+
+Changes in this release:
+
+* Support multiple activations of the extension. Import from multiple spaces
+* Decouple mapping of entries from blog post layout. Support custom mappers
+* Store imported entries as local data
+* Optionally rebuild static site only when there are changes in the imported data
+
+## 0.0.4
+### Other
 * Publish first Gem version
 
-0.0.3
-===
+## 0.0.3
 
+### Other
 * Minor updates
 
 
-0.0.2
-===
-
+## 0.0.2
+### Other
 * First release

data/README.md

@@ -2,12 +2,10 @@
 
 [![Build Status](https://travis-ci.org/contentful/contentful_middleman.png)](https://travis-ci.org/contentful/contentful_middleman)
 
-Contentful Middleman is a [Middleman](http://middlemanapp.com/) extension to use the Middleman static side generator together with the API-driven [Contentful CMS](https://www.contentful.com). It is powered by the [Contentful Ruby Gem](https://github.com/contentful/contentful.rb).
+Contentful Middleman is a [Middleman](http://middlemanapp.com/) extension to use the Middleman static site generator together with the API-driven [Contentful CMS](https://www.contentful.com). It is powered by the [Contentful Ruby Gem](https://github.com/contentful/contentful.rb).
 
 Experience the power of Middleman while staying sane as a developer by letting end-users edit content in a web-based interface.
 
-This extensions supports both page-based content as well as blog posts through middleman-blog.
-
 ## Installation
 
 Add the following line to the Gemfile of your Middleman project:
@@ -22,62 +20,138 @@ Then as usual, run:
 bundle install
 ```
 
+## Usage
+
+Run `middleman contentful` in your terminal. This will fetch entries for the configured
+spaces and content types and put the resulting data in the
+[local data folder](https://middlemanapp.com/advanced/local-data/) as yaml files.
+
+### --rebuild option
+
+The `contentful` command has a `--rebuild` option which will trigger a rebuild of your site only if there were changes between the last
+and the current import.
+
 ## Configuration
 
 To configure the extension, add the following configuration block to Middleman's config.rb:
 
+```ruby
+activate :contentful do |f|
+  f.space         = SPACE
+  f.access_token  = ACCESS_TOKEN
+  f.cda_query     = QUERY
+  f.content_types = CONTENT_TYPES_MAPPINGS
+end
+```
+
+Parameter     | Description
+----------    |------------
+space         | Hash with an user choosen name for the space as key and the space id as value
+access_token  | Contentful Delivery API access token
+cda_query     | Hash describing query configuration. See [contentful.rb](https://github.com/contentful/contentful.rb) for more info
+content_types | Hash describing the mapping applied to entries of the imported content types
+
+You can activate the extension multiple times to import entries from different spaces.
+## Entry mapping
+
+The extension will transform every fetched entry before storing it as a yaml file in the local
+data folder. If a custom mapper is not specified a default one will be used.
+
+The default mapper will map fields, assets and linked entries.
+
+### Custom mappers
+
+You can create your own mappers if you need so. The only requirement for a class to behave as a
+mapper is to have a `map(context, entry)` instance method. This method will take as parameters:
+
+  * A context object. All properties set on this object will be written to the yaml file
+  * An entry
+
+Following is an example of such custom mapper:
+
+```ruby
+class MyAwesomeMapper
+  def map(context, entry)
+    context.slug = entry.title.parameterize
+    #... more transformations
+  end
+end
+```
+
+If you don't want to map all the fields by hand inherit from the Base mappper:
+
+```ruby
+class MyAwesomeMapper < ContentfulMiddleman::Mappers::Base
+  def map(context, entry)
+    super
+    # After calling super the context object
+    # will have a property for every field in the
+    # entry
+  end
+end
 ```
+
+## Configuration: examples
+
+```ruby
 activate :contentful do |f|
-  # The Space ID of your Contentful space
-  f.space = 'YOUR_SPACE_ID'
-
-  # The access token (API Key) for the Content Delivery API
-  f.access_token = 'YOUR_CONTENT_DELIVERY_API_ACCESS_TOKEN'
-
-  # Optional: Options for middleman-blog
-
-  # Filter Entries for your blog posts. See Contentful gem and Content Delivery API documentation.
-  f.blog_posts_query = {content_type: "6LbnqgnwA08qYaU", category: "news" } 
-  
-  # Which keys to use in the article template for blog posts
-  # Key: template variable
-  # Value: Entry method or block
-  f.blog_post_mappings = {
-      slug: :id,
-      date: :created_at,
-      body: :id,
-      tags: :tags,
-      title: ->(e){"#{e.id}XXXX"}
-  }
-
-  # Define your own template for blog posts
-  f.new_article_template = "/my_templates/article.tt"
-
-  # Automatically synchronize blog posts before building with "middleman build"
-  f.sync_blog_before_build = true # default: false
+  f.space         = {partners: 'space-id'}
+  f.access_token  = 'some_access_token'
+  f.cda_query     = { content_type: 'content-type-id', include: 1 }
+  f.content_types = { partner: 'content-type-id'}
 end
 ```
+The above configuration does the following:
 
-## Using managed content in regular pages
+  * Sets the alias `partners` to the space with id _some-id_
+  * Sets the alias `partner` to the content type with id _content-type-id_
+  * Uses the default mapper to transform `partner` entries into yaml files (no mapper specified for the `partner` content type)
 
-The `contentful` helper provides a Contentful gem client object, that can be used to fetch managed content from Contentful:
+Entries fetched using this configuration will be stored as yaml files in `data/partners/partner/ENTRY_ID.yaml`.
+
+```ruby
+class Mapper
+  def map(context, entry)
+    context.title = "#{entry.title}-title"
+    #...
+  end
+end
 
+activate :contentful do |f|
+  f.space         = {partners: 'space-id'}
+  f.access_token  = 'some_access_token'
+  f.cda_query     = { content_type: '1EVL9Bl48Euu28QEOa44ai', include: 1 }
+  f.content_types = { partner: {mapper: Mapper, id: 'content-type-id'}}
+end
 ```
-  <ol>
-    <% contentful.entries(content_type: '6LbnqgnwA08qYaU').each do |entry| %>
-      <li>
-        <%= entry.title %>
-        <%= entry.body %>
-        <%= entry.created_at %>
-      </li>
-    <% end %>
-  </ol>
+
+The above configuration is the same as the previous one only that this time we are setting a custom mapper
+for the entries belonging to the `partner` content type.
+
+
+## Using imported entries in templates
+
+Middleman will load all the yaml files stored in the local data folder. This lets you use all the imported
+data into your templates.
+
+Consider that we have data stored under `data/partners/partner`. Then in our templates we could use that data like
+this:
+
+```html
+<h1>Partners</h1>
+<ol>
+  <% data.partners.partner.each do |id, partner| %>
+    <li><%= partner["name"] %></li>
+  <% end %>
+</ol>
 ```
 
-## Synchronizing blog posts manually
+### Rendering Markdown:
 
-Blog posts are synchronized to your repo as YAML files with front matter, just as if you would write them manually. Either automatically when building, or manually by running:
+If you want to use markdown in your content types you manually have to render this to markdown.
+Depending on the markdown library you need to transform the data.
+For Kramdown this would be:
 
 ```
-middleman contentful
+<%= Kramdown::Document.new(data).to_html %>
 ```

data/Rakefile

@@ -9,7 +9,7 @@ require 'rspec/core/rake_task'
 desc "Run RSpec"
 RSpec::Core::RakeTask.new do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
-  spec.rspec_opts = ['--color', '--format nested']
+  spec.rspec_opts = ['--color']
 end
 
 begin

data/contentful_middleman.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.name        = "contentful_middleman"
   s.version     = ContentfulMiddleman::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Sascha Konietzke"]
-  s.email       = ["sascha@contentful.com"]
+  s.authors     = ["Sascha Konietzke", "Farruco Sanjurjoj"]
+  s.email       = ["sascha@contentful.com", "madtrick@gmail.com"]
   s.homepage    = "https://www.contentful.com"
   s.summary     = %q{Include mangablable content from the Contentful CMS and API into your Middleman projects}
   s.description = %q{Load blog posts and other managed content into Middleman}

data/lib/contentful_middleman.rb

@@ -2,6 +2,6 @@ require "middleman-core"
 
 require 'contentful_middleman/version'
 require 'contentful_middleman/core'
-require "contentful_middleman/commands/sync_blog"
+require "contentful_middleman/commands/contentful"
 
 ::Middleman::Extensions.register(:contentful, ContentfulMiddleman::Core)

data/lib/contentful_middleman/commands/contentful.rb

@@ -0,0 +1,79 @@
+require 'middleman-core/cli'
+require 'middleman-blog/uri_templates'
+require 'date'
+require 'digest'
+require 'contentful_middleman/commands/context'
+require 'contentful_middleman/tools/backup'
+require 'contentful_middleman/version_hash'
+require 'Contentful_middleman/import_task'
+require 'contentful_middleman/local_data/store'
+require 'contentful_middleman/local_data/file'
+
+module Middleman
+  module Cli
+    # This class provides an "contentful" command for the middleman CLI.
+
+    class Contentful < Thor
+      include Thor::Actions
+
+      # Path where Middleman expects the local data to be stored
+      MIDDLEMAN_LOCAL_DATA_FOLDER = 'data'
+
+      check_unknown_options!
+
+      namespace :contentful
+      desc 'contentful', 'Import data from Contentful'
+
+      method_option "rebuild",
+        aliases: "-r",
+        desc: "Rebuilds the site if there were changes in the imported data"
+
+      def self.source_root
+        ENV['MM_ROOT']
+      end
+
+      # Tell Thor to exit with a nonzero exit code on failure
+      def self.exit_on_failure?
+        true
+      end
+
+      def contentful
+        if shared_instance.respond_to? :contentful_instances
+          ContentfulMiddleman::VersionHash.source_root    = self.class.source_root
+          ContentfulMiddleman::LocalData::Store.base_path = MIDDLEMAN_LOCAL_DATA_FOLDER
+          ContentfulMiddleman::LocalData::File.thor       = self
+
+          hash_local_data_changed = contentful_instances.reduce(false) do |changes, instance|
+            import_task = create_import_task(instance)
+            import_task.run
+
+            changes || import_task.changed_local_data?
+          end
+
+          Middleman::Cli::Build.new.build if hash_local_data_changed && options[:rebuild]
+          shared_instance.logger.info 'Contentful Import: Done!'
+        else
+          raise Thor::Error.new "You need to activate the contentful extension in config.rb before you can import data from Contentful"
+        end
+      end
+
+      private
+        def contentful_instances
+          shared_instance.contentful_instances
+        end
+
+        def create_import_task(instance)
+          space_name           = instance.space_name.to_s
+          content_type_names   = instance.content_types_ids_to_names
+          content_type_mappers = instance.content_types_ids_to_mappers
+
+          ContentfulMiddleman::ImportTask.new(space_name, content_type_names, content_type_mappers, instance)
+        end
+
+        def shared_instance
+          @shared_instance ||= ::Middleman::Application.server.inst
+        end
+    end
+
+  end
+end

data/lib/contentful_middleman/commands/context.rb

@@ -0,0 +1,76 @@
+module ContentfulMiddleman
+  class Context < BasicObject
+    def initialize
+      @variables       = {}
+      @nexted_contexts = []
+    end
+
+    def method_missing(symbol, *args, &block)
+      if symbol =~ /\A.+=\z/
+        variable_name              = symbol.to_s.gsub('=','')
+        variable_value             = args.first
+
+        set variable_name, variable_value
+      else
+        get symbol
+      end
+    end
+
+    def nest(field_name)
+      @nexted_contexts << field_name
+      new_context = Context.new
+      yield new_context
+
+      set field_name, new_context
+    end
+
+    def map(field_name, elements)
+      @nexted_contexts << field_name
+      new_contexts = elements.map do |element|
+        new_context = Context.new
+        yield element, new_context
+        new_context
+      end
+
+      set field_name, new_contexts
+    end
+
+    def set(name, value)
+      @variables[name.to_sym] = value
+    end
+
+    def get(name)
+      @variables.fetch(name.to_sym)
+    end
+
+    def is_a?(klass)
+      Context == klass
+    end
+
+    def to_hash
+      @variables
+    end
+
+    def to_yaml
+      variables = @variables.dup
+      variables.update(variables) do |variable_name, variable_value|
+        if @nexted_contexts.include? variable_name
+          hashize_nested_context(variable_value)
+        else
+          variable_value
+        end
+      end
+
+      variables.to_yaml
+    end
+
+    def hashize_nested_context(nested_context)
+      case nested_context
+      when ::Array
+        nested_context.map {|e| e.to_hash}
+      else
+        nested_context.to_hash
+      end
+    end
+  end
+end

data/lib/contentful_middleman/core.rb

@@ -1,69 +1,71 @@
 require 'middleman-core'
 require 'contentful'
+require_relative 'mappers/base'
+require_relative 'helpers'
+require_relative 'instance'
 
 # The Contentful Middleman extensions allows to load managed content into Middleman projects through the Contentful Content Management Platform.
 module ContentfulMiddleman
+  def self.instances
+    @contentful_middleman_instances ||= []
+  end
+
   class Core < ::Middleman::Extension
-    DEFAULT_BLOG_MAPPINGS = {
-      slug: :id,
-      date: :created_at,
-      title: :id,
-      body: :id,
-      tags: :tags
-    }
+    self.supports_multiple_instances = true
 
-    self.supports_multiple_instances = false
+    option :space, nil,
+      'The Contentful Space ID and name'
 
-    option :space, nil, 'The Contentful Space ID'
-    option :access_token, nil, 'The Contentful Content Delivery API access token'
+    option :access_token, nil,
+      'The Contentful Content Delivery API access token'
 
-    option :new_article_template, File.expand_path('../commands/article.tt', __FILE__), 'Path (relative to project root) to an ERb template that will be used to generate new Contentful articles from the "middleman contentful" command.'
+    option :cda_query, {},
+      'The conditions that are used on the Content Delivery API to query for blog posts'
 
-    option :blog_posts_query, {}, "The conditions that are used on the Content Delivery API to query for blog posts"
-    option :blog_post_mappings, {}, "The mappings from Contentful DynamicResources to Middleman"
+    option :content_types, {},
+      'The mapping of Content Types names to ids'
 
-    option :sync_blog_before_build, false, "Synchronize the blog from Contentful before the build phase"
 
-    def initialize(app, options_hash={}, &block)
-      super
+    helpers ContentfulMiddleman::Helpers
 
-      app.set :contentful_middleman, self
-      app.set :contentful_middleman_client, client
+    #
+    # Middleman hooks
+    #
+    def after_configuration
+      massage_options
 
-      app.before_build do |builder|
-        contentful_middleman.sync_blog if contentful_middleman.middleman_blog_enabled? && contentful_middleman.options.sync_blog_before_build
-      end
+      ContentfulMiddleman.instances << (ContentfulMiddleman::Instance.new self)
     end
 
-    # Is the Middleman blog extension enabled?
-    def middleman_blog_enabled?
-      app.respond_to? :blog
+    private
+    def massage_options
+      massage_space_options
+      massage_content_types_options
     end
 
-    # Synchronize blog posts from Contentful through the CLI task
-    def sync_blog
-      Middleman::Cli::SyncBlog.new.contentful
-      true
-    end
+    def massage_space_options
+      space_option          = options.space
+      space_name            = space_option.keys.first
+      space_id              = space_option.fetch(space_name)
 
-    def blog_post_mappings
-      @blog_post_mappings ||= ContentfulMiddleman::Core::DEFAULT_BLOG_MAPPINGS.merge(options.blog_post_mappings)
+      options.space = { name: space_name, id: space_id }
     end
 
-    # The Contentful Gem client for the Content Delivery API
-    def client
-      @client ||= Contentful::Client.new(
-        access_token: options.access_token,
-        space: options.space,
-        dynamic_entries: :auto
-      )
-    end
+    def massage_content_types_options
+      content_types_options     = options.content_types
+      new_content_types_options = content_types_options.each_with_object({}) do |(content_type_name, value), options|
+        if value.is_a? Hash
+          mapper = value.fetch(:mapper)
+          id     = value.fetch(:id)
+        else
+          mapper = Mapper::Base
+          id     = value
+        end
 
-    helpers do
-      # A helper method to access the Contentful Gem client
-      def contentful
-        contentful_middleman_client
+        options[id] = {name: content_type_name, mapper: mapper}
       end
+
+      options.content_types = new_content_types_options
     end
   end
 end

data/lib/contentful_middleman/helpers.rb

@@ -0,0 +1,7 @@
+module ContentfulMiddleman
+  module Helpers
+    def contentful_instances
+      ContentfulMiddleman.instances
+    end
+  end
+end

data/lib/contentful_middleman/import_task.rb

@@ -0,0 +1,42 @@
+module ContentfulMiddleman
+  class ImportTask
+    def initialize(space_name, content_type_names, content_type_mappers, contentful)
+      @space_name           = space_name
+      @content_type_names   = content_type_names
+      @content_type_mappers = content_type_mappers
+      @changed_local_data   = false
+      @contentful           = contentful
+    end
+
+    def run
+      old_version_hash = ContentfulMiddleman::VersionHash.read_for_space(@space_name)
+
+      LocalData::Store.new(local_data_files, @space_name).write
+
+      new_version_hash = ContentfulMiddleman::VersionHash.write_for_space_with_entries(@space_name, entries)
+
+      @changed_local_data = new_version_hash != old_version_hash
+    end
+
+    def changed_local_data?
+      @changed_local_data
+    end
+
+    private
+    def local_data_files
+      entries.map do |entry|
+        content_type_mapper = @content_type_mappers.fetch(entry.content_type.id)
+        content_type_name   = @content_type_names.fetch(entry.content_type.id).to_s
+        context             = ContentfulMiddleman::Context.new
+
+        content_type_mapper.new.map(context, entry)
+
+        LocalData::File.new(context.to_yaml, File.join(@space_name, content_type_name, entry.id))
+      end
+    end
+
+    def entries
+      @entries ||= @contentful.entries
+    end
+  end
+end

data/lib/contentful_middleman/instance.rb

@@ -0,0 +1,45 @@
+module ContentfulMiddleman
+  class Instance
+    def initialize(extension)
+      @extension = extension
+    end
+
+    def entries
+      client.entries(options.cda_query)
+    end
+
+    def space_name
+      @space_name ||= options.space.fetch(:name)
+    end
+
+    def content_types_ids_to_mappers
+      @content_types_mappers ||= options.content_types.reduce({}) do |acc, (content_type_id, config)|
+        content_type_mapper  = config.fetch(:mapper)
+        acc[content_type_id] = content_type_mapper
+        acc
+      end
+    end
+
+    def content_types_ids_to_names
+      @content_types_names ||= options.content_types.reduce({}) do |acc, (content_type_id, config)|
+        content_type_name    = config.fetch(:name)
+        acc[content_type_id] = content_type_name
+        acc
+      end
+    end
+
+    private
+    def client
+      @client ||= Contentful::Client.new(
+        access_token:     options.access_token,
+        space:            options.space.fetch(:id),
+        dynamic_entries:  :auto,
+        raise_errors:     true
+      )
+    end
+
+    def options
+      @extension.options
+    end
+  end
+end

data/lib/contentful_middleman/local_data/file.rb

@@ -0,0 +1,29 @@
+module ContentfulMiddleman
+  module LocalData
+    class File
+      class << self
+        def thor=(thor)
+          @thor = thor
+        end
+
+        def thor
+          @thor
+        end
+      end
+
+      def initialize(data, path)
+        @data = data
+        @path = path
+      end
+
+      def write
+        self.class.thor.create_file(local_data_file_path, nil, {}) { @data }
+      end
+
+      def local_data_file_path
+        base_path = LocalData::Store.base_path
+        ::File.join(base_path, @path)
+      end
+    end
+  end
+end

data/lib/contentful_middleman/local_data/store.rb

@@ -0,0 +1,37 @@
+module ContentfulMiddleman
+  module LocalData
+    class Store
+      include ContentfulMiddleman::Tools::Backup::InstanceMethods
+
+      class << self
+        def base_path=(path)
+          @base_path = path
+        end
+
+        def base_path
+          @base_path
+        end
+      end
+
+      def initialize(files, folder)
+        @files  = files
+        @folder = folder
+      end
+
+      def write
+        do_with_backup backup_name, path_to_backup do
+          @files.each(&:write)
+        end
+      end
+
+      private
+      def backup_name
+        "#{@folder}-data-backup"
+      end
+
+      def path_to_backup
+        ::File.join(self.class.base_path, @folder)
+      end
+    end
+  end
+end

data/lib/contentful_middleman/mappers/base.rb

@@ -0,0 +1,39 @@
+module ContentfulMiddleman
+  module Mapper
+    class Base
+      def map(context, entry)
+        map_entry(context, entry)
+      end
+
+      private
+      def map_entry(context, entry)
+        context.id = entry.id
+        entry.fields.each {|k, v| map_field context, k, v}
+      end
+
+      def map_field(context, field_name, field_value)
+        case field_value
+        when Contentful::Asset
+          map_asset(context, field_name, field_value)
+        when Array
+          map_array(context, field_name, field_value)
+        else
+          context.set(field_name, field_value)
+        end
+      end
+
+      def map_asset(context, field_name, field_value)
+        context.nest(field_name) do |nested_context|
+          nested_context.title = field_value.title
+          nested_context.url   = field_value.file.url
+        end
+      end
+
+      def map_array(context, field_name, field_value)
+          context.map(field_name, field_value) do |element, new_context|
+            map_entry(new_context, element)
+          end
+      end
+    end
+  end
+end

data/lib/contentful_middleman/tools/backup.rb

@@ -0,0 +1,87 @@
+require 'fileutils'
+
+module ContentfulMiddleman
+  module Tools
+    class NullBackup
+      def restore; end
+      def destroy; end
+    end
+
+    class Backup
+
+      class << self
+        def basepath
+          ::File.join ENV["MM_ROOT"], ".tmp", "backups"
+        end
+
+        def ensure_backup_path!
+          return if ::File.exists? basepath
+
+          FileUtils.mkdir_p basepath
+        end
+      end
+
+
+      def initialize(name, source)
+        @name   = name
+        @source = source
+
+        self.class.ensure_backup_path!
+
+        FileUtils.mkdir(path)
+        FileUtils.mv(source, path)
+      end
+
+
+      def restore
+        FileUtils.rm_rf(@source)
+        FileUtils.mv(path, @source)
+      end
+
+      def destroy
+        FileUtils.rm_rf(path)
+      end
+
+      private
+      def path
+        ::File.join self.class.basepath, name_and_date
+      end
+
+      def all_files_in_path(path)
+        Dir.glob(::File.join(path, "*"))
+      end
+
+      def name_and_date
+        @name_and_date ||= "#{@name}-#{Time.now.strftime("%Y%m%d%H%M%S")}"
+      end
+
+      module InstanceMethods
+        def do_with_backup(backup_name, path_to_backup)
+          backup        = create_backup backup_name,  path_to_backup
+          remove_backup = false
+
+          begin
+            yield
+            remove_backup = true
+          rescue StandardError => e
+            backup.restore
+            remove_backup = true
+            raise e
+          ensure
+            backup.destroy if remove_backup
+          end
+        end
+
+        private
+        def create_backup(backup_name, path_to_backup)
+          if ::File.exist? path_to_backup
+            Backup.new(backup_name, path_to_backup)
+          else
+            NullBackup.new
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/contentful_middleman/version.rb

@@ -1,3 +1,3 @@
 module ContentfulMiddleman
-   VERSION = "0.0.4"
+  VERSION = "1.0.0"
 end

data/lib/contentful_middleman/version_hash.rb

@@ -0,0 +1,29 @@
+module ContentfulMiddleman
+  class VersionHash
+    class << self
+      def source_root=(source_root)
+        @source_root = source_root
+      end
+
+      def read_for_space(space_name)
+        hashfilename_for_space = hashfilename(space_name)
+        ::File.read(hashfilename_for_space) if File.exist? hashfilename_for_space
+      end
+
+      def write_for_space_with_entries(space_name, entries)
+        sorted_entries           = entries.sort {|a, b| a.id <=> b.id}
+        ids_and_revisions_string = sorted_entries.map {|e| "#{e.id}#{e.revision}"}.join
+        entries_hash             = Digest::SHA1.hexdigest( ids_and_revisions_string )
+
+        File.open(hashfilename(space_name), 'w') { |file| file.write(entries_hash) }
+
+        entries_hash
+      end
+
+      private
+        def hashfilename(space_name)
+          ::File.join(@source_root, ".#{space_name}-space-hash")
+        end
+    end
+  end
+end

data/spec/contentful_middleman_spec.rb

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
 
 describe 'ContentfulMiddleman' do
-  it "should be pending" do
-    pending
-  end
+  it "should be pending"
 end

metadata

@@ -1,67 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: contentful_middleman
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Sascha Konietzke
+- Farruco Sanjurjoj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2015-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: middleman-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
 - !ruby/object:Gem::Dependency
   name: contentful
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rubygems-tasks
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
 description: Load blog posts and other managed content into Middleman
 email:
 - sascha@contentful.com
+- madtrick@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
-- .yardopts
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -71,10 +73,18 @@ files:
 - TODO
 - contentful_middleman.gemspec
 - lib/contentful_middleman.rb
-- lib/contentful_middleman/commands/article.tt
-- lib/contentful_middleman/commands/sync_blog.rb
+- lib/contentful_middleman/commands/contentful.rb
+- lib/contentful_middleman/commands/context.rb
 - lib/contentful_middleman/core.rb
+- lib/contentful_middleman/helpers.rb
+- lib/contentful_middleman/import_task.rb
+- lib/contentful_middleman/instance.rb
+- lib/contentful_middleman/local_data/file.rb
+- lib/contentful_middleman/local_data/store.rb
+- lib/contentful_middleman/mappers/base.rb
+- lib/contentful_middleman/tools/backup.rb
 - lib/contentful_middleman/version.rb
+- lib/contentful_middleman/version_hash.rb
 - lib/middleman_extension.rb
 - spec/contentful_middleman_spec.rb
 - spec/spec_helper.rb
@@ -88,17 +98,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Include mangablable content from the Contentful CMS and API into your Middleman

data/lib/contentful_middleman/commands/article.tt

@@ -1,9 +0,0 @@
----
-# Warning: This file is auto-generated from the Contentful CMS. Local changes will overriden on next sync.
-
-title: <%= @title %>
-date: <%= @date.strftime('%F %R %Z') %>
-tags: <%= @tags.join(', ') %>
----
-
-<%= @body %>

data/lib/contentful_middleman/commands/sync_blog.rb

@@ -1,88 +0,0 @@
-require 'middleman-core/cli'
-require 'date'
-require 'middleman-blog/uri_templates'
-
-module Middleman
-  module Cli
-    # This class provides an "contentful" command for the middleman CLI.
-    class SyncBlog < Thor
-      include Thor::Actions
-      include ::Middleman::Blog::UriTemplates
-
-      check_unknown_options!
-
-      namespace :contentful
-
-      def self.source_root
-        ENV['MM_ROOT']
-      end
-
-      # Tell Thor to exit with a nonzero exit code on failure
-      def self.exit_on_failure?
-        true
-      end
-
-      desc "contentful", "Synchronize Contentful blog posts"
-      method_option "lang",
-        aliases: "-l",
-        desc: "The language to create the post with (defaults to I18n.default_locale if avaliable)"
-      method_option "blog",
-        aliases: "-b",
-        desc: "The name of the blog to create the post inside (for multi-blog apps, defaults to the only blog in single-blog apps)"
-      def contentful
-        contentful_middleman = shared_instance.contentful_middleman
-        client = shared_instance.contentful_middleman_client
-        contentful_middleman_options = contentful_middleman.options
-        blog_post_mappings = contentful_middleman.blog_post_mappings
-
-        if shared_instance.respond_to? :blog
-          shared_instance.logger.info "  Contentful Sync: Start..."
-
-          client.entries(contentful_middleman_options.blog_posts_query).each do |entry|
-            slug  = value_from_object(entry, blog_post_mappings[:slug])
-            title = value_from_object(entry, blog_post_mappings[:title])
-            date  = value_from_object(entry, blog_post_mappings[:date]).strftime("%Y-%m-%d")
-            tags  = value_from_object(entry, blog_post_mappings[:tags]) || []
-            body  = value_from_object(entry, blog_post_mappings[:body])
-
-            @title = title
-            @slug  = slug || safe_parameterize(title)
-            @date  = date ? Time.zone.parse(date) : Time.zone.now
-            @tags  = tags
-            @lang  = options[:lang] || ( I18n.default_locale if defined? I18n )
-            @body  = body
-
-            blog_inst = shared_instance.blog(options[:blog])
-
-            path_template = blog_inst.source_template
-            params = date_to_params(@date).merge(lang: @lang.to_s, title: @slug)
-            article_path = apply_uri_template path_template, params
-
-            template contentful_middleman.options.new_article_template, File.join(shared_instance.source_dir, article_path + blog_inst.options.default_extension)
-          end
-
-          shared_instance.logger.info " Contentful Sync: Done!"
-        else
-          raise Thor::Error.new "You need to activate the blog extension in config.rb before you can create an article"
-        end
-      end
-
-      private
-        def shared_instance
-          @shared_instance ||= ::Middleman::Application.server.inst
-        end
-
-        def value_from_object(object, mapping)
-          if ( mapping.is_a?(Symbol) || mapping.is_a?(String) ) && object.respond_to?(mapping)
-            object.send(mapping)
-          elsif mapping.is_a?(Proc)
-            object.instance_exec(object, &mapping)
-          else
-            shared_instance.logger.warn "Warning - Unknown mapping (#{mapping}) for object (#{object.class}) with ID (#{object.id})"
-            nil
-          end
-        end
-    end
-
-  end
-end