value_class 0.1.0.pre.prerelease2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e3ea3aec695d36750ca2629b6348ae5ea195f7d0225b415051b2bf6df665faf5
+  data.tar.gz: d90ca345053f89ff2f3db5ea88ee5ea887aa4ca1633743cb09eff1e6c40391cb
+SHA512:
+  metadata.gz: 56047ca389a9e46e4d78498e1b65906363efb0ff20942389157504a7044ae9e508d7b9e74adcc57c533b15c524103502fb4b2e804d86301c7bcc794af97c0379
+  data.tar.gz: 3549fe478d4177a84cd2f97c5863f60e17b192a074acdc95c0f5c37f4acde03ffc320e4d7a8c3e385ac2e1811ab5bbe521c7618e5b2bb066324acd971e8f9b69

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/
+spec/reports/*
+.rubocop-http*

data/.jenkins/Jenkinsfile

@@ -0,0 +1,61 @@
+#!/usr/bin/groovy
+@Library('jenkins-pipeline@v0.4.5')
+import com.invoca.docker.*;
+
+pipeline {
+  agent {
+    kubernetes {
+      defaultContainer "ruby"
+      yamlFile ".jenkins/ruby_build_pod.yml"
+    }
+  }
+
+  environment {
+    GITHUB_TOKEN = credentials('github_token')
+    GITHUB_KEY = credentials('github_key')
+    BUNDLE_GEM__FURY__IO = credentials('gemfury_deploy_token')
+  }
+
+  stages {
+    stage('Setup') {
+      steps {
+        script {
+         sh '''
+            # get SSH setup inside the container
+            eval `ssh-agent -s`
+            echo "$GITHUB_KEY" | ssh-add -
+            mkdir -p /root/.ssh
+            ssh-keyscan -t rsa github.com > /root/.ssh/known_hosts
+            bundle install
+          '''
+        }
+      }
+    }
+
+    stage('Unit Test') {
+      steps {
+        script {
+         sh 'bundle exec rspec --format RspecJunitFormatter --out spec/reports/rspec.xml'
+        } 
+      }
+
+      post {
+        always { junit 'spec/reports/rspec.xml' }
+        success { updateGitHubStatus('clean-build', 'success', 'Unit tests.') }
+        failure { updateGitHubStatus('clean-build', 'failure', 'Unit tests.') }
+      }
+    }
+  }
+}
+
+void updateGitHubStatus(String context, String status, String description) {
+  gitHubStatus([
+    repoSlug:    'Invoca/value_class',
+    sha:         env.GIT_COMMIT,
+    description: description,
+    context:     context,
+    targetURL:   env.BUILD_URL,
+    token:       env.GITHUB_TOKEN,
+    status:      status
+  ])
+}

data/.jenkins/ruby_build_pod.yml

@@ -0,0 +1,19 @@
+---
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+  jenkins/active-table-set: 'true'
+  namespace: jenkins
+  name: active-table-set
+spec:
+  containers:
+  - name: ruby
+    image: ruby:2.6.1
+    tty: true
+    resources:
+    requests:
+      memory: "100Mi"
+    command:
+      - cat
+

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,5 @@
+# This rubocop config file inherits from our centralized style-guide repository.
+# If you are looking to update the ruby style guide, be sure to both update the rubocop config
+# as well as the README.md
+# https://github.com/Invoca/style-guide/tree/master/ruby
+inherit_from: https://raw.githubusercontent.com/Invoca/style-guide/master/ruby/.rubocop.yml

data/.ruby-version

@@ -0,0 +1 @@
+2.6.1

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# CHANGELOG for `value_class`
+
+Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0]
+
+### Changed
+
+- Cloned from Active Table Set

data/Gemfile

@@ -0,0 +1,16 @@
+source 'https://rubygems.org'
+source 'https://gem.fury.io/invoca'
+
+# Specify your gem's dependencies in value_class.gemspec
+gemspec
+
+group :development do
+  gem 'bundler',     '~> 1.8'
+  gem 'pry'
+  gem 'pry-byebug'
+  gem 'rake',        '~> 13.0'
+  gem 'rspec',       '~> 3.7'
+  gem 'rspec-mocks', '~> 3.7'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop', '0.74.0'
+end

data/Gemfile.lock

@@ -0,0 +1,69 @@
+PATH
+  remote: .
+  specs:
+    value_class (0.1.0.pre.prerelease2)
+      attr_comparable
+
+GEM
+  remote: https://rubygems.org/
+  remote: https://gem.fury.io/invoca/
+  specs:
+    ast (2.4.0)
+    attr_comparable (0.2.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    jaro_winkler (1.5.4)
+    method_source (0.9.0)
+    parallel (1.19.1)
+    parser (2.7.1.1)
+      ast (~> 2.4.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.74.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-progressbar (1.10.1)
+    unicode-display_width (1.6.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.8)
+  pry
+  pry-byebug
+  rake (~> 13.0)
+  rspec (~> 3.7)
+  rspec-mocks (~> 3.7)
+  rspec_junit_formatter
+  rubocop (= 0.74.0)
+  value_class!
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -0,0 +1,100 @@
+# ValueClass
+
+Provides a simple mechanism for declaring a class with complex attributes.  Instances of the class can be progressively
+constructed in a using a block.  The class is immutable outside of the block.   This is useful for building simple
+configuration DSLs.  
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'value_class'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install value_class
+
+## Usage
+
+The following class declaration allow a bicycle to be declared: 
+ 
+```ruby
+  class BikeTire
+    include ValueClass::Constructable
+
+    value_attr :diameter, description: "The diameter in inches"
+    value_attr :tred,     description: "The tred on the tire"
+  end
+
+  class BikeSeat
+    include ValueClass::Constructable
+
+    value_attr :size, description: "The size of the bike seat in inches"
+    value_attr :color
+  end
+
+  class Bicycle
+    include ValueClass::Constructable
+
+    value_description "For riding around town"
+    value_attr :speeds
+    value_attr :color, default: :orange
+    value_attr :seat, class_name: 'BikeSeat'
+
+    value_list_attr :riders, insert_method: :add_rider
+    value_list_attr :tires, insert_method: :tire, class_name: 'BikeTire'
+  end
+```
+
+Given the above declarations, you can then configure a bicycle with the following code.
+
+```ruby
+  bike = Bicycle.config do |bicycle|
+    bicycle.speeds 10
+    bicycle.color  :blue
+    bicycle.seat do |seat|
+      seat.color :green
+      seat.size  :large
+    end
+  end
+```
+
+You can also directly declare the class:
+
+```ruby 
+  bike = Bicycle.new(speeds: 10, color: :gold, tires: [{ diameter: 40, tred: :mountain }, { diameter: 50, tred: :slicks }])
+```
+
+If you have a simple class, ValueClass provides a replacement for ruby struct that allows for a quick class declaration.
+
+```ruby
+        
+  Gears = ValueClass.struct(:first_gear, :second_gear, :third_gear, default: 200)
+  gear = Gears.new(first_gear: 20) 
+```  
+
+Once an instance of a class is returned. It is immutable: it is frozen and all if its attributes are frozen.
+
+### Running Tests
+
+Tests in this gem are written in Rspec and can be executed through the main rake task for the repo
+```bash
+bundle exec rake
+```
+
+If there is a subset of tests you would like to run, you can add the `focus: true` tag to the test or context to only run the subset of tests.
+
+## Contributing
+
+1. Fork it ( https://github.com/invoca/value_class/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+4. Make sure the tests pass: `rspec spec`
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :rubocop do
+  puts "rubocop"
+  rubocop_output = `rubocop -a app lib test`
+  print rubocop_output
+  unless rubocop_output.match(/files inspected, no offenses detected/)
+    exit 1
+  end
+end
+
+task default: [:spec, :rubocop]

data/lib/value_class/attribute.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ValueClass
+  class Attribute
+    attr_reader :name, :options, :limit
+
+    OPTIONS = {
+      description: "A description of the attribute.",
+      default: "The default value for this parameter.",
+      class_name: "The name of the value class for this attribute.  Allows for construction from a nested hash.",
+      list_of_class: "Used to declare an attribute that is a list of a class.",
+      required: "If true, the parameter is required",
+      limit: "The set of valid values",
+      insert_method: "The name of the method to create to allow inserting into a list during progressive construction"
+    }.freeze
+
+    def initialize(name, options)
+      if (invalid_options = options.keys - OPTIONS.keys).any?
+        raise ArgumentError, "Unknown option(s): #{invalid_options.join(',')}"
+      end
+
+      @name = name.to_sym.freeze
+      @options = options.freeze
+      @limit = options[:limit]
+    end
+
+    def description(prefix = "")
+      if options[:description]
+        "#{prefix}#{name}: #{options[:description]}"
+      else
+        "#{prefix}#{name}"
+      end
+    end
+
+    def get_value(config)
+      raw_value = raw_value(config)
+
+      cast_value = cast_value(raw_value)
+
+      if cast_value.nil? && options[:required]
+        raise ArgumentError, "must provide a value for #{name}"
+      end
+
+      if !cast_value.nil? && limit && !limit.include?(cast_value)
+        raise ArgumentError, "invalid value #{cast_value.inspect} for #{name}. allowed values #{limit.inspect}"
+      end
+
+      if cast_value.nil?
+        default
+      else
+        cast_value
+      end
+    end
+
+    def hash_value(raw_value)
+      if options[:list_of_class] && raw_value.is_a?(Array)
+        raw_value.map(&:to_hash)
+      elsif options[:class_name] && raw_value
+        raw_value.to_hash
+      else
+        raw_value
+      end
+    end
+
+    def default
+      value = options[:default]
+      begin
+        value.dup
+      rescue TypeError
+        value
+      end
+    end
+
+    private
+
+    def cast_value(raw_value)
+      if options[:list_of_class] && raw_value.is_a?(Array)
+        inner_class = options[:list_of_class]
+        raw_value.map { |v| Object.const_get(inner_class).new(v).freeze }
+      elsif options[:class_name] && raw_value
+        Object.const_get(options[:class_name]).new(raw_value).freeze
+      else
+        raw_value
+      end
+    end
+
+    def raw_value(config)
+      if config.is_a?(Hash)
+        config[name]
+      else
+        config.send(name)
+      end
+    end
+  end
+end

data/lib/value_class/constructable.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ValueClass
+  module Constructable
+    def self.included(base)
+      base.extend ClassMethods
+      base.include(ValueClass)
+    end
+
+    def clone_config
+      config = self.class.config_class.new
+      self.class.value_attributes.each do |attr|
+        current_value = send(attr.name)
+        dup_value =
+          begin
+            current_value.dup
+          rescue TypeError
+            current_value
+          end
+        config.send("#{attr.name}=", dup_value)
+      end
+      yield config
+      self.class.new(config)
+    end
+
+    module ClassMethods
+      # Constructs an instance using the configuration created in the passed in block.
+      def config
+        config = config_class.new
+        value_attributes.each do |attr|
+          if attr.default
+            config.send("#{attr.name}=", attr.default)
+          end
+        end
+        yield config
+        new(config)
+      end
+
+      def config_class
+        unless @config_class
+          @config_class = Class.new
+
+          value_attributes.each do |attribute|
+            # Define assignment operator
+            @config_class.send(:attr_writer, attribute.name)
+
+            define_accessor(attribute)
+            if (insert_method = attribute.options[:insert_method])
+              define_insert(attribute, insert_method)
+            end
+          end
+        end
+        @config_class
+      end
+
+      private
+
+      def define_insert(attribute, insert_method)
+        if (class_name = attribute.options[:list_of_class])
+          config_class.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+                  def #{insert_method}(value=nil, &blk)
+                    if blk
+                      @#{attribute.name} << #{class_name}.config { |config| yield config }
+                    else
+                      @#{attribute.name} << #{class_name}.new(value)
+                    end
+                    @#{attribute.name}
+                  end
+          EORUBY
+        else
+          config_class.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+                  def #{insert_method}(value)
+                    @#{attribute.name} << value
+                    @#{attribute.name}
+                  end
+          EORUBY
+        end
+      end
+
+      def define_accessor(attribute)
+        if (class_name = attribute.options[:class_name])
+          config_class.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+                def #{attribute.name}(&blk)
+                  if blk
+                    @#{attribute.name} = #{class_name}.config { |config| yield config }
+                  end
+                  @#{attribute.name}
+                end
+          EORUBY
+        else
+          config_class.class_eval <<-EORUBY, __FILE__, __LINE__ + 1
+                def #{attribute.name}(value = nil)
+                  unless value.nil?
+                    @#{attribute.name} = value
+                  end
+                  @#{attribute.name}
+                end
+          EORUBY
+        end
+      end
+    end
+  end
+end

data/lib/value_class/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ValueClass
+  VERSION = "0.1.0-prerelease2"
+end

data/lib/value_class.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'attr_comparable'
+require 'value_class/attribute'
+
+module ValueClass
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Default constructor
+  def initialize(config = {})
+    check_constructor_params(config)
+    self.class.declare_comparison_operators
+    self.class.value_attributes.each do |attribute|
+      instance_variable_set("@#{attribute.name}", attribute.get_value(config).freeze)
+    end
+  end
+
+  # TODO: These need to be added to attr_comparible
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    self.class.value_attributes.map do |attribute|
+      instance_variable_get("@#{attribute.name}")
+    end.hash
+  end
+
+  def to_hash
+    self.class.value_attributes.each_with_object({}) do |attribute, hash|
+      # Attributes are frozen, but hash with indifferent access mutates values (!!!), so we have to dup
+      # in order to get a value we can use
+      unsafe_version = attribute.hash_value(instance_variable_get("@#{attribute.name}"))
+      safe_version =
+        begin
+          unsafe_version.dup
+        rescue TypeError
+          unsafe_version
+        end
+
+      hash[attribute.name.to_sym] = safe_version
+    end
+  end
+
+  def self.struct(*args)
+    Class.new do
+      include ValueClass::Constructable
+      value_attrs(*args)
+    end
+  end
+
+  protected
+
+  def check_constructor_params(config)
+    if config.is_a?(Hash)
+      extra_keys = config.keys - self.class.value_attributes.map(&:name)
+      extra_keys.empty? or raise ArgumentError, "unknown attribute #{extra_keys.join(', ')}"
+    end
+  end
+
+  module ClassMethods
+    def value_description(value = nil)
+      if value
+        @value_description = value
+      end
+      @value_description
+    end
+
+    def value_list_attr(attribute_name, options = {})
+      value_attr(attribute_name, options.merge(default: [], class_name: nil, list_of_class: options[:class_name]))
+    end
+
+    def value_attr(attribute_name, options = {})
+      attribute = Attribute.new(attribute_name, options)
+      value_attributes << attribute
+
+      attr_reader(attribute.name)
+    end
+
+    def value_attrs(*args)
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      args.each { |arg| value_attr(arg, options) }
+    end
+
+    def config_help(prefix = "")
+      [
+        "#{name}: #{value_description}",
+        "  attributes:",
+        value_attributes.map { |ca| ca.description(prefix + "    ") }
+      ].flatten.join("\n") + "\n"
+    end
+
+    def value_attributes
+      @value_attributes ||= []
+    end
+
+    def declare_comparison_operators
+      unless @comparison_operators_declared
+        @comparison_operators_declared = true
+
+        include AttrComparable
+        attr_compare(value_attributes.map(&:name))
+      end
+    end
+
+    def inherited(new_child_class)
+      value_attributes.each { |attr| new_child_class.value_attributes << attr }
+    end
+  end
+end
+
+# These build off of the above, so they are required last
+require 'value_class/constructable'

data/value_class.gemspec

@@ -0,0 +1,21 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'value_class/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "value_class"
+  spec.version       = ValueClass::VERSION
+  spec.authors       = ["Bob Smith"]
+  spec.email         = ["bob@invoca.com"]
+
+  spec.summary       = %q{ValueClass a lightweight way to define configuration DSLs.}
+  spec.description   = %q{ValueClass provides an interface to declare simple classes that can be progressively constructed but that are imutable afterwards.}
+  spec.homepage      = "https://github.com/invoca/value_class"
+  spec.license       = ""
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'attr_comparable'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: value_class
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.prerelease2
+platform: ruby
+authors:
+- Bob Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: attr_comparable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ValueClass provides an interface to declare simple classes that can be
+  progressively constructed but that are imutable afterwards.
+email:
+- bob@invoca.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".jenkins/Jenkinsfile"
+- ".jenkins/ruby_build_pod.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/value_class.rb
+- lib/value_class/attribute.rb
+- lib/value_class/constructable.rb
+- lib/value_class/version.rb
+- value_class.gemspec
+homepage: https://github.com/invoca/value_class
+licenses:
+- ''
+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: 1.3.1
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: ValueClass a lightweight way to define configuration DSLs.
+test_files: []