dyndrop 0.0.1 → 0.0.2

data/lib/dyndrop/trace_helpers.rb

@@ -0,0 +1,40 @@
+require "net/https"
+require "multi_json"
+
+module Dyndrop
+  module TraceHelpers
+
+    def request_trace(request)
+      return nil unless request
+      info = ["REQUEST: #{request[:method]} #{request[:url]}"]
+      info << "REQUEST_HEADERS:"
+      info << header_trace(request[:headers])
+      info << "REQUEST_BODY: #{request[:body]}" if request[:body]
+      info.join("\n")
+    end
+
+
+    def response_trace(response)
+      return nil unless response
+      info = ["RESPONSE: [#{response[:status]}]"]
+      info << "RESPONSE_HEADERS:"
+      info << header_trace(response[:headers])
+      info << "RESPONSE_BODY:"
+      begin
+        parsed_body = MultiJson.load(response[:body])
+        info << MultiJson.dump(parsed_body, :pretty => true)
+      rescue
+        info << "#{response[:body]}"
+      end
+      info.join("\n")
+    end
+
+    private
+
+    def header_trace(headers)
+      headers.sort.map do |key, value|
+        "  #{key} : #{value}"
+      end
+    end
+  end
+end

data/lib/dyndrop/v1/base.rb

@@ -0,0 +1,28 @@
+require "multi_json"
+require "tmpdir"
+
+require "dyndrop/baseclient"
+
+require "dyndrop/errors"
+
+module Dyndrop::V1
+  class Base < Dyndrop::BaseClient
+
+    def get_token(email, payload)
+      post("1", "users", email, "tokens", :content => :json, :accept => :json, :payload => payload)
+    end
+
+    # Users
+    def create_user(payload)
+      # no JSON response
+      post("users", :content => :json, :payload => payload)
+    end
+
+    # Applications
+    def instances(name)
+      get("apps", name, "instances", :accept => :json)[:instances]
+    end
+
+
+  end
+end

data/lib/dyndrop/v1/client.rb

@@ -0,0 +1,114 @@
+module Dyndrop::V1
+  # The primary API entrypoint. Wraps a BaseClient to provide nicer return
+  # values. Initialize with the target and, optionally, an auth token. These
+  # are the only two internal states.
+  class Client
+
+    attr_reader :base
+
+    # Create a new Client for interfacing with the given target.
+    #
+    # A token may also be provided to skip the login step.
+    def initialize(target = "http://api.dyndrop.com", token = nil)
+      @base = Base.new(target, token)
+    end
+
+    def version
+      1
+    end
+
+    # The current target URL of the client.
+    def target
+      @base.target
+    end
+
+    # Current authentication token.
+    def token
+      @base.token
+    end
+
+    # Set the authentication token.
+    def token=(token)
+      @base.token = token
+    end
+
+    # Current proxy user. Usually nil.
+    def proxy
+      @base.proxy
+    end
+
+    # Set the proxy user for the client. Must be authorized as an
+    # administrator for this to have any effect.
+    def proxy=(email)
+      @base.proxy = email
+    end
+
+    # Is the client tracing API requests?
+    def trace
+      @base.trace
+    end
+
+    # Set the tracing flag; if true, API requests and responses will be
+    # printed out.
+    def trace=(bool)
+      @base.trace = bool
+    end
+
+    # The current log. See +log=+.
+    def log
+      @base.log
+    end
+
+    # Set the logging mode. Mode can be one of:
+    #
+    # [+String+] Name of a file to log the last 10 requests to.
+    # [+Array+]  Array to append with log data (a Hash).
+    # [+IO+]     An IO object to write to.
+    # [+false+]  No logging.
+    def log=(mode)
+      @base.log = mode
+    end
+
+    # The currently authenticated user.
+    def current_user
+      if user = info[:user]
+        user(user)
+      end
+    end
+
+    def current_space
+      nil
+    end
+
+    def current_org
+      nil
+    end
+
+
+    # Retrieve target metadata.
+    def info
+      @base.info
+    end
+
+    def login(username, password)
+      @base.token = Dyndrop::AuthToken.from_token_info(@base.get_token(username, {:password => password}))
+    end
+
+
+    # Create a user on the target and return a User object representing them.
+    def register(email, password)
+      @base.create_user(:email => email, :password => password)
+      user(email)
+    end
+
+    # Clear client token. No requests are made for this.
+    def logout
+      @base.token = nil
+    end
+
+    # Is an authentication token set on the client?
+    def logged_in?
+      !!@base.token
+    end
+  end
+end

data/lib/dyndrop/v1/model_magic.rb

@@ -0,0 +1,129 @@
+require "dyndrop/validator"
+
+module Dyndrop::V1
+  module BaseClientMethods
+  end
+
+  module ClientMethods
+  end
+
+  module ModelMagic
+    attr_accessor :guid_name
+
+    def read_locations
+      @read_locations ||= {}
+    end
+
+    def write_locations
+      @write_locations ||= {}
+    end
+
+    def read_only_attributes
+      @read_only_attributes ||= []
+    end
+
+    def on_client(&blk)
+      ClientMethods.module_eval(&blk)
+    end
+
+    def on_base_client(&blk)
+      BaseClientMethods.module_eval(&blk)
+    end
+
+    def define_client_methods(klass = self)
+      singular = klass.object_name
+      plural = klass.plural_object_name
+
+      base_singular = klass.base_object_name
+      base_plural = klass.plural_base_object_name
+
+      on_base_client do
+        define_method(base_singular) do |guid|
+          get(base_plural, guid, :accept => :json)
+        end
+
+        define_method(:"create_#{base_singular}") do |payload|
+          post(base_plural, :content => :json, :accept => :json, :payload => payload)
+        end
+
+        define_method(:"delete_#{base_singular}") do |guid|
+          delete(base_plural, guid)
+          true
+        end
+
+        define_method(:"update_#{base_singular}") do |guid, payload|
+          put(base_plural, guid, :content => :json, :payload => payload)
+        end
+
+        define_method(base_plural) do |*args|
+          get(base_plural, :accept => :json)
+        end
+      end
+
+      on_client do
+        if klass.guid_name
+          define_method(:"#{singular}_by_#{klass.guid_name}") do |guid|
+            obj = send(singular, guid)
+            obj if obj.exists?
+          end
+        end
+
+        define_method(singular) do |*args|
+          guid, _ = args
+          klass.new(guid, self)
+        end
+
+        define_method(plural) do |*args|
+          options, _ = args
+          options ||= {}
+
+          @base.send(base_plural).collect do |json|
+            klass.new(json[klass.guid_name], self, json)
+          end
+        end
+      end
+    end
+
+    def attribute(name, type, opts = {})
+      default = opts[:default]
+      is_guid = opts[:guid]
+      read_only = opts[:read_only]
+      write_only = opts[:write_only]
+      has_default = opts.key?(:default)
+
+      read_locations[name] = Array(opts[:read] || opts[:at] || name) unless write_only
+      write_locations[name] = Array(opts[:write] || opts[:at] || name) unless read_only
+
+      read_only_attributes << name if read_only
+
+      self.guid_name = name if is_guid
+
+      define_method(name) do
+        return @guid if @guid && is_guid
+
+        read = read_manifest
+        read.key?(name) ? read[name] : default
+      end
+
+      define_method(:"#{name}=") do |val|
+        unless has_default && val == default
+          Dyndrop::Validator.validate_type(val, type)
+        end
+
+        @guid = val if is_guid
+
+        @manifest ||= {}
+
+        old = read_manifest[name]
+        @changes[name] = [old, val] if old != val
+
+        write_to = read_only ? self.class.read_locations : self.class.write_locations
+
+        put(val, @manifest, write_to[name])
+      end
+
+      private name if write_only
+      private :"#{name}=" if read_only
+    end
+  end
+end

data/lib/dyndrop/validator.rb

@@ -0,0 +1,39 @@
+module Dyndrop
+  module Validator
+    class << self
+      def value_matches?(val, type)
+        case type
+        when Class
+          val.is_a?(type)
+        when Regexp
+          val.is_a?(String) && val =~ type
+        when :url
+          value_matches?(val, URI::regexp(%w(http https)))
+        when :https_url
+          value_matches?(val, URI::regexp("https"))
+        when :boolean
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+        when Array
+          val.all? do |x|
+            value_matches?(x, type.first)
+          end
+        when Hash
+          val.is_a?(Hash) &&
+            type.all? { |name, subtype|
+              val.key?(name) && value_matches?(val[name], subtype)
+            }
+        when nil
+          true
+        else
+          val.is_a?(Object.const_get(type.to_s.capitalize))
+        end
+      end
+
+      def validate_type(val, type)
+        unless value_matches?(val, type)
+          raise Dyndrop::Mismatch.new(type, val)
+        end
+      end
+    end
+  end
+end

data/lib/dyndrop/version.rb

@@ -1,4 +1,4 @@
 module Dyndrop # :nodoc:
   # Dyndrop library version number.
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dyndrop
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -19,7 +19,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
+- lib/dyndrop.rb
+- lib/dyndrop/baseclient.rb
 - lib/dyndrop/version.rb
+- lib/dyndrop/client.rb
+- lib/dyndrop/auth_token.rb
+- lib/dyndrop/errors.rb
+- lib/dyndrop/rest_client.rb
+- lib/dyndrop/validator.rb
+- lib/dyndrop/trace_helpers.rb
+- lib/dyndrop/v1/client.rb
+- lib/dyndrop/v1/model_magic.rb
+- lib/dyndrop/v1/base.rb
 homepage: http://github.com/dyndrop/dyndrop
 licenses: []
 post_install_message: