extended_her 0.5

data/lib/her/model/introspection.rb

@@ -0,0 +1,57 @@
+module Her
+  module Model
+    module Introspection
+      extend ActiveSupport::Concern
+      # Inspect an element, returns it for introspection.
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #   end
+      #
+      #   @user = User.find(1)
+      #   p @user # => #<User(/users/1) id=1 name="Tobias Fünke">
+      def inspect
+        "#<#{self.class} #{@data.keys.map { |k| "#{k}: #{attribute_for_inspect(send(k))}" }.join(", ")}>"
+      end
+
+      private
+      # @private
+      def attribute_for_inspect(value)
+        if value.is_a?(String) && value.length > 50
+          "#{value[0..50]}...".inspect
+        elsif value.is_a?(Date) || value.is_a?(Time)
+          %("#{value}")
+        else
+          value.inspect
+        end
+      end
+
+      module ClassMethods
+        # Finds a class at the same level as this one or at the global level.
+        # @private
+        def nearby_class(name)
+          sibling_class(name) || name.constantize rescue nil
+        end
+
+        protected
+        # Looks for a class at the same level as this one with the given name.
+        # @private
+        def sibling_class(name)
+          if mod = self.containing_module
+            @sibling_class ||= {}
+            @sibling_class[mod] ||= {}
+            @sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
+          end
+        end
+
+        # If available, returns the containing Module for this class.
+        # @private
+        def containing_module
+          return unless self.name =~ /::/
+          self.name.split("::")[0..-2].join("::").constantize
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm.rb

@@ -0,0 +1,191 @@
+module Her
+  module Model
+    # This module adds ORM-like capabilities to the model
+    module ORM
+      extend ActiveSupport::Concern
+      include CreateMethods
+      include DestroyMethods
+      include FindMethods
+      include SaveMethods
+      include UpdateMethods
+      include RelationMapper
+      include ErrorMethods
+      include ComparisonMethods
+      include PersistanceMethods
+      include SerializationMethods
+      include FieldsDefinition
+
+      attr_accessor :data, :metadata, :errors
+      alias :attributes :data
+      alias :attributes= :data=
+
+      # Initialize a new object with data received from an HTTP request
+      def initialize(params={})
+        fields = self.class.instance_variable_defined?(:@fields) ? self.class.instance_variable_get(:@fields) : []
+        @data = Hash[fields.map{ |field| [field, nil] }]
+        @metadata = params.delete(:_metadata) || {}
+        @errors = params.delete(:_errors) || {}
+
+        # Use setter methods first, then translate attributes of relationships
+        # into relationship instances, then merge the parsed_data into @data.
+        unset_data = Her::Model::ORM.use_setter_methods(self, params)
+        parsed_data = self.class.parse_relationships(unset_data)
+        @data.update(convert_types(parsed_data))
+      end
+
+      def convert_types(parsed_data)
+        parsed_data.each do |key, value|
+          "2013-01-26T09:29:39.358Z"
+          if value.is_a?(String)
+            m = value.match(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z/)
+            next if m.nil?
+            if m[1].nil?
+              parsed_data[key] = Time.strptime(value, '%Y-%m-%dT%H:%M:%S%Z')
+            else
+              parsed_data[key] = Time.strptime(value, '%Y-%m-%dT%H:%M:%S.%L%Z')
+            end
+          end
+        end
+      end
+
+      # Initialize a collection of resources
+      # @private
+      def self.initialize_collection(klass, parsed_data={})
+        collection_data = parsed_data[:data].map do |item_data|
+          resource = klass.new(klass.parse(item_data))
+          klass.wrap_in_hooks(resource, :find)
+          resource
+        end
+
+        collection_class = Her::Collection
+        if parsed_data[:metadata].is_a?(Hash) && parsed_data[:metadata].has_key?(:current_page)
+          collection_class = Her::PaginatedCollection
+        end
+        collection_class.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
+      end
+
+      # Handles missing methods by routing them through @data
+      # @private
+      def method_missing(method, *args, &blk)
+        if method.to_s.end_with?('=')
+          @data[method.to_s.chomp('=').to_sym] = args.first
+        elsif method.to_s.end_with?('?')
+          @data.include?(method.to_s.chomp('?').to_sym)
+        elsif @data.include?(method)
+          @data[method]
+        else
+          super
+        end
+      end
+
+      # Handles returning true for the cases handled by method_missing
+      def respond_to?(method, include_private = false)
+        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @data.include?(method) || super
+      end
+
+      # Assign new data to an instance
+      def assign_data(new_data)
+        new_data = Her::Model::ORM.use_setter_methods(self, new_data)
+        @data.update new_data
+      end
+      alias :assign_attributes :assign_data
+
+      # Handles returning true for the accessible attributes
+      def has_data?(attribute_name)
+        @data.include?(attribute_name)
+      end
+
+      # Handles returning attribute value from data
+      def get_data(attribute_name)
+        @data[attribute_name]
+      end
+
+      # Override the method to prevent from returning the object ID (in ruby-1.8.7)
+      # @private
+      def id
+        @data[:id] || super
+      end
+
+      # Use setter methods of model for each key / value pair in params
+      # Return key / value pairs for which no setter method was defined on the model
+      # @private
+      def self.use_setter_methods(model, params)
+        setter_method_names = model.class.setter_method_names
+        params.inject({}) do |memo, (key, value)|
+          setter_method = key.to_s + '='
+          if setter_method_names.include?(setter_method)
+            model.send(setter_method, value)
+          else
+            if key.is_a?(String)
+              key = key.to_sym
+            end
+            memo[key] = value
+          end
+          memo
+        end
+      end
+
+      module ClassMethods
+        # Initialize a collection of resources with raw data from an HTTP request
+        #
+        # @param [Array] parsed_data
+        def new_collection(parsed_data)
+          Her::Model::ORM.initialize_collection(self, parsed_data)
+        end
+
+        # Parse data before assigning it to a resource
+        #
+        # @param [Hash] data
+        def parse(data)
+          if parse_root_in_json
+            parse_root_in_json == true ? data[root_element.to_sym] : data[parse_root_in_json]
+          else
+            data
+          end
+        end
+
+        # Save an existing resource and return it
+        #
+        # @example
+        #   @user = User.save_existing(1, { fullname: "Tobias Fünke" })
+        #   # Called via PUT "/users/1"
+        def save_existing(id, params)
+          resource = new(params.merge(id: id))
+          resource.save
+          resource
+        end
+
+        # Destroy an existing resource
+        #
+        # @example
+        #   User.destroy_existing(1)
+        #   # Called via DELETE "/users/1"
+        def destroy_existing(id, params={})
+          request(params.merge(_method: :delete, _path: build_request_path(params.merge(id: id)))) do |parsed_data|
+            new(parse(parsed_data[:data]))
+          end
+        end
+
+        # @private
+        def setter_method_names
+          @setter_method_names ||= instance_methods.inject(Set.new) do |memo, method_name|
+            memo << method_name.to_s if method_name.to_s.end_with?('=')
+            memo
+          end
+        end
+
+        # Return or change the value of `include_root_in_json`
+        def include_root_in_json(value=nil)
+          return @include_root_in_json if value.nil?
+          @include_root_in_json = value
+        end
+
+        # Return or change the value of `parse_root_in`
+        def parse_root_in_json(value=nil)
+          return @parse_root_in_json if value.nil?
+          @parse_root_in_json = value
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/comparison_methods.rb

@@ -0,0 +1,20 @@
+module Her
+  module Model
+    module ORM
+      module ComparisonMethods
+        extend ActiveSupport::Concern
+
+        # Return `true` if the other object is also a Her::Model and has matching data
+        def ==(other)
+          other.is_a?(Her::Model) && @data == other.data
+        end
+
+        # Delegate to the == method
+        def eql?(other)
+          self == other
+        end
+      end
+    end
+  end
+end
+

data/lib/her/model/orm/create_methods.rb

@@ -0,0 +1,29 @@
+module Her
+  module Model
+    module ORM
+      module CreateMethods
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Create a resource and return it
+          #
+          # @example
+          #   @user = User.create({ fullname: "Tobias Fünke" })
+          #   # Called via POST "/users/1"
+          def create(params = {})
+            resource = new(params)
+            resource.save
+            resource
+          end
+
+          def create!(params = {})
+            resource = create(params)
+            raise RecordInvalid.new(resource.errors) unless resource.errors.empty?
+
+            resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/destroy_methods.rb

@@ -0,0 +1,53 @@
+module Her
+  module Model
+    module ORM
+      module DestroyMethods
+        extend ActiveSupport::Concern
+
+        # Destroy a resource
+        #
+        # @example
+        #   @user = User.find(1)
+        #   @user.destroy
+        #   # Called via DELETE "/users/1"
+        def destroy
+          resource = self
+          self.class.wrap_in_hooks(resource, :destroy) do |resource, klass|
+            klass.request(_method: :delete, _path: request_path) do |parsed_data|
+              self.data = self.class.parse(parsed_data[:data])
+              self.metadata = parsed_data[:metadata]
+              self.errors = parsed_data[:errors]
+            end
+          end
+          self
+        end
+
+        def delete
+          resource = self
+          self.class.wrap_in_hooks(resource, :destroy) do |resource, klass|
+            klass.request({_method: :delete, _path: build_request_path(params.merge(soft: true))}) do |parsed_data|
+              self.data = self.class.parse(parsed_data[:data])
+              self.metadata = parsed_data[:metadata]
+              self.errors = parsed_data[:errors]
+            end
+          end
+          self
+        end
+
+        module ClassMethods
+          def destroy(ids)
+            is_array = ids.is_a?(Array)
+            ids = Array(ids)
+            collection = ids.map{ |id| new(id: id).destroy }
+            collection = collection.first unless is_array
+            collection
+          end
+
+          def delete(ids)
+            Array(ids).map{ |id| new(id: id).delete }.count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/error_methods.rb

@@ -0,0 +1,19 @@
+module Her
+  module Model
+    module ORM
+      module ErrorMethods
+        extend ActiveSupport::Concern
+
+        # Return `true` if a resource does not contain errors
+        def valid?
+          errors.empty?
+        end
+
+        # Return `true` if a resource contains errors
+        def invalid?
+          errors.any?
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/fields_definition.rb

@@ -0,0 +1,15 @@
+module Her
+  module Model
+    module ORM
+      module FieldsDefinition
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def fields(*fields)
+            self.instance_variable_set(:@fields, fields)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/find_methods.rb

@@ -0,0 +1,46 @@
+module Her
+  module Model
+    module ORM
+      module FindMethods
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          # Fetch specific resource(s) by their ID
+          #
+          # @example
+          #   @user = User.find(1)
+          #   # Fetched via GET "/users/1"
+          #
+          # @example
+          #   @users = User.find([1, 2])
+          #   # Fetched via GET "/users/1" and GET "/users/2"
+          def find(*ids)
+            params = ids.last.is_a?(Hash) ? ids.pop : {}
+            prepared_ids = ids.flatten.compact.uniq
+            results = prepared_ids.map do |id|
+              resource = nil
+              request(params.merge(_method: :get, _path: build_request_path(params.merge(id: id)))) do |parsed_data|
+                resource = new(parse(parsed_data[:data]).merge _metadata: parsed_data[:data], _errors: parsed_data[:errors])
+                wrap_in_hooks(resource, :find)
+              end
+              resource
+            end
+            if ids.length > 1 || ids.first.kind_of?(Array)
+              raise RecordNotFound.one(self.class, ids) if results.nil?
+              results
+            else
+              raise RecordNotFound.some(self.class, ids, results.length, prepared_ids.length) if results.length != prepared_ids.length
+              results.first
+            end
+          end
+
+          def find_by_id(id)
+            find(id)
+          rescue RecordNotFound
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/model/orm/persistance_methods.rb

@@ -0,0 +1,22 @@
+module Her
+  module Model
+    module ORM
+      module PersistanceMethods
+        extend ActiveSupport::Concern
+
+        def new?
+          !@data.include?(:id)
+        end
+        alias_method :new_record?, :new?
+
+        def persisted?
+          !new_record?
+        end
+
+        def destroyed?
+          @metadata.include?(:destroyed) && @metadata[:destroyed] == true
+        end
+      end
+    end
+  end
+end