gecko-ruby 0.0.4

data/lib/gecko/helpers/association_helper.rb

@@ -0,0 +1,69 @@
+module Gecko
+  module Helpers
+    # Helper for has_many/belongs_to relationships
+    module AssociationHelper
+      # Set up a belongs_to relationship between two classes based on a
+      # JSON key of {class_name}_id.
+      #
+      # @example
+      #   class Gecko::Record::Variant
+      #     belongs_to :product
+      #   end
+      #
+      # @param [Symbol] model_name
+      # @param [#to_hash] options options for setting up the relationship
+      # @option options [String] :class_name Override the default class name
+      # @option options [String] :readonly (false) Whether to serialize
+      #   this attribute
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def belongs_to(model_name, options={})
+        class_name  = options[:class_name] || model_name.to_s.classify
+        foreign_key = model_name.to_s.foreign_key.to_sym
+
+        define_method model_name do
+          if (id = attributes[foreign_key])
+            @client.adapter_for(class_name).find(id)
+          end
+        end
+        attribute foreign_key, Integer, readonly: options[:readonly]
+      end
+
+      # Set up a has_many relationship between two classes based on a
+      # JSON key of {class_name}_ids.
+      #
+      # @example
+      #   class Gecko::Record::Product
+      #     has_many :variants
+      #   end
+      #
+      # @param [Symbol] model_name
+      # @param [#to_hash] options options for setting up the relationship
+      # @option options [String] :class_name Override the default class name
+      # @option options [String] :readonly (true) Whether to serialize this
+      #   attribute
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def has_many(association_name, options={})
+        model_name = association_name.to_s.singularize
+        class_name = options[:class_name] || model_name.classify
+        foreign_key = model_name.foreign_key.pluralize.to_sym
+        readonly    = options.key?(:readonly) ? options[:readonly] : true
+
+        define_method association_name do
+          ids = self.attributes[foreign_key]
+          if ids.any?
+            @client.adapter_for(class_name).find_many(ids)
+          else
+            []
+          end
+        end
+        attribute foreign_key, Array[Integer], readonly: readonly
+      end
+    end
+  end
+end

data/lib/gecko/helpers/inspection_helper.rb

@@ -0,0 +1,51 @@
+module Gecko
+  module Helpers
+    # Helper for providing custom #inspect values to Records
+    module InspectionHelper
+      # Overrides the default inspect to just return the defined attributes
+      #
+      # @example
+      #   company.inspect #=> <Gecko::Record::Company id=123 name="Gecko Inc">
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        inspection = self.class.attribute_set.map do |attribute|
+          name = attribute.name
+          "#{name}: #{attribute_for_inspect(name)}"
+        end.join(', ')
+        "#<#{self.class} #{inspection}>"
+      end
+
+    private
+
+      # Returns an #inspect-like string for the value of the attribute
+      # attr_name.
+      # String attributes are truncated up to 50 characters,
+      # and Date and Time attributes are returned in the :db format.
+      # Other attributes return the value of #inspect without modification.
+      # Duplicated from Rails implementation
+      #
+      # @example
+      #   company.inspect #=> <Gecko::Record::Company id=123 name="Gecko Inc">
+      #
+      # @return [String]
+      #
+      # @api private
+      def attribute_for_inspect(attr_name)
+        value = attributes[attr_name]
+
+        if value.is_a?(String) && value.length > 50
+          "#{value[0..50]}...".inspect
+        elsif value.is_a?(DateTime) || value.is_a?(Time)
+          %("#{value.strftime("%Y-%m-%d %H:%M:%S")}")
+        elsif value.is_a?(Date)
+          %("#{value.strftime("%Y-%m-%d")}")
+        else
+          value.inspect
+        end
+      end
+    end
+  end
+end

data/lib/gecko/helpers/record_helper.rb

@@ -0,0 +1,29 @@
+module Gecko
+  module Helpers
+    # Helper for registering valid record types
+    module RecordHelper
+      # Registers a record type on the Gecko::Client
+      #
+      # @example
+      #  class Gecko::Client
+      #    record :Invoice
+      #  end
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def record(record_type)
+        define_method record_type do
+          adapter_cache = "@#{record_type}_cache".to_sym
+          unless instance_variable_defined?(adapter_cache)
+            adapter_name  = "#{record_type}Adapter".to_sym
+            adapter_klass = Gecko::Record.const_get(adapter_name)
+            adapter = adapter_klass.new(self, record_type)
+            instance_variable_set(adapter_cache, adapter)
+          end
+          instance_variable_get(adapter_cache)
+        end
+      end
+    end
+  end
+end

data/lib/gecko/helpers/serialization_helper.rb

@@ -0,0 +1,61 @@
+module Gecko
+  module Helpers
+    # Provides serialization to records
+    module SerializationHelper
+      # Returns a full JSON representation of a record
+      #
+      # @example
+      #   product.as_json #=> {product: {id: 12, name: "Big"}}
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def as_json
+        {
+          root => serializable_hash
+        }
+      end
+
+      # Return a serialized hash of the record's attributes
+      #
+      # @example
+      #   product.serializable_hash #=> {id: 12, name: "Big"}
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def serializable_hash
+        attribute_hash = {}
+        attribute_set.each do |attribute|
+          next if attribute.options[:readonly]
+          serialize_attribute(attribute_hash, attribute)
+        end
+        attribute_hash
+      end
+
+      # Serialize a single attribute
+      #
+      # @param [Hash] attribute_hash Serialized record being iterated over
+      # @param [Virtus::Attribute] attribute The attribute being serialized
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def serialize_attribute(attribute_hash, attribute)
+        attribute_hash[attribute.name] = attributes[attribute.name]
+      end
+
+      # Return JSON root key for a record
+      #
+      # @example
+      #   product.root #=> "product"
+      #
+      # @return [String]
+      #
+      # @api private
+      def root
+        self.class.demodulized_name.underscore.to_sym
+      end
+    end
+  end
+end

data/lib/gecko/helpers/validation_helper.rb

@@ -0,0 +1,91 @@
+module Gecko
+  module Helpers
+    # Provides record validation
+    module ValidationHelper
+      # Returns whether a record is considered valid or not
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def valid?
+        errors.empty?
+      end
+
+      # Returns the validation errors object for the record
+      #
+      # @return [Gecko::Errors]
+      #
+      # @api public
+      def errors
+        @errors ||= Gecko::Errors.new(self)
+      end
+    end
+  end
+
+  class Errors
+    # The hash of errors for this record
+    #
+    # @return [Hash]
+    #
+    # @api public
+    attr_reader :messages
+
+    # Set up the error object
+    #
+    # @api private
+    def initialize(base)
+      @base     = base
+      @messages = {}
+    end
+
+    # Fetch the errors for a specific attribute
+    #
+    # @example
+    #   product.errors[:name]
+    #     #=> ["can't be blank"]
+    #
+    # @params [Symbol] :attribute
+    #
+    # @return [Array]
+    #
+    # @api public
+    def [](attribute)
+      messages[attribute.to_sym]
+    end
+
+    # Clear the validation errors
+    #
+    # @example
+    #   product.errors.clear
+    #
+    # @return [undefined]
+    #
+    # @api public
+    def clear
+      @messages.clear
+    end
+
+    # Whether there are any errors
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      messages.all? { |k, v| v && v.empty? && !v.is_a?(String) }
+    end
+
+    # Parse JSON errors response into the error object
+    #
+    # @params [#to_hash] :error_hash hash of errors where key is an attribute
+    #   name and value is an array of error strings
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def from_response(error_hash)
+      error_hash.each do |attr, errors|
+        @messages[attr.to_sym] = errors
+      end
+    end
+  end
+end

data/lib/gecko/record/account.rb

@@ -0,0 +1,66 @@
+require 'gecko/record/base'
+
+module Gecko
+  module Record
+    class Account < Base
+      has_many :users
+      has_many :locations
+
+      attribute :name,             String
+      attribute :industry,         String
+      attribute :logo_url,         String,  readonly: true
+      attribute :website,          String
+      attribute :tax_number,       String
+      attribute :country,          String
+      attribute :time_zone,        String
+
+      attribute :contact_email,    String
+      attribute :contact_mobile,   String
+      attribute :contact_phone,    String
+
+      attribute :invoice_details,  String
+      attribute :order_details,    String
+      attribute :quote_details,    String
+
+      attribute :default_tax_rate, String
+
+      attribute :default_tax_type_id, Integer
+
+      attribute :tax_number_label, String
+      attribute :tax_label,        String
+
+      belongs_to :billing_contact,          class_name: "User"
+      belongs_to :primary_location,         class_name: "Location"
+      belongs_to :primary_billing_location, class_name: "Location"
+
+      # belongs_to :default_currency, class_name: "Currency"
+      # belongs_to :default_payment_term, class_name: "PaymentTerm"
+      # belongs_to :default_purchase_order_price_list, class_name: "PriceList"
+      # belongs_to :default_order_price_list, class_name: "PriceList"
+
+      # attribute :stock_level_warn, String
+      # attribute :subscription_name,          String
+      # attribute :subscription_price,         String
+      # attribute :annual_subscription_price,  String
+      # attribute :expires_at,                 String
+    end
+
+    class AccountAdapter < BaseAdapter
+      undef :count
+      undef :build
+
+      # Return the account for the logged in user
+      #
+      # @return [Gecko::Record::Account]
+      #
+      # @api public
+      def current
+        if self.has_record_for_id?(:current)
+          record_for_id(:current)
+        else
+          @identity_map[:current] = find(:current)
+        end
+      end
+    end
+  end
+end

data/lib/gecko/record/address.rb

@@ -0,0 +1,33 @@
+require 'gecko/record/base'
+
+module Gecko
+  module Record
+    class Address < Base
+      belongs_to :company
+
+      attribute :phone_number, String
+      attribute :email,        String
+
+      attribute :label,        String
+      attribute :company_name, String
+      attribute :address1,     String
+      attribute :address2,     String
+      attribute :suburb,       String
+      attribute :city,         String
+      attribute :state,        String
+      attribute :country,      String
+      attribute :zip_code,     String
+
+      attribute :status,       String,  readonly: true
+
+      alias_method :country_code, :country
+    end
+
+    class AddressAdapter < BaseAdapter
+      # Override plural_path to properly pluralize address
+      def plural_path
+        'addresses'
+      end
+    end
+  end
+end

data/lib/gecko/record/base.rb

@@ -0,0 +1,66 @@
+require 'gecko/helpers/association_helper'
+require 'gecko/helpers/inspection_helper'
+require 'gecko/helpers/serialization_helper'
+require 'gecko/helpers/validation_helper'
+
+module Gecko
+  module Record
+    class Base
+      include Virtus.model
+      extend  Gecko::Helpers::AssociationHelper
+      include Gecko::Helpers::InspectionHelper
+      include Gecko::Helpers::SerializationHelper
+      include Gecko::Helpers::ValidationHelper
+
+      # Set up the default attributes associated with all records
+      attribute :id,          Integer,    readonly: true
+      attribute :updated_at,  DateTime,   readonly: true
+      attribute :created_at,  DateTime,   readonly: true
+
+      # Overrides the default Virtus functionality to store:
+      # - The Gecko::Client used to create the object
+      # - a raw copy of the attributes for the association helpers to read from
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(client, attributes={})
+        super(attributes)
+        @client   = client
+      end
+
+      # Whether the record has been persisted
+      #
+      # @example
+      #   variant.persisted? #=> true
+      #
+      # @return <Boolean>
+      #
+      # @api public
+      def persisted?
+        !!id
+      end
+
+      # Save a record
+      #
+      # @return <Gecko::Record::Base>
+      #
+      # @api public
+      def save
+        @client.adapter_for(self.class.demodulized_name).save(self)
+      end
+
+      # Return the demodulized class name
+      #
+      # @example
+      #   Gecko::Record::Product.demodulized_name #=> "Product"
+      #
+      # @return [String]
+      #
+      # @api private
+      def self.demodulized_name
+        self.name.split('::').last
+      end
+    end
+  end
+end