contentful 1.2.2 → 2.0.0

data/lib/contentful/dynamic_entry.rb

@@ -1,57 +0,0 @@
-require_relative 'resource'
-require_relative 'resource/fields'
-require_relative 'location'
-
-module Contentful
-  # Wrapper for Entries with Cached Content Types
-  class DynamicEntry < Entry
-    # Coercions from Contentful Types to Ruby native types
-    KNOWN_TYPES = {
-      'String'   => :string,
-      'Text'     => :string,
-      'Symbol'   => :string,
-      'Integer'  => :integer,
-      'Float'    => :float,
-      'Boolean'  => :boolean,
-      'Date'     => :date,
-      'Location' => Location
-    }
-
-    # @private
-    def self.create(content_type)
-      unless content_type.is_a? ContentType
-        content_type = ContentType.new(content_type)
-      end
-
-      fields_coercions = Hash[
-                         content_type.fields.map do |field|
-                           [field.id.to_sym, KNOWN_TYPES[field.type]]
-                         end
-      ]
-
-      Class.new DynamicEntry do
-        content_type.fields.each do |f|
-          define_method Support.snakify(f.id).to_sym do |wanted_locale = nil|
-            fields(wanted_locale)[f.id.to_sym]
-          end
-        end
-
-        define_singleton_method :fields_coercions do
-          fields_coercions
-        end
-
-        define_singleton_method :content_type do
-          content_type
-        end
-
-        define_singleton_method :to_s do
-          "Contentful::DynamicEntry[#{content_type.id}]"
-        end
-
-        define_singleton_method :inspect do
-          "Contentful::DynamicEntry[#{content_type.id}]"
-        end
-      end
-    end
-  end
-end

data/lib/contentful/resource.rb

@@ -1,239 +0,0 @@
-require_relative 'resource/system_properties'
-require 'contentful/constants'
-require 'date'
-
-module Contentful
-  # Include this module to declare a class to be a contentful resource.
-  # This is done by the default in the existing resource classes
-  #
-  # You can define your own classes that behave like contentful resources:
-  # See examples/custom_classes.rb to see how.
-  #
-  # Take a look at examples/resource_mapping.rb on how to register them to be returned
-  # by the client by default
-  #
-  # @see _ examples/custom_classes.rb Custom Class as Resource
-  # @see _ examples/resource_mapping.rb Mapping a Custom Class
-  module Resource
-    # @private
-    # rubocop:disable Style/DoubleNegation
-    COERCIONS = {
-      string:  ->(v) { v.nil? ? nil : v.to_s },
-      integer: ->(v) { v.to_i },
-      float:   ->(v) { v.to_f },
-      boolean: ->(v) { !!v },
-      date:    ->(v) { DateTime.parse(v) }
-    }
-    # rubocop:enable Style/DoubleNegation
-
-    attr_reader :properties, :request, :client, :default_locale, :raw
-
-    # @private
-    def initialize(object = nil,
-                   request = nil,
-                   client = nil,
-                   default_locale = Contentful::Client::DEFAULT_CONFIGURATION[:default_locale])
-      self.class.update_coercions!
-      @default_locale = default_locale
-
-      @properties = {}
-      self.class.property_coercions.keys.each do |property_name|
-        @properties[property_name] = nil
-      end
-
-      @properties = @properties.merge(
-        extract_from_object(object, :property,
-                            self.class.property_coercions.keys)
-      )
-      @request = request
-      @client = client
-      @raw = object
-    end
-
-    # @private
-    def inspect(info = nil)
-      properties_info = properties.empty? ? '' : " @properties=#{properties.inspect}"
-      "#<#{self.class}:#{properties_info}#{info}>"
-    end
-
-    # Returns true for resources that are entries
-    def entry?
-      false
-    end
-
-    # Returns true for resources that behave like an array
-    def array?
-      false
-    end
-
-    # Resources that don't include SystemProperties return nil for #sys
-    def sys
-      nil
-    end
-
-    # Resources that don't include Fields or AssetFields return nil for #fields
-    def fields
-      nil
-    end
-
-    # Issues the request that was made to fetch this response again.
-    # Only works for top-level resources
-    def reload
-      if request
-        request.get
-      else
-        false
-      end
-    end
-
-    # Register the resources properties on class level by using the #property method
-    # @private
-    module ClassMethods
-      # By default, fields come flattened in the current locale. This is different for sync
-      def property_coercions
-        @property_coercions ||= {}
-      end
-
-      # Defines which properties of a resource your class expects
-      # Define them in :camelCase, they will be available as #snake_cased methods
-      #
-      # You can pass in a second "type" argument:
-      # - If it is a class, it will be initialized for the property
-      # - Symbols are looked up in the COERCION constant for a lambda that
-      #   defines a type conversion to apply
-      #
-      # Note: This second argument is not meant for contentful sub-resources,
-      # but for structured objects (like locales in a space)
-      # Sub-resources are handled by the resource builder
-      def property(name, property_class = nil)
-        property_coercions[name.to_sym] = property_class
-        define_method Contentful::Support.snakify(name) do
-          properties[name.to_sym]
-        end
-      end
-
-      # Ensure inherited classes pick up coercions
-      def update_coercions!
-        return if @coercions_updated
-
-        if superclass.respond_to? :property_coercions
-          @property_coercions = superclass.property_coercions.dup.merge(@property_coercions || {})
-        end
-
-        if superclass.respond_to? :sys_coercions
-          @sys_coercions = superclass.sys_coercions.dup.merge(@sys_coercions || {})
-        end
-
-        if superclass.respond_to? :fields_coercions
-          @fields_coercions = superclass.fields_coercions.dup.merge(@fields_coercions || {})
-        end
-
-        @coercions_updated = true
-      end
-    end
-
-    # @private
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    private
-
-    def initialize_fields_for_localized_resource(object)
-      @fields = {}
-
-      object.fetch('fields', {}).each do |field_name, nested_child_object|
-        if Support.localized?(nested_child_object)
-          nested_child_object.each do |object_locale, real_child_object|
-            @fields[object_locale] ||= {}
-            @fields[object_locale].merge! extract_from_object(
-              { field_name => real_child_object }, :fields
-            )
-          end
-        else
-          # if sys.locale property not present (due to select operator) use default_locale
-          @fields[locale || default_locale] ||= {}
-          @fields[locale || default_locale].merge! extract_from_object({ field_name => nested_child_object }, :fields)
-        end
-      end
-    end
-
-    def extract_from_object(object, namespace, keys = nil)
-      if object
-        keys ||= object.keys
-        keys.each.with_object({}) do |name, res|
-          value = object.is_a?(::Array) ? object : object[name.to_s]
-          kind = self.class.public_send(:"#{namespace}_coercions")[name.to_sym]
-          res[name.to_sym] = coerce_value_or_array(value, kind)
-        end
-      else
-        {}
-      end
-    end
-
-    def coerce_value_or_array(value, what = nil)
-      if value.is_a? ::Array
-        value.map { |v| coerce_or_create_class(v, what) }
-      elsif should_coerce_hash?(value)
-        ::Hash[value.map do |k, v|
-          to_coerce = pre_coerce(v)
-          coercion = v.is_a?(Numeric) ? v : coerce_or_create_class(to_coerce, what)
-          [k.to_sym, coercion]
-        end]
-      else
-        coerce_or_create_class(value, what)
-      end
-    end
-
-    def pre_coerce(value)
-      case value
-      when Numeric, true, false, nil
-        value
-      when Hash
-        result = {}
-        value.each_key do |k|
-          result[k.to_sym] = pre_coerce(value[k])
-        end
-        result
-      when ::Array
-        value.map { |e| pre_coerce(e) }
-      else
-        value.to_s
-      end
-    end
-
-    def should_coerce_hash?(value)
-      value.is_a?(::Hash) &&
-        !is_a?(Asset) &&
-        !is_a?(Field) &&
-        !location?(value) &&
-        !link?(value) &&
-        !image?(value)
-    end
-
-    def location?(value)
-      value.key?('lat') || value.key?('lon')
-    end
-
-    def link?(value)
-      value.key?('sys') && value['sys']['type'] == 'Link'
-    end
-
-    def image?(value)
-      value.key?('image')
-    end
-
-    def coerce_or_create_class(value, what)
-      case what
-      when Symbol
-        COERCIONS[what] ? COERCIONS[what][value] : value
-      when Proc
-        what[value]
-      when Class
-        what.new(value, client) if value
-      else
-        value
-      end
-    end
-  end
-end

data/lib/contentful/resource/array_like.rb

@@ -1,39 +0,0 @@
-module Contentful
-  module Resource
-    # Useful methods for array-like resources that can be included if an
-    # :items property exists
-    module ArrayLike
-      include Enumerable
-
-      # Returns true for array-like resources
-      #
-      # @return [true]
-      def array?
-        true
-      end
-
-      # Delegates to items#each
-      #
-      # @yield [Contentful::Entry, Contentful::Asset]
-      def each_item(&block)
-        items.each(&block)
-      end
-      alias each each_item
-
-      # Delegates to items#empty?
-      #
-      # @return [Boolean]
-      def empty?
-        items.empty?
-      end
-
-      # Delegetes to items#size
-      #
-      # @return [Number]
-      def size
-        items.size
-      end
-      alias length size
-    end
-  end
-end

data/lib/contentful/resource/asset_fields.rb

@@ -1,58 +0,0 @@
-require_relative '../file'
-
-module Contentful
-  module Resource
-    # Special fields for Asset. Don't include together wit Contentful::Resource::Fields
-    #
-    # It depends on system properties being available
-    module AssetFields
-      # Special field coercions for Asset.
-      FIELDS_COERCIONS = {
-        title: :string,
-        description: :string,
-        file: File
-      }
-
-      # Returns all fields of the asset
-      #
-      # @return [Hash] localized fields
-      def fields(wanted_locale = default_locale)
-        @fields[locale || wanted_locale] || {}
-      end
-
-      # @private
-      def initialize(object, *)
-        super
-
-        initialize_fields_for_localized_resource(object)
-      end
-
-      # @private
-      def inspect(info = nil)
-        if fields.empty?
-          super(info)
-        else
-          super("#{info} @fields=#{fields.inspect}")
-        end
-      end
-
-      # @private
-      module ClassMethods
-        def fields_coercions
-          FIELDS_COERCIONS
-        end
-      end
-
-      # @private
-      def self.included(base)
-        base.extend(ClassMethods)
-
-        base.fields_coercions.keys.each do |name|
-          base.send :define_method, Contentful::Support.snakify(name) do
-            fields[name.to_sym]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/contentful/resource/custom_resource.rb

@@ -1,29 +0,0 @@
-module Contentful
-  module Resource
-    # Module for simplifying Custom Resource Creation
-    # Allows auto-mapping of fields to properties and properties to fields
-    module CustomResource
-      # @private
-      def initialize(*)
-        super
-
-        update_mappings!
-      end
-
-      # @private
-      def update_mappings!
-        properties.keys.each do |name|
-          define_singleton_method Contentful::Support.snakify(name).to_sym do |wanted_locale = default_locale|
-            properties[name] ||= fields(wanted_locale)[name]
-          end
-        end
-      end
-
-      # @private
-      def marshal_load(raw_object)
-        super raw_object
-        update_mappings!
-      end
-    end
-  end
-end

data/lib/contentful/resource/fields.rb

@@ -1,73 +0,0 @@
-require 'contentful/constants'
-
-module Contentful
-  module Resource
-    # Include this module into your Resource class to enable it
-    # to deal with entry fields (but not asset fields)
-    #
-    # It depends on system properties being available
-    module Fields
-      # Returns all fields of the asset
-      #
-      # @return [Hash] fields for Resource on selected locale
-      def fields(wanted_locale = nil)
-        wanted_locale = (locale || default_locale) if wanted_locale.nil?
-        @fields[wanted_locale.to_s] || {}
-      end
-
-      # Returns all fields of the asset with locales nested by field
-      #
-      # @return [Hash] fields for Resource grouped by field name
-      def fields_with_locales
-        remapped_fields = {}
-        locales.each do |locale|
-          fields(locale).each do |name, value|
-            remapped_fields[name] ||= {}
-            remapped_fields[name][locale.to_sym] = value
-          end
-        end
-
-        remapped_fields
-      end
-
-      # @private
-      module ClassMethods
-        # No coercions, since no content type available
-        def fields_coercions
-          {}
-        end
-      end
-
-      # @private
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      # @private
-      def initialize(object = nil, *)
-        super
-        extract_fields_from_object! object if object
-      end
-
-      # @private
-      def inspect(info = nil)
-        if fields.empty?
-          super(info)
-        else
-          super("#{info} @fields=#{fields.inspect}")
-        end
-      end
-
-      # Provides a list of the available locales for a Resource
-      def locales
-        @fields.keys
-      end
-
-      private
-
-      def extract_fields_from_object!(object)
-        initialize_fields_for_localized_resource(object)
-      end
-    end
-  end
-end