cs 0.1.0beta3 → 0.1.0

data/lib/cs/end_point/trigger.rb

@@ -0,0 +1,16 @@
+module CS
+  module EndPoint
+    class Trigger
+      include EndPoint
+
+      attribute :name, :expression, :inactivity, :creation_date
+
+      resources "triggers"
+      resource "trigger"
+
+      def initialize(hash={})
+        from_hash(hash)
+      end
+    end
+  end
+end

data/lib/{commonsense-ruby-lib → cs}/end_point/user.rb

@@ -1,15 +1,15 @@
 require 'digest/md5'
 
-module CommonSense
+module CS
   module EndPoint
     class User
       include EndPoint
 
-      resources :users
-      resource :user
+      resources "users"
+      resource "user"
 
       attribute :email, :username, :name, :surname, :address, :zipcode,
-        :country, :mobile, :uuid, :openid, :password
+        :country, :mobile, :UUID, :openid, :password
 
       def initialize(hash={})
         if hash[:password]
@@ -38,6 +38,10 @@ module CommonSense
         current_user
       end
 
+      def save!(options={})
+        raise Error::ClientError, "No session found. use Client#new_user instead" unless @session
+        super(options)
+      end
 
       # get groups that this users belongs to
       def groups

data/lib/{commonsense-ruby-lib → cs}/error.rb

@@ -1,4 +1,4 @@
-module CommonSense
+module CS
   module Error
     class Error < ::RuntimeError
       def initialize(message = "")
@@ -6,6 +6,12 @@ module CommonSense
       end
     end
 
+    class ClientError < Error
+      def initialize(message = "Invalid uses of the library : #{self.class}")
+        super(message)
+      end
+    end
+
     class ResourceIdError < Error
       def initialize(message = "No id found for Resrouce: #{self.class}")
         super(message)

data/lib/cs/parameter_processor.rb

@@ -0,0 +1,99 @@
+module CS
+  module ParameterProcessor
+    def process_alias!(params)
+      return if self.class.parameters_alias.nil?
+
+      aliases = params.select { |param| self.class.parameters_alias.include?(param) }
+      aliases.each do |alias_to, value|
+        alias_for = self.class.parameters_alias[alias_to]
+        params[alias_for] = value
+        params.delete(alias_to)
+      end
+    end
+
+    def process_valid_values(name, value, param_option)
+      return value unless param_option[:valid_values]
+
+      if param_option[:valid_values].include?(value)
+        value
+      elsif !value.nil?
+        raise ArgumentError, "Invalid value for parameter '#{name}'"
+      end
+    end
+
+    def process_default_value(name, value, param_option)
+      value.nil? ? param_option[:default] : value
+    end
+
+
+    def process_param(name, value, param_option)
+      retval = value
+
+      # this should be refactored to it's own classes
+      retval = process_param_integer(name, value, param_option) if param_option[:type] == Integer
+      retval = process_param_boolean(name, value, param_option) if param_option[:type] == Boolean
+      retval = process_param_string(name, value, param_option) if param_option[:type] == String
+      retval = process_param_time(name, value, param_option) if param_option[:type] == Time
+      retval
+    end
+
+    def process_param_integer(name, value, param_option)
+      if value.kind_of?(Integer)
+        retval = value
+        retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+        maximum = param_option[:maximum]
+        retval = maximum if maximum && retval > maximum
+      end
+
+      retval = process_default_value(name, retval, param_option)
+
+      if !value.nil?  && !value.kind_of?(Integer)
+        raise ArgumentError, "Received non Integer value for parameter '#{name}'"
+      end
+
+      retval
+    end
+
+    def process_param_boolean(name, value, param_option)
+      retval = nil
+
+      if value.nil?
+        retval = param_option[:default] ? param_option[:default] : nil
+      elsif [0, "0", false, "false"].include?(value)
+        retval = 0
+      else
+        retval = 1
+      end
+
+      retval
+    end
+
+    def process_param_string(name, value, param_option)
+      retval = value
+      retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+      retval = process_default_value(name, retval, param_option)
+
+      retval
+    end
+
+    # This method prosess assignment for properties with datatype Time.
+    # There are 3 type that is valid for this properties:
+    #
+    # * **Time**
+    # * **Numeric**. It will convert this to ruby {Time}
+    # * **Obejct that respond to #to_time** and return ruby {Time}
+    #
+    def process_param_time(name, value, param_option)
+      retval = value
+
+      if !value.nil?
+        retval =  CS::Time.new(value)
+      end
+
+      retval = process_default_value(name, retval, param_option)
+      retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+
+      retval
+    end
+  end
+end

data/lib/cs/relation.rb

@@ -0,0 +1,244 @@
+module CS
+  module Boolean; end
+  module Relation
+
+    def check_session!
+      raise Error::SessionEmptyError unless @session
+    end
+
+    def get_url
+      raise Error::NotImplementedError, "the class #{self.class} does not respond to 'get_url' "
+    end
+
+    def initialize(session=nil)
+      @session = session
+    end
+
+    # Create a new Endpoint object.
+    #
+    # example:
+    #
+    #    sensor = client.sensors.build
+    def build(attributes={})
+      resource = resource_class.new(attributes)
+      resource.session = self.session
+      resource
+    end
+
+    def get_data!(params={})
+      check_session!
+      options = get_options(params)
+      session.get(get_url, options)
+    end
+
+    def limit(num)
+      @limit = num
+      return self
+    end
+
+    def parameter(name)
+      self.instance_variable_get("@#{name}")
+    end
+
+    def parameters
+      self.class.parameters
+    end
+
+    def get_data(params={})
+      get_data!(params)
+    end
+
+    def all
+      self.to_a
+    end
+
+    def count
+      check_session!
+      resource = get_single_resource
+      resource["total"] if resource
+    end
+
+    def find_or_new(attribute)
+      check_session!
+
+      self.each do |resource|
+        found = true
+        attribute.each do |key, value|
+          if resource.parameter(key) != value
+            found = false
+            break
+          end
+        end
+
+        return resource if found
+      end
+
+      resource = resource_class.new(attribute)
+      resource.session = self.session
+      resource
+    end
+
+    def find_or_create!(attribute)
+      resource = find_or_new(attribute)
+      resource.save! if resource.id.nil?
+      resource
+    end
+
+    def find_or_create(attribute)
+      find_or_create!(attribute) rescue nil
+    end
+
+    def first
+      resource = get_single_resource
+      parse_single_resource(resource)
+    end
+
+    def last
+      resource = get_single_resource(page: count - 1)
+      parse_single_resource(resource)
+    end
+
+    def inspect
+      entries = to_a.take(11).map!(&:inspect)
+      entries[10] = '...' if entries.size == 11
+
+      "#<#{self.class.name} [#{entries.join(", \n")}]>"
+    end
+
+    def get_options(input={})
+      options = {}
+
+      self.class.parameters.each do |name, param_option|
+        value = self.parameter(name) # get value from object
+        value = input[name] if input.has_key?(name) # override
+
+        value = process_param(name, value, param_option)
+        value = value.to_f if value.kind_of?(Time)
+
+        options[name] = value if value
+      end
+
+      options
+    end
+
+    def where(params={})
+      process_alias!(params)
+      params.keep_if {|k| self.class.parameters[k]}
+
+      params.each do |name,value|
+        param_option = self.class.parameters[name]
+
+        value = process_param(name, value, param_option)
+        self.send("#{name}=", value)
+      end
+
+      self
+    end
+
+    def each_batch(params={}, &block)
+      check_session!
+      options = get_options(params)
+
+      self.page ||= 0;
+
+      begin
+        options[:page] = self.page
+        data = get_data(options)
+
+        data = data[resource_class.resources_name] unless data.nil?
+        if !data.nil? && !data.empty?
+          yield data
+          self.page += 1
+        end
+      end while data && data.size == self.per_page
+    end
+
+    def each(&block)
+      counter = 0
+      self.each_batch do |data|
+        data.each do |data_point|
+          resource = resource_class.new(data_point)
+          resource.session = session
+          yield resource
+          counter += 1
+
+          return if @limit && @limit == counter
+        end
+      end
+    end
+
+    module ClassMethod
+      def parameter(name, type, *args)
+        attr_accessor name
+        self.parameters ||= {}
+
+        param = {type: type}
+        param.merge!(args[0]) unless args.empty?
+
+        self.class_eval %{
+          def #{name}
+            if @#{name}.nil? && (default = self.class.parameters[:#{name}][:default])
+              @#{name} = default
+            end
+
+            @#{name}
+          end
+        }
+
+        self.parameters[name] = param
+      end
+
+      def parameter_alias(name, name_alias)
+        attr_accessor name
+        self.parameters_alias ||= {}
+        self.parameters_alias[name] = name_alias
+      end
+
+      def parameters_alias=(parameters_alias)
+        @parameters_alias = parameters_alias
+      end
+
+      def parameters_alias
+        @parameters_alias
+      end
+
+      def parameters=(parameters)
+        @parameters = parameters
+      end
+
+      def parameters
+        @parameters
+      end
+    end
+
+    protected
+    def self.included(base)
+      base.send(:include, Enumerable)
+      base.send(:include, ParameterProcessor)
+      base.extend(ClassMethod)
+      base.class_eval do
+        attr_accessor :session
+      end
+    end
+
+    def resource_class
+      raise Error::NotImplementedError, "resource_class is not implemented for class : #{self.class}"
+    end
+
+    def parse_single_resource(data)
+      resources = data[resource_class.resources_name]
+      if !resources.empty?
+        resource = resource_class.new(resources[0])
+        resource.session = self.session
+
+        return resource
+      end
+    end
+
+    def get_single_resource(params={})
+      options = get_options.merge!({ page: 0, per_page: 1 })
+      options.merge!(params)
+      get_data(options)
+    end
+  end
+end

data/lib/cs/relation/group_relation.rb

@@ -0,0 +1,24 @@
+module CS
+  module Relation
+    class GroupRelation
+      include Relation
+
+      parameter :page, Integer, default: 0, required: true
+      parameter :per_page, Integer, default: 1000, required: true, maximum: 1000
+      parameter :public, Boolean
+      parameter :total, Boolean
+      parameter :sort, String, valid_values: ["ASC", "DESC"]
+      parameter :sort_field, String, valid_values: ["id", "username", "email", "public", "description", "name"]
+
+
+      private
+      def resource_class
+        EndPoint::Group
+      end
+
+      def get_url
+        "/groups.json"
+      end
+    end
+  end
+end

data/lib/cs/relation/notification_relation.rb

@@ -0,0 +1,20 @@
+module CS
+  module Relation
+    class NotificationRelation
+      include Relation
+
+      parameter :page, Integer, default: 0, required: true
+      parameter :per_page, Integer, default: 1000, required: true, maximum: 1000
+      parameter :total, Boolean
+
+      private
+      def resource_class
+        EndPoint::Notification
+      end
+
+      def get_url
+        "/notifications.json"
+      end
+    end
+  end
+end