katana_resource 0.7.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13fe737e54c6eec8768b494347bc898ab0a19f8c
+  data.tar.gz: e19e589f3574b569a53c8f75b959dff4bcf7bae4
+SHA512:
+  metadata.gz: 1f488768b4ee804de25ddd539c30c6ad7ff08a0427ca401806c6dda481153b8c4396f61350e480b66d86f74d00a9f2891f6d7110beabf16b489cddcb58991f52
+  data.tar.gz: ef99d4b43abca67bf9fe9bad3ec7a2e3f969e76f6b2943208c1b68e7f1974fb2904753d8b99316bf382164371c6c0f5ab891efaede37afe3fcbc6d6c7899640b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+./build
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.repl_history
+.ruby-version
+build/iPhoneSimulator-8.0-Development
+katana_resource-*.gem
+vendor

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/RKSwipeBetweenViewControllers"]
+	path = vendor/RKSwipeBetweenViewControllers
+	url = git@github.com:cwRichardKim/RKSwipeBetweenViewControllers.git
+[submodule "vendor/AKETooltip"]
+	path = vendor/AKETooltip
+	url = git@github.com:akeara/AKETooltip.git

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in katana_resource.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bodacious
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# KatanaResource
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/katana_resource`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'katana_resource'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install katana_resource
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/katana_resource.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+$:.unshift("./lib")
+require 'motion/project/template/ios'
+
+begin
+  Bundler.setup
+  Bundler.require
+rescue LoadError
+  puts "Please install bundler!"
+end
+
+Motion::Require.require_relative_enabled = true
+require "afmotion"
+require "webstub"
+
+
+require "katana_resource"
+
+Motion::Require.all(Dir.glob('app/**/*.rb'))
+
+# Better test output
+ENV["output"] ||= "test_unit"
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = "Katana Resource"
+
+  app.identifier = "com.katanacode.katanaresource"
+
+  app.deployment_target = "8.0"
+
+  app.files += Dir.glob(File.join(File.dirname(__FILE__), "lib/katana_resource/**/*.rb"))
+
+
+end

data/app/app_delegate.rb

@@ -0,0 +1,10 @@
+class AppDelegate
+
+  def application(application, didFinishLaunchingWithOptions: launchOptions)
+    # If we're in test mode, don't create a UIWindow
+    return true if RUBYMOTION_ENV == 'test'
+
+    true
+  end
+
+end

data/app/models/bicycle.rb

@@ -0,0 +1,4 @@
+class Bicycle  < KatanaResource::Base
+  self.root_url = "http://localhost:3000"
+
+end

data/katana_resource.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'katana_resource/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "katana_resource"
+  spec.version       = KatanaResource::VERSION
+  spec.authors       = ["Bodacious"]
+  spec.email         = ["gavin@gavinmorrice.com"]
+
+  spec.summary       = %q{A work in progress, please ignore for now}
+  spec.description   = %q{A work in progress, please ignore for now :)}
+  spec.homepage      = "http://katanacode.com"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0").
+    reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency "motion-require", "~> 0.2"
+  spec.add_runtime_dependency "afmotion", "~> 2.6"
+  spec.add_runtime_dependency "motion-support", "~> 1.1.0"
+  spec.add_runtime_dependency "motion-cocoapods", ">= 1.7.8"
+  spec.add_runtime_dependency "bubble-wrap", "~> 1.9"
+  spec.add_development_dependency "webstub", "~> 1.1"
+  spec.add_development_dependency "motion-redgreen", "~> 1.0"
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/katana_resource.rb

@@ -0,0 +1,9 @@
+require "motion-require"
+require "motion-support"
+require "afmotion"
+require "bubble-wrap/core"
+
+Motion::Require.require_relative_enabled = true
+
+Motion::Require.all(Dir.glob(File.expand_path('../core_ext/**/*.rb', __FILE__)))
+Motion::Require.all(Dir.glob(File.expand_path('../katana_resource/**/*.rb', __FILE__)))

data/lib/katana_resource/associations.rb

@@ -0,0 +1,22 @@
+module KatanaResource
+
+  module Associations
+
+    extend MotionSupport::Concern
+
+    module ClassMethods
+
+      def has_one(assoc_name, options = {})
+        options[:class_name] ||= assoc_name.to_s.classify
+        attribute(assoc_name, options[:class_name].to_s.constantize)
+      end
+
+      def has_many(assoc_name, options = {})
+        options[:class_name] ||= assoc_name.to_s.singularize.classify
+        attribute(assoc_name, options[:class_name].to_s.constantize, collection: true)          end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/attributes.rb

@@ -0,0 +1,178 @@
+require_relative "resource_attribute"
+require_relative "unknown_attribute_type"
+module KatanaResource
+
+
+  module Attributes
+
+    extend MotionSupport::Concern
+
+    def encodeWithCoder(coder)
+      self.class.resource_attributes.each do |att|
+        value = self.send(att.name)
+        coder.send(:"encode#{coder_method_for_type(att.type)}:forKey", value, att.name)
+      end
+    end
+
+    def initWithCoder(coder)
+      self.class.resource_attributes.each do |att|
+        value = coder.send(:"decode#{coder_method_for_type(att.type)}ForKey", att.name)
+        self.send(:"#{att.name}=", value)
+      end
+      return self
+    end
+
+    # This record's attributes. Keys are always Strings.
+    #
+    # Example:
+    #
+    #   User.new(name: "Bodacious", id: 7).attributes
+    #   # => {"name" => "Bodacious", "id" => 7}
+    #
+    # Returns a Hash
+    def attributes
+      return_val = Hash[self.class.resource_attributes.map do |attribute|
+        [attribute.name.to_s, send(attribute.name)]
+      end]
+    end
+
+    def non_association_attributes()
+      return_val = Hash[self.class.resource_attributes.map do |attribute|
+        [attribute.name.to_s, send(attribute.name)] unless attribute.options[:collection]
+      end]
+    end
+
+    def primary_key
+      @primary_key ||= self.class.primary_key
+    end
+
+
+    private
+
+
+    def coder_method_for_type(type)
+      case type
+      when Integer then :Int
+      when Float then :Float
+      when Boolean then :Bool
+      else
+        :Object
+      end
+    end
+
+
+    module ClassMethods
+
+      # When a class is inherited, pass on the inherited attributes to subclass.
+      #   If the class is inheriting from Base, don't pass on attributes.
+      #
+      #
+      # klass - The class inheriting from self
+      def inherited(klass)
+        return if self == KatanaResource::Base
+        klass.instance_variable_set("@resource_attributes", resource_attributes)
+      end
+
+      def resource_attributes
+        @resource_attributes ||= []
+      end
+
+      def primary_key(value = nil)
+        if value
+          @primary_key = value
+        else
+          return @primary_key || :id
+        end
+      end
+
+      def attribute(*args)
+        options = args.extract_options!
+        type    = args.last.is_a?(Class) ? args.pop : String
+        args.each do |name|
+          self.resource_attributes << ResourceAttribute.new(name, type, options)
+
+          define_method :"#{name}?" do
+            instance_variable_get(:"@#{name}").present?
+          end
+
+          define_method :"#{name}=" do |value|
+            instance_variable_set(:"@#{name}",
+            self.class.cast_value_as_attribute_type(value, name))
+          end unless options[:read_only]
+
+          define_method :"#{name}" do
+            default_val = options[:collection] == true ? [] : nil
+            ivar_val    = instance_variable_get(:"@#{name}")
+            ivar_val.nil? ? default_val : ivar_val
+          end unless options[:write_only]
+
+        end
+      end
+
+      def cast_value_as_attribute_type(value, name)
+        case
+        when type_name_for_attribute(name) == "Time"
+          time = Time.iso8601_with_timezone(value)
+          time.utc if time
+
+        when type_name_for_attribute(name) == "Date"    then value.to_date
+        when type_name_for_attribute(name) == "String"  then unescape_string(value.to_s)
+        when type_name_for_attribute(name) == "Symbol"  then value.to_sym
+        when type_name_for_attribute(name) == "Integer" then value.to_i
+        when type_name_for_attribute(name) == "Float"   then value.to_f
+        when type_name_for_attribute(name) == "Boolean" then Boolean.new(value).bool_val
+        when defined?(type_for_attribute(name))
+
+          # This will be true if we're decoding the record from disc rather than loading
+          # from server
+          # TODO: Refacator this...
+          if value.is_a?(KatanaResource::Base)
+            return value
+          end
+          return_val = [value].flatten.map { |atts| type_for_attribute(name).new(atts) }
+          if attribute_is_collection?(name)
+            return_val
+          else
+            return_val.first
+          end
+        else
+          raise UnknownAttributeType, "Don't know how to cast #{type} for attribute"
+        end
+      end
+
+      def attribute_named(name)
+        resource_attributes.detect { |att| att.name.to_s == name.to_s }
+      end
+
+
+      private
+
+
+      def type_for_attribute(name)
+        attribute_named(name).type
+      end
+
+      def type_name_for_attribute(name)
+        attribute_named(name).type.name
+      end
+
+      def attribute_is_collection?(name)
+        attribute_named(name).collection?
+      end
+
+      UNESCAPES = {
+          'a' => "\x07", 'b' => "\x08", 't' => "\x09",
+          'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
+          'r' => "\x0d", 'e' => "\x1b", "\\\\" => "\x5c",
+          "\"" => "\x22", "'" => "\x27"
+      }
+
+      def unescape_string(string)
+        string
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/base.rb

@@ -0,0 +1,61 @@
+require_relative "associations"
+require_relative "attributes"
+require_relative "client"
+require_relative "create"
+require_relative "delete"
+require_relative "freeform_requests"
+require_relative "read"
+require_relative "resource_paths"
+require_relative "singleton_records"
+require_relative "url_encoding"
+require_relative "configuration"
+
+module KatanaResource
+
+
+  class Base
+
+    include KatanaResource::Associations
+    include KatanaResource::Attributes
+    include KatanaResource::Client
+    include KatanaResource::Configuration
+    include KatanaResource::Create
+    include KatanaResource::Delete
+    include KatanaResource::Read
+    include KatanaResource::FreeformRequests
+    include KatanaResource::ResourcePaths
+    include KatanaResource::SingletonRecords
+    include KatanaResource::UrlEncoding
+
+    def initialize(attributes = {})
+      attributes = attributes.with_indifferent_access
+      self.class.resource_attributes.each do |resource_att|
+        next unless attributes[resource_att.name]
+        send(:"#{resource_att.name}=", attributes[resource_att.name])
+      end
+    end
+
+    # TODO: Find a better way to represent a persisted record
+    def persisted?
+      id.present?
+    end
+
+    def ==(record)
+      return false unless record.respond_to?(:id)
+      self.id == record.id
+    end
+
+
+
+
+
+    class << self
+
+      def fetched_data=(data)
+        @fetched_data = data
+      end
+
+    end
+
+  end
+end

data/lib/katana_resource/boolean.rb

@@ -0,0 +1,15 @@
+module KatanaResource
+  class ::Boolean
+  
+    def initialize(value)
+      @value = true  if value.to_s =~ /true|1/
+      @value = false if value.to_s =~ /false|0/   
+      raise ArgumentError, "#{value} is not a valid boolean" if @value.nil? && !value.nil?
+    end
+  
+    def bool_val
+      @value
+    end
+  
+  end
+end

data/lib/katana_resource/client.rb

@@ -0,0 +1,29 @@
+module KatanaResource
+
+  module Client
+
+    extend MotionSupport::Concern
+
+    module ClassMethods
+
+      # DSL Mapping to properties of AFHTTPSessionManager
+      def client
+        AFMotion::Client.shared || load_client
+      end
+
+
+      def load_client
+        AFMotion::Client.build_shared(root_url) do
+          header "Accept", "application/json"
+          KatanaResource::Base.additional_headers.each do |name, value|
+            header name, value
+          end
+          response_serializer :json
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/configuration.rb

@@ -0,0 +1,25 @@
+module KatanaResource
+
+  module Configuration
+
+    extend MotionSupport::Concern
+
+    module ClassMethods
+
+
+      def additional_headers
+        @additional_headers ||= {}
+      end
+
+      def root_url=(value)
+        @@root_url = value
+      end
+
+      def root_url
+        @@root_url || raise("Base::root_url not defined")
+      end
+
+    end
+  end
+
+end

data/lib/katana_resource/core_ext/ns_string.rb

@@ -0,0 +1,15 @@
+class NSString
+
+  def to_date
+    Date.new(*split(/\/|\-/))
+  end
+
+  def to_time
+    Time.iso8601_with_timezone(self)
+  end
+
+  def to_bool
+    KatanaResource::Boolean.new(self).bool_val
+  end
+
+end

data/lib/katana_resource/create.rb

@@ -0,0 +1,54 @@
+module KatanaResource
+
+  module Create
+
+    extend MotionSupport::Concern
+
+    def save(additional_params = {}, &block)
+      attributes = self.attributes
+      record     = self
+      self.class.class_eval { save_record(record, attributes, additional_params, &block) }
+    end
+
+    module ClassMethods
+
+
+      def create(attributes, &block)
+        new(attributes).save(&block)
+      end
+
+
+      protected
+
+
+      def save_record(record, attributes = {}, additional_params = {}, &block)
+        UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(true)
+        attributes        = attributes.reject { |k,v| v.nil? }
+        nested_attributes = { record.class.name.underscore => attributes }
+        verb              = save_verb_for_record(record)
+        path              = save_path_for_record(record)
+        params            = nested_attributes.merge(additional_params)
+        call_block        = Proc.new do |result, error|
+          UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(false)
+          prepare_return_object_for_result(result, block)
+        end
+        client.send(verb, path, params, &call_block)
+      end
+
+      def save_path_for_record(record)
+        if record.persisted?
+          prepare_url_and_params(singular_resource_path, id: record.id)
+        else
+          prepare_url_and_params(plural_resource_path)
+        end.first
+      end
+
+      def save_verb_for_record(record)
+        record.persisted? ? :patch : :post
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/delete.rb

@@ -0,0 +1,33 @@
+module KatanaResource
+
+  module Delete
+
+    extend MotionSupport::Concern
+
+    def delete(additional_params = {}, &block)
+      return false unless persisted?
+      attributes = self.attributes
+      record     = self
+      self.class.class_eval do
+        delete_record(record, attributes, additional_params, &block)
+      end
+    end
+
+    module ClassMethods
+
+      def delete_record(record, attributes = {}, params = {}, &block)
+        UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(true)
+        verb = :delete
+        path = prepare_url_and_params(singular_resource_path, id: record.id).first
+        call_block = Proc.new do |result, error|
+          UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(false)
+          prepare_return_object_for_result(result, block)
+        end
+        client.send(:delete, path, params, &call_block)
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/error.rb

@@ -0,0 +1,65 @@
+module KatanaResource
+
+  class Error
+
+    attr_reader :ns_error
+
+    attr_reader :description
+
+    attr_reader :localized_description
+
+
+    def initialize(ns_error)
+      @ns_error              = ns_error
+      @description           = ns_error.description unless nil?
+      @localized_description = ns_error.localizedDescription unless nil?
+    end
+
+    def code
+      val = description[/(?<=\()\d{3}(?=\))/].to_i
+      return val if val > 0
+    end
+
+    def unauthorized?
+      code == 401
+    end
+
+    def bad_request?
+      code == 400
+    end
+
+    def not_found?
+      code == 404
+    end
+
+    def offline?
+      description.index('The Internet connection appears to be offline.')
+    end
+
+    def nil?
+      ns_error.nil?
+    end
+
+    def data
+      json = user_info["com.alamofire.serialization.response.error.data"] || "{}"
+      BW::JSON.parse(json)
+    end
+
+    def user_info
+      ns_error.userInfo
+    end
+
+    def message
+      if !nil? && data["errors"]
+        case data["errors"]
+        when String then data["errors"]
+        when Array then data["errors"].join(", ")
+        else
+          data["errors"].to_s
+        end
+      end
+    end
+
+  end
+
+end

data/lib/katana_resource/freeform_requests.rb

@@ -0,0 +1,33 @@
+module KatanaResource
+  module FreeformRequests
+
+    extend MotionSupport::Concern
+
+
+    def patch(action_name, params = {}, &block)
+      self.class.patch(self, action_name, params, &block)
+    end
+
+
+    alias_method :put, :patch
+
+
+    module ClassMethods
+
+      def patch(record, action_name, params = {}, &block)
+        resource_action_path = File.join(singular_resource_path, action_name)
+        params_with_primary_key = params.merge(primary_key => record.send(primary_key))
+        url_and_params = prepare_url_and_params(resource_action_path,
+          params_with_primary_key)
+        UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(true)
+        client.put(*url_and_params) do |result, error|
+          UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(false)
+          prepare_return_object_for_result(result, block)
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/katana_resource/read.rb

@@ -0,0 +1,94 @@
+require_relative "error"
+module KatanaResource
+
+  module Read
+
+    extend MotionSupport::Concern
+
+    module ClassMethods
+
+      # TODO: Support finding records where id is not provided
+      def find(key, params = {}, &block)
+        UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(true)
+        client.get(*resource_path_for_key(key, params)) do |result, error|
+          UIApplication.sharedApplication.setNetworkActivityIndicatorVisible(false)
+          prepare_return_object_for_result(result, block)
+        end
+      end
+
+      def all
+        @all ||= []
+      end
+
+      def all=(value)
+        @all = value
+      end
+
+      def any?
+        all.any?
+      end
+
+      def none?
+        all.none?
+      end
+
+      alias :empty? :none?
+
+      def disabled_method(*)
+        puts "Cannot call :#{__callee__} from #{self}. Is disabled"
+      end
+
+
+      private
+
+
+      def require_parent_resource!
+        singleton_class.send(:alias_method, :find, :disabled_method)
+        singleton_class.send(:alias_method, :all,  :disabled_method)
+      end
+
+      def prepare_return_object_for_result(result, block)
+        puts "No block given for find" and return unless block
+        if result.success?
+          return_val = prepare_success_return_object_for_result(result, block)
+        else
+          return_val = prepare_failure_return_object_for_result(result, block)
+        end
+        block.call(return_val, Error.new(result.error))
+      end
+
+      def prepare_success_return_object_for_result(result, block)
+        if result.object.is_a?(Hash)
+          new(result.object)
+        else
+          result.object.map { |atts| new(atts) }
+        end
+      end
+
+      def prepare_failure_return_object_for_result(result, block)
+        log_result(result) && nil
+      end
+
+      def resource_path_for_key(key, params)
+        case key
+        when Integer, String
+          complete_params = params.merge(primary_key => key)
+          prepare_url_and_params(singular_resource_path, complete_params)
+        when :all
+          prepare_url_and_params(plural_resource_path, params)
+        else
+          raise "FREAKOUT!"
+        end
+      end
+
+      def log_result(result)
+        if RUBYMOTION_ENV == "development"
+          log("#{result.object}.\n#{result.error.description}")
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/resource_attribute.rb

@@ -0,0 +1,29 @@
+module KatanaResource
+
+  class ResourceAttribute
+
+
+    attr_reader :name
+
+    attr_reader :type
+
+    attr_reader :options
+
+
+    def initialize(name, type, options = {})
+      @name    = name
+      @type    = type
+      @options = options.with_indifferent_access
+    end
+
+    def collection?
+      options[:collection] == true
+    end
+
+    def singular?
+      !collection?
+    end
+
+  end
+
+end

data/lib/katana_resource/resource_paths.rb

@@ -0,0 +1,42 @@
+module KatanaResource
+
+  module ResourcePaths
+
+    extend MotionSupport::Concern
+
+    module ClassMethods
+
+      def plural_resource_path(value = nil)
+        if value
+          @plural_resource_path = value
+        else
+          @plural_resource_path || default_plural_resource_path
+        end
+      end
+
+
+      def singular_resource_path(value = nil)
+        if value
+          @singular_resource_path = value
+        else
+          @singular_resource_path || default_singular_resource_path
+        end
+      end
+
+
+      private
+
+
+      def default_plural_resource_path
+        self.name.underscore.pluralize
+      end
+
+      def default_singular_resource_path
+        self.name.underscore.pluralize + "/:id"
+      end
+
+    end
+
+  end
+
+end

data/lib/katana_resource/singleton_records.rb

@@ -0,0 +1,50 @@
+module KatanaResource
+
+  module SingletonRecords
+
+    extend MotionSupport::Concern
+
+    module IncludedClassMethods
+
+      def current=(record)
+        @current = record
+      end
+
+      def current
+        @current
+      end
+
+      def current?
+        !!@current
+      end
+
+      def current_path
+        (App.documents_path + "/#{name}.current").freeze
+      end
+
+      def save_current(value = nil)
+        self.current = value if value
+        NSKeyedArchiver.archiveRootObject(current, toFile: current_path)
+      end
+
+      def clear_current
+        self.current = nil
+        save_current
+      end
+
+      def load_current
+        self.current = NSKeyedUnarchiver.unarchiveObjectWithFile(current_path)
+      end
+
+    end
+
+    module ClassMethods
+
+      def singleton_record!
+        extend IncludedClassMethods
+      end
+
+    end
+  end
+
+end

data/lib/katana_resource/unknown_attribute_type.rb

@@ -0,0 +1,6 @@
+module KatanaResource
+
+  class UnknownAttributeType < StandardError
+  end
+
+end

data/lib/katana_resource/url_encoding.rb

@@ -0,0 +1,33 @@
+module KatanaResource
+
+  module UrlEncoding
+
+    extend MotionSupport::Concern
+
+
+    module ClassMethods
+
+      # Prepares a url string by replacing named parameters with param values and
+      # removing these from the params.
+      #
+      # Examples
+      #
+      #   prepare_url_and_params("users/:id/:foo", {id: 1, foo: 'foo', bar: 'bar'})
+      #   # => ["users/1/foo", {bar: "bar"}]
+      #
+      # Returns an Array with url String and params Hash
+      def prepare_url_and_params(url_string, params = {})
+        params, key_names = params.with_indifferent_access, []
+        new_string = url_string.gsub(/\:([^\/\:]+)/) { |match| 
+          key_names << match.slice(1..-1)
+          "%{#{$1}}" 
+        } % params
+        return "#{new_string}.json", params.delete_if { |key,v| key_names.include?(key) }
+      end
+      
+    end
+
+  end
+
+end
+

data/lib/katana_resource/version.rb

@@ -0,0 +1,3 @@
+module KatanaResource
+  VERSION = "0.7.3"
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: katana_resource
+version: !ruby/object:Gem::Version
+  version: 0.7.3
+platform: ruby
+authors:
+- Bodacious
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: motion-require
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: afmotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: motion-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: motion-cocoapods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.8
+- !ruby/object:Gem::Dependency
+  name: bubble-wrap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: webstub
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: motion-redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: A work in progress, please ignore for now :)
+email:
+- gavin@gavinmorrice.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- app/models/bicycle.rb
+- katana_resource-0.1.0.gem
+- katana_resource.gemspec
+- lib/katana_resource.rb
+- lib/katana_resource/associations.rb
+- lib/katana_resource/attributes.rb
+- lib/katana_resource/base.rb
+- lib/katana_resource/boolean.rb
+- lib/katana_resource/client.rb
+- lib/katana_resource/configuration.rb
+- lib/katana_resource/core_ext/ns_string.rb
+- lib/katana_resource/create.rb
+- lib/katana_resource/delete.rb
+- lib/katana_resource/error.rb
+- lib/katana_resource/freeform_requests.rb
+- lib/katana_resource/read.rb
+- lib/katana_resource/resource_attribute.rb
+- lib/katana_resource/resource_paths.rb
+- lib/katana_resource/singleton_records.rb
+- lib/katana_resource/unknown_attribute_type.rb
+- lib/katana_resource/url_encoding.rb
+- lib/katana_resource/version.rb
+homepage: http://katanacode.com
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A work in progress, please ignore for now
+test_files: []