motion-prime 0.1.0

data/motion-prime.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../motion-prime/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "motion-prime"
+  spec.version       = MotionPrime::VERSION
+  spec.authors       = ["Iskander Haziev"]
+  spec.email         = ["gvalmon@gmail.com"]
+  spec.description   = %q{RubyMotion apps development framework}
+  spec.summary       = %q{RubyMotion apps development framework}
+  spec.homepage      = ""
+  spec.license       = ""
+
+  spec.files         = `git ls-files`.split($\)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake"
+  spec.add_dependency "cocoapods"
+  spec.add_dependency "motion-cocoapods"
+  spec.add_dependency "motion-require"
+  spec.add_dependency "motion-support"
+  spec.add_dependency 'bubble-wrap'
+  spec.add_dependency 'sugarcube'
+  spec.add_dependency 'nano-store'
+end

data/motion-prime/app_delegate.rb

@@ -0,0 +1,56 @@
+motion_require './helpers/has_authorization'
+module MotionPrime
+  class BaseAppDelegate
+    include MotionPrime::HasAuthorization
+
+    attr_accessor :window, :sidebar_container
+
+    def application(application, didFinishLaunchingWithOptions:launch_options)
+      on_load(application, launch_options)
+      true
+    end
+
+    def app_delegate
+      UIApplication.sharedApplication.delegate
+    end
+
+    def app_window
+      self.app_delegate.window
+    end
+
+    def open_root_screen(screen)
+      screen.send(:on_screen_load) if screen.respond_to?(:on_screen_load)
+      screen = screen.main_controller if screen.respond_to?(:main_controller)
+
+      self.window ||= UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+      self.window.rootViewController = screen
+      self.window.makeKeyAndVisible
+      screen
+    end
+
+    def open_screen(screen)
+      if sidebar?
+        sidebar_container.content_controller = screen
+      else
+        open_root_screen(screen)
+      end
+    end
+
+    def sidebar?
+      !sidebar_container.nil?
+    end
+
+    def open_with_sidebar(content, menu, options={})
+      self.sidebar_container = SidebarContainerScreen.new(menu, content, options)
+      open_root_screen(sidebar_container)
+    end
+
+    def show_sidebar
+      sidebar_container.show_sidebar
+    end
+
+    def hide_sidebar
+      sidebar_container.hide_sidebar
+    end
+  end
+end

data/motion-prime/elements/base.rb

@@ -0,0 +1,94 @@
+module MotionPrime
+  class BaseElement
+    # MotionPrime::BaseElement is container for UIView class elements with options.
+    # Elements are located inside Sections
+
+    include ::MotionSupport::Callbacks
+    attr_accessor :options, :section, :name,
+                  :view_class, :view, :styles, :screen
+
+    define_callbacks :render
+
+    def initialize(options = {})
+      @options = options
+      @section = WeakRef.new(options.delete(:section))
+      @name = options[:name]
+      @block = options.delete(:block)
+      @view_class = options.delete(:view_class) || "UIView"
+      @view_name = self.class.name.demodulize.underscore.gsub('_element', '')
+    end
+
+    def render(options = {}, &block)
+      self.screen = options[:to]
+      run_callbacks :render do
+        render!(&block)
+      end
+    end
+
+    def render!(&block)
+      @view = screen.add_view view_class.constantize, computed_options, &block
+    end
+
+    # Lazy-computing options
+    def computed_options
+      compute_options! if @computed_options.blank?
+      @computed_options
+    end
+
+    def compute_options!
+      @computed_options = options
+      compute_block_options
+      compute_style_options
+      @computed_options = normalize_options(@computed_options)
+    end
+
+    # Compute options sent inside block, e.g.
+    # element :button do
+    #   {name: model.name}
+    # end
+    def compute_block_options
+      if block = @block
+        @computed_options.merge!(section.send :instance_eval, &block)
+      end
+    end
+
+    def compute_style_options
+      @styles = [:"base_#{@view_name}"]
+      @styles += Array.wrap(@computed_options.delete(:styles))
+      @styles += [:"#{section.name}_#{name}"] if section.present?
+      @computed_options.merge!(style_options)
+    end
+
+    def style_options
+      Styles.for(styles)
+    end
+
+    def normalize_options(options)
+      options.each do |key, option|
+        options[key] = if option.is_a?(Proc) && key != :block
+          section.send :instance_eval, &option
+        else
+          option
+        end
+      end
+    end
+
+    class << self
+      def factory(type, options = {})
+        class_name = "#{type.classify}Element"
+        options.merge!({view_class: "UI#{type.classify}"})
+        if MotionPrime.const_defined?(class_name)
+          "MotionPrime::#{class_name}".constantize.new(options)
+        else
+          self.new(options)
+        end
+      end
+      def before_render(method_name)
+        set_callback :render, :before, method_name
+      end
+      def after_render(method_name)
+        set_callback :render, :after, method_name
+      end
+    end
+  end
+end

data/motion-prime/elements/button.rb

@@ -0,0 +1,7 @@
+module MotionPrime
+  class ButtonElement < BaseElement
+    def view_class
+      "DMButton"
+    end
+  end
+end

data/motion-prime/elements/draw.rb

@@ -0,0 +1,56 @@
+module MotionPrime
+  class DrawElement < BaseElement
+    # MotionPrime::DrawElement is container for drawRect method options.
+    # Elements are located inside Sections
+
+    def render!
+    end
+
+    def view
+      @view ||= section.container_view
+    end
+
+    def computed_left
+      width = computed_options[:width]
+      left = computed_options[:left]
+      right = computed_options[:right]
+      return left if left
+      return 0 if right.nil?
+
+      width = 0.0 if width.nil?
+      max_width = view.bounds.size.width
+
+      # calculate left if width is relative, e.g 0.7
+      if width > 0 && width <= 1
+        max_width - (max_width * width) - right
+      else
+        max_width - width - right
+      end
+    end
+
+    def computed_top
+      height = computed_options[:height]
+      top = computed_options[:top]
+      bottom = computed_options[:bottom]
+      return top if top
+      return 0 if bottom.nil?
+
+      height = 0.0 if height.nil?
+      max_height = view.bounds.size.height
+
+      # calculate top if height is relative, e.g 0.7
+      if height > 0 && height <= 1
+        max_height - (max_height * height) - bottom
+      else
+        max_height - height - bottom
+      end
+    end
+
+    class << self
+      def factory(type, options = {})
+        class_name = "#{type.classify}DrawElement"
+        "MotionPrime::#{class_name}".constantize.new(options)
+      end
+    end
+  end
+end

data/motion-prime/elements/draw/image.rb

@@ -0,0 +1,43 @@
+motion_require '../draw.rb'
+module MotionPrime
+  class ImageDrawElement < DrawElement
+    attr_accessor :image_data
+    def draw_in(rect)
+      image_rect = CGRectMake(
+        computed_left,
+        computed_top,
+        computed_options[:width],
+        computed_options[:height]
+      )
+      # draw already initialized image
+      if image_data
+        image_data.drawInRect(image_rect)
+      # draw image from resources
+      elsif computed_options[:image]
+        self.image_data = computed_options[:image].uiimage
+        image_data.drawInRect(image_rect)
+      # show default image and download image from url
+      elsif computed_options[:url]
+        if computed_options[:default]
+          computed_options[:default].uiimage.drawInRect(image_rect)
+        end
+        manager = SDWebImageManager.sharedManager
+        manager.downloadWithURL(computed_options[:url],
+          options: 0,
+          progress: lambda{ |r_size, e_size|  },
+          completed: lambda{ |image, error, type, finished|
+            if image
+              self.image_data = image
+              if type == SDImageCacheTypeNone || type == SDImageCacheTypeDisk
+                # if it's first call, we should redraw view, because it's async
+                section.container_view.setNeedsDisplay
+              else
+                # if it's second call, we should just draw image
+                self.image_data.drawInRect(image_rect)
+              end
+            end
+          } )
+      end
+    end
+  end
+end

data/motion-prime/elements/draw/label.rb

@@ -0,0 +1,13 @@
+motion_require '../draw.rb'
+module MotionPrime
+  class LabelDrawElement < DrawElement
+    def draw_in(rect)
+      color = computed_options[:color] || computed_options[:text_color]
+      color.uicolor.set if color
+      computed_options[:text].to_s.drawAtPoint(
+        CGPointMake(computed_left, computed_top),
+        withFont: computed_options[:font]
+      )
+    end
+  end
+end

data/motion-prime/elements/image.rb

@@ -0,0 +1,14 @@
+module MotionPrime
+  class ImageElement < BaseElement
+    after_render :fetch_image
+    def view_class
+      "UIImageView"
+    end
+
+    def fetch_image
+      return unless computed_options[:url]
+      view.setImageWithURL NSURL.URLWithString(computed_options[:url]),
+                        placeholderImage: computed_options[:default].uiimage
+    end
+  end
+end

data/motion-prime/elements/label.rb

@@ -0,0 +1,20 @@
+module MotionPrime
+  class LabelElement < BaseElement
+    after_render :size_to_fit
+
+    def size_to_fit
+      if computed_options[:size_to_fit] || style_options[:size_to_fit]
+        view.sizeToFit
+      end
+    end
+
+    def height
+      width = computed_options[:width]
+      font = computed_options[:font] || :system.uifont
+      raise "Please set element width for height calculation" unless width
+      computed_options[:text].sizeWithFont(font,
+            constrainedToSize: [width, Float::MAX],
+            lineBreakMode:UILineBreakModeWordWrap).height
+    end
+  end
+end

data/motion-prime/elements/text_field.rb

@@ -0,0 +1,7 @@
+module MotionPrime
+  class TextFieldElement < BaseElement
+    def view_class
+      "DMTextField"
+    end
+  end
+end

data/motion-prime/elements/text_view.rb

@@ -0,0 +1,7 @@
+module MotionPrime
+  class TextViewElement < BaseElement
+    def view_class
+      "DMTextView"
+    end
+  end
+end

data/motion-prime/helpers/has_authorization.rb

@@ -0,0 +1,10 @@
+module MotionPrime
+  module HasAuthorization
+    def current_user
+      @current_user = User.current
+    end
+    def api_client
+      @api_client ||= ApiClient.new(access_token: current_user.access_token)
+    end
+  end
+end

data/motion-prime/helpers/has_search_bar.rb

@@ -0,0 +1,25 @@
+# This module adds search functionality, to Screen or TableSection
+module MotionPrime
+  module HasSearchBar
+    def add_search_bar(&block)
+      search_bar = create_search_bar
+      search_bar.delegate = self
+      self.table_view.tableHeaderView = search_bar if is_a?(TableSection)
+      @search_callback = block
+    end
+
+    def create_search_bar
+      name = is_a?(TableSection) ? name : self.class.name.underscore
+      screen = is_a?(TableSection) ? self.screen : self
+      screen.search_bar(styles: [:"base_search_bar", :"#{name}_search_bar"]).view
+    end
+
+    def searchBar(search_bar, textDidChange: text)
+      @search_callback.call(text)
+    end
+
+    def searchBarSearchButtonClicked(search_bar)
+      search_bar.resignFirstResponder
+    end
+  end
+end

data/motion-prime/models/base.rb

@@ -0,0 +1,220 @@
+motion_require '../helpers/has_authorization'
+module MotionPrime
+  class BaseModel < NanoStore::Model
+    class_attribute :sync_url
+    class_attribute :sync_attributes
+    class_attribute :_associations
+    alias_method :attributes, :info
+    include MotionPrime::HasAuthorization
+
+    def sync_url
+      self.class.sync_url.to_s.gsub(':id', id.to_s)
+    end
+
+    def model_name
+      self.class.name.underscore
+    end
+
+    def new_record?
+      id.blank?
+    end
+
+    def destroy(&block)
+      use_callback = block_given?
+      api_client.delete(sync_url) do
+        block.call() if use_callback
+      end
+      delete
+    end
+
+    # fetch attributes from url
+    def sync_with_url(url, &block)
+      api_client.get(url) do |data|
+        if data.present?
+          sync_with_attributes(data, &block)
+        end
+      end
+    end
+
+    def update_with_url(url, &block)
+      use_callback = block_given?
+      post_data = { model_name => filtered_sync_attributes}
+      api_client.send(id ? :put : :post, url, post_data) do |data|
+        self.id ||= data['id']
+        block.call() if use_callback
+      end
+    end
+
+    # set attributes
+    def sync_with_attributes(attrs, &block)
+      attrs.each do |key, value|
+        if respond_to?(:"sync_#{key}")
+          self.send(:"sync_#{key}", value)
+        elsif respond_to?(:"#{key}=")
+          self.send(:"#{key}=", value)
+        end
+      end
+      block.call(self) if block_given?
+    end
+
+    def sync!(sync_options = {}, &block)
+      sync(sync_options.merge(save: true), &block)
+    end
+
+    # sync with url and
+    # TODO: order of fetch/update should be based on updated time
+    def sync(sync_options = {}, &block)
+      use_callback = block_given?
+      should_fetch = sync_options[:fetch]
+      should_update = sync_options[:update]
+
+      should_fetch = !new_record? if should_fetch.nil?
+      should_update = new_record? if should_update.nil?
+
+      sync_with_url self.sync_url do
+        save if sync_options[:save]
+        block.call if use_callback
+      end if should_fetch
+      update_with_url self.sync_url do
+        save if sync_options[:save]
+        block.call if use_callback
+      end if should_update
+
+      sync_associations(sync_options)
+    end
+
+    def sync_associations(sync_options = {})
+      (self.class._associations || []).each do |key, options|
+        sync_association(key, sync_options)
+      end
+    end
+
+    def sync_association(key, sync_options = {}, &block)
+      options = self.class._associations[key]
+      return unless options[:sync_url]
+      options[:type] == :many ?
+      sync_has_many(key, options, sync_options, &block) :
+      sync_has_one(key, options, sync_options, &block)
+    end
+
+    def sync_has_many(key, options = {}, sync_options = {}, &block)
+      old_collection = self.send(key)
+      use_callback = block_given?
+      puts "SYNC: started sync for #{key} in #{self.class.name}"
+      api_client.get(options[:sync_url]) do |data|
+        if data.present?
+          # Update/Create existing records
+          data.each do |attributes|
+            model = old_collection.detect{ |model| model.id == attributes[:id]}
+            unless model
+              model = key.singularize.to_s.classify.constantize.new
+              self.send(:"#{key}_bag") << model
+            end
+            model.sync_with_attributes(attributes)
+            model.save if sync_options[:save]
+          end
+          old_collection.each do |old_model|
+            model = data.detect{ |model| model[:id] == old_model.id}
+            unless model
+              old_model.delete
+            end
+          end
+          save if sync_options[:save]
+          puts "SYNC: finished sync for #{key} in #{self.class.name}"
+          block.call if use_callback
+        else
+          puts "SYNC ERROR: failed sync for #{key} in #{self.class.name}"
+          block.call if use_callback
+        end
+      end
+    end
+
+    def sync_has_one(key, options = {}, &block)
+      # TODO: add implementation
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + BW::JSON.generate(attributes)
+    end
+
+    # NOTE: .clear method doesn't work, using removeArray hack for now
+    def _clear_bag(bag_name)
+      bag = self.send(bag_name.to_sym)
+      bag_copy = bag.to_a.clone
+      bag - bag.to_a # this removes association from model
+      bag_copy.each(&:delete) # this removes collection from db
+    end
+
+    def filtered_sync_attributes
+      return attributes if self.class.sync_attributes.blank?
+      attributes.reject do |key, value|
+        self.class.sync_attributes.exclude?(key.to_sym)
+      end
+    end
+
+    class << self
+      def sync_url(url = nil)
+        url ? self.sync_url = url : super
+      end
+
+      def sync_attributes(*attrs)
+        attrs ? self.sync_attributes = attrs : super
+      end
+
+      def has_one(association_name, options = {})
+        bag_name = "#{association_name.pluralize}_bag"
+        self.bag bag_name.to_sym
+
+        self._associations ||= {}
+        self._associations[association_name] = options.merge(type: :one)
+
+        define_method("#{association_name}=") do |value|
+          self._clear_bag(bag_name)
+
+          self.send(:"#{bag_name}") << value
+          value
+        end
+        define_method("#{association_name}_attributes=") do |value|
+          self._clear_bag(bag_name)
+
+          association = association_name.classify.constantize.new
+          association.sync_with_attributes(value)
+          association.save
+          self.send(:"#{bag_name}") << association
+          association
+        end
+        define_method("#{association_name}") do
+          self.send(:"#{bag_name}").to_a.first
+        end
+      end
+
+      def has_many(association_name, options = {})
+        bag_name = "#{association_name}_bag"
+        self.bag bag_name.to_sym
+
+        self._associations ||= {}
+        self._associations[association_name] = options.merge(type: :many)
+
+        define_method("#{association_name}_attributes=") do |value|
+          self._clear_bag(bag_name)
+
+          association = []
+          value.each do |attrs|
+            model = association_name.classify.constantize.new
+            model.sync_with_attributes(attrs)
+            association << model
+          end
+          self.send(:"#{bag_name}=", association)
+          association
+        end
+        define_method("#{association_name}=") do |value|
+          self._clear_bag(bag_name)
+          self.send(:"#{bag_name}=", value)
+        end
+        define_method("#{association_name}") do
+          self.send(:"#{bag_name}").to_a
+        end
+      end
+    end
+  end
+end