arkenstone-open 3.0.1

data/lib/arkenstone/errors/no_url_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Raised if an Arkenstone document does not have a URL associated with it. A URL is set with the +url+ directive:
+#
+#    class Widget
+#      url 'http://example.com/widgets'
+#    end
+class NoUrlError < StandardError
+  class << self
+    def default_message
+      'A `url` must be defined for the class.'
+    end
+  end
+end

data/lib/arkenstone/helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Helpers
+    class << self
+      def included(base)
+        base.send :include, Arkenstone::Helpers::GeneralMethods
+        base.extend Arkenstone::Helpers::GeneralMethods
+      end
+    end
+
+    module GeneralMethods
+      def full_url(url)
+        url =~ %r{(/$)} ? url : "#{url}/"
+      end
+    end
+  end
+end

data/lib/arkenstone/network/env.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  # Environment is a wrapper around most of the properties created in a network request.
+  # A raw net/http object doesn't allow for much customization after it is instantiated. This allows the caller to manipulate data via hooks before a request is created.
+  class Environment
+    attr_accessor :url, :verb, :body, :headers
+
+    def initialize(options)
+      options.each do |key, value|
+        send("#{key}=".to_sym, value) if respond_to? key
+      end
+    end
+
+    def to_s
+      "#{@verb} #{@url}\n#{@body}"
+    end
+  end
+end

data/lib/arkenstone/network/hook.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  class Hook
+    def before_request(env); end
+
+    def after_complete(response); end
+
+    def encode_attributes(attributes); end
+
+    def on_error(response); end
+
+    class << self
+      ### Calls all of the available `before_request` hooks available for the class.
+      def call_request_hooks(klass, request)
+        call_hook klass, proc { |h| h.before_request request }
+      end
+
+      ### Calls all of the available `after_complete` hooks available for the class.
+      def call_response_hooks(klass, response)
+        call_hook klass, proc { |h| h.after_complete response }
+      end
+
+      ### Calls all of the available `on_error` hooks available for the class.
+      def call_error_hooks(klass, response)
+        call_hook klass, proc { |h| h.on_error response }
+      end
+
+      def all_hooks_for_class(klass)
+        all_hooks = []
+        if klass.arkenstone_inherit_hooks
+          klass.ancestors.each do |ancestor|
+            break if     ancestor == Arkenstone::Associations::InstanceMethods
+            break unless ancestor.respond_to?(:arkenstone_hooks)
+
+            all_hooks.concat ancestor.arkenstone_hooks unless ancestor.arkenstone_hooks.nil?
+          end
+        else
+          all_hooks = klass.arkenstone_hooks
+        end
+        all_hooks
+      end
+
+      def has_hooks?(klass)
+        return true if klass_has_hooks? klass
+        if klass.respond_to?(:arkenstone_inherit_hooks) && klass.arkenstone_inherit_hooks
+          return klass.ancestors.any? { |ancestor| klass_has_hooks? ancestor }
+        end
+
+        false
+      end
+
+      def klass_has_hooks?(klass)
+        klass.respond_to?(:arkenstone_hooks) and klass.arkenstone_hooks and klass.arkenstone_hooks.count.positive?
+      end
+
+      def call_hook(klass, enumerator)
+        hooks = []
+        if klass.arkenstone_inherit_hooks == true
+          klass.ancestors.each do |ancestor|
+            break if ancestor == Arkenstone::Associations::InstanceMethods
+
+            if ancestor.respond_to?(:arkenstone_hooks) && !ancestor.arkenstone_hooks.nil?
+              hooks.concat ancestor.arkenstone_hooks
+            end
+          end
+        else
+          hooks = klass.arkenstone_hooks
+        end
+        hooks&.each(&enumerator)
+      end
+    end
+  end
+end

data/lib/arkenstone/network/network.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Network
+    module ClassMethods
+      def send_request(url, verb, data = nil, call_hooks = true)
+        env = Arkenstone::Environment.new url:, verb:, body: data
+        Arkenstone::Hook.call_request_hooks self, env if call_hooks
+        response = Arkenstone::Network.send_request env
+        handle_response response
+        response
+      end
+
+      ### Takes appropriate action if the request was a success or failure.
+      def handle_response(response)
+        if Arkenstone::Network.response_is_success response
+          Arkenstone::Hook.call_response_hooks self, response
+        else
+          Arkenstone::Hook.call_error_hooks self, response
+        end
+      end
+    end
+
+    class << self
+      def included(base)
+        base.extend Arkenstone::Network::ClassMethods
+      end
+
+      ### All http requests go through here.
+      def send_request(request_env)
+        http = create_http request_env.url
+        request = build_request request_env.url, request_env.verb
+        set_request_data request, request_env.body
+        set_request_headers request, request_env.headers unless request_env.headers.nil?
+        http.request request
+      end
+
+      ### Determines if the response was successful.
+      # TODO: Refactor this to handle more status codes.
+      # TODO: How do we handle redirects (30x)?
+      def response_is_success(response)
+        %w[200 204].include? response.code
+      end
+
+      ### Creates the http object used for requests.
+      def create_http(url)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = true if uri.scheme == 'https'
+        http
+      end
+
+      ### Builds a Net::HTTP request object for the appropriate verb.
+      def build_request(url, verb)
+        klass = Kernel.const_get('Net::HTTP').const_get(verb.capitalize)
+        klass.new URI(url)
+      end
+
+      ### Fills in the body of a request with the appropriate serialized data.
+      def set_request_data(request, data)
+        data = data.to_json unless data.instance_of?(String)
+        request.body = data
+        request.content_type = 'application/json'
+      end
+
+      ### Sets HTTP headers on the request.
+      def set_request_headers(request, headers)
+        headers.each { |key, val| request.add_field key, val }
+      end
+    end
+  end
+end

data/lib/arkenstone/query_builder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  #
+  # = Builder
+  # Builds up the query from the DSL and returns a ruby hash.
+  class QueryBuilder
+    ### Initializes the @hash variable, which is used to build complex queries.
+    def initialize
+      @cache = {}
+    end
+
+    ### Main entry point for processing the DSL.
+    def build(&)
+      result = instance_eval(&)
+      result = flush.merge result unless @cache.empty?
+      result.to_json
+    end
+
+    ### Finds the entries that have a value for a column in the provided +value_array+.
+    def _in(value_array)
+      { '$in' => value_array }
+    end
+
+    ### Finds entries who's values for a column are greater than the value provided.
+    def _gt(val)
+      { '$gt' => val }
+    end
+
+    ### Finds entries who's values for a column are greater than or equal to the value provided.
+    def _gte(val)
+      { '$gte' => val }
+    end
+
+    ### Finds entries who's values for a column are less than the value provided.
+    def _lt(val)
+      { '$lt' => val }
+    end
+
+    ### Finds entries who's values for a column are less than or equal to the value provided.
+    def _lte(val)
+      { '$lte' => val }
+    end
+
+    ### Finds entries that match *all* expressions in the value provided.
+    def _and(*vals)
+      evaluate_expression '$and', vals
+    end
+
+    ### Finds entries that match *any* expression in the value provided.
+    def _or(*vals)
+      evaluate_expression '$or', vals
+    end
+
+    ### Finds entries that do *not* match any expression in the value provided.
+    def _not(*vals)
+      evaluate_expression '$not', vals
+    end
+
+    ### Adds include statements for the database endpoint to parse.
+    def _include(values)
+      @cache = evaluate_expression '$include', values
+    end
+
+    ### Sets a max number of results to return.
+    def _limit(max)
+      @cache = evaluate_expression '$limit', max
+    end
+
+    private
+
+    ### Evaluates an expression that takes multiple arguments. Used to walk through nested boolean statements.
+    def evaluate_expression(bool_type, hash)
+      { bool_type.to_s => hash }
+    end
+
+    ### Spits out the stored expressions in the +hash+ and resets it.
+    def flush
+      result = @cache
+      @cache = {}
+      result
+    end
+  end
+end

data/lib/arkenstone/queryable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Queryable
+    class << self
+      def included(base)
+        base.extend Arkenstone::Queryable::ClassMethods
+      end
+    end
+
+    module ClassMethods
+      def query_url
+        "#{full_url(arkenstone_url)}query"
+      end
+
+      def where(query = nil, &)
+        check_for_url
+        body = build_where_body(query, &)
+        return nil if body.nil?
+
+        # TODO: - refactor the network stuff into it's own module, so that we don't have `self` here
+        response = send_request query_url, :post, body
+        parse_all response.body if Arkenstone::Network.response_is_success response
+      end
+
+      def build_where_body(query = nil, &)
+        if query.instance_of?(String)
+          body = query
+        elsif query.instance_of?(Hash)
+          body = query.to_json
+        elsif query.nil? && block_given?
+          builder = Arkenstone::QueryBuilder.new
+          body = builder.build(&)
+        end
+      end
+    end
+  end
+end

data/lib/arkenstone/timestamps.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Timestamps
+    class << self
+      def included(base)
+        base.send :include, Arkenstone::Timestamps::InstanceMethods
+      end
+    end
+
+    module InstanceMethods
+      attr_accessor :created_at, :updated_at
+
+      def timestampable
+        true
+      end
+
+      def timestamp
+        current_time = Time.now
+        self.created_at = current_time unless created_at
+        self.updated_at = current_time
+      end
+    end
+  end
+end

data/lib/arkenstone/validation/validation_error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Validation
+    class ValidationError
+      attr_accessor :messages
+
+      def initialize
+        @messages = {}
+      end
+
+      def count
+        @messages.count
+      end
+
+      def [](key)
+        @messages[key]
+      end
+
+      def []=(key, val)
+        @messages[key] = val
+      end
+
+      def add(attr, message)
+        errors_for_attr = @messages[attr]
+        if errors_for_attr.nil?
+          @messages[attr] = [message]
+        else
+          errors_for_attr << message
+        end
+      end
+    end
+  end
+end

data/lib/arkenstone/validation/validations.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  module Validation
+    class << self
+      def included(base)
+        base.send :include, Arkenstone::Validation::InstanceMethods
+        base.extend Arkenstone::Validation::ClassMethods
+      end
+    end
+
+    module InstanceMethods
+      attr_accessor :errors
+
+      ### Does a model's attributes pass all of the validation requirements?
+      def valid?
+        validate
+        @errors.count.zero?
+      end
+
+      # Run through all the validators.
+      def validate
+        @errors = Arkenstone::Validation::ValidationError.new
+        validate_with_validators
+        validate_with_custom_validators
+      end
+
+      private
+
+      # Loops through the provided validators. A validator is passed when a validation method returns nil. All other values are treated as errors.
+      def validate_with_validators
+        return if self.class.fields_to_validate.nil?
+
+        self.class.fields_to_validate.each do |attr, validators|
+          validators.each do |validator_hash, _arg|
+            key = validator_hash.keys.first
+            validation_method = "validate_#{key}"
+            options = validator_hash[key]
+            result = send validation_method, attr, options
+            @errors.add(attr, result) unless result.nil?
+          end
+        end
+      end
+
+      # Loops through all the custom validators created with `validate`.
+      def validate_with_custom_validators
+        self.class.custom_validators&.each do |custom_validator|
+          send custom_validator
+        end
+      end
+
+      # Checks if the attribute is on the instance of the model. If the attribute is a string, checks if it's empty.
+      # Example:
+      #
+      #     validates :name, presence: true
+      #
+      def validate_presence(attr, options)
+        message = options[:message] || "can't be blank"
+        test = options[:presence]
+        method_not_defined = test != self.class.method_defined?(attr)
+        if method_not_defined
+          message
+        else
+          val = send(attr)
+          value_is_nil = test == val.nil?
+          return message if value_is_nil
+
+          value_is_string = val.instance_of?(String)
+          message if value_is_string && val.empty?
+        end
+      end
+
+      def validate_empty(attr, options)
+        message = options[:message] || 'must not be empty'
+        val = send(attr)
+        return message if val.nil?
+        return message if val.respond_to? :empty
+        return message if val.empty?
+      end
+
+      # Checks if an attribute is the appropriate boolean value.
+      #
+      # Example:
+      #
+      #     validates :accepts_terms, acceptance: true
+      def validate_acceptance(attr, options)
+        acceptance = options[:acceptance]
+        message = options[:message] || "must be #{acceptance}"
+        val = send(attr)
+        message if val != acceptance
+      end
+
+      # Checks if an attribute is an instance of a specific type, or one of its descendents.
+      #
+      # Example:
+      #
+      #     validates :should_be_string, type: String
+      #
+      # That will check if `should_be_string` is a `String` or a subclass of `String`
+      def validate_type(attr, options)
+        type = options[:type]
+        message = options[:message] || "must be type #{type}"
+        val = send(attr)
+        message if !val.nil? && !(val.is_a? type)
+      end
+
+      # Checks if the attribute conforms with the provided regular expression.
+      # Example:
+      #
+      #     validates :name, with: format: { with: /\d+/, message: "must be lowercase" }
+      def validate_format(attr, options)
+        val = send attr
+        regex = options[:format][:with]
+        options[:format][:message] if regex.match(val).nil?
+      end
+
+      # Checks if the attribute is on the instance of the model. If the attribute is a string, checks if it's empty.
+      # Example:
+      #     attr_accessor :email_confirmation
+      #     attributes :email
+      #
+      #     validates :email, confirmation: true
+      #
+      def validate_confirmation(attr, options)
+        message           = options[:message] || "confirmation does not match #{attr}"
+        test              = options[:confirmation]
+        attr_confirmation = "#{attr}_confirmation".to_sym
+
+        confirmation_not_found = test = !self.class.method_defined?(attr_confirmation) # attr_confirmation not defined
+        if confirmation_not_found
+          message
+        else
+          send(attr)
+          return message if send(attr) != send(attr_confirmation)
+        end
+      end
+    end
+
+    module ClassMethods
+      class << self
+        def extended(base)
+          base.fields_to_validate = {}
+        end
+      end
+
+      attr_accessor :fields_to_validate, :custom_validators
+
+      # Adds a custom validator method. Custom validators are responsible for adding errors to the `errors` hash.
+      # Example:
+      #
+      #     class MyClass
+      #       validate :special_case
+      #
+      #       def special_case
+      #         if 1 == 2
+      #           errors.add(:the_bad_property, "Error Message")
+      #         end
+      #       end
+      #     end
+      def validate(custom_validation_method)
+        self.custom_validators = [] if custom_validators.nil?
+        custom_validators << custom_validation_method
+      end
+
+      # Adds one of the provided validators to an attribute. Specify the validator in the `options` splat.
+      # Example:
+      #
+      # class MyClass
+      #   validates :name, presence: true
+      #   validates :email, with: format: { with: /[a-z]+/, message: "must be valid email" }
+      # end
+      def validates(attr, *options)
+        self.fields_to_validate = {} if fields_to_validate.nil?
+        sym = attr.downcase.to_sym
+        fields_for_attr = fields_to_validate[sym]
+        if fields_for_attr.nil?
+          fields_for_attr = []
+          fields_to_validate[sym] = fields_for_attr
+        end
+        fields_for_attr << create_validator(Hash[*options])
+      end
+
+      ### Creates a validator hash from the options passed into a `validates` method.
+      def create_validator(options_hash)
+        key = options_hash.first[0]
+        validator = {}
+        validator[key] = options_hash
+        validator
+      end
+    end
+  end
+end

data/lib/arkenstone/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Arkenstone
+  VERSION = '3.0.1'
+end

data/lib/arkenstone.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'arkenstone/version'
+require 'arkenstone/errors/no_url_error'
+require 'arkenstone/enumerable/query_list'
+require 'arkenstone/network/hook'
+require 'arkenstone/network/env'
+require 'arkenstone/network/network'
+require 'arkenstone/associations'
+require 'arkenstone/associations/resources'
+require 'arkenstone/validation/validation_error'
+require 'arkenstone/validation/validations'
+require 'arkenstone/query_builder'
+require 'arkenstone/queryable'
+require 'arkenstone/document'
+require 'arkenstone/timestamps'
+require 'arkenstone/helpers'
+
+module Arkenstone
+  # Your code goes here...
+end

data/test/associations/test_document_overrides.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class DocumentOverridesTest < Test::Unit::TestCase
+  def test_reload_override
+    eval %(
+      class Brand
+        include Arkenstone::Document
+
+        url 'http://example.com/brands'
+        attributes :name
+        has_many :balls
+      end
+
+      class Ball
+        include Arkenstone::Document
+
+        attributes :color
+        belongs_to :brand
+      end
+    )
+
+    stub_request(:post, "#{Brand.arkenstone_url}/").to_return(status: '200', body: { id: 1, name: 'Foo' }.to_json)
+    stub_request(:get, "#{Brand.arkenstone_url}/1/balls").to_return(status: 200, body: [].to_json)
+
+    brand = Brand.create(name: 'Foo')
+    assert(!brand.arkenstone_data[:balls])
+
+    stub_request(:post, "#{Brand.arkenstone_url}/1/balls/").to_return(status: '200',
+                                                                      body: {
+                                                                        id: 1, color: 'blue', brand_id: brand.id
+                                                                      }.to_json)
+
+    ball = brand.balls.create(color: 'blue')
+    assert(brand.arkenstone_data[:balls])
+
+    stub_request(:get, "#{Ball.arkenstone_url}/1").to_return(status: 200,
+                                                             body: {
+                                                               id: 1, color: 'blue', brand_id: brand.id
+                                                             }.to_json)
+    ball.reload
+
+    assert(ball.color == 'blue')
+
+    found_ball = Ball.find(ball.id)
+    assert(found_ball.color == 'blue')
+    assert_equal(ball.to_json, found_ball.to_json)
+  end
+end