brujula 0.0.1

data/lib/brujula/data_transformers/property_declaration.rb

@@ -0,0 +1,28 @@
+module Brujula
+  module DataTransformers
+    class PropertyDeclaration
+      class << self
+        def call(*args)
+          new(*args).call
+        end
+      end
+
+      attr_reader :data, :parent
+
+      def initialize(parent, data)
+        @parent = parent
+        @data   = data
+      end
+
+      def call
+        data.each_with_object({}) do |(key, property), object|
+          if property.is_a?(String) # data as type
+            object.merge!(key => { "type" => property })
+          else
+            object.merge!(key => property)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/brujula/data_transformers/security_scheme_settings_declaration.rb

@@ -0,0 +1,23 @@
+module Brujula
+  module DataTransformers
+    class SecuritySchemeSettingsDeclaration
+      class << self
+        def call(*args)
+          new(*args).call
+        end
+      end
+
+      attr_reader :data, :parent
+
+      def initialize(parent, data)
+        @parent = parent
+        @data   = data
+      end
+
+      # Add the type from the parent and carry on
+      def call
+        data.merge("type" => parent.type)
+      end
+    end
+  end
+end

data/lib/brujula/initializers/inflecto_ramelize.rb

@@ -0,0 +1,9 @@
+module Inflecto
+  class << self
+    def ramelize(string)
+      camelize(string).tap do |string|
+        string[0] = string[0].downcase
+      end
+    end
+  end
+end

data/lib/brujula/initializers/yaml_include.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+
+# stolen from https://github.com/coub/raml_ruby/
+module Brujula
+  class YamlInclude
+    attr_reader :path
+
+    def init_with(coder)
+      @path = coder.scalar
+    end
+
+    def load_external_data(base_dir)
+      YAML.load external_data_content(base_dir)
+    end
+
+    def parseable?
+      parseable_extensions.include?(path_extension)
+    end
+
+    private
+
+    def external_data_content(base_dir)
+      File.read(external_data_path(base_dir))
+    end
+
+    def external_data_path(base_dir)
+      return path if path.start_with?('/') # absolute path reference
+
+      File.join(base_dir, path)
+    end
+
+    def path_extension
+      File.extname(path)
+    end
+
+    def parseable_extensions
+      %w( .yaml .yml .raml )
+    end
+  end
+end
+
+YAML.add_tag '!include', Brujula::YamlInclude

data/lib/brujula/key.rb

@@ -0,0 +1,45 @@
+module Brujula
+  class Key
+    attr_reader :expression, :required, :options, :for_types, :referrable,
+                :data_transformer, :name
+
+    alias_method :required?, :required
+    alias_method :referrable?, :referrable
+
+    def initialize(expression, options)
+      @expression       = expression
+      @name             = expression.to_s
+      @options          = options
+      @required         = !!options[:required]
+      @referrable       = !!options[:referrable]
+      @for_types        = options[:for_types] || []
+      @data_transformer = options[:data_transformer]
+    end
+
+    def accessor_name
+      options[:accessor] || expression
+    end
+
+    def fixed?
+      expression.is_a?(Symbol)
+    end
+
+    def matches?(key_name)
+      !(expression =~ key_name).nil?
+    end
+
+    def valid_for_type?(type)
+      return true if for_types.empty?
+
+      for_types.include?(type)
+    end
+
+    def basic_type?
+      basic_types.include?(options[:as])
+    end
+
+    def basic_types
+      %i( any array boolean markdown media_type number string uri_template )
+    end
+  end
+end

data/lib/brujula/map_object.rb

@@ -0,0 +1,99 @@
+module Brujula
+  class MapObject
+    include Enumerable
+
+    attr_reader :parent, :name, :child_class
+
+    def initialize(data:, parent: nil, name:, child_class:)
+      @parent      = parent
+      @name        = name
+      @child_class = child_class
+      @collection  = {}
+      each_flatted_child(data) do |child_name, child_data|
+        child_object = build_object(child_name, child_data)
+
+        @collection.merge!(child_name.to_s => child_object)
+      end
+    end
+
+    def key?(key)
+      @collection.key?(key.to_s)
+    end
+
+    def [](key)
+      @collection.fetch(key.to_s, nil)
+    end
+
+    def fetch(key)
+      @collection.fetch(key.to_s)
+    rescue KeyError => error
+      $stderr.puts "Couldn't find item #{ key } in collection #{ name }"
+      raise error
+    end
+
+    def merge(key, value)
+      @collection.merge!(key.to_s => value)
+    end
+
+    def each
+      @collection.values.each { |item| yield item }
+    end
+
+    def expand
+      self
+    end
+
+    private
+
+    def build_object(name, data)
+      child_data = normalize_child_data(data)
+      options    = { data: child_data, name: name, parent: self }
+      object     = child_klass.new(options)
+      apply_inheritance(object)
+    end
+
+    def child_klass
+      Brujula::Raml::V1_0.const_get(Inflecto.camelize(child_class))
+    end
+
+    def normalize_child_data(data)
+      return data unless data.is_a?(Brujula::YamlInclude)
+
+      data.load_external_data(parent.root.base_dir)
+    end
+
+    def apply_inheritance(child)
+      case child
+      when Brujula::Raml::V1_0::Resource
+        Brujula::TypeExtender::Resource.new(definition: child).call
+      when Brujula::Raml::V1_0::Method
+        Brujula::TypeExtender::Method.new(definition: child).call
+      when Brujula::Raml::V1_0::ResourceType
+        Brujula::TypeExtender::ResourceType.new(definition: child).call
+      else
+        child
+      end
+    end
+
+    def each_flatted_child(data)
+      flatten_children(data).each do |child_name, child_data|
+        yield child_name, child_data
+      end
+    end
+
+    def flatten_children(data)
+      case data
+      when Array
+        data.each_with_object({}) do |child, children|
+          child.each do |key, value|
+            children.merge!(key => value)
+          end
+        end
+      when Hash
+        data
+      else
+        raise 'Invalid data for map_object'
+      end
+    end
+  end
+end

data/lib/brujula/mergers/map_object_merger.rb

@@ -0,0 +1,78 @@
+module Brujula
+  module Mergers
+    class MapObjectMerger
+      attr_reader :superinstance, :instance
+
+      def initialize(instance:, superinstance:)
+        @superinstance = superinstance
+        @instance      = instance
+      end
+
+      def call
+        return superinstance.dup if instance.nil?
+
+        instance.dup.tap do |extended_instance|
+          each_inheritable_items do |inherit_item|
+            extended_instance.merge(inherit_item.name, inherit_item)
+          end
+        end
+      end
+
+      def each_inheritable_items
+        superinstance.each do |inherit_item|
+
+          merge_item = case item_reference(inherit_item.name)
+          when :optional_to_optional
+            instance.fetch(inherit_item.name)
+          when :optional
+            instance.fetch(inherit_item.name.gsub(/\?$/, ''))
+          when :direct
+            instance.key?(inherit_item.name) ?
+              instance.fetch(inherit_item.name) : nil
+          else
+            next
+          end
+
+          yield merger(merge_item, inherit_item)
+        end
+      end
+
+      def merger(merge_item, inherit_item)
+        Merger.new(instance: merge_item, superinstance: inherit_item).call
+      end
+
+      def item_reference(key)
+        case
+        when optional_key?(key) && instance_has_optional_item?(key)
+          :optional_to_optional
+        when optional_key?(key) && instance_has_item?(key)
+          :optional
+        when !optional_key?(key)
+          :direct
+        end
+      end
+
+      def merge_item?(key)
+        return true unless optional_key?(key)
+
+        instance_has_item?(key) || instance_has_optional_item?(key)
+      end
+
+      def optional_key?(key)
+        key.to_s.end_with?('?')
+      end
+
+      def instance_has_item?(key)
+        item_names.include?(key.gsub(/\?$/, ''))
+      end
+
+      def instance_has_optional_item?(key)
+        item_names.include?(key)
+      end
+
+      def item_names
+        @item_names ||= instance.to_a.map(&:name)
+      end
+    end
+  end
+end

data/lib/brujula/mergers/merger.rb

@@ -0,0 +1,27 @@
+module Brujula
+  module Mergers
+    class Merger
+      attr_reader :superinstance, :instance
+
+      def initialize(instance:, superinstance:)
+        @superinstance = superinstance
+        @instance      = instance
+      end
+
+      def call
+        case
+        when superinstance.is_a?(Brujula::MapObject)
+          MapObjectMerger.new(
+            instance: instance, superinstance: superinstance
+          ).call
+        when superinstance.is_a?(Brujula::Object)
+          ObjectMerger.new(
+            instance: instance, superinstance: superinstance
+          ).call
+        else
+          superinstance.dup
+        end
+      end
+    end
+  end
+end

data/lib/brujula/mergers/object_merger.rb

@@ -0,0 +1,41 @@
+module Brujula
+  module Mergers
+    class ObjectMerger
+      attr_reader :superinstance, :instance
+
+      def initialize(instance:, superinstance:)
+        @superinstance = superinstance
+        @instance      = instance
+      end
+
+      def call
+        return superinstance.dup if instance.nil?
+        instance.dup.tap do |object|
+          each_inheritable_attributes do |name, attribute|
+            original_item = object.instance_variable_get("@#{ name }")
+            thing = Merger.new(
+              instance: original_item, superinstance: attribute
+            ).call
+            object.instance_variable_set("@#{ name }", thing)
+          end
+        end
+      end
+
+      def each_inheritable_attributes
+        applicable_attributes.each do |name|
+          next if superinstance.instance_variable_get(name).nil?
+          string_name = name.to_s.gsub(/^@/, '')
+          yield(string_name, superinstance.instance_variable_get(name))
+        end
+      end
+
+      def applicable_attributes
+        superinstance.instance_variables - excluded_attributes
+      end
+
+      def excluded_attributes
+        %i( @parent @name @type )
+      end
+    end
+  end
+end

data/lib/brujula/object.rb

@@ -0,0 +1,40 @@
+module Brujula
+  class Object
+    attr_reader :name
+
+    class << self
+      attr_reader :scheme, :block
+
+      def scheme(options = {}, &block) # TODO
+        return @scheme unless @scheme.nil?
+
+        if block_given?
+          @block  = block
+          @scheme = Brujula::Scheme.new(self, options, block)
+        else
+          @scheme = Brujula::Scheme.new(self, options)
+        end
+      end
+    end
+
+    def initialize(data:, parent: nil, name:)
+      @name = name
+      define_singleton_method(:raw_data) { data }
+      define_singleton_method(:parent)   { parent }
+
+      Brujula::ObjectParser.call(definition: self, data: data, parent: parent)
+    end
+
+    def expand # TODO
+      @representation || self
+    end
+
+    def root
+      object = self
+      until object.is_a? Brujula::Raml::V1_0::Root
+        object = object.parent
+      end
+      object
+    end
+  end
+end