agave-client 0.1.0

data/lib/agave/dump/operation/directory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'fileutils'
+
+module Agave
+  module Dump
+    module Operation
+      class Directory
+        attr_reader :context, :path
+
+        def initialize(context, path)
+          @context = context
+          @path = File.join(context.path, path)
+          @operations = []
+        end
+
+        def add(operation)
+          @operations << operation
+        end
+
+        def perform
+          FileUtils.remove_dir(path) if Dir.exist?(path)
+
+          FileUtils.mkdir_p(path)
+
+          operations.each(&:perform)
+        end
+
+        private
+
+        attr_reader :operations
+      end
+    end
+  end
+end

data/lib/agave/dump/operation/root.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Agave
+  module Dump
+    module Operation
+      class Root
+        attr_reader :path
+
+        def initialize(path)
+          @operations = []
+          @path = path
+        end
+
+        def add(operation)
+          @operations << operation
+        end
+
+        def perform
+          operations.each(&:perform)
+        end
+
+        private
+
+        attr_reader :operations
+      end
+    end
+  end
+end

data/lib/agave/dump/runner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'agave/dump/dsl/root'
+require 'agave/dump/operation/root'
+require 'agave/dump/ssg_detector'
+require 'agave/local/loader'
+
+module Agave
+  module Dump
+    class Runner
+      attr_reader :config_path, :client, :destination_path, :preview_mode
+
+      def initialize(config_path, client, preview_mode, destination_path = Dir.pwd)
+        @config_path = config_path
+        @preview_mode = preview_mode
+        @client = client
+        @destination_path = destination_path
+      end
+
+      def run
+        print 'Fetching content from AgaveCMS... '
+
+        loader.load
+
+        I18n.available_locales = loader.items_repo.available_locales
+        I18n.locale = I18n.available_locales.first
+
+        Dsl::Root.new(
+          File.read(config_path),
+          loader.items_repo,
+          operation
+        )
+
+        operation.perform
+
+        puts "\e[32m✓\e[0m Done!"
+      end
+
+      def operation
+        @operation ||= Operation::Root.new(destination_path)
+      end
+
+      def loader
+        @loader ||= Agave::Local::Loader.new(client, preview_mode)
+      end
+    end
+  end
+end

data/lib/agave/dump/ssg_detector.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'toml'
+require 'json'
+require 'yaml'
+
+module Agave
+  module Dump
+    class SsgDetector
+      attr_reader :path
+
+      RUBY = %w(jekyll).freeze
+
+      def initialize(path)
+        @path = path
+      end
+
+      def detect
+        ruby_generator ||
+          'unknown'
+      end
+
+      private
+
+      def ruby_generator
+        gemfile_path = File.join(path, 'Gemfile')
+        return unless File.exist?(gemfile_path)
+
+        gemfile = File.read(gemfile_path)
+
+        RUBY.find do |generator|
+          gemfile =~ /('#{generator}'|"#{generator}")/
+        end
+      end
+    end
+  end
+end

data/lib/agave/json_api_deserializer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module Agave
+  class JsonApiDeserializer
+    def deserialize(data)
+      data = data[:data]
+
+      if data.is_a? Array
+        data.map { |resource| deserialize_resource(resource) }
+      else
+        deserialize_resource(data)
+      end
+    end
+
+    def deserialize_resource(data)
+      result = { id: data[:id] }
+
+      if data[:attributes]
+        result.merge!(data[:attributes])
+      end
+
+      relationships = data.delete(:relationships)
+
+      if relationships
+        relationships.each do |key, handle|
+          handle_data = handle['data']
+          value = if handle_data.is_a? Array
+                    handle_data.map { |ref| ref['id'] }
+                  elsif handle_data.is_a? Hash
+                    handle_data[:id]
+                  end
+          result[key] = value
+        end
+      end
+
+      result.with_indifferent_access
+    end
+  end
+end

data/lib/agave/json_api_serializer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+module Agave
+  class JsonApiSerializer
+    attr_reader :link, :type
+
+    def initialize(type, link)
+      @link = link
+      @type = type
+    end
+
+    def serialize(resource, id = nil)
+      resource = resource.with_indifferent_access
+      data = {}
+
+      data[:id] = id || resource[:id] if id || resource[:id]
+
+      data[:type] = type
+      data[:attributes] = serialized_attributes(resource)
+
+      if relationships.any?
+        data[:relationships] = serialized_relationships(resource)
+      end
+
+      { data: data }
+    end
+
+    def serialized_attributes(resource)
+      result = {}
+
+      attributes(resource).each do |attribute|
+        if resource.key? attribute
+          result[attribute] = resource[attribute]
+        elsif required_attributes.include? attribute
+          throw "Required attribute: #{attribute}"
+        end
+      end
+
+      result
+    end
+
+    def serialized_relationships(resource)
+      result = {}
+
+      relationships.each do |relationship, meta|
+        if resource.key? relationship
+          value = resource[relationship]
+
+          data = if value
+                   if meta[:collection]
+                     value.map do |id|
+                       { type: meta[:type], id: id.to_s }
+                     end
+                   else
+                     { type: meta[:type], id: value.to_s }
+                   end
+                 end
+          result[relationship] = { data: data }
+
+        elsif required_relationships.include?(relationship)
+          throw "Required attribute: #{relationship}"
+        end
+      end
+
+      result
+    end
+
+    def attributes(resource)
+      if type == "item"
+        return resource.keys.map(&:to_sym) - [
+          :item_type,
+          :id,
+          :created_at,
+          :updated_at,
+          :is_valid,
+          :published_version,
+          :current_version
+        ]
+      end
+
+      link_attributes["properties"].keys.map(&:to_sym)
+    end
+
+    def required_attributes
+      if type == "item"
+        return []
+      end
+
+      (link_attributes.required || []).map(&:to_sym)
+    end
+
+    def relationships
+      if type == "item"
+        if link.rel == :create
+          return { item_type: { collection: false, type: 'item_type' } }
+        else
+          {}
+        end
+      end
+
+      if !link_relationships
+        return {}
+      end
+
+      link_relationships.properties.reduce({}) do |acc, (relationship, schema)|
+        is_collection = schema.properties["data"].type.first == 'array'
+
+        definition = if is_collection
+                       schema.properties['data'].items
+                     elsif schema.properties['data'].type.first == 'object'
+                       schema.properties['data']
+                     else
+                       schema.properties['data'].any_of.find do |option|
+                         option.type.first == 'object'
+                       end
+                     end
+
+        type = definition.properties['type']
+                         .pattern.source.gsub(/(^\^|\$$)/, '')
+
+        acc[relationship.to_sym] = {
+          collection: is_collection,
+          type: type,
+        }
+
+        acc
+      end
+    end
+
+    def required_relationships
+      if type == "item"
+        return %i(item_type)
+      end
+
+      (link_relationships.required || []).map(&:to_sym)
+    end
+
+    def link_attributes
+      link.schema.properties["data"].properties["attributes"]
+    end
+
+    def link_relationships
+      link.schema.properties["data"].properties["relationships"]
+    end
+  end
+end

data/lib/agave/local/entities_repo.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'agave/local/json_api_entity'
+
+module Agave
+  module Local
+    class EntitiesRepo
+      attr_reader :entities
+
+      def initialize(*payloads)
+        @entities = {}
+
+        payloads.each do |payload|
+          EntitiesRepo.payload_entities(payload).each do |entity_payload|
+            object = JsonApiEntity.new(entity_payload, self)
+            @entities[object.type] ||= {}
+            @entities[object.type][object.id] = object
+          end
+        end
+      end
+
+      def find_entities_of_type(type)
+        entities.fetch(type, {}).values
+      end
+
+      def find_entity(type, id)
+        entities.fetch(type, {}).fetch(id, nil)
+      end
+
+      def self.payload_entities(payload)
+        acc = []
+
+        if payload[:data]
+          acc = if payload[:data].is_a? Array
+                  acc + payload[:data]
+                else
+                  acc + [payload[:data]]
+                end
+        end
+
+        acc += payload[:included] if payload[:included]
+
+        acc
+      end
+    end
+  end
+end

data/lib/agave/local/field_type/boolean.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Agave
+  module Local
+    module FieldType
+      class Boolean
+        def self.parse(value, _repo)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/agave/local/field_type/color.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+#
+module Agave
+  module Local
+    module FieldType
+      class Color
+        attr_reader :red, :green, :blue, :alpha
+
+        def self.parse(value, _repo)
+          value && new(
+            value[:red],
+            value[:green],
+            value[:blue],
+            value[:alpha]
+          )
+        end
+
+        def initialize(red, green, blue, alpha)
+          @red = red
+          @green = green
+          @blue = blue
+          @alpha = alpha / 255.0
+        end
+
+        def rgb
+          if alpha == 1.0
+            "rgb(#{red}, #{green}, #{blue})"
+          else #
+            "rgba(#{red}, #{green}, #{blue}, #{alpha})"
+          end
+        end
+
+        def hex
+          r = red.to_s(16)
+          g = green.to_s(16)
+          b = blue.to_s(16)
+          a = (alpha * 255).to_i.to_s(16)
+
+          r = "0#{r}" if r.length == 1
+          g = "0#{g}" if g.length == 1
+          b = "0#{b}" if b.length == 1
+          a = "0#{a}" if a.length == 1
+
+          hex = '#' + r + g + b
+
+          hex += a if a != 'ff'
+
+          hex
+        end
+
+        def to_hash(*_args)
+          {
+            red: red,
+            green: green,
+            blue: blue,
+            rgb: rgb,
+            hex: hex
+          }
+        end
+      end
+    end
+  end
+end