agave-client 0.1.0

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

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

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

@@ -0,0 +1,43 @@
+module Agave
+  module Local
+    module FieldType
+      class Theme
+        attr_reader :primary_color, :dark_color, :light_color, :accent_color
+
+        def self.parse(value, repo)
+          value && new(
+            value[:logo],
+            value[:primary_color],
+            value[:dark_color],
+            value[:light_color],
+            value[:accent_color],
+            repo
+          )
+        end
+
+        def initialize(logo, primary_color, dark_color, light_color, accent_color, repo)
+          @logo = logo
+          @primary_color = primary_color
+          @dark_color = dark_color
+          @light_color = light_color
+          @accent_color = accent_color
+          @repo = repo
+        end
+
+        def logo
+          @logo && File.parse(@logo, @repo)
+        end
+
+        def to_hash(*args)
+          {
+            primary_color: primary_color,
+            dark_color: dark_color,
+            light_color: light_color,
+            accent_color: accent_color,
+            logo: logo && logo.to_hash(*args)
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/hash/compact'
+
+module Agave
+  module Local
+    module FieldType
+      class Video
+        attr_reader :url
+        attr_reader :thumbnail_url
+        attr_reader :title
+        attr_reader :width
+        attr_reader :height
+        attr_reader :provider
+        attr_reader :provider_url
+        attr_reader :provider_uid
+
+        def self.parse(value, _repo)
+          value && new(
+            value[:url],
+            value[:thumbnail_url],
+            value[:title],
+            value[:width],
+            value[:height],
+            value[:provider],
+            value[:provider_url],
+            value[:provider_uid]
+          )
+        end
+
+        def initialize(
+          url,
+          thumbnail_url,
+          title,
+          width,
+          height,
+          provider,
+          provider_url,
+          provider_uid
+        )
+          @url            = url
+          @thumbnail_url  = thumbnail_url
+          @title          = title
+          @width          = width
+          @height         = height
+          @provider       = provider
+          @provider_url   = provider_url
+          @provider_uid   = provider_uid
+        end
+
+        def iframe_embed(width = self.width, height = self.height)
+          # rubocop:disable Metrics/LineLength
+          if provider == 'youtube'
+            %(<iframe width="#{width}" height="#{height}" src="//www.youtube.com/embed/#{provider_uid}?rel=0" frameborder="0" allowfullscreen></iframe>)
+          elsif provider == 'vimeo'
+            %(<iframe src="//player.vimeo.com/video/#{provider_uid}?title=0&amp;byline=0&amp;portrait=0" width="#{width}" height="#{height}" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>)
+          elsif provider == 'facebook'
+           %(<iframe src="//www.facebook.com/plugins/video.php?href=#{url}&width=#{width}&show_text=false&height=#{height}" width="#{width}" height="#{height}" style="border:none;overflow:hidden;width:100%;" scrolling="no" frameborder="0" allowTransparency="true" allow="encrypted-media" allowFullScreen="true"></iframe>)
+          end
+          # rubocop:enable Metrics/LineLength
+        end
+
+        def to_hash(*_args)
+          {
+            url: url,
+            thumbnail_url: thumbnail_url,
+            title: title,
+            width: width,
+            height: height,
+            provider: provider,
+            provider_url: provider_url,
+            provider_uid: provider_uid
+          }
+        end
+      end
+    end
+  end
+end

data/lib/agave/local/item.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'active_support/inflector/transliterate'
+require 'active_support/hash_with_indifferent_access'
+require 'agave/utils/locale_value'
+
+Dir[File.dirname(__FILE__) + '/field_type/*.rb'].each do |file|
+  require file
+end
+
+module Agave
+  module Local
+    class Item
+      extend Forwardable
+
+      attr_reader :entity
+      def_delegators :entity, :id
+
+      def initialize(entity, items_repo)
+        @entity = entity
+        @items_repo = items_repo
+      end
+
+      def ==(other)
+        other.is_a?(Item) && other.id == id
+      end
+
+      def seo_meta_tags
+        Utils::SeoTagsBuilder.new(self, @items_repo.site).meta_tags
+      end
+
+      def singleton?
+        item_type.singleton
+      end
+      alias single_instance? singleton?
+
+      def item_type
+        @item_type ||= entity.item_type
+      end
+
+      def fields
+        @fields ||= item_type.fields.sort_by(&:position)
+      end
+
+      def attributes
+        fields.each_with_object(
+          ActiveSupport::HashWithIndifferentAccess.new
+        ) do |field, acc|
+          acc[field.api_key.to_sym] = send(field.api_key)
+        end
+      end
+
+      def position
+        entity.position
+      end
+
+      def parent
+        @items_repo.find(entity.parent_id) if item_type.tree && entity.parent_id
+      end
+
+      def children
+        @items_repo.children_of(id).sort_by(&:position) if item_type.tree
+      end
+
+      def updated_at
+        Time.parse(entity.updated_at).utc
+      end
+
+      def created_at
+        # @TODO ?
+        # Time.parse(entity.created_at).utc
+      end
+
+      def to_s
+        api_key = item_type.api_key
+        "#<Item id=#{id} item_type=#{api_key} attributes=#{attributes}>"
+      end
+      alias inspect to_s
+
+      def to_hash(max_depth = 3, current_depth = 0)
+        return id if current_depth >= max_depth
+
+        base = {
+          id: id,
+          item_type: item_type.api_key,
+          updated_at: updated_at,
+          created_at: created_at
+        }
+
+        base[:position] = position if item_type.sortable
+
+        if item_type.tree
+          base[:position] = position
+          base[:children] = children.map do |child|
+            child.to_hash(
+              max_depth,
+              current_depth + 1
+            )
+          end
+        end
+
+        fields.each_with_object(base) do |field, result|
+          value = send(field.api_key)
+
+          result[field.api_key.to_sym] =
+            if value.respond_to?(:to_hash)
+              m = value.method(:to_hash)
+              if m.arity == 2
+                value.to_hash(max_depth, current_depth + 1)
+              else
+                value.to_hash
+              end
+            else
+              value
+            end
+        end
+      end
+
+      private
+
+      def read_attribute(method, field)
+        field_type = field.field_type
+        type_klass_name = "::Agave::Local::FieldType::#{field_type.camelize}"
+        type_klass = type_klass_name.safe_constantize
+
+        value = if field.localized
+                  obj = entity.send(method) || {}
+                  Utils::LocaleValue.find(obj)
+                else
+                  entity.send(method)
+                end
+
+        if type_klass
+          type_klass.parse(value, @items_repo)
+        else
+          warning = [
+            "Warning: unrecognized field of type `#{field_type}`",
+            "for item `#{item_type.api_key}` and",
+            "field `#{method}`: returning a simple Hash instead.",
+            'Please upgrade to the latest version of the `agave` gem!'
+          ]
+          puts warning.join(' ')
+
+          value
+        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
+      rescue NoMethodError => e
+        if e.name === method
+          message = []
+          message << "Undefined method `#{method}`"
+          message << "Available fields for a `#{item_type.api_key}` item:"
+          message += fields.map do |f|
+            "* .#{f.api_key}"
+          end
+          raise NoMethodError, message.join("\n")
+        else
+          raise e
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        field = fields.find { |f| f.api_key.to_sym == method }
+        if field
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/agave/local/items_repo.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/string'
+require 'agave/local/item'
+require 'agave/local/site'
+
+module Agave
+  module Local
+    class ItemsRepo
+      attr_reader :entities_repo, :collections_by_type, :item_type_methods
+
+      def initialize(entities_repo)
+        @entities_repo = entities_repo
+        @collections_by_type = {}
+        @items_by_id = {}
+        @items_by_parent_id = {}
+        @item_type_methods = {}
+
+        build_cache!
+      end
+
+      def find(id)
+        @items_by_id[id.to_s]
+      end
+
+      def children_of(id)
+        @items_by_parent_id.fetch(id.to_s, [])
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        if collections_by_type.key?(method)
+          true
+        else
+          super
+        end
+      end
+
+      def site
+        Site.new(
+          entities_repo.find_entities_of_type('site').first,
+          self
+        )
+      end
+
+      def available_locales
+        site.locales.map(&:to_sym)
+      end
+
+      def item_types
+        entities_repo.find_entities_of_type('item_type')
+      end
+
+      def single_instance_item_types
+        item_types.select(&:singleton)
+      end
+
+      def collection_item_types
+        item_types.select do |item_type|
+          !item_type.singleton
+        end
+      end
+
+      def items_of_type(item_type)
+        method = item_type_methods[item_type]
+
+        if item_type.singleton
+          Array(@collections_by_type[method])
+        else
+          @collections_by_type[method]
+        end
+      end
+
+      private
+
+      def build_cache!
+        build_item_type_methods!
+        build_collections_by_type!
+        build_singletons_by_type!
+      end
+
+      def build_item_type_methods!
+        @item_type_methods = {}
+
+        singleton_keys = single_instance_item_types.map(&:api_key)
+        collection_keys = collection_item_types.map(&:api_key)
+                                               .map(&:pluralize)
+
+        clashing_keys = singleton_keys & collection_keys
+
+        item_types.each do |item_type|
+          pluralized_api_key = item_type.api_key.pluralize
+
+          method = if item_type.singleton
+                     item_type.api_key
+                   else
+                     pluralized_api_key
+                   end
+
+          if clashing_keys.include?(pluralized_api_key)
+            suffix = item_type.singleton ? 'instance' : 'collection'
+            method = "#{method}_#{suffix}"
+          end
+
+          @item_type_methods[item_type] = method.to_sym
+        end
+      end
+
+      def build_collections_by_type!
+        item_types.each do |item_type|
+          method = item_type_methods[item_type]
+          @collections_by_type[method] = if item_type.singleton
+                                           nil
+                                         else
+                                           ItemCollection.new
+                                         end
+        end
+
+        item_entities.each do |item_entity|
+          item = Item.new(item_entity, self)
+          method = item_type_methods[item_entity.item_type]
+
+          unless item_entity.item_type.singleton
+            @collections_by_type[method].push item
+          end
+
+          @items_by_id[item.id] = item
+
+          if item_entity.respond_to?(:parent_id) && item_entity.parent_id
+            @items_by_parent_id[item_entity.parent_id] ||= []
+            @items_by_parent_id[item_entity.parent_id] << item
+          end
+        end
+
+        item_types.each do |item_type|
+          method = item_type_methods[item_type]
+          if !item_type.singleton && item_type.sortable
+            @collections_by_type[method].sort_by!(&:position)
+          elsif item_type.ordering_field
+            @collections_by_type[method].sort_by! do |item|
+              item.send(item_type.ordering_field.api_key)
+            end
+            if item_type.ordering_direction == 'desc'
+              @collections_by_type[method].reverse!
+            end
+          end
+        end
+      end
+
+      def build_singletons_by_type!
+        item_types.each do |item_type|
+          method = item_type_methods[item_type]
+          next unless item_type.singleton
+
+          item = if item_type.singleton_item
+                   @items_by_id[item_type.singleton_item.id]
+                 end
+
+          @collections_by_type[method] = item
+        end
+      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
+      rescue NoMethodError
+        message = []
+        message << "Undefined method `#{method}`"
+        message << 'Available AgaveCMS collections/items:'
+        message += collections_by_type.map do |key, _value|
+          "* .#{key}"
+        end
+        raise NoMethodError, message.join("\n")
+      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
+end