lean_motion 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11a512b0eb4900d63e392c755728747ceaafbabd
+  data.tar.gz: 0edccd1ef76eef1b8790fdb754657b09749e4f29
+SHA512:
+  metadata.gz: 93ef272d5136b2fabc8db74b670093a1cdda48f153aac7e8d3d28a033b6850c1fa08a385e4bd093ac1d20ae94de6bacd7b388caf1f332688c85fbae271a99756
+  data.tar.gz: 71c044f0ec94eef4b4dca0cccf94b3a77bc37c865572a224af2d5bf78286be7c69d6d52789186f9a3201f72744ac0b6cfa8a2eb8b9450e97a44d5a151d828365

data/README.md

@@ -0,0 +1,76 @@
+# LeanMotion
+
+LeanMotion 是一个RubyMotion的Gem，可以更加方便地使用LeanCloud SDK。用更Ruby的写法来操作LeanCloud的数据，类Rails的ActiveRecord，增删查改。
+
+## 安装说明
+
+1、安装gem
+```
+gem install lean_motion
+```
+
+2、创建项目
+```
+lean_motion create app-name
+```
+
+3、设置LeanCloud的App ID和App Key
+修改 app_delegate.rb
+
+```
+    app_id   = "your_app_id"
+    app_key  = "your_app_key" 
+```
+
+4、运行
+```
+rake
+```
+
+## 使用说明
+1、在LeanCloud后台创建一个Class，比如Product，并添加以下字段
+```
+name: String
+description: String
+url: String
+```
+
+2、添加model文件 product.rb，建议放在app/models/目录下
+```
+class Product
+  include LM::Model
+
+  fields :name, :description, :url
+end
+```
+
+3、操作数据
+
+新建产品
+```
+product = Product.new
+product.name 		= 'iPhone 6'
+product.description = '目前最好的智能手机'
+product.url 		= 'http://www.apple.com'
+product.save
+```
+
+产品数量
+```
+Product.count
+```
+
+查询产品
+```
+Product.where(:name=>'iPhone 6').find
+```
+
+获得第一条记录
+```
+Product.first
+```
+
+排序
+```
+Product.sort(:createdAt=>:desc).find
+```

data/bin/lean_motion

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'methadone'
+require 'lean_motion/version'
+
+class App
+  include Methadone::Main
+  include Methadone::CLILogging
+  include Methadone::SH
+  
+  main do |command, opt|
+    case command.to_sym
+    when :create then create(opt)
+    when :create_pro then create_pro(opt)
+    when :create_user then create_user(opt)
+    when :help then show_help
+    else show_help
+    end
+
+    0 # Good!
+  end
+
+  def self.show_help
+    info "lean_motion - Command line tools for LeanMotion."
+    info "By smartweb"
+    info ""
+    info "Commands:"
+    info "  create <appname>"
+    info "    Creates a new LeanMotion app from a template."
+    info ""
+    info "  create_pro <appname>"
+    info "    Creates a new LeanMotion + ProMotion app from a template."
+    info ""
+    info "  create_user <appname>"
+    info "    Creates a new LeanMotion + ProMotion + User app from a template."
+  end
+
+  def self.create(name)
+    return puts "Usage: lean_motion create <appname>" unless name.to_s.length > 0
+    info "Creating new LeanMotion iOS app #{name}"
+    sh "motion create --template=git://coding.net/smartweb/LeanMotionTemplate.git #{name}"
+  end
+
+  def self.create_pro(name)
+    return puts "Usage: lean_motion create <appname>" unless name.to_s.length > 0
+    info "Creating new LeanMotion iOS app #{name}"
+    sh "motion create --template=git://coding.net/smartweb/LeanProMotionTemplate.git #{name}"
+  end
+
+  def self.create_user(name)
+    return puts "Usage: lean_motion create <appname>" unless name.to_s.length > 0
+    info "Creating new LeanMotion iOS app #{name}"
+    sh "motion create --template=git://coding.net/smartweb/LeanUserTemplate.git #{name}"
+  end
+
+  description "Command line for LeanMotion."
+
+  arg :command
+  arg :opt, :optional
+
+  version LeanMotion::VERSION
+
+  go!
+end

data/lib/lean_motion.rb

@@ -0,0 +1,17 @@
+unless defined?(Motion::Project::Config)
+  raise "The lean_motion gem must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  core_lib = File.join(File.dirname(__FILE__), 'lean_motion')
+  insert_point = app.files.find_index { |file| file =~ /^(?:\.\/)?app\// } || 0
+
+  Dir.glob(File.join(core_lib, '**/*.rb')).reverse.each do |file|
+    app.files.insert(insert_point, file)
+  end
+
+  app.vendor_project('vendor/AVOSCloud.framework', 
+                      :static, 
+                      :products => ['AVOSCloud'], 
+                      :headers_dir => 'Headers')
+end

data/lib/lean_motion/cloud.rb

@@ -0,0 +1,9 @@
+module LeanMotion
+
+  def self.run(function_name, params, &block)
+    AVCloud.callFunctionInBackground(function_name, withParameters:params, block:lambda do |object, error|
+        block.call(object, error)
+    end)
+  end
+  
+end

data/lib/lean_motion/config.rb

@@ -0,0 +1,21 @@
+module LeanMotion
+  class Config
+
+    def self.init(app_id, app_key)
+      if app_id == "your_app_id" || app_key == "your_app_key"
+        NSLog("=========== LeanMotion Error ==========")
+        NSLog("LeanCloud App ID and App Key require")
+        NSLog("=======================================")
+        return
+      end
+
+      AVOSCloud.setApplicationId(app_id, clientKey:app_key)
+      AVOSCloud.useAVCloudCN
+    end
+       
+    def self.channel(name)
+      AVAnalytics.setChannel name
+    end
+
+  end
+end

data/lib/lean_motion/lean_motion.rb

@@ -0,0 +1,3 @@
+module LeanMotion
+end
+::LM = LeanMotion unless defined?(::LM)

data/lib/lean_motion/model.rb

@@ -0,0 +1,322 @@
+module LeanMotion
+  module Model
+    attr_accessor :AVObject, :errors
+    
+    RESERVED_KEYS = [:objectId, :createdAt, :updatedAt]
+
+    def initialize(av=nil)
+      if av
+        self.AVObject = av
+      else
+        self.AVObject = AVObject.objectWithClassName(self.class.to_s)
+      end
+
+      self
+    end
+    
+    def method_missing(method, *args, &block)
+      method = method.to_sym
+      setter = false
+      
+      if setter?(method)
+        setter = true
+        method = method.split("=")[0].to_sym
+      end
+
+      # Setters
+      if RESERVED_KEYS.include?(method) && setter
+        return self.AVObject.send("#{method}=", args)
+      elsif fields.include?(method) && setter
+        return setField(method, args.first)
+      # Getters
+      elsif RESERVED_KEYS.include?(method)
+        return self.AVObject.send(method)
+      elsif fields.include? method
+        return getField(method)
+      elsif self.AVObject.respond_to?("#{method}=")
+        return self.AVObject.send("#{method}=", *args, &block)
+      elsif self.AVObject.respond_to?(method)
+        return self.AVObject.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def getter?(method)
+      !setter?(method)
+    end
+
+    def setter?(method)
+      method.to_s.include?("=")
+    end
+
+    # Override of ruby's respond_to?
+    # 
+    # @param [Symbol] method
+    # @return [Bool] true/false
+    def respond_to?(method)
+      if setter?(method)
+        method = method.to_s.split("=")[0]
+      end
+
+      method = method.to_sym unless method.is_a? Symbol
+
+      return true if fields.include?(method)
+
+      super
+    end 
+
+    def fields
+      self.class.send(:get_fields)
+    end
+
+
+    def getField(field)
+      field = field.to_sym
+      return @AVObject.send(field) if RESERVED_KEYS.include?(field)
+      return @AVObject[field] if fields.include? field
+      raise "AVCloud Exception: Invalid field name #{field} for object #{self.class.to_s}"
+    end
+
+    def setField(field, value)
+      if RESERVED_KEYS.include?(field) || fields.include?(field.to_sym)
+        return @AVObject.removeObjectForKey(field.to_s) if value.nil?
+        return @AVObject.send("#{field}=", value) if RESERVED_KEYS.include?(field)
+        return @AVObject[field] = value
+      else
+        raise "AVCloud Exception: Invalid field name #{field} for object #{self.class.to_s}"
+      end
+    end
+
+    # Returns all of the attributes of the Model
+    # 
+    # @return [Hash] attributes of Model
+    def attributes
+      attributes = {}
+      fields.each do |f|
+        attributes[f] = getField(f)
+      end
+      @attributes = attributes
+    end
+
+    # Sets the attributes of the Model
+    # 
+    # @param [Hash] attrs to set on the Model
+    # @return [Hash] that you gave it
+    # @note will throw an error if a key is invalid
+    def attributes=(attrs)
+      attrs.each do |k, v|
+        if v.respond_to?(:each) && !v.is_a?(AVObject)
+          self.attributes = v
+        elsif self.respond_to? "#{k}="
+          self.send("#{k}=", v) 
+        else
+          setField(k, v) unless k.nil?
+        end
+      end
+    end
+
+    # Save the current state of the Model to Parse
+    #
+    # @note calls before/after_save hooks
+    # @note before_save MUST return true, or save will not be called on AVObject
+    # @note does not save if validations fail
+    # 
+    # @return [Bool] true/false
+    def save
+      saved = false
+      unless before_save == false
+        self.validate
+
+        if @errors && @errors.length > 0
+          saved = false
+        else
+          saved = @AVObject.save
+        end
+
+        after_save if saved
+      end
+      saved
+    end
+    def before_save; end
+    def after_save; end
+
+    def validate
+      reset_errors
+      self.attributes.each do |field, value|
+        validateField field, value
+      end
+    end
+
+    # Checks to see if the current Model has errors
+    #
+    # @return [Bool] true/false
+    def is_valid?
+      self.validate
+      return false if @errors && @errors.length > 0
+      true
+    end
+
+    def delete
+      deleted = false
+      unless before_delete == false
+        deleted = @AVObject.delete
+      end
+      after_delete if deleted
+      deleted
+    end
+    def before_delete; end
+    def after_delete; end
+
+
+    # Validations
+    def presenceValidations
+      self.class.send(:get_presence_validations)
+    end
+
+    def presenceValidationMessages
+      self.class.send(:get_presence_validation_messages)
+    end
+
+    
+
+    def validateField(field, value)
+      @errors ||= {}
+      if presenceValidations.include?(field) && (value.nil? || value == "")
+        messages = presenceValidationMessages
+        if messages.include?(field) 
+          @errors[field] = messages[field]
+        else
+          @errors[field] = "#{field} can't be blank" 
+        end
+      end
+    end
+
+    def errorForField(field)
+      @errors[field] || false
+    end
+
+    def errors
+      @errors
+    end
+
+    def valid?
+      self.errors.nil? || self.errors.length == 0
+    end
+
+    def invalid?
+      !self.valid?
+    end
+
+    def reset_errors
+      @errors = nil
+    end
+
+    module ClassMethods
+      
+      def query
+          LeanMotion::CloudQuery.alloc.initWithClassNameAndClassObject(self.name, classObject:self)
+      end
+
+      def count(&block)
+        cloud_query = query
+        return cloud_query.countObjects unless block_given?
+
+        cloud_query.count do |count, error|
+          block.call(count, error)
+        end
+      end
+
+      def all(&block)
+        cloud_query = query
+        return cloud_query.find unless block_given?
+        
+        cloud_query.find do |objects, error|
+          block.call(objects, error)
+        end
+      end
+
+      def where(hash)
+        cloud_query = query
+        cloud_query.findByHash(hash)
+      end
+
+      def first(&block)
+        cloud_query = query
+        return cloud_query.first unless block_given?
+
+        cloud_query.first do |object, error|
+          block.call(object, error)
+        end
+      end
+
+      def destroy(&block)
+        cloud_query = query
+        return cloud_query.delete unless block_given?
+
+        cloud_query.destroy do |object, error|
+          block.call(object, error)
+        end
+      end
+
+      def sort(hash)
+        cloud_query = query
+        cloud_query.sort(hash)
+      end
+
+      def page(number, pagesize=20)
+        cloud_query = query
+        cloud_query.page(number, pagesize)
+      end
+
+      # set the fields for the current Model
+      #   used in method_missing
+      #
+      # @param [Symbol] args one or more fields
+      def fields(*args)
+        args.each {|arg| field(arg)}
+      end
+    
+      # set a field for the current Model
+      #
+      # @param [Symbol] name of field
+      # (see #fields)
+      def field(name)
+        @fields ||= [:objectId]
+        @fields << name.to_sym
+        @fields.uniq!
+      end
+      
+      def get_fields
+        @fields ||= []
+      end
+
+      # require a certain field to be present (not nil And not an empty String)
+      # 
+      # @param [Symbol, Hash] field and options (now only has message)
+      def validates_presence_of(field, opts={})
+        @presenceValidationMessages ||= {}
+        @presenceValidationMessages[field] = opts[:message] if opts[:message]
+        validate_presence(field)
+      end
+
+      def get_presence_validations
+        @presenceValidations ||= {}
+      end
+      
+      def get_presence_validation_messages
+        @presenceValidationMessages ||= {}
+      end
+
+      def validate_presence(field)
+        @presenceValidations ||= []
+        @presenceValidations << field
+      end
+   end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end

data/lib/lean_motion/query.rb

@@ -0,0 +1,120 @@
+module LeanMotion
+  class CloudQuery < AVQuery
+    
+    def setClassObject(classObject)
+      @classObject = classObject
+      self
+    end
+
+    def initWithClassNameAndClassObject(className, classObject:myClassObject)
+      @className = className
+      self.initWithClassName(className)
+      self.setClassObject(myClassObject)
+      self
+    end
+
+    def findByHash(hash)
+      hash.each do |k, v|
+        symbols = [:gt, :greater, :lt, :less, :gte, :greater_and_equal, 
+                   :lte, :less_and_equal, :bt, :between]
+
+        if v.class == Array && (symbols.include? v[0])
+          compare(k, v)
+        else
+          equal(k, v)
+        end
+      end
+      self
+    end
+
+    def equal(k, v)
+      if v.nil?
+        self.whereKeyDoesNotExist(k)
+      elsif v == :exist
+        self.whereKeyExists(k)
+      else
+        self.whereKey(k, equalTo:v)
+      end
+    end
+
+    def compare(k, v)
+      type  = v[0]
+      value = v[1]
+      case type
+      when :gt, :greater
+        self.whereKey(k, greaterThan: value)
+      when :lt, :less
+        self.whereKey(k, lessThan: value)
+      when :gte, :greater_and_equal
+        self.whereKey(k, greaterThanOrEqualTo: value)
+      when :lte, :less_and_equal
+        self.whereKey(k, lessThanOrEqualTo: value)
+      when :bt, :between
+        self.whereKey(k, greaterThan: v[1])
+        self.whereKey(k, lessThan: v[2])
+      end
+      self
+    end
+
+    def find(&block)
+      return self.findObjects.map {|obj| @classObject.new(obj)} unless block_given?
+       
+      self.findObjectsInBackgroundWithBlock(lambda do |objects, error|
+        objects = objects.map {|obj| @classObject.new(obj)} if objects
+        block.call(objects, error)
+      end)
+    end
+
+    def first(&block)
+      return @classObject.new(self.getFirstObject) unless block_given?
+
+      self.getFirstObjectInBackgroundWithBlock(lambda do |object, error|
+        obj = @classObject.new(object) if object
+        block.call(obj, error)
+      end)
+    end
+
+    def get(id, &block)
+      return @classObject.new(self.getObjectWithId(id)) unless block_given?
+
+      self.getObjectInBackgroundWithId(id, block:lambda do |object, error|
+        obj = @classObject.new(object) if object
+        block.call(obj, error)
+      end)
+    end
+
+    def count(&block)
+      return self.countObjects unless block_given?
+
+      self.countObjectsInBackgroundWithBlock(lambda do |count, error|
+        block.call(count, error)
+      end)
+    end
+
+    def destroy(&block)
+      self.deleteAllInBackgroundWithBlock(lambda do |objects, error|
+        block.call(objects, error)
+      end)
+    end
+
+    def page(number, pagesize=20)
+        number ||= 1
+        self.limit = pagesize
+        self.skip  = (number - 1) * pagesize
+        self
+    end
+
+    def sort(hash)
+      key = hash.first[0]
+      sort= hash.first[1]
+      if sort == :asc
+        self.orderByAscending(key)
+      else
+        self.orderByDescending(key)
+      end
+      self
+    end
+
+  end
+
+end

data/lib/lean_motion/user.rb

@@ -0,0 +1,137 @@
+module LeanMotion
+  module User
+    attr_accessor :AVUser
+
+    RESERVED_KEYS = ['username', 'password', 'email']
+
+    def initialize(av_user_object=nil)
+      if av_user_object
+        @AVUser = av_user_object
+      else
+        @AVUser = AVUser.user
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if RESERVED_KEYS.include?("#{method}")
+        @AVUser.send(method)
+      elsif RESERVED_KEYS.map {|f| "#{f}="}.include?("#{method}")
+        @AVUser.send(method, args.first)
+      elsif fields.include?(method)
+        @AVUser.objectForKey(method)
+      elsif fields.map {|f| "#{f}="}.include?("#{method}")
+        method = method.split("=")[0]
+        @AVUser.setObject(args.first, forKey:method)
+      elsif @AVUser.respond_to?(method)
+        @AVUser.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def fields
+      self.class.send(:get_fields)
+    end
+
+    def sign(&block)
+      return true unless block_given?
+      @AVUser.signUpInBackgroundWithBlock(lambda do |succeeded, error|
+          block.call(succeeded, error)
+      end)
+    end
+
+    module ClassMethods
+      
+      def login(username, password, &block)
+        AVUser.logInWithUsernameInBackground(username, password:password, block:lambda do |user, error|
+          block.call(user, error)
+        end)
+      end
+
+
+      def query
+          LeanMotion::CloudQuery.alloc.initWithClassNameAndClassObject('_User', classObject:self)
+      end
+
+      def count(&block)
+        cloud_query = query
+        return cloud_query.countObjects unless block_given?
+
+        cloud_query.countObjectsInBackgroundWithBlock(lambda do |count, error|
+          block.call(count, error)
+        end)
+      end
+
+      def where(hash)
+        cloud_query = query
+        cloud_query.findByHash(hash)
+      end
+      
+      def first(&block)
+        cloud_query = query
+        return cloud_query.getFirst unless block_given?
+
+        cloud_query.getFirstObjectInBackgroundWithBlock(lambda do |object, error|
+          block.call(object, error)
+        end)
+      end
+
+      def order(hash)
+        cloud_query = query
+        key = hash.first[0]
+        sort= hash.first[1]
+        if sort == :asc
+          cloud_query.orderByAscending(key)
+        else
+          cloud_query.orderByDescending(key)
+        end
+      end
+
+      def page(number, pagesize=20)
+        number ||= 1
+        cloud_query = query
+        cloud_query.limit = pagesize
+        cloud_query.skip  = (number - 1) * pagesize
+        cloud_query
+      end
+
+      def fields(*args)
+        args.each {|arg| field(arg)}
+      end
+
+      def field(name)
+        @fields ||= []
+        @fields << name
+      end
+
+      def current_user
+        if AVUser.currentUser
+          u = new
+          u.AVUser = AVUser.currentUser
+          return u
+        else
+          return nil
+        end
+      end
+
+      def all(&block)
+        return AVUser.query.findObjects.map {|obj| self.new(obj)} unless block_given?
+
+        AVUser.query.findObjectsInBackgroundWithBlock(lambda do |objects, error|
+          objects = objects.map {|obj| self.new(obj)} if objects
+          block.call(objects, error)
+        end)
+      end
+
+      def get_fields
+        @fields
+      end
+
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end

data/lib/lean_motion/version.rb

@@ -0,0 +1,3 @@
+module LeanMotion
+  VERSION = "0.1" unless defined?(LeanMotion::VERSION)
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: lean_motion
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- smartweb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: methadone
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Make it more easy to use LeanCloud SDK in RubyMotion. Inspired by ParseModel.
+email: sam@chamobile.com
+executables:
+- lean_motion
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/lean_motion
+- lib/lean_motion.rb
+- lib/lean_motion/cloud.rb
+- lib/lean_motion/config.rb
+- lib/lean_motion/lean_motion.rb
+- lib/lean_motion/model.rb
+- lib/lean_motion/query.rb
+- lib/lean_motion/user.rb
+- lib/lean_motion/version.rb
+homepage: http://github.com/smartweb/lean_motion
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Rubymotion wrapper for LeanCloud SDK
+test_files: []