typekit-client 0.0.5 → 0.0.6

data/lib/typekit/element.rb

@@ -0,0 +1,27 @@
+require_relative 'element/association'
+require_relative 'element/persistence'
+require_relative 'element/query'
+require_relative 'element/serialization'
+require_relative 'element/base'
+
+module Typekit
+  module Element
+    def self.dictionary
+      @dictionary ||= Hash[
+        ObjectSpace.each_object(Class).select do |klass|
+          klass < Base && klass.name
+        end.map do |klass|
+          [Helper.tokenize(klass), klass]
+        end
+      ]
+    end
+
+    def self.classify(name)
+      dictionary[Helper.tokenize(name)]
+    end
+
+    def self.build(name, *arguments)
+      classify(name).new(*arguments)
+    end
+  end
+end

data/lib/typekit/element/association.rb

@@ -0,0 +1,63 @@
+module Typekit
+  module Element
+    module Association
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def possessions
+          @possessions ||= []
+        end
+
+        def owners
+          @owners ||= []
+        end
+
+        def has_many(name)
+          possessions << name
+
+          define_method(name) do
+            value = attributes[name]
+            return value if value.is_a?(Collection::Base)
+
+            unless value.nil?
+              attributes[name] = Collection.build(name, self, value)
+              return attributes[name]
+            end
+
+            if feature?(:persistence) && new?
+              attributes[name] = Collection.build(name, self, [])
+              return attributes[name]
+            end
+
+            load!
+
+            value = attributes[name]
+            raise Error, 'Cannot load the association' if value.nil?
+
+            attributes[name] = Collection.build(name, self, value)
+          end
+
+          define_method("#{name}=") do |value|
+            if value.is_a?(Collection::Base)
+              attributes[name] = value
+            else
+              attributes[name] = Collection.build(name, self, value)
+            end
+          end
+        end
+
+        def belongs_to(name)
+          owners << name
+
+          define_method(name) do
+            value = attributes[name]
+            return value if value.nil? || value.is_a?(Element::Base)
+            attributes[name] = Element.build(name, self, attributes[name])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/typekit/element/base.rb

@@ -0,0 +1,61 @@
+module Typekit
+  module Element
+    class Base
+      extend Forwardable
+
+      include Client::Proxy
+
+      attr_reader :attributes
+      def_delegators :attributes, :to_hash, :to_h, :to_json
+
+      def initialize(*arguments)
+        @attributes = prepare_attributes(Helper.extract_hash!(arguments))
+        @attributes[:id] = nil unless @attributes.key?(:id)
+        connect(arguments.first)
+      end
+
+      def become(another)
+        raise ArgumentError, 'Invalid class' unless self.class == another.class
+        @attributes = another.attributes
+        true
+      end
+
+      def self.feature?(name)
+        name = Helper.constantize(name)
+        @features ||= {}
+        return @features[name] if @features.key?(name)
+        @features[name] = include?(Element.const_get(name))
+      end
+
+      def feature?(name)
+        self.class.feature?(name)
+      end
+
+      def attribute?(name)
+        attributes.key?(name)
+      end
+
+      def assign_attributes(*arguments)
+        prepare_attributes(*arguments).each do |name, value|
+          attributes[name] = value
+        end
+      end
+
+      private
+
+      def prepare_attributes(attributes)
+        Helper.symbolize_keys(attributes)
+      end
+
+      def method_missing(name, *arguments)
+        if name.to_s =~ /^(?<name>.*)=$/
+          name = Regexp.last_match(:name).to_sym
+          attributes.send(:[]=, name, *arguments)
+        else
+          return super unless attributes.key?(name)
+          attributes[name]
+        end
+      end
+    end
+  end
+end

data/lib/typekit/element/persistence.rb

@@ -0,0 +1,61 @@
+module Typekit
+  module Element
+    module Persistence
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def new?
+        id.to_s.empty?
+      end
+
+      def persistent?
+        !(new? || deleted?)
+      end
+
+      def deleted?
+        !!@deleted
+      end
+
+      def save!
+        if new?
+          element = process(:create, serialize)
+        else
+          element = process(:update, id, serialize)
+        end
+        become(element)
+        true
+      end
+
+      def update!(*arguments)
+        assign_attributes(*arguments)
+        become(process(:update, id, serialize))
+        true
+      end
+
+      def delete!
+        process(:delete, id) if persistent?
+        @deleted = true
+        true
+      end
+
+      [:save, :update, :delete].each do |method|
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{method}(*arguments)
+            #{method}!(*arguments)
+          rescue ServerError
+            false
+          end
+        CODE
+      end
+
+      module ClassMethods
+        def create(*arguments)
+          element = new(*arguments)
+          element.save
+          element
+        end
+      end
+    end
+  end
+end

data/lib/typekit/element/query.rb

@@ -0,0 +1,25 @@
+module Typekit
+  module Element
+    module Query
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def all
+          process(:index)
+        end
+
+        def find!(id)
+          process(:show, id)
+        end
+
+        def find(id)
+          find!(id)
+        rescue ServerError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/typekit/element/serialization.rb

@@ -0,0 +1,17 @@
+module Typekit
+  module Element
+    module Serialization
+      def serialize(options = {})
+        keys = attributes.keys
+        keys = keys & Array(options[:only]) if options.key?(:only)
+        Hash[
+          keys.map do |key|
+            value = attributes[key]
+            value = value.serialize if value.respond_to?(:serialize)
+            [key, value]
+          end
+        ]
+      end
+    end
+  end
+end

data/lib/typekit/error.rb

@@ -0,0 +1,23 @@
+module Typekit
+  class Error < StandardError
+  end
+
+  class ServerError < Error
+    ERRORS = {
+      400 => 'There are errors in the data provided by your application',
+      401 => 'Authentication is needed to access the requested endpoint',
+      403 => 'Your application has been rate limited',
+      404 => 'You are requesting a resource that does not exist',
+      500 => 'The servers of Typekit are unable to process the request',
+      503 => 'The Typekit API is offline for maintenance'
+    }
+    ERRORS.default = 'Unknown server error'
+
+    attr_reader :code
+
+    def initialize(code, message = '')
+      @code = code
+      super(message.empty? ? ERRORS[code] : message)
+    end
+  end
+end

data/lib/typekit/helper.rb

@@ -1,29 +1,78 @@
 module Typekit
   module Helper
-    def self.pluralize(name)
-      case name
+    # Returns the plural form of the given word.
+    #
+    # @param word [String]
+    # @return [String]
+    def self.pluralize(word)
+      case word
       when /^.*s$/
-        name
+        word
       when /^(?<root>.*)y$/
-        "#{ Regexp.last_match(:root) }ies"
+        "#{Regexp.last_match(:root)}ies"
       else
-        "#{ name }s"
+        "#{word}s"
       end
     end
 
-    def self.singularize(name)
-      case name
+    # Returns the singular form of the given word.
+    #
+    # @param word [String]
+    # @return [String]
+    def self.singularize(word)
+      case word
       when /^(?<root>.*)ies$/
-        "#{ Regexp.last_match(:root) }y"
+        "#{Regexp.last_match(:root)}y"
       when /^(?<root>.*)s$/
         Regexp.last_match(:root)
       else
-        name
+        word
       end
     end
 
+    # Constructs a symbol suitable for looking up modules among the constants
+    # defined in a module.
+    #
+    # @param object [String, Symbol]
+    # @return [Symbol]
+    def self.constantize(object)
+      object.to_s.sub(/^.*::/, '').capitalize.to_sym
+    end
+
+    # Constructs a symbolic representation of the given object.
+    #
+    # @param object
+    # @option options [Boolean] :pluralize (true) indicates if the result
+    #   should be plural
+    def self.tokenize(object, options = {})
+      name = object.to_s.sub(/^.*::/, '').downcase
+      (options.fetch(:pluralize, true) ? pluralize(name) : name).to_sym
+    end
+
+    # Copies the given hash while converting its keys into symbols.
+    #
+    # @param hash [Hash]
+    # @return [Hash]
     def self.symbolize_keys(hash)
-      Hash[hash.map { |k, v| [ k.to_sym, v ] }]
+      Hash[hash.map { |k, v| [k.to_sym, v] }]
+    end
+
+    # Removes and returns the last element of the given array if that element
+    # is a hash; otherwise, a new hash is returned.
+    #
+    # @param array [Array]
+    # @return [Hash]
+    def self.extract_hash!(array)
+      array.last.is_a?(Hash) ? array.pop : {}
+    end
+
+    # Removes and returns the last element of the given array if that element
+    # is an array; otherwise, a new array is returned.
+    #
+    # @param array [Array]
+    # @return [Array]
+    def self.extract_array!(array)
+      array.last.is_a?(Array) ? array.pop : {}
     end
   end
 end

data/lib/typekit/record.rb

@@ -1,35 +1,31 @@
-require_relative 'record/base'
-require_relative 'record/family'
-require_relative 'record/variation'
 require_relative 'record/kit'
+require_relative 'record/family'
 require_relative 'record/library'
+require_relative 'record/variation'
 
 module Typekit
   module Record
-    def self.mapping
-      @mapping ||= Hash[
-        ObjectSpace.each_object(Class).select do |klass|
-          klass < Base && klass.name
-        end.map do |klass|
-          [ klass.name.downcase.sub(/^.*::/, '').to_sym, klass ]
-        end
-      ]
-    end
-
-    def self.classify(name)
-      mapping[Helper.singularize(name.to_s).to_sym]
-    end
-
     def self.identify(name)
-      if mapping.include?(name.to_s.to_sym)
-        :record
-      elsif mapping.include?(Helper.singularize(name.to_s).to_sym)
+      if Element.dictionary.key?(Helper.tokenize(name, pluralize: false))
         :collection
+      elsif Element.dictionary.key?(Helper.tokenize(name))
+        :element
       end
     end
 
-    def self.build(name, *arguments)
-      classify(name).new(*arguments)
+    def self.build(name, client)
+      klass = Element.classify(name)
+      Class.new(klass) do
+        extend Client::Proxy
+
+        connect(client, Helper.tokenize(name))
+
+        singleton_class.instance_eval do
+          define_method(:new) do |*arguments|
+            klass.new(client, *arguments)
+          end
+        end
+      end
     end
   end
 end

data/lib/typekit/record/family.rb

@@ -1,8 +1,31 @@
 module Typekit
   module Record
-    class Family < Base
+    class Family < Element::Base
+      include Element::Association
+      include Element::Query
+      include Element::Serialization
+
       has_many :libraries
       has_many :variations
+
+      def complete?
+        attribute?(:libraries) && attribute?(:variations)
+      end
+
+      def load!
+        become(process(:show, id))
+        true
+      end
+
+      def load
+        load!
+      rescue ServerError
+        false
+      end
+
+      def serialize
+        super(only: [:id, :subset, :variations])
+      end
     end
   end
 end