extended_her 0.5

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

@@ -0,0 +1,21 @@
+module Her
+  module Model
+    module ORM
+      module RelationMapper
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          %w[ where group having order limit offset all count first last paginate ].each do |name|
+            define_method(name) do |*args|
+              to_relation.send(name, *args)
+            end
+          end
+
+          def to_relation
+            ::Her::Relation.new(self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Her
+  module Model
+    module ORM
+      module SaveMethods
+        extend ActiveSupport::Concern
+
+        # Save a resource
+        #
+        # @example Save a resource after fetching it
+        #   @user = User.find(1)
+        #   # Fetched via GET "/users/1"
+        #   @user.fullname = "Tobias Fünke"
+        #   @user.save
+        #   # Called via PUT "/users/1"
+        #
+        # @example Save a new resource by creating it
+        #   @user = User.new({ fullname: "Tobias Fünke" })
+        #   @user.save
+        #   # Called via POST "/users"
+        def save
+          create_or_update
+        end
+
+        def save!
+          save
+          raise RecordInvalid.new(self.errors) unless self.errors.empty?
+
+          self
+        end
+
+        def create_or_update
+          params = to_params
+          resource = self
+
+          if @data[:id]
+            hooks = [:update, :save]
+            method = :put
+          else
+            hooks = [:create, :save]
+            method = :post
+          end
+
+          self.class.wrap_in_hooks(resource, *hooks) do |resource, klass|
+            klass.request(params.merge(_method: method, _path: request_path)) do |parsed_data|
+              self.data = self.class.parse(parsed_data[:data]) if parsed_data[:data].any?
+              self.metadata = parsed_data[:metadata]
+              self.errors = parsed_data[:errors]
+
+              return false if self.errors.any?
+            end
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Her
+  module Model
+    module ORM
+      module SerializationMethods
+        extend ActiveSupport::Concern
+
+        # Delegate to @data, allowing models to act correctly in code like:
+        #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
+        def hash
+          @data.hash
+        end
+
+        # Convert into a hash of request parameters
+        #
+        # @example
+        #   @user.to_params
+        #   # => { id: 1, name: 'John Smith' }
+        def to_params
+          if self.class.include_root_in_json
+            { (self.class.include_root_in_json == true ? self.class.root_element : self.class.include_root_in_json) => @data.dup }
+          else
+            @data.dup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Her
+  module Model
+    module ORM
+      module UpdateMethods
+        extend ActiveSupport::Concern
+
+        # Update resource attribute
+        #
+        # @example Update resource attribute
+        #   @user = User.find(1)
+        #   # Fetched via GET "/users/1"
+        #   @user.update_attributes(:fullname, "Tobias Fünke")
+        #   # Called via PUT "/users/1"
+        def update_attribute(attribute, value)
+          send(attribute.to_s + '=', value)
+          save
+        end
+
+        def update_attributes(attributes)
+          self.data.merge!(attributes)
+          save
+        end
+
+        def update_attributes!(attributes)
+          self.data.merge!(attributes)
+          save!
+        end
+      end
+    end
+  end
+end

data/lib/her/model/paths.rb

@@ -0,0 +1,82 @@
+module Her
+  module Model
+    module Paths
+      extend ActiveSupport::Concern
+      # Return a path based on the collection path and a resource data
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #     collection_path "/utilisateurs"
+      #   end
+      #
+      #   User.find(1) # Fetched via GET /utilisateurs/1
+      def request_path
+        self.class.build_request_path(@data.dup)
+      end
+
+      module ClassMethods
+
+        # Defines a custom collection path for the resource
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    collection_path "/users"
+        #  end
+        def collection_path(path=nil)
+          @her_collection_path ||= begin
+            superclass.collection_path.dup if superclass.respond_to?(:collection_path)
+          end
+
+          return @her_collection_path unless path
+          @her_resource_path = "#{path}/:id"
+          @her_collection_path = path
+        end
+
+        # Defines a custom resource path for the resource
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    resource_path "/users/:id"
+        #  end
+        def resource_path(path=nil)
+          @her_resource_path ||= begin
+            superclass.resource_path.dup if superclass.respond_to?(:resource_path)
+          end
+
+          return @her_resource_path unless path
+          @her_resource_path = path
+        end
+
+        # Return a custom path based on the collection path and variable parameters
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     collection_path "/utilisateurs"
+        #   end
+        #
+        #   User.all # Fetched via GET /utilisateurs
+        def build_request_path(path=nil, parameters={})
+          unless path.is_a?(String)
+            parameters = path || {}
+            path = parameters.include?(:id) && !parameters[:id].nil? ? resource_path : collection_path
+          end
+
+          path.gsub(/:([\w_]+)/) do
+            # Look for :key or :_key, otherwise raise an exception
+            parameters.delete($1.to_sym) || parameters.delete("_#{$1}".to_sym) || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path (#{path})."))
+          end
+        end
+
+        # Return or change the value of `root_element`
+        def root_element(value=nil)
+          return @root_element if value.nil?
+          @root_element = value
+        end
+      end
+    end
+  end
+end

data/lib/her/model/relationships.rb

@@ -0,0 +1,191 @@
+module Her
+  module Model
+    # This module adds relationships to models
+    module Relationships
+      extend ActiveSupport::Concern
+
+      # Returns true if the model has a relationship_name relationship, false otherwise.
+      def has_relationship?(relationship_name)
+        relationships = self.class.relationships.values.flatten.map { |r| r[:name] }
+        relationships.include?(relationship_name)
+      end
+
+      # Returns the resource/collection corresponding to the relationship_name relationship.
+      def get_relationship(relationship_name)
+        send(relationship_name) if has_relationship?(relationship_name)
+      end
+
+      module ClassMethods
+        # Return @her_relationships, lazily initialized with copy of the
+        # superclass' her_relationships, or an empty hash.
+        #
+        # @private
+        def relationships
+          @her_relationships ||= begin
+            if superclass.respond_to?(:relationships)
+              superclass.relationships.dup
+            else
+              {}
+            end
+          end
+        end
+
+        # Parse relationships data after initializing a new object
+        #
+        # @private
+        def parse_relationships(data)
+          relationships.each_pair do |type, definitions|
+            definitions.each do |relationship|
+              name = relationship[:name]
+              next unless data[name]
+              klass = self.nearby_class(relationship[:class_name])
+              data[name] = case type
+                when :has_many
+                  Her::Model::ORM.initialize_collection(klass, :data => data[name])
+                when :has_one, :belongs_to
+                  klass.new(klass.parse(data[name]))
+                else
+                  nil
+              end
+            end
+          end
+          data
+        end
+
+        # Define an *has_many* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     has_many :articles
+        #   end
+        #
+        #   class Article
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
+        #   # Fetched via GET "/users/1/articles"
+        def has_many(name, attrs={})
+          attrs = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(attrs)
+          (relationships[:has_many] ||= []) << attrs
+
+          define_method(name) do |*method_attrs|
+            method_attrs = method_attrs[0] || {}
+            klass = self.class.nearby_class(attrs[:class_name])
+            if method_attrs.any?
+              @data[name] = klass.get_collection("#{self.class.build_request_path(method_attrs.merge(:id => id))}#{attrs[:path]}")
+            else
+              @data[name] ||= klass.get_collection("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+            end
+
+            inverse_of = if attrs[:inverse_of]
+                               attrs[:inverse_of]
+                            else
+                             self.class.name.split('::').last.tableize.singularize
+                           end
+            @data[name].each do |entry|
+              entry.send("#{inverse_of}=", self)
+            end
+
+            @data[name]
+          end
+        end
+
+        # Define an *has_one* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     has_one :organization
+        #   end
+        #
+        #   class Organization
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
+        #   # Fetched via GET "/users/1/organization"
+        def has_one(name, attrs={})
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :path => "/#{name}"
+          }.merge(attrs)
+          (relationships[:has_one] ||= []) << attrs
+
+          define_method(name) do |*method_attrs|
+            method_attrs = method_attrs[0] || {}
+            klass = self.class.nearby_class(attrs[:class_name])
+            if method_attrs.any?
+              klass.get_resource("#{self.class.build_request_path(method_attrs.merge(:id => id))}#{attrs[:path]}")
+            else
+              @data[name] ||= klass.get_resource("#{self.class.build_request_path(:id => id)}#{attrs[:path]}")
+            end
+          end
+        end
+
+        # Define a *belongs_to* relationship.
+        #
+        # @param [Symbol] name The name of the model
+        # @param [Hash] attrs Options (currently not used)
+        #
+        # @example
+        #   class User
+        #     include Her::API
+        #     belongs_to :team, :class_name => "Group"
+        #   end
+        #
+        #   class Group
+        #     include Her::API
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.team # => #<Team(teams/2) id=2 name="Developers">
+        #   # Fetched via GET "/teams/2"
+        def belongs_to(name, attrs={})
+          attrs = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :foreign_key => "#{name}_id",
+            :path => "/#{name.to_s.pluralize}/:id"
+          }.merge(attrs)
+          (relationships[:belongs_to] ||= []) << attrs
+
+          define_method(name) do |*method_attrs|
+            method_attrs = method_attrs[0] || {}
+            klass = self.class.nearby_class(attrs[:class_name])
+            if method_attrs.any?
+              klass.get_resource("#{klass.build_request_path(method_attrs.merge(:id => @data[attrs[:foreign_key].to_sym]))}")
+            else
+              @data[name] ||= klass.get_resource("#{klass.build_request_path(:id => @data[attrs[:foreign_key].to_sym])}")
+            end
+          end
+        end
+
+        # @private
+        def relationship_accessor(type, attrs)
+          name = attrs[:name]
+          class_name = attrs[:class_name]
+          define_method(name) do
+            klass = self.class.nearby_class(attrs[:class_name])
+            @data[name] ||= klass.get_resource("#{klass.build_request_path(attrs[:path], :id => @data[attrs[:foreign_key].to_sym])}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/her/paginated_collection.rb

@@ -0,0 +1,20 @@
+module Her
+  class PaginatedCollection < Collection
+    def current_page
+      metadata[:current_page].to_i
+    end
+
+    def per_page
+      metadata[:per_page].to_i
+    end
+
+    def total_entries
+      metadata[:total_entries].to_i
+    end
+
+    def total_pages
+      return 0 if total_entries == 0 || per_page == 0
+      (total_entries.to_f / per_page).ceil
+    end
+  end
+end

data/lib/her/relation.rb

@@ -0,0 +1,94 @@
+module Her
+  class Relation
+    def initialize(model)
+      @model = model
+      @conditions = []
+      @group_conditions = []
+      @having_conditions = []
+      @order_conditions = []
+      @limit_value = nil
+      @offset_value = nil
+      @do_paginate = false
+      @do_count = false
+    end
+
+    def where(*args)
+      args = args.first if args.first.is_a?(Hash)
+      @conditions.push(args)
+      self
+    end
+
+    def group(*args)
+      @group_conditions += args
+      self
+    end
+
+    def having(*args)
+      @having_conditions += args
+      self
+    end
+
+    def order(*args)
+      @order_conditions += args
+      self
+    end
+
+    def limit(value)
+      @limit_value = value
+      self
+    end
+
+    def offset(value)
+      @offset_value = value
+      self
+    end
+
+    def all(params = {})
+      with_response(params) do |data|
+        @model.new_collection(data)
+      end
+    end
+
+    def count
+      @do_count = true
+      with_response do |data|
+        data.first
+      end
+    end
+
+    def first
+      order('id asc').limit(1)
+      all.first if all.respond_to?(:first)
+    end
+
+    def last
+      order('id desc').limit(1)
+      all.first if all.respond_to?(:first)
+    end
+
+    def paginate(page = 1, per_page = 20)
+      page = page.to_i < 1 ? 1 : page.to_i
+      per_page = per_page.to_i < 1 ? 20 : per_page.to_i
+
+      @do_paginate = true
+      offset((page - 1) * per_page).limit(per_page)
+    end
+
+  private
+
+    def with_response(params = {})
+      params[:her_special_where] = MultiJson.dump(@conditions) unless @conditions.empty?
+      params[:her_special_group] = MultiJson.dump(@group_conditions) unless @group_conditions.empty?
+      params[:her_special_having] = MultiJson.dump(@having_conditions) unless @having_conditions.empty?
+      params[:her_special_order] = MultiJson.dump(@order_conditions) unless @order_conditions.empty?
+      params[:her_special_limit] = @limit_value unless @limit_value.nil?
+      params[:her_special_offset] = @offset_value unless @offset_value.nil?
+      params[:her_special_paginate] = 1 if @do_paginate
+      params[:her_special_count] = 1 if @do_count
+
+      @model.request(params.merge(_method: :get, _path: @model.build_request_path(params))) do |parsed_data|
+        yield parsed_data if block_given?
+      end
+    end
+  end
+end