alba 1.5.0 → 2.0.0

data/lib/alba/default_inflector.rb

@@ -1,36 +1,25 @@
+begin
+  require 'active_support/inflector'
+  require 'active_support/core_ext/module/delegation'
+rescue LoadError
+  raise ::Alba::Error, 'To use default inflector, please install `ActiveSupport` gem.'
+end
+
 module Alba
-  # This module represents the inflector, which is used by default
+  # This module has two purposes.
+  # One is that we require `active_support/inflector` in this module so that we don't do that all over the place.
+  # Another is that `ActiveSupport::Inflector` doesn't have `camelize_lower` method that we want it to have, so this module works as an adapter.
   module DefaultInflector
-    begin
-      require 'active_support/inflector'
-    rescue LoadError
-      raise ::Alba::Error, 'To use transform_keys, please install `ActiveSupport` gem.'
-    end
-
-    module_function
-
-    # Camelizes a key
-    #
-    # @param key [String] key to be camelized
-    # @return [String] camelized key
-    def camelize(key)
-      ActiveSupport::Inflector.camelize(key)
+    class << self
+      delegate :camelize, :dasherize, :underscore, :classify, :demodulize, :pluralize, to: ActiveSupport::Inflector
     end
 
     # Camelizes a key, 1st letter lowercase
     #
     # @param key [String] key to be camelized
     # @return [String] camelized key
-    def camelize_lower(key)
+    def self.camelize_lower(key)
       ActiveSupport::Inflector.camelize(key, false)
     end
-
-    # Dasherizes a key
-    #
-    # @param key [String] key to be dasherized
-    # @return [String] dasherized key
-    def dasherize(key)
-      ActiveSupport::Inflector.dasherize(key)
-    end
   end
 end

data/lib/alba/errors.rb

@@ -0,0 +1,10 @@
+module Alba
+  # Base class for Errors
+  class Error < StandardError; end
+
+  # Error class for backend which is not supported
+  class UnsupportedBackend < Error; end
+
+  # Error class for type which is not supported
+  class UnsupportedType < Error; end
+end

data/lib/alba/layout.rb

@@ -0,0 +1,67 @@
+require 'erb'
+require 'forwardable'
+
+module Alba
+  # Layout serialization
+  class Layout
+    extend Forwardable
+
+    def_delegators :@resource, :object, :params, :serializable_hash, :to_h
+
+    # @params file [String] name of the layout file
+    # @params inline [Proc] a proc returning JSON string or a Hash representing JSON
+    def initialize(file:, inline:)
+      if file
+        raise ArgumentError, 'File layout must be a String representing filename' unless file.is_a?(String)
+
+        @body = file
+      elsif inline
+        raise ArgumentError, 'Inline layout must be a Proc returning a Hash or a String' unless inline.is_a?(Proc)
+
+        @body = inline
+      else
+        raise ArgumentError, 'Layout must be either String or Proc'
+      end
+    end
+
+    # Serialize within layout
+    #
+    # @param resource [Alba::Resource] the original resource calling this layout
+    # @param serialized_json [String] JSON string for embedding
+    # @param binding [Binding] context for serialization
+    def serialize(resource:, serialized_json:, binding:)
+      @resource = resource
+      @serialized_json = serialized_json
+
+      if @body.is_a?(String)
+        serialize_within_string_layout(binding)
+      else
+        serialize_within_inline_layout
+      end
+    end
+
+    private
+
+    attr_reader :serialized_json
+
+    def serialize_within_string_layout(bnd)
+      ERB.new(File.read(@body)).result(bnd)
+    end
+
+    def serialize_within_inline_layout
+      inline = instance_eval(&@body)
+      case inline
+      when Hash then encode(inline)
+      when String then inline
+      else
+        raise Alba::Error, 'Inline layout must be a Proc returning a Hash or a String'
+      end
+    end
+
+    # This methods exists here instead of delegation because
+    # `Alba::Resource#encode` is private and it prints warning if we use `def_delegators`
+    def encode(hash)
+      @resource.instance_eval { encode(hash) }
+    end
+  end
+end

data/lib/alba/nested_attribute.rb

@@ -0,0 +1,18 @@
+module Alba
+  # Representing nested attribute
+  class NestedAttribute
+    # @param key_transformation [Symbol] determines how to transform keys
+    # @param block [Proc] class body
+    def initialize(key_transformation: :none, &block)
+      @key_transformation = key_transformation
+      @block = block
+    end
+
+    # @return [Hash]
+    def value(object)
+      resource_class = Alba.resource_class(&@block)
+      resource_class.transform_keys(@key_transformation)
+      resource_class.new(object).serializable_hash
+    end
+  end
+end